Showing preview only (5,841K chars total). Download the full file or copy to clipboard to get everything.
Repository: Illumina/Nirvana
Branch: main
Commit: 62d30326985a
Files: 1266
Total size: 5.3 MB
Directory structure:
gitextract_hj0kftnn/
├── .gitattributes
├── .gitignore
├── AnnotationLambda/
│ ├── AnnotationLambda.cs
│ ├── AnnotationLambda.csproj
│ ├── AssemblyInfo.cs
│ └── S3Utilities.cs
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── CacheUtils/
│ ├── AssemblyInfo.cs
│ ├── BuildCache.sh
│ ├── CacheUtils.cs
│ ├── CacheUtils.csproj
│ ├── CacheUtils.dll.gene.json
│ ├── Commands/
│ │ ├── CombineCacheDirectories/
│ │ │ └── CombineCacheDirectoriesMain.cs
│ │ ├── CreateCache/
│ │ │ └── CreateNirvanaDatabaseMain.cs
│ │ ├── Download/
│ │ │ ├── DownloadMain.cs
│ │ │ ├── ExternalFiles.cs
│ │ │ └── GenbankFile.cs
│ │ ├── ExtractTranscripts/
│ │ │ └── ExtractTranscriptsMain.cs
│ │ ├── GFF/
│ │ │ ├── CreateGffMain.cs
│ │ │ └── InternalGenes.cs
│ │ ├── Header/
│ │ │ └── HeaderMain.cs
│ │ ├── ParseVepCacheDirectory/
│ │ │ ├── ParseVepCacheDirectoryMain.cs
│ │ │ ├── RegulatoryRegionMerger.cs
│ │ │ ├── TranscriptFilter.cs
│ │ │ ├── TranscriptIdFilter.cs
│ │ │ ├── TranscriptMerger.cs
│ │ │ ├── TranscriptMergerLogger.cs
│ │ │ ├── VepCacheParser.cs
│ │ │ └── VepRootDirectory.cs
│ │ ├── RegulatoryGFF/
│ │ │ └── CreateRegulatoryGffMain.cs
│ │ └── UniversalGeneArchive/
│ │ ├── FilePaths.cs
│ │ └── UniversalGeneArchiveMain.cs
│ ├── DataDumperImport/
│ │ ├── DataStructures/
│ │ │ ├── GenomeSymbolSource.cs
│ │ │ ├── Import/
│ │ │ │ ├── IImportNode.cs
│ │ │ │ ├── ImportNodeExtensions.cs
│ │ │ │ ├── ListObjectKeyValueNode.cs
│ │ │ │ ├── ObjectKeyValueNode.cs
│ │ │ │ ├── ObjectValueNode.cs
│ │ │ │ ├── StringKeyValueNode.cs
│ │ │ │ └── StringValueNode.cs
│ │ │ └── Mutable/
│ │ │ ├── MutableExon.cs
│ │ │ ├── MutableGene.cs
│ │ │ ├── MutableTranscript.cs
│ │ │ └── MutableTranscriptRegion.cs
│ │ ├── FauxRegex/
│ │ │ └── RegexDecisionTree.cs
│ │ ├── IO/
│ │ │ ├── DataDumperReader.cs
│ │ │ └── EntryType.cs
│ │ ├── Import/
│ │ │ ├── Attribute.cs
│ │ │ ├── ImportExon.cs
│ │ │ ├── ImportGene.cs
│ │ │ ├── ImportIntron.cs
│ │ │ ├── ImportKeys.cs
│ │ │ ├── ImportMapper.cs
│ │ │ ├── ImportMapperPair.cs
│ │ │ ├── ImportMapperUnit.cs
│ │ │ ├── ImportPairGenomic.cs
│ │ │ ├── ImportPrediction.cs
│ │ │ ├── ImportProteinFunctionPredictions.cs
│ │ │ ├── ImportRegulatoryFeature.cs
│ │ │ ├── ImportSeqEdits.cs
│ │ │ ├── ImportTranscript.cs
│ │ │ ├── ImportTranscriptMapper.cs
│ │ │ ├── ImportTranslation.cs
│ │ │ └── ImportVariantEffectFeatureCache.cs
│ │ └── Utilities/
│ │ ├── ImportUtilities.cs
│ │ ├── MutableTranscriptComparer.cs
│ │ └── TranscriptUtilities.cs
│ ├── GFF/
│ │ ├── GeneralAttributes.cs
│ │ ├── GffCreator.cs
│ │ ├── GffGene.cs
│ │ ├── GffUtilities.cs
│ │ ├── GffWriter.cs
│ │ ├── IGeneralAttributes.cs
│ │ ├── IGffGene.cs
│ │ ├── IRequiredFields.cs
│ │ └── RequiredFields.cs
│ ├── Genbank/
│ │ ├── GenbankEntry.cs
│ │ ├── GenbankReader.cs
│ │ └── GenbankState.cs
│ ├── Genes/
│ │ ├── Combiners/
│ │ │ ├── CombinerUtils.cs
│ │ │ ├── HgncIdCombiner.cs
│ │ │ ├── ICombiner.cs
│ │ │ └── PartitionCombiner.cs
│ │ ├── DataStores/
│ │ │ ├── AssemblyDataStore.cs
│ │ │ ├── EnsemblGtf.cs
│ │ │ ├── GeneInfoData.cs
│ │ │ ├── GlobalCache.cs
│ │ │ ├── Hgnc.cs
│ │ │ ├── IUpdateHgncData.cs
│ │ │ ├── RefSeqGff.cs
│ │ │ └── UpdateHgncData.cs
│ │ ├── DataStructures/
│ │ │ ├── EnsemblGene.cs
│ │ │ ├── GeneInfo.cs
│ │ │ ├── HgncGene.cs
│ │ │ ├── IFlatGene.cs
│ │ │ ├── RefSeqGene.cs
│ │ │ └── UgaGene.cs
│ │ ├── GeneFlattener.cs
│ │ ├── GeneMerger.cs
│ │ ├── GeneSymbolUpdater.cs
│ │ ├── HgncIdConsolidator.cs
│ │ ├── HgncIdUpdater.cs
│ │ ├── IO/
│ │ │ ├── EnsemblGtfReader.cs
│ │ │ ├── GeneInfoReader.cs
│ │ │ ├── HgncReader.cs
│ │ │ ├── RefSeqGffReader.cs
│ │ │ ├── UgaGeneReader.cs
│ │ │ └── UgaGeneWriter.cs
│ │ ├── UgaAssemblyCombiner.cs
│ │ └── Utilities/
│ │ └── DictionaryUtilities.cs
│ ├── Helpers/
│ │ ├── BioTypeHelper.cs
│ │ ├── GeneSymbolSourceHelper.cs
│ │ ├── RegulatoryRegionTypeHelper.cs
│ │ └── TranscriptCacheHelper.cs
│ ├── IntermediateIO/
│ │ ├── CcdsReader.cs
│ │ ├── GenbankReader.cs
│ │ ├── GenbankWriter.cs
│ │ ├── IntermediateIoCommon.cs
│ │ ├── IntermediateIoHeader.cs
│ │ ├── LrgReader.cs
│ │ ├── MutableTranscriptReader.cs
│ │ ├── MutableTranscriptWriter.cs
│ │ ├── PredictionReader.cs
│ │ ├── PredictionWriter.cs
│ │ ├── RegulatoryRegionReader.cs
│ │ └── RegulatoryRegionWriter.cs
│ ├── MiniCache/
│ │ ├── DataBundle.cs
│ │ └── IStaging.cs
│ ├── PredictionCache/
│ │ ├── PredictionCacheBuilder.cs
│ │ ├── PredictionCacheStaging.cs
│ │ ├── PredictionCacheWriter.cs
│ │ ├── PredictionExtensions.cs
│ │ ├── PredictionUtilities.cs
│ │ ├── RoundedEntry.cs
│ │ └── RoundedEntryPrediction.cs
│ ├── TranscriptCache/
│ │ ├── CanonicalTranscriptMarker.cs
│ │ ├── Comparers/
│ │ │ ├── GeneComparer.cs
│ │ │ ├── IntervalComparer.cs
│ │ │ ├── RegulatoryRegionComparer.cs
│ │ │ ├── TranscriptRegionComparer.cs
│ │ │ └── UgaGeneComparer.cs
│ │ ├── NSequence.cs
│ │ ├── SortExtensions.cs
│ │ ├── TranscriptCacheBuilder.cs
│ │ ├── TranscriptCacheStaging.cs
│ │ ├── TranscriptCacheUtilities.cs
│ │ ├── TranscriptCacheWriter.cs
│ │ ├── TranscriptConversionExtensions.cs
│ │ ├── TranscriptRegionMerger.cs
│ │ └── TranscriptRegionValidater.cs
│ └── Utilities/
│ ├── AccessionUtilities.cs
│ ├── HeaderUtilities.cs
│ ├── RemoteFile.cs
│ └── TaskExtensions.cs
├── Cloud/
│ ├── AmazonS3ClientWrapper.cs
│ ├── AssemblyInfo.cs
│ ├── Cloud.appsettings.json
│ ├── Cloud.csproj
│ ├── Configuration.cs
│ ├── LambdaUrlHelper.cs
│ ├── Messages/
│ │ ├── Annotation/
│ │ │ ├── AnnotationConfig.cs
│ │ │ ├── AnnotationPosition.cs
│ │ │ ├── AnnotationRange.cs
│ │ │ └── AnnotationResult.cs
│ │ ├── Custom/
│ │ │ ├── CustomConfig.cs
│ │ │ └── CustomResult.cs
│ │ ├── FileList.cs
│ │ ├── Gene/
│ │ │ └── GeneConfig.cs
│ │ ├── JwtFields.cs
│ │ ├── Nirvana/
│ │ │ ├── NirvanaConfig.cs
│ │ │ └── NirvanaResult.cs
│ │ ├── S3Path.cs
│ │ ├── SaUrls.cs
│ │ ├── Single/
│ │ │ ├── SingleConfig.cs
│ │ │ └── SingleVariant.cs
│ │ └── StrValidation/
│ │ ├── ValidationConfig.cs
│ │ └── ValidationResult.cs
│ ├── Notifications/
│ │ └── SNS.cs
│ ├── RedactionUtilities.cs
│ └── Utilities/
│ ├── AwsExceptionUtilities.cs
│ ├── JsonUtilities.cs
│ ├── LambdaUtilities.cs
│ ├── LogUtilities.cs
│ └── UploadUtilities.cs
├── CommandLine/
│ ├── AssemblyInfo.cs
│ ├── Builders/
│ │ ├── ConsoleAppBuilder.cs
│ │ ├── IConsoleAppBuilder.cs
│ │ ├── ITopLevelAppBuilder.cs
│ │ ├── TopLevelAppBuilder.cs
│ │ ├── TopLevelOption.cs
│ │ └── ValidationExtensions.cs
│ ├── CommandLine.csproj
│ ├── NDesk.Options/
│ │ └── Options.cs
│ ├── Utilities/
│ │ ├── Benchmark.cs
│ │ ├── CommandLineUtilities.cs
│ │ ├── Help.cs
│ │ ├── MemoryUtilities.cs
│ │ └── OutputHelper.cs
│ └── VersionProviders/
│ ├── DefaultVersionProvider.cs
│ └── IVersionProvider.cs
├── CommonAssemblyInfo.props
├── Compression/
│ ├── Algorithms/
│ │ ├── ICompressionAlgorithm.cs
│ │ ├── Zlib.cs
│ │ └── Zstandard.cs
│ ├── AssemblyInfo.cs
│ ├── Compression.csproj
│ ├── DataStructures/
│ │ └── Block.cs
│ ├── FileHandling/
│ │ ├── BgzBlockReader.cs
│ │ ├── BgzfBlock.cs
│ │ ├── BgzipTextReader.cs
│ │ ├── BgzipTextWriter.cs
│ │ ├── BlockGZipStream.cs
│ │ ├── BlockHeader.cs
│ │ └── BlockStream.cs
│ └── Utilities/
│ ├── BlockExtensions.cs
│ ├── GZipUtilities.cs
│ └── LibraryUtilities.cs
├── CreateLambdaZips.sh
├── CustomAnnotationLambda/
│ ├── CustomAnnotationLambda.cs
│ ├── CustomAnnotationLambda.csproj
│ ├── CustomConfigExtensions.cs
│ ├── GeneAnnotationCreator.cs
│ └── VariantAnnotationCreator.cs
├── CustomStrValidationLambda/
│ ├── CustomStrValidationLambda.cs
│ └── CustomStrValidationLambda.csproj
├── Downloader/
│ ├── AnnotationRepository.cs
│ ├── AssemblyInfo.cs
│ ├── Client.cs
│ ├── Configuration.cs
│ ├── Downloader.appsettings.json
│ ├── Downloader.csproj
│ ├── DownloaderMain.cs
│ ├── FileExtensions/
│ │ ├── CacheFileExtensions.cs
│ │ ├── ReferencesFileExtensions.cs
│ │ └── SupplementaryAnnotationFileExtensions.cs
│ ├── IClient.cs
│ ├── Manifest.cs
│ ├── OutputDirectory.cs
│ ├── RemoteFile.cs
│ └── Utilities/
│ ├── ConsoleEmbellishments.cs
│ ├── DiskSpaceUtilities.cs
│ ├── GenomeAssemblyHelper.cs
│ ├── ParallelUtilities.cs
│ └── SyncUtilities.cs
├── ErrorHandling/
│ ├── AssemblyInfo.cs
│ ├── ErrorCategory.cs
│ ├── ErrorHandling.csproj
│ ├── ExceptionUtilities.cs
│ ├── Exceptions/
│ │ ├── CompressionException.cs
│ │ ├── DeploymentErrorException.cs
│ │ ├── FileNotSortedException.cs
│ │ ├── InvalidFileFormatException.cs
│ │ ├── MissingCompressionLibraryException.cs
│ │ ├── ProcessLockedFileException.cs
│ │ └── UserErrorException.cs
│ ├── ExitCodeUtilities.cs
│ └── ExitCodes.cs
├── GeneAnnotationLambda/
│ ├── GeneAnnotationLambda.cs
│ ├── GeneAnnotationLambda.csproj
│ └── GeneResult.cs
├── Genome/
│ ├── Band.cs
│ ├── Chromosome.cs
│ ├── ChromosomeInterval.cs
│ ├── ContigInfo.cs
│ ├── CytogeneticBands.cs
│ ├── Genome.csproj
│ ├── GenomeAssembly.cs
│ ├── GenomeAssemblyHelper.cs
│ ├── GenomicPosition.cs
│ ├── GenomicRange.cs
│ ├── GenomicRangeChecker.cs
│ ├── IChromosomeInterval.cs
│ ├── ISequence.cs
│ ├── ReferenceNameUtilities.cs
│ └── SequenceUtilities.cs
├── IO/
│ ├── BufferedBinaryReader.cs
│ ├── CacheConstants.cs
│ ├── ExtendedBinaryReader.cs
│ ├── ExtendedBinaryWriter.cs
│ ├── FilePathUtilities.cs
│ ├── FileUtilities.cs
│ ├── HttpUtilities.cs
│ ├── IBufferedBinaryReader.cs
│ ├── IConnect.cs
│ ├── IExtendedBinaryWriter.cs
│ ├── IO.csproj
│ ├── IS3Client.cs
│ ├── ISerializable.cs
│ ├── LengthStream.cs
│ ├── Logger.cs
│ ├── MD5Stream.cs
│ ├── PersistentConnect.cs
│ ├── PersistentStream.cs
│ ├── PersistentStreamUtils.cs
│ ├── SpanBufferBinaryReader.cs
│ ├── UrlUtilities.cs
│ └── v2/
│ ├── FileType.cs
│ └── Header.cs
├── Intervals/
│ ├── Extensions.cs
│ ├── IInterval.cs
│ ├── IIntervalForest.cs
│ ├── IIntervalSearch.cs
│ ├── Interval.cs
│ ├── IntervalArray.cs
│ ├── IntervalForest.cs
│ ├── Intervals.csproj
│ ├── NullIntervalSearch.cs
│ ├── OverlapType.cs
│ └── Utilities.cs
├── Jasix/
│ ├── AssemblyInfo.cs
│ ├── DataStructures/
│ │ ├── JasixChrIndex.cs
│ │ ├── JasixCommons.cs
│ │ ├── JasixIndex.cs
│ │ ├── JasixNode.cs
│ │ ├── JsonSchema.cs
│ │ └── Utilities.cs
│ ├── IndexCreator.cs
│ ├── Jasix.csproj
│ ├── JasixMain.cs
│ ├── OnTheFlyIndexCreator.cs
│ └── QueryProcessor.cs
├── Jist/
│ ├── Jist.csproj
│ ├── JistMain.cs
│ ├── JistUtilities.cs
│ └── JsonStitcher.cs
├── LICENSE
├── MitoHeteroplasmy/
│ ├── MitoHeteroplasmy.csproj
│ ├── MitoHeteroplasmyProvider.cs
│ └── MitoHeteroplasmyReader.cs
├── Nirvana/
│ ├── AnnotationFiles.cs
│ ├── AnnotationResources.cs
│ ├── Nirvana.cs
│ ├── Nirvana.csproj
│ ├── PreLoadUtilities.cs
│ ├── ProviderUtilities.cs
│ └── StreamAnnotation.cs
├── Nirvana.sln
├── Nirvana.sln.DotSettings
├── NirvanaLambda/
│ ├── AnnotationJob.cs
│ ├── AnnotationResultSummary.cs
│ ├── AssemblyInfo.cs
│ ├── NirvanaLambda.cs
│ ├── NirvanaLambda.csproj
│ └── PartitionUtilities.cs
├── OptimizedCore/
│ ├── ExpandableArray.cs
│ ├── NullSequenceEqual.cs
│ ├── OptimizedCore.csproj
│ ├── StringBuilderPool.cs
│ └── StringExtensions.cs
├── Phantom/
│ ├── AssemblyInfo.cs
│ └── Phantom.csproj
├── README.md
├── ReferenceSequence/
│ ├── AssemblyInfo.cs
│ ├── Commands/
│ │ ├── CreateReferenceMain.cs
│ │ ├── CreateSubstringMain.cs
│ │ └── CreateTestSeqMain.cs
│ ├── Common/
│ │ ├── IndexEntry.cs
│ │ ├── MaskedEntry.cs
│ │ └── Sequence.cs
│ ├── Compression/
│ │ └── TwoBitCompressor.cs
│ ├── Creation/
│ │ ├── FastaSequence.cs
│ │ ├── ReferenceBuffer.cs
│ │ ├── ReferenceDictionaryUtils.cs
│ │ └── ReferenceSequence.cs
│ ├── IO/
│ │ ├── AssemblyReader.cs
│ │ ├── CytogeneticBandsReader.cs
│ │ ├── FastaReader.cs
│ │ ├── ReferenceNamesReader.cs
│ │ ├── ReferenceSequenceReader.cs
│ │ └── ReferenceSequenceWriter.cs
│ ├── ReferenceSequence.csproj
│ ├── ReferenceSequenceCommon.cs
│ ├── ReferenceUtilsMain.cs
│ └── Utilities/
│ └── SequenceHelper.cs
├── RepeatExpansions/
│ ├── AssemblyInfo.cs
│ ├── IO/
│ │ └── RepeatExpansionReader.cs
│ ├── IRepeatExpansionProvider.cs
│ ├── Matcher.cs
│ ├── PercentileUtilities.cs
│ ├── RepeatExpansionPhenotype.cs
│ ├── RepeatExpansionProvider.cs
│ ├── RepeatExpansionSupplementaryAnnotation.cs
│ ├── RepeatExpansions.csproj
│ └── Resources/
│ ├── RepeatExpansions.GRCh37.tsv
│ └── RepeatExpansions.GRCh38.tsv
├── SAUtils/
│ ├── AAConservation/
│ │ ├── AaConservationMain.cs
│ │ ├── AaConservationUtilities.cs
│ │ ├── ProteinConservationParser.cs
│ │ └── ProteinConservationWriter.cs
│ ├── AssemblyInfo.cs
│ ├── ClinGen/
│ │ ├── DosageMapRegionItem.cs
│ │ ├── DosageMapRegionParser.cs
│ │ ├── DosageMapRegions.cs
│ │ ├── DosageSensitivity.cs
│ │ ├── DosageSensitivityItem.cs
│ │ ├── DosageSensitivityParser.cs
│ │ ├── GeneDiseaseValidity.cs
│ │ ├── GeneDiseaseValidityItem.cs
│ │ ├── GeneDiseaseValidityParser.cs
│ │ └── ScoreToDescription.cs
│ ├── CosmicGeneFusions/
│ │ ├── Cache/
│ │ │ ├── ReferenceLoader.cs
│ │ │ └── TranscriptCache.cs
│ │ ├── Conversion/
│ │ │ ├── CosmicConverter.cs
│ │ │ ├── CosmicGeneFusion.cs
│ │ │ ├── HgvsRnaFixer.cs
│ │ │ ├── HgvsRnaParser.cs
│ │ │ ├── Histology.cs
│ │ │ ├── RawCosmicGeneFusion.cs
│ │ │ └── Site.cs
│ │ ├── CreateCosmicGeneFusions.cs
│ │ ├── IO/
│ │ │ ├── CosmicGeneFusionParser.cs
│ │ │ └── GeneFusionJsonWriter.cs
│ │ └── Utilities/
│ │ └── CosmicCountUtilities.cs
│ ├── CreateClinvarDb/
│ │ ├── ClinVarMain.cs
│ │ └── ClinVarStats.cs
│ ├── CreateCosmicDb/
│ │ └── Main.cs
│ ├── CreateDbsnpDb/
│ │ └── Main.cs
│ ├── CreateDecipherDb/
│ │ └── Main.cs
│ ├── CreateGlobalAllelesDb/
│ │ └── Main.cs
│ ├── CreateGmeDb/
│ │ └── Main.cs
│ ├── CreateOneKgDb/
│ │ └── Main.cs
│ ├── CreateTopMedDb/
│ │ └── Main.cs
│ ├── Custom/
│ │ ├── AllowedValues.cs
│ │ ├── CaUtilities.cs
│ │ ├── CustomGene.cs
│ │ ├── GeneAnnotationsParser.cs
│ │ ├── GeneMain.cs
│ │ ├── ParserUtilities.cs
│ │ ├── VariantAnnotationsParser.cs
│ │ └── VariantMain.cs
│ ├── Dann/
│ │ └── Create.cs
│ ├── DataStructures/
│ │ ├── AlleleFrequencyItem.cs
│ │ ├── AncestralAlleleItem.cs
│ │ ├── ClinGenItem.cs
│ │ ├── ClinVarItem.cs
│ │ ├── ComputingUtilities.cs
│ │ ├── ConservationItem.cs
│ │ ├── CosmicItem.cs
│ │ ├── CounterDictionary.cs
│ │ ├── CustomInterval.cs
│ │ ├── CustomItem.cs
│ │ ├── DbSnpItem.cs
│ │ ├── DecipherItem.cs
│ │ ├── DgvItem.cs
│ │ ├── GlobalMinorItem.cs
│ │ ├── GmeItem.cs
│ │ ├── GnomadItem.cs
│ │ ├── GnomadSvItem.cs
│ │ ├── KeyCounts.cs
│ │ ├── MinHeap.cs
│ │ ├── OmimItem.cs
│ │ ├── OneKGenItem.cs
│ │ ├── OnekGenSvItem.cs
│ │ ├── RefMinorItem.cs
│ │ ├── SuppDataUtilities.cs
│ │ └── TopMedItem.cs
│ ├── DbSnpRemapper/
│ │ ├── ChromMapper.cs
│ │ ├── DbSnpRemapperMain.cs
│ │ ├── GenomicLocation.cs
│ │ ├── LeftoverMapper.cs
│ │ └── Utilities.cs
│ ├── DegenerateBaseUtilities.cs
│ ├── ExtractCosmicSvs/
│ │ ├── CosmicCnvItem.cs
│ │ ├── CosmicCnvReader.cs
│ │ ├── CosmicSvReader.cs
│ │ └── ExtractCosmicSvsMain.cs
│ ├── ExtractMiniSa/
│ │ ├── ExtractMiniSaMain.cs
│ │ └── MiniSaExtractor.cs
│ ├── ExtractMiniXml/
│ │ ├── ExtractMiniXmlMain.cs
│ │ ├── RcvXmlExtractor.cs
│ │ └── VcvXmlExtractor.cs
│ ├── FusionCatcher/
│ │ ├── CollectionType.cs
│ │ ├── CreateFusionCatcher.cs
│ │ ├── FusionCatcherDataSource.cs
│ │ ├── FusionCatcherOncogenes.cs
│ │ ├── GeneFusionSourceBuilder.cs
│ │ ├── GeneFusionSourceWriter.cs
│ │ └── IndexBuilder.cs
│ ├── GERP/
│ │ └── GerpMain.cs
│ ├── GeneIdentifiers/
│ │ ├── GeneSymbolUpdater.cs
│ │ └── GeneUtilities.cs
│ ├── GenericScore/
│ │ ├── GenericScoreParser/
│ │ │ ├── GenericScoreItem.cs
│ │ │ ├── GenericScoreParser.cs
│ │ │ └── SaItemValidator.cs
│ │ ├── ParserSettings.cs
│ │ ├── ScoreFileWriter.cs
│ │ └── WriterSettings.cs
│ ├── GnomadGeneScores/
│ │ ├── GnomadGeneItem.cs
│ │ ├── GnomadGeneParser.cs
│ │ └── GnomadGenesMain.cs
│ ├── InputFileParsers/
│ │ ├── AncestralAlleleReader.cs
│ │ ├── ClinGen/
│ │ │ └── ClinGenReader.cs
│ │ ├── ClinVar/
│ │ │ ├── ClinVarCommon.cs
│ │ │ ├── ClinVarParser.cs
│ │ │ ├── ClinVarSchema.cs
│ │ │ ├── ClinVarVariationReader.cs
│ │ │ ├── ClinvarVariant.cs
│ │ │ ├── IClinVarSaItem.cs
│ │ │ ├── VariantAligner.cs
│ │ │ ├── VcvItem.cs
│ │ │ └── VcvSaItem.cs
│ │ ├── Cosmic/
│ │ │ └── MergedCosmicReader.cs
│ │ ├── DGV/
│ │ │ └── DgvReader.cs
│ │ ├── DataSourceVersionReader.cs
│ │ ├── DbSnp/
│ │ │ ├── DbSnpReader.cs
│ │ │ └── GlobalMinorReader.cs
│ │ ├── Decipher/
│ │ │ └── DecipherParser.cs
│ │ ├── Gme/
│ │ │ └── GmeParser.cs
│ │ ├── OneKGen/
│ │ │ ├── OneKGenReader.cs
│ │ │ ├── RefMinorReader.cs
│ │ │ └── oneKGenSvReader.cs
│ │ ├── SequenceExtensions.cs
│ │ └── TOPMed/
│ │ └── TopMedReader.cs
│ ├── MakeAaDb/
│ │ └── Main.cs
│ ├── MakeClinGenDb/
│ │ └── Main.cs
│ ├── MitoHeteroplasmy/
│ │ ├── MitoHeteroplasmyDb.cs
│ │ ├── MitoHeteroplasmyParser.cs
│ │ └── StatClasses.cs
│ ├── MitoMap/
│ │ ├── CircularGenomeModel.cs
│ │ ├── MitoMapDatabaseUtilities.cs
│ │ ├── MitoMapInputDb.cs
│ │ ├── MitoMapItem.cs
│ │ ├── MitoMapSvItem.cs
│ │ ├── MitoMapSvReader.cs
│ │ ├── MitoMapVariantReader.cs
│ │ ├── ParsingUtilities.cs
│ │ ├── SmallVarDb.cs
│ │ └── StructVarDb.cs
│ ├── NgaWriter.cs
│ ├── NsaConcatenator/
│ │ ├── ConcatUtilities.cs
│ │ └── NsaConcatenator.cs
│ ├── NsaIndexUpdater/
│ │ └── UpdateIndex.cs
│ ├── NsaWriter.cs
│ ├── Omim/
│ │ ├── Downloader.cs
│ │ ├── EntryApiResponse/
│ │ │ ├── EntryResponse.cs
│ │ │ └── GeneMap.cs
│ │ ├── Main.cs
│ │ ├── OmimParser.cs
│ │ ├── OmimPhenotypeSchema.cs
│ │ ├── OmimQuery.cs
│ │ ├── OmimSchema.cs
│ │ ├── OmimStatistics.cs
│ │ ├── OmimUtilities.cs
│ │ └── OmimVersion.cs
│ ├── OneKGenSvDb/
│ │ ├── Create.cs
│ │ └── VcfToBed.cs
│ ├── ParseUtils/
│ │ ├── SAParseUtilities.cs
│ │ ├── SplitLine.cs
│ │ └── TsvIndices.cs
│ ├── PhyloP/
│ │ ├── Main.cs
│ │ ├── NpdWriter.cs
│ │ └── PhylopParser.cs
│ ├── PrimateAi/
│ │ ├── PrimateAiDb.cs
│ │ ├── PrimateAiItem.cs
│ │ ├── PrimateAiParser.cs
│ │ └── PrimateAiUtilities.cs
│ ├── ProcessSpliceNetTsv/
│ │ ├── PredictionFilter.cs
│ │ └── SpliceNetPredictionFilterMain.cs
│ ├── RefMinorDb/
│ │ ├── Main.cs
│ │ └── RefMinorDbWriter.cs
│ ├── RegionUtilities.cs
│ ├── Revel/
│ │ └── Create.cs
│ ├── SAUtils.cs
│ ├── SAUtils.csproj
│ ├── SaUtilsCommon.cs
│ ├── Schema/
│ │ ├── SaJsonKeyAnnotation.cs
│ │ ├── SaJsonKeyProperties.cs
│ │ ├── SaJsonSchema.cs
│ │ └── SaJsonValueType.cs
│ ├── SpliceAi/
│ │ ├── SpliceAiDb.cs
│ │ ├── SpliceAiItem.cs
│ │ ├── SpliceAiParser.cs
│ │ └── SpliceUtilities.cs
│ ├── gnomAD/
│ │ ├── GnomadSnvMain.cs
│ │ ├── GnomadSnvReader.cs
│ │ ├── GnomadSvBedParser.cs
│ │ ├── GnomadSvMain.cs
│ │ ├── GnomadSvParser.cs
│ │ ├── GnomadSvTsvParser.cs
│ │ ├── GnomadUtilities.cs
│ │ ├── LcrInterval.cs
│ │ ├── LcrRegionParser.cs
│ │ └── LcrRegionsMain.cs
│ └── makeDgvDb/
│ └── Main.cs
├── Sandbox/
│ ├── AminoAcidAligner/
│ │ ├── AlignmentBuilder.cs
│ │ ├── AminoAcidAligner.csproj
│ │ ├── ExonToTranscript.cs
│ │ └── Utilities.cs
│ ├── GenerateMustGenotypeVcf/
│ │ ├── ConfigurationSettings.cs
│ │ ├── GenerateMustGenotypeVcf.csproj
│ │ ├── GenerateMustGenotypeVcfsMain.cs
│ │ └── MustGenotypeExtractor.cs
│ ├── Piano/
│ │ ├── ConfigurationSettings.cs
│ │ ├── Piano.cs
│ │ ├── Piano.csproj
│ │ ├── PianoAnnotatedTranscript.cs
│ │ ├── PianoAnnotationProvider.cs
│ │ ├── PianoAnnotationUtils.cs
│ │ ├── PianoAnnotator.cs
│ │ ├── PianoTranscriptAnnotator.cs
│ │ └── ProviderUtilities.cs
│ ├── Sandbox.sln
│ ├── Sandbox.sln.DotSettings
│ ├── Scripts/
│ │ ├── ConvertCacheMatrix.pl
│ │ ├── StressTestUnitTests.ps1
│ │ ├── UpdateCacheFiles.ps1
│ │ ├── UpdateMiniSaFiles.ps1
│ │ └── updateSA.ps1
│ └── UnitTests/
│ ├── Piano/
│ │ ├── PianoAnnotatedTranscriptTests.cs
│ │ ├── PianoTests.cs
│ │ └── SimpleSequence.cs
│ ├── Resources/
│ │ ├── ConflicitingEntries1000G.vcf
│ │ ├── RefMinorAllele.vcf
│ │ ├── Test1000GFile.vcf
│ │ ├── TestCosmicParser.Coding.vcf
│ │ ├── TestCosmicParser.NonCoding.vcf
│ │ ├── TestCosmicParser.tsv
│ │ ├── TestWigParser.wig
│ │ ├── chr1.npd
│ │ ├── chr1_10918_150000.npd
│ │ ├── mini.WigFix
│ │ ├── missingLastVariantHgmd.vcf
│ │ ├── testClinGenUnifier.txt
│ │ ├── tmpPopInfo.txt
│ │ └── tmpSampleInfo.txt
│ ├── UnitTests.csproj
│ └── Utilities/
│ ├── ResourceUtilities.cs
│ └── Resources.cs
├── SingleAnnotationLambda/
│ ├── CacheConfiguration.cs
│ ├── CacheUtilities.cs
│ ├── ExceptionHandler.cs
│ ├── SingleAnnotationLambda.cs
│ ├── SingleAnnotationLambda.csproj
│ ├── SingleConfigExtensions.cs
│ ├── SingleResult.cs
│ └── SupplementaryAnnotationUtilities.cs
├── Tabix/
│ ├── AssemblyInfo.cs
│ ├── BgzfBlockVcfReader.cs
│ ├── BinUtilities.cs
│ ├── Constants.cs
│ ├── Index.cs
│ ├── Interval.cs
│ ├── Reader.cs
│ ├── ReferenceIndex.cs
│ ├── Search.cs
│ ├── SearchUtilities.cs
│ ├── Tabix.csproj
│ └── VirtualPosition.cs
├── UnitTests/
│ ├── AnnotationLambda/
│ │ ├── AnnotationLambdaTests.cs
│ │ └── S3UtilitiesTests.cs
│ ├── CacheUtils/
│ │ ├── DataDumperImport/
│ │ │ ├── DataStructures/
│ │ │ │ └── Import/
│ │ │ │ └── ImportNodeExtensionsTests.cs
│ │ │ ├── FauxRegex/
│ │ │ │ └── RegexDecisionTreeTests.cs
│ │ │ ├── FileHandling/
│ │ │ │ └── DataDumperReaderTests.cs
│ │ │ └── Import/
│ │ │ ├── ImportRegulatoryFeatureTests.cs
│ │ │ └── ImportTranscriptTests.cs
│ │ ├── Genes/
│ │ │ ├── Combiners/
│ │ │ │ ├── CombinerUtilsTests.cs
│ │ │ │ ├── HgncIdCombinerTests.cs
│ │ │ │ └── PartitionCombinerTests.cs
│ │ │ ├── GeneFlattenerTests.cs
│ │ │ └── Utilities/
│ │ │ └── DictionaryUtilitiesTests.cs
│ │ ├── IO/
│ │ │ └── Caches/
│ │ │ └── TranscriptCacheWriterTests.cs
│ │ ├── TranscriptCache/
│ │ │ └── TranscriptRegionMergerTests.cs
│ │ └── Utilities/
│ │ ├── AccessionUtilitiesTests.cs
│ │ └── RemoteFileTests.cs
│ ├── Cloud/
│ │ ├── ConsistencyTests.cs
│ │ ├── JsonUtilitiesTests.cs
│ │ ├── LambdaUrlHelperTests.cs
│ │ ├── RedactionUtilitiesTests.cs
│ │ ├── S3PathTests.cs
│ │ ├── SaUrlsTests.cs
│ │ └── UploadUtilitiesTests.cs
│ ├── CommandLine/
│ │ ├── Builders/
│ │ │ ├── ConsoleAppBuilderDataTests.cs
│ │ │ ├── ConsoleAppBuilderTests.cs
│ │ │ ├── TopLevelAppBuilderTests.cs
│ │ │ └── ValidationExtensionsTests.cs
│ │ ├── NDesk.Options/
│ │ │ ├── OptionContextTests.cs
│ │ │ ├── OptionSetTests.cs
│ │ │ └── OptionsTests.cs
│ │ ├── Utilities/
│ │ │ ├── BenchmarkTests.cs
│ │ │ └── MemoryUtilitiesTests.cs
│ │ └── VersionProviders/
│ │ └── DefaultVersionProviderTests.cs
│ ├── Compression/
│ │ ├── CompressionAlgorithmTests.cs
│ │ ├── DataStructures/
│ │ │ └── BlockTests.cs
│ │ ├── FileHandling/
│ │ │ ├── BgzipTextWriterTests.cs
│ │ │ ├── BlockGZipStreamTests.cs
│ │ │ ├── BlockHeaderTests.cs
│ │ │ └── BlockStreamTests.cs
│ │ └── Utilities/
│ │ ├── GZipUtilitiesTests.cs
│ │ └── LibraryUtilitiesTests.cs
│ ├── CustomAnnotationLambda/
│ │ └── CustomAnnotationConfigTests.cs
│ ├── Downloader/
│ │ ├── AnnotationRepositoryTests.cs
│ │ ├── ConfigurationTests.cs
│ │ ├── FileExtensions/
│ │ │ ├── CacheFileExtensionsTests.cs
│ │ │ ├── ReferencesFileExtensionTests.cs
│ │ │ └── SupplementaryAnnotationFileExtensionsTests.cs
│ │ ├── GenomeAssemblyHelperTests.cs
│ │ ├── ManifestTests.cs
│ │ └── RemoteFileComparer.cs
│ ├── EndToEndTests.cs
│ ├── ErrorHandling/
│ │ ├── ExceptionUtilitiesTests.cs
│ │ ├── Exceptions/
│ │ │ └── ExceptionsTests.cs
│ │ ├── ExitCodeUtilitiesTests.cs
│ │ └── ExitCodesTests.cs
│ ├── GeneAnnotationLambda/
│ │ ├── GeneAnnotationLambdaTests.cs
│ │ └── GeneConfigTests.cs
│ ├── Genome/
│ │ ├── ChromosomeIntervalTests.cs
│ │ ├── CytogeneticBandTests.cs
│ │ ├── EmptyChromosomeTests.cs
│ │ ├── GenomeAssemblyHelperTests.cs
│ │ ├── ReferenceNameUtilitiesTests.cs
│ │ └── SequenceUtilitiesTests.cs
│ ├── IO/
│ │ ├── BufferedBinaryReaderTests.cs
│ │ ├── ExtendedBinaryReaderTests.cs
│ │ ├── FilePathUtilitiesTests.cs
│ │ ├── FileUtilitiesTests.cs
│ │ ├── HttpUtilitiesTests.cs
│ │ ├── LengthStreamTests.cs
│ │ ├── MD5StreamTests.cs
│ │ ├── PersistentStreamTests.cs
│ │ └── UrlUtilitiesTests.cs
│ ├── Intervals/
│ │ ├── IntervalArrayTests.cs
│ │ ├── IntervalExtensionsTests.cs
│ │ ├── IntervalForestTests.cs
│ │ ├── IntervalOperationsTests.cs
│ │ ├── NullIntervalSearchTests.cs
│ │ └── OverlapTypeTests.cs
│ ├── Jasix/
│ │ ├── IndexTests.cs
│ │ ├── JasixFunctionalityTests.cs
│ │ ├── JasixQueryProcessingTests.cs
│ │ └── OtfIndexCreatorTests.cs
│ ├── Jist/
│ │ └── JiSTtests.cs
│ ├── MitoHeteroplasmy/
│ │ └── MitoHeteroplasmyProviderTests.cs
│ ├── MockedData/
│ │ ├── Genes.cs
│ │ ├── TranscriptRegions.cs
│ │ ├── Transcripts.cs
│ │ └── Translations.cs
│ ├── Nirvana/
│ │ ├── AnnotationFilesTests.cs
│ │ ├── PreLoadUtilitiesTests.cs
│ │ └── ProviderUtilitiesTests.cs
│ ├── NirvanaLambda/
│ │ ├── AnnotationJobTests.cs
│ │ ├── NirvanaConfigTests.cs
│ │ ├── NirvanaLambdaTests.cs
│ │ └── PartitionUtilitiesTests.cs
│ ├── OptimizedCore/
│ │ ├── StringBuilderCacheTests.cs
│ │ └── StringExtensionsTests.cs
│ ├── RepeatExpansions/
│ │ ├── MatcherTests.cs
│ │ ├── PercentileUtilitiesTests.cs
│ │ └── RepeatExpansionProviderTests.cs
│ ├── Resources/
│ │ ├── COSM18152.tsv
│ │ ├── COSM18152.vcf
│ │ ├── COSM983708.tsv
│ │ ├── COSM983708.vcf
│ │ ├── ClinGen_Dosage_Sensitivity_Map_20190507.nga
│ │ ├── ClinVarXmlFiles/
│ │ │ ├── RCV000000101.xml
│ │ │ ├── RCV000000734.xml
│ │ │ ├── RCV000001054.xml
│ │ │ ├── RCV000001373.xml
│ │ │ ├── RCV000001752.xml
│ │ │ ├── RCV000003254.xml
│ │ │ ├── RCV000005426.xml
│ │ │ ├── RCV000007484.xml
│ │ │ ├── RCV000010551.xml
│ │ │ ├── RCV000016673.xml
│ │ │ ├── RCV000017510.xml
│ │ │ ├── RCV000021819.xml
│ │ │ ├── RCV000030349.xml
│ │ │ ├── RCV000032548.xml
│ │ │ ├── RCV000032707.xml
│ │ │ ├── RCV000038438.xml
│ │ │ ├── RCV000050055.xml
│ │ │ ├── RCV000073701.xml
│ │ │ ├── RCV000077146.xml
│ │ │ ├── RCV000080071.xml
│ │ │ ├── RCV000083638.xml
│ │ │ ├── RCV000087262.xml
│ │ │ ├── RCV000112977.xml
│ │ │ ├── RCV000113363.xml
│ │ │ ├── RCV000120902.xml
│ │ │ ├── RCV000124712.xml
│ │ │ ├── RCV000144179.xml
│ │ │ ├── RCV000152657.xml
│ │ │ ├── RCV000153339.xml
│ │ │ ├── RCV000167792.xml
│ │ │ ├── RCV000169296.xml
│ │ │ ├── RCV000170338.xml
│ │ │ ├── RCV000171474.xml
│ │ │ ├── RCV000179026.xml
│ │ │ ├── RCV000194003.xml
│ │ │ ├── RCV000203290.xml
│ │ │ ├── RCV000205418.xml
│ │ │ ├── RCV000207071.xml
│ │ │ ├── RCV000207504.xml
│ │ │ ├── RCV000235027.xml
│ │ │ ├── RCV000267121.xml
│ │ │ ├── RCV000342164.xml
│ │ │ ├── RCV000373191.xml
│ │ │ ├── RCV000401212.xml
│ │ │ ├── RCV000406351.xml
│ │ │ ├── RCV000435546.xml
│ │ │ ├── RCV000485802.xml
│ │ │ ├── RCV000537563.xml
│ │ │ ├── RCV000724338.xml
│ │ │ ├── Two_RCVs.xml
│ │ │ └── VCVs/
│ │ │ ├── TwoRecords.xml
│ │ │ ├── VCV000000081.xml
│ │ │ ├── VCV000137106.xml
│ │ │ ├── VCV000431749.xml
│ │ │ ├── VCV000476472.xml
│ │ │ └── VCV000618791.xml
│ │ ├── Clinvar20150901.json.gz.jsi
│ │ ├── EndToEnd/
│ │ │ └── GRCh37/
│ │ │ ├── chr12_7018490_7086889_Both.bases
│ │ │ ├── chr12_7018490_7086889_Both.polyphen.ndb
│ │ │ ├── chr12_7018490_7086889_Both.sift.ndb
│ │ │ └── chr12_7018490_7086889_Both.transcripts.ndb
│ │ ├── JasixTest.json.gz.jsi
│ │ ├── Mother_chr22.genome.vcf.gz.tbi
│ │ ├── OMIM_20190812.nga
│ │ ├── SA/
│ │ │ ├── CosmicCNV.tsv
│ │ │ └── MockSaFiles/
│ │ │ ├── not_sa.txt
│ │ │ ├── sa1.nsa
│ │ │ ├── sa1.nsa.idx
│ │ │ ├── sa2.nsa
│ │ │ ├── sa2.nsa.idx
│ │ │ ├── sa3.nsi
│ │ │ ├── sa4.nsi
│ │ │ ├── sa5.npd
│ │ │ ├── sa5.npd.idx
│ │ │ ├── sa6.nga
│ │ │ ├── sa7.nga
│ │ │ ├── sa8.rma
│ │ │ └── sa8.rma.idx
│ │ ├── TinyAnnotated.json
│ │ ├── clinvar.dict
│ │ ├── cosm5428243.tsv
│ │ ├── cosm5428243.vcf
│ │ ├── cosmicv72.indels.json.gz.jsi
│ │ ├── custom_gene.nga
│ │ ├── dbSNP.version
│ │ ├── gnomAD_gene_scores_2.1.nga
│ │ ├── manifest.txt
│ │ ├── mini.WigFix
│ │ ├── miniHEXA_minimal.vcf.gz.tbi
│ │ └── testDgvParser.txt
│ ├── SAUtils/
│ │ ├── AnnotationItems/
│ │ │ └── CosmicCnvItemTests.cs
│ │ ├── ClinGen/
│ │ │ └── GeneDiseaseValidityTests.cs
│ │ ├── CosmicGeneFusions/
│ │ │ ├── Cache/
│ │ │ │ └── TranscriptCacheTests.cs
│ │ │ ├── Conversion/
│ │ │ │ ├── CosmicConverterTests.cs
│ │ │ │ ├── HgvsRnaFixerTests.cs
│ │ │ │ ├── HgvsRnaParserTests.cs
│ │ │ │ ├── HistologyTests.cs
│ │ │ │ └── SiteTests.cs
│ │ │ ├── CreateCosmicGeneFusionsTests.cs
│ │ │ └── IO/
│ │ │ ├── CosmicGeneFusionParserTests.cs
│ │ │ └── GeneFusionJsonWriterTests.cs
│ │ ├── CustomAnnotations/
│ │ │ ├── AllowedValuesTests.cs
│ │ │ ├── GeneAnnotationParserTests.cs
│ │ │ ├── ParserUtilitiesTests.cs
│ │ │ └── VariantAnnotationsParserTests.cs
│ │ ├── Dann/
│ │ │ └── DannParserTests.cs
│ │ ├── DataStructures/
│ │ │ └── CounterDictionaryTests.cs
│ │ ├── DbVar/
│ │ │ ├── DosageMapRegionParserTests.cs
│ │ │ └── DosageSensitivityParserTests.cs
│ │ ├── FusionCatcher/
│ │ │ ├── FusionCatcherDataSourceTests.cs
│ │ │ ├── GeneFusionSourceWriterTests.cs
│ │ │ └── IndexBuilderTests.cs
│ │ ├── GERP/
│ │ │ ├── GerpParserTests.cs
│ │ │ └── GerpReaderTests.cs
│ │ ├── GeneAnnotationsTest.cs
│ │ ├── GenericScoreParserTests/
│ │ │ └── GenericScoreParserTests.cs
│ │ ├── InputFileParsers/
│ │ │ ├── AlleleReaderTests.cs
│ │ │ ├── ClinGenTests.cs
│ │ │ ├── ClinVarXmlReaderTests.cs
│ │ │ ├── ClinvarVariationParserTests.cs
│ │ │ ├── CosmicCnvReaderTests.cs
│ │ │ ├── CosmicItemTests.cs
│ │ │ ├── DataSourceVersionTests.cs
│ │ │ ├── DbSnpReaderTests.cs
│ │ │ ├── DecipherReaderTest.cs
│ │ │ ├── DgvReaderTests.cs
│ │ │ ├── DgvTests.cs
│ │ │ ├── GlobalMinorReaderTests.cs
│ │ │ ├── GmeReaderTests.cs
│ │ │ ├── MergedCosmicReaderTests.cs
│ │ │ ├── OneKGenTests.cs
│ │ │ ├── ParserTestUtils.cs
│ │ │ ├── RefMinorTests.cs
│ │ │ └── TopMedReaderTests.cs
│ │ ├── MitoHeteroplasmy/
│ │ │ └── MitoHeteroplasmyTests.cs
│ │ ├── MitoMap/
│ │ │ ├── MitoMapSvReaderTests.cs
│ │ │ ├── MitoMapVariantReaderTests.cs
│ │ │ └── ParsingUtilitiesTests.cs
│ │ ├── NsaWriters/
│ │ │ ├── IntervalWriterReaderTests.cs
│ │ │ ├── NsaUtilitiesTests.cs
│ │ │ └── WriterReaderTests.cs
│ │ ├── Omim/
│ │ │ └── OmimUtilitiesTests.cs
│ │ ├── ParseUtils/
│ │ │ ├── SplitLineTests.cs
│ │ │ └── TsvIndicesTests.cs
│ │ ├── PhylopTests.cs
│ │ ├── PrimateAi/
│ │ │ └── PrimateAiTests.cs
│ │ ├── ProteinConservation/
│ │ │ └── ParserTests.cs
│ │ ├── Revel/
│ │ │ └── RevelParserTests.cs
│ │ ├── SaJsonSchemaTests.cs
│ │ ├── SpliceAi/
│ │ │ └── SpliceAiTests.cs
│ │ └── gnomAD/
│ │ ├── GnomadGeneScoreTests.cs
│ │ ├── GnomadReaderTests.cs
│ │ ├── GnomadSvBedParserTests.cs
│ │ ├── GnomadSvItemTests.cs
│ │ ├── GnomadSvTsvParserTests.cs
│ │ └── LcrParserTests.cs
│ ├── SingleAnnotationLambda/
│ │ ├── SingleConfigTests.cs
│ │ └── SingleVariantTests.cs
│ ├── Tabix/
│ │ ├── BgzfBlockVcfReaderTests.cs
│ │ ├── BinUtilitiesTests.cs
│ │ ├── ReaderTests.cs
│ │ ├── SearchTests.cs
│ │ ├── SearchTestsLocalMother.cs
│ │ ├── SearchTestsRemoteMother.cs
│ │ ├── SearchUtilitiesTests.cs
│ │ └── VirtualPositionTests.cs
│ ├── TestDataStructures/
│ │ └── SimpleSequence.cs
│ ├── TestUtilities/
│ │ ├── AnnotationUtilities.cs
│ │ ├── ByteUtilities.cs
│ │ ├── ChromosomeUtilities.cs
│ │ ├── RandomPath.cs
│ │ ├── ResourceUtilities.cs
│ │ ├── Resources.cs
│ │ └── TestDataGenerator.cs
│ ├── UnitTests.csproj
│ ├── VariantAnnotation/
│ │ ├── Algorithms/
│ │ │ └── SwapTests.cs
│ │ ├── AnnotatedPositions/
│ │ │ ├── AnnotatedPositionTests.cs
│ │ │ ├── AnnotatedVariantTests.cs
│ │ │ ├── ConsequenceTests.cs
│ │ │ ├── HgvsCodingNomenclatureTests.cs
│ │ │ ├── HgvsProteinNomenclatureTests.cs
│ │ │ ├── HgvsUtilitiesTests.cs
│ │ │ ├── HgvscNotationTests.cs
│ │ │ ├── HgvsgNotationTests.cs
│ │ │ ├── HgvspNotationTests.cs
│ │ │ ├── ProteinChangeTests.cs
│ │ │ ├── RegulatoryRegionAnnotatorTests.cs
│ │ │ └── Transcript/
│ │ │ ├── AminoAcidTests.cs
│ │ │ ├── AnnotatedTranscriptTests.cs
│ │ │ ├── CdnaSequenceTests.cs
│ │ │ ├── CodingSequenceTests.cs
│ │ │ ├── CodonsTests.cs
│ │ │ ├── CompactIdTests.cs
│ │ │ ├── FeatureVariantEffectsTests.cs
│ │ │ ├── MappedPositionUtilitiesTests.cs
│ │ │ ├── StringExtensionsTests.cs
│ │ │ ├── TranscriptPositionalEffectTests.cs
│ │ │ ├── TranscriptUtilitiesTests.cs
│ │ │ └── VariantEffectTests.cs
│ │ ├── AnnotatorTests.cs
│ │ ├── Caches/
│ │ │ ├── DataStructures/
│ │ │ │ ├── EncodedTranscriptDataTests.cs
│ │ │ │ ├── GeneTests.cs
│ │ │ │ ├── RegulatoryRegionTests.cs
│ │ │ │ ├── TranscriptRegionExtensionsTests.cs
│ │ │ │ ├── TranscriptRegionTests.cs
│ │ │ │ ├── TranscriptTests.cs
│ │ │ │ └── TranslationTests.cs
│ │ │ ├── TranscriptCacheTests.cs
│ │ │ └── Utilities/
│ │ │ ├── RnaEditUtilitiesTests.cs
│ │ │ └── TranscriptUtilitiesTests.cs
│ │ ├── GeneFusions/
│ │ │ ├── Calling/
│ │ │ │ └── GeneFusionCallerTests.cs
│ │ │ ├── IO/
│ │ │ │ ├── GeneFusionIndexEntryTests.cs
│ │ │ │ └── GeneFusionSourceReaderTests.cs
│ │ │ ├── SA/
│ │ │ │ ├── GeneFusionPairTests.cs
│ │ │ │ ├── GeneFusionSourceCollectionTests.cs
│ │ │ │ └── GeneFusionSourceUtilitiesTests.cs
│ │ │ └── Utilities/
│ │ │ ├── GeneFusionKeyTests.cs
│ │ │ └── IndexEntryExtensionsTests.cs
│ │ ├── IO/
│ │ │ ├── Caches/
│ │ │ │ ├── CacheConstantsTests.cs
│ │ │ │ ├── CacheHeaderTests.cs
│ │ │ │ └── TranscriptCacheReaderTests.cs
│ │ │ ├── JsonObjectTests.cs
│ │ │ ├── JsonWriterTests.cs
│ │ │ └── SampleExtensionsTests.cs
│ │ ├── NSA/
│ │ │ ├── NsaIndexTests.cs
│ │ │ ├── RefMinorIndexTests.cs
│ │ │ ├── SuppAnnotationsOutputTests.cs
│ │ │ └── SuppIntervalUtilitiesTests.cs
│ │ ├── ProviderTests/
│ │ │ ├── GsaProviderTests.cs
│ │ │ ├── LcrProviderTests.cs
│ │ │ └── NsaProviderTests.cs
│ │ ├── ScoreFile/
│ │ │ ├── GenericScoreEncoderTests.cs
│ │ │ ├── GenericScoreEndToEndTests.cs
│ │ │ ├── GenericScoreTests.cs
│ │ │ ├── HeaderTests.cs
│ │ │ ├── ReaderSettingsTests.cs
│ │ │ ├── SaItemValidatorTests.cs
│ │ │ ├── ScoreEncoderTests.cs
│ │ │ ├── ScoreIndexTests.cs
│ │ │ └── ScoreJsonEncoderTests.cs
│ │ ├── Sequence/
│ │ │ ├── CompressedSequenceReaderTests.cs
│ │ │ └── CompressedSequenceTests.cs
│ │ ├── TranscriptAnnotation/
│ │ │ ├── BreakEndUtilitiesTests.cs
│ │ │ ├── FullTranscriptAnnotatorTests.cs
│ │ │ └── TranscriptAnnotationFactoryTests.cs
│ │ └── Utilities/
│ │ ├── DateTests.cs
│ │ ├── FormatUtilitiesTests.cs
│ │ └── GeneComparerTests.cs
│ ├── Variants/
│ │ ├── BiDirectionalTrimmerTests.cs
│ │ ├── SimpleVariantTests.cs
│ │ ├── VariantRotatorTests.cs
│ │ └── VariantTests.cs
│ └── Vcf/
│ ├── Samples/
│ │ ├── BooleanExtensionsTests.cs
│ │ ├── FormatIndicesTests.cs
│ │ ├── Legacy/
│ │ │ └── LegacySampleFieldExtractorTests.cs
│ │ ├── SampleFieldExtractorTests.cs
│ │ ├── SampleParsingExtensionsTests.cs
│ │ ├── SampleTests.cs
│ │ ├── TestUtilities.cs
│ │ └── VariantFrequencyTests.cs
│ ├── StringExtensionsTests.cs
│ ├── VariantCreator/
│ │ ├── CnvCreatorTests.cs
│ │ ├── LegacyVariantIdTests.cs
│ │ ├── ReferenceVariantCreatorTests.cs
│ │ ├── SmallVariantCreatorTests.cs
│ │ ├── VariantFactoryTests.cs
│ │ ├── VariantFactoryTestsWithLegacyVids.cs
│ │ └── VariantIdTests.cs
│ ├── VcfFilterTests.cs
│ ├── VcfInfoParserTests.cs
│ ├── VcfReaderTests.cs
│ └── VcfReaderUtilsTests.cs
├── VariantAnnotation/
│ ├── Algorithms/
│ │ └── Swap.cs
│ ├── AnnotatedPositions/
│ │ ├── AnnotatedPosition.cs
│ │ ├── AnnotatedRegulatoryRegion.cs
│ │ ├── AnnotatedVariant.cs
│ │ ├── Consequence/
│ │ │ └── Consequences.cs
│ │ ├── HgvsCodingNomenclature.cs
│ │ ├── HgvsProteinNomenclature.cs
│ │ ├── HgvsUtilities.cs
│ │ ├── HgvscNotation.cs
│ │ ├── HgvsgNotation.cs
│ │ ├── HgvspNotation.cs
│ │ ├── PositionOffset.cs
│ │ ├── RegulatoryRegionAnnotator.cs
│ │ └── Transcript/
│ │ ├── AminoAcids.cs
│ │ ├── AnnotatedConservationScore.cs
│ │ ├── AnnotatedGeneFusion.cs
│ │ ├── AnnotatedTranscript.cs
│ │ ├── CdnaSequence.cs
│ │ ├── CodingSequence.cs
│ │ ├── Codons.cs
│ │ ├── CompactId.cs
│ │ ├── FeatureVariantEffects.cs
│ │ ├── MappedPosition.cs
│ │ ├── MappedPositionUtilities.cs
│ │ ├── StringExtensions.cs
│ │ ├── TranscriptPositionalEffect.cs
│ │ ├── TranscriptUtilities.cs
│ │ ├── VariantEffect.cs
│ │ └── VariantEffectCache.cs
│ ├── Annotator.cs
│ ├── AssemblyInfo.cs
│ ├── Caches/
│ │ ├── DataStructures/
│ │ │ ├── CodingRegion.cs
│ │ │ ├── EncodedTranscriptData.cs
│ │ │ ├── Gene.cs
│ │ │ ├── IndexEntry.cs
│ │ │ ├── Prediction.cs
│ │ │ ├── RegulatoryRegion.cs
│ │ │ ├── RnaEdit.cs
│ │ │ ├── Transcript.cs
│ │ │ ├── TranscriptRegion.cs
│ │ │ ├── TranscriptRegionExtensions.cs
│ │ │ └── Translation.cs
│ │ ├── PredictionCache.cs
│ │ ├── TranscriptCache.cs
│ │ ├── TranscriptCacheData.cs
│ │ ├── TranscriptIntervalForestExtensions.cs
│ │ └── Utilities/
│ │ ├── ExonUtilities.cs
│ │ ├── GeneForestGenerator.cs
│ │ └── RnaEditUtilities.cs
│ ├── GeneAnnotation/
│ │ └── GeneAnnotationProvider.cs
│ ├── GeneFusions/
│ │ ├── Calling/
│ │ │ ├── BreakEndAdjacency.cs
│ │ │ ├── BreakEndAdjacencyFactory.cs
│ │ │ ├── BreakPoint.cs
│ │ │ ├── BreakPointTranscript.cs
│ │ │ └── GeneFusionCaller.cs
│ │ ├── HGVS/
│ │ │ └── HgvsRnaNomenclature.cs
│ │ ├── IO/
│ │ │ ├── GeneFusionIndexEntry.cs
│ │ │ ├── GeneFusionJsonReader.cs
│ │ │ ├── GeneFusionSourceReader.cs
│ │ │ └── IGeneFusionSaReader.cs
│ │ ├── SA/
│ │ │ ├── GeneFusionPair.cs
│ │ │ ├── GeneFusionSource.cs
│ │ │ ├── GeneFusionSourceCollection.cs
│ │ │ └── GeneFusionSourceUtilities.cs
│ │ └── Utilities/
│ │ ├── GeneFusionKey.cs
│ │ └── IndexEntryExtensions.cs
│ ├── GenericScore/
│ │ ├── ChromosomeBlock.cs
│ │ ├── EncoderType.cs
│ │ ├── GenericScoreEncoder.cs
│ │ ├── IScoreEncoder.cs
│ │ ├── MetaData.cs
│ │ ├── ReaderSettings.cs
│ │ ├── ScoreBlock.cs
│ │ ├── ScoreIndex.cs
│ │ ├── ScoreIndexBlock.cs
│ │ ├── ScoreJsonEncoder.cs
│ │ ├── ScoreReader.cs
│ │ └── ZeroToOneScoreEncoder.cs
│ ├── IO/
│ │ ├── Caches/
│ │ │ ├── CacheHeader.cs
│ │ │ ├── Header.cs
│ │ │ ├── PredictionCacheCustomHeader.cs
│ │ │ ├── PredictionCacheReader.cs
│ │ │ ├── PredictionHeader.cs
│ │ │ ├── TranscriptCacheCustomHeader.cs
│ │ │ └── TranscriptCacheReader.cs
│ │ ├── IntervalExtensions.cs
│ │ ├── JsonCommon.cs
│ │ ├── JsonObject.cs
│ │ ├── JsonWriter.cs
│ │ └── SampleExtensions.cs
│ ├── NSA/
│ │ ├── NgaReader.cs
│ │ ├── NsaBlock.cs
│ │ ├── NsaIndex.cs
│ │ ├── NsaIndexBlock.cs
│ │ ├── NsaReader.cs
│ │ ├── NsiReader.cs
│ │ ├── NsiWriter.cs
│ │ ├── RefMinorDbReader.cs
│ │ ├── RefMinorIndex.cs
│ │ ├── SuppInterval.cs
│ │ ├── SuppIntervalUtilities.cs
│ │ └── SupplementaryAnnotation.cs
│ ├── PerformanceMetrics.cs
│ ├── PhyloP/
│ │ ├── NpdIndex.cs
│ │ └── NpdReader.cs
│ ├── Pools/
│ │ ├── AnnotatedPositionPool.cs
│ │ ├── AnnotatedTranscriptPool.cs
│ │ ├── AnnotatedVariantPool.cs
│ │ └── VariantPool.cs
│ ├── ProteinConservation/
│ │ ├── ProteinConservationCommon.cs
│ │ ├── ProteinConservationItem.cs
│ │ ├── ProteinConservationReader.cs
│ │ └── TranscriptConservationScores.cs
│ ├── Providers/
│ │ ├── ConservationScoreProvider.cs
│ │ ├── DataSourceVersion.cs
│ │ ├── LcrProvider.cs
│ │ ├── NsaProvider.cs
│ │ ├── ProteinConservationProvider.cs
│ │ ├── RefMinorProvider.cs
│ │ ├── ReferenceSequenceProvider.cs
│ │ ├── ScoreProvider.cs
│ │ ├── TranscriptAnnotationProvider.cs
│ │ └── VersionProvider.cs
│ ├── SA/
│ │ ├── CustomAnnotationCategories.cs
│ │ ├── JsonDataType.cs
│ │ └── SaCommon.cs
│ ├── TranscriptAnnotation/
│ │ ├── FlankingTranscriptAnnotator.cs
│ │ ├── FullTranscriptAnnotator.cs
│ │ ├── ReducedTranscriptAnnotator.cs
│ │ ├── RohTranscriptAnnotator.cs
│ │ ├── SequenceChange.cs
│ │ └── TranscriptAnnotationFactory.cs
│ ├── Utilities/
│ │ ├── BaseFormatting.cs
│ │ ├── Date.cs
│ │ ├── FormatUtilities.cs
│ │ └── GeneComparer.cs
│ └── VariantAnnotation.csproj
├── VariantAnnotation.Interface/
│ ├── AnnotatedPositions/
│ │ ├── BioType.cs
│ │ ├── ConsequenceTag.cs
│ │ ├── IAnnotatedGeneFusion.cs
│ │ ├── IAnnotatedPosition.cs
│ │ ├── IAnnotatedRegulatoryRegion.cs
│ │ ├── IAnnotatedTranscript.cs
│ │ ├── IAnnotatedVariant.cs
│ │ ├── ICodingRegion.cs
│ │ ├── ICompactId.cs
│ │ ├── IFeatureVariantEffects.cs
│ │ ├── IGene.cs
│ │ ├── IGeneFusion.cs
│ │ ├── IGeneFusionPair.cs
│ │ ├── IMappedPosition.cs
│ │ ├── IRegulatoryRegion.cs
│ │ ├── IRnaEdit.cs
│ │ ├── ITranscript.cs
│ │ ├── ITranscriptRegion.cs
│ │ ├── ITranslation.cs
│ │ ├── IVariantEffect.cs
│ │ └── PredictionScore.cs
│ ├── Caches/
│ │ ├── IPredictionCache.cs
│ │ ├── ITranscriptCache.cs
│ │ └── RegulatoryRegionType.cs
│ ├── Constants.cs
│ ├── GeneAnnotation/
│ │ └── IGeneAnnotationProvider.cs
│ ├── IAnnotationResources.cs
│ ├── IAnnotator.cs
│ ├── IO/
│ │ ├── IJsonSerializer.cs
│ │ ├── IJsonWriter.cs
│ │ ├── IVcfReader.cs
│ │ └── VcfCommon.cs
│ ├── IVariantIdCreator.cs
│ ├── Positions/
│ │ ├── ICustomFields.cs
│ │ ├── IInfoData.cs
│ │ ├── IPosition.cs
│ │ ├── ISample.cs
│ │ └── ISimplePosition.cs
│ ├── Providers/
│ │ ├── IAnnotationProvider.cs
│ │ ├── IDataSourceVersion.cs
│ │ ├── IMitoHeteroplasmyProvider.cs
│ │ ├── IProvider.cs
│ │ ├── IRefMinorProvider.cs
│ │ ├── ISequenceProvider.cs
│ │ └── ITranscriptAnnotationProvider.cs
│ ├── SA/
│ │ ├── INsaReader.cs
│ │ ├── INsiReader.cs
│ │ ├── ISaMetadata.cs
│ │ ├── ISupplementaryAnnotation.cs
│ │ ├── ISupplementaryDataItem.cs
│ │ ├── ISupplementaryInterval.cs
│ │ ├── IsuppGeneItem.cs
│ │ └── IsuppIntervalItem.cs
│ ├── VariantAnnotation.Interface.csproj
│ └── VariantCategory.cs
├── Variants/
│ ├── AnnotationBehavior.cs
│ ├── BiDirectionalTrimmer.cs
│ ├── ISimpleVariant.cs
│ ├── IVariant.cs
│ ├── RepeatExpansion.cs
│ ├── SimpleVariant.cs
│ ├── Variant.cs
│ ├── VariantRotator.cs
│ ├── VariantType.cs
│ ├── VariantUtils.cs
│ └── Variants.csproj
└── Vcf/
├── AssemblyInfo.cs
├── IVcfFilter.cs
├── Info/
│ ├── CustomFields.cs
│ ├── InfoData.cs
│ └── VcfInfoParser.cs
├── NullVcfFilter.cs
├── Position.cs
├── PositionPool.cs
├── Sample/
│ ├── BooleanExtensions.cs
│ ├── FormatIndices.cs
│ ├── Legacy/
│ │ ├── AlleleDepths.cs
│ │ ├── FailedFilter.cs
│ │ ├── Genotype.cs
│ │ ├── GenotypeQuality.cs
│ │ ├── IntermediateSampleFields.cs
│ │ ├── LegacySampleFieldExtractor.cs
│ │ ├── LegacyVariantFrequency.cs
│ │ ├── ReadCounts.cs
│ │ └── TotalDepth.cs
│ ├── Sample.cs
│ ├── SampleFieldExtractor.cs
│ ├── SampleParsingExtensions.cs
│ └── VariantFrequency.cs
├── SimplePosition.cs
├── StringExtensions.cs
├── VariantCreator/
│ ├── CnvCreator.cs
│ ├── LegacyVariantId.cs
│ ├── ReferenceVariantCreator.cs
│ ├── RepeatExpansionCreator.cs
│ ├── RohVariantCreator.cs
│ ├── SmallVariantCreator.cs
│ ├── StructuralVariantCreator.cs
│ ├── VariantFactory.cs
│ └── VariantId.cs
├── Vcf.csproj
├── VcfFilter.cs
└── VcfReader.cs
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
*.dat binary
================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates
aws-lambda*.json
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
# Visual Studio 2015 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# DNX
project.lock.json
project.fragment.lock.json
artifacts/
*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# TODO: Comment the next line if you want to checkin your web deploy settings
# but database connection strings (with potential passwords) will be unencrypted
#*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/packages/*
# except build/, which is used as an MSBuild target.
!**/packages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/packages/repositories.config
# NuGet v3's project.json files produces more ignoreable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
node_modules/
orleans.codegen.cs
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SQL Server files
*.mdf
*.ldf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# JetBrains Rider
.idea/
*.sln.iml
# CodeRush
.cr/
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
================================================
FILE: AnnotationLambda/AnnotationLambda.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Security.Cryptography;
using System.Text;
using Amazon.Lambda.Core;
using Cloud;
using Cloud.Messages.Annotation;
using Cloud.Notifications;
using Cloud.Utilities;
using CommandLine.Utilities;
using Compression.FileHandling;
using ErrorHandling;
using Genome;
using IO;
using Nirvana;
using Vcf;
using Tabix;
using VariantAnnotation;
using VariantAnnotation.SA;
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
namespace AnnotationLambda
{
// ReSharper disable once UnusedMember.Global
// ReSharper disable once ClassNeverInstantiated.Global
public sealed class AnnotationLambda
{
// ReSharper disable once UnusedMember.Global
public AnnotationResult Run(AnnotationConfig config, ILambdaContext context)
{
var result = new AnnotationResult { id = config.id };
string snsTopicArn = null;
var runLog = new StringBuilder();
try
{
LogUtilities.UpdateLogger(context.Logger, runLog);
LogUtilities.LogLambdaInfo(context, CommandLineUtilities.InformationalVersion);
LogUtilities.LogObject("Config", config);
LogUtilities.Log(new[] { LambdaUrlHelper.UrlBaseEnvironmentVariableName, LambdaUtilities.SnsTopicKey });
LambdaUtilities.GarbageCollect();
LambdaUtilities.DeleteTempOutput();
snsTopicArn = LambdaUtilities.GetEnvironmentVariable(LambdaUtilities.SnsTopicKey);
string vcfUrl = config.vcfUrl;
int variantCount = 0;
using (var annotationResources = GetAnnotationResources(config))
{
if (annotationResources.InputStartVirtualPosition == -1) return GetSuccessOutput(result);
long fileOffset = VirtualPosition.From(annotationResources.InputStartVirtualPosition).FileOffset;
using (var preloadVcfStream = PersistentStreamUtils.GetReadStream(vcfUrl, fileOffset))
{
var annotationRange = config.annotationRange?.ToGenomicRange(annotationResources.SequenceProvider.RefNameToChromosome);
annotationResources.GetVariantPositions(new BlockGZipStream(preloadVcfStream, CompressionMode.Decompress), annotationRange);
}
Logger.WriteLine("Scan for positions to preload complete.");
using (var aes = new AesCryptoServiceProvider())
{
FileMetadata jsonMetadata, jasixMetadata;
string jsonPath = Path.GetTempPath() + LambdaUrlHelper.JsonSuffix;
string jasixPath = jsonPath + LambdaUrlHelper.JsonIndexSuffix;
using (var inputVcfStream = new BlockGZipStream(PersistentStreamUtils.GetReadStream(vcfUrl, fileOffset), CompressionMode.Decompress))
using (var headerStream = config.annotationRange == null ? null : new BlockGZipStream(PersistentStreamUtils.GetReadStream(vcfUrl), CompressionMode.Decompress))
//
using (var jsonFileStream = FileUtilities.GetCreateStream(jsonPath))
using (var jsonCryptoStream = new CryptoStream(jsonFileStream, aes.CreateEncryptor(), CryptoStreamMode.Write))
using (var jsonMd5Stream = new MD5Stream(jsonCryptoStream))
//
using (var jasixFileStream = FileUtilities.GetCreateStream(jasixPath))
using (var jasixCryptoStream = new CryptoStream(jasixFileStream, aes.CreateEncryptor(), CryptoStreamMode.Write))
using (var jasixMd5Stream = new MD5Stream(jasixCryptoStream))
{
IVcfFilter vcfFilter = config.annotationRange == null
? new NullVcfFilter()
: new VcfFilter(config.annotationRange.ToGenomicRange(annotationResources.SequenceProvider.RefNameToChromosome));
using (var jsonCompressStream = new BlockGZipStream(jsonMd5Stream, CompressionMode.Compress))
{
variantCount = StreamAnnotation.Annotate(headerStream, inputVcfStream, jsonCompressStream,
jasixMd5Stream, annotationResources, vcfFilter, true, false,
config.desiredVcfInfo == null? null: new HashSet<string>(config.desiredVcfInfo),
config.desiredVcfSampleInfo == null? null: new HashSet<string>(config.desiredVcfSampleInfo)).variantCount;
}
Logger.WriteLine("Annotation done.");
jsonMetadata = jsonMd5Stream.GetFileMetadata();
jasixMetadata = jasixMd5Stream.GetFileMetadata();
}
result.filePath = S3Utilities.GetKey(config.outputDir.path, config.outputPrefix + LambdaUrlHelper.JsonSuffix);
string jasixKey = result.filePath + LambdaUrlHelper.JsonIndexSuffix;
var s3Client = config.outputDir.GetS3Client(context.RemainingTime);
s3Client.DecryptUpload(config.outputDir.bucketName, jasixKey, jasixPath, aes, jasixMetadata);
s3Client.DecryptUpload(config.outputDir.bucketName, result.filePath, jsonPath, aes, jsonMetadata);
Logger.WriteLine("Nirvana result files uploaded.");
}
}
LambdaUtilities.DeleteTempOutput();
if (string.IsNullOrEmpty(result.filePath)) throw new FileNotFoundException();
result.variantCount = variantCount;
return GetSuccessOutput(result);
}
catch (Exception exception)
{
LambdaUtilities.DeleteTempOutput();
return HandleException(runLog, result, exception, snsTopicArn);
}
}
private static AnnotationResult GetSuccessOutput(AnnotationResult result)
{
result.status = LambdaUtilities.SuccessMessage;
LogUtilities.LogObject("Result", result);
return result;
}
private static AnnotationResult HandleException(StringBuilder runLog, AnnotationResult result, Exception e, string snsTopicArn)
{
Logger.Log(e);
result.status = e.Message;
result.errorCategory = ExceptionUtilities.ExceptionToErrorCategory(e);
Logger.WriteLine($"Error Category: {result.errorCategory}");
if (result.errorCategory != ErrorCategory.UserError)
{
string snsMessage = SNS.CreateMessage(runLog.ToString(), result.status, e.StackTrace);
SNS.SendMessage(snsTopicArn, snsMessage);
}
LogUtilities.LogObject("Result", result);
return result;
}
internal static long GetTabixVirtualPosition(AnnotationRange annotationRange, Stream stream, Dictionary<string, Chromosome> refNameToChromosome)
{
// process the entire file if no range specified
if (annotationRange == null) return 0;
var tabixIndex = Reader.GetTabixIndex(stream, refNameToChromosome);
return tabixIndex.GetOffset(annotationRange.Start.Chromosome, annotationRange.Start.Position);
}
private static AnnotationResources GetAnnotationResources(AnnotationConfig annotationConfig)
{
var genomeAssembly = GenomeAssemblyHelper.Convert(annotationConfig.genomeAssembly);
string cachePathPrefix = LambdaUrlHelper.GetCacheFolder().UrlCombine(genomeAssembly.ToString()).UrlCombine(LambdaUrlHelper.DefaultCacheSource);
string nirvanaS3Ref = LambdaUrlHelper.GetRefUrl(genomeAssembly);
// SaVersion will be provided as an environment variable. Defaults to "latest"
string saVersion = Environment.GetEnvironmentVariable("SaVersion");
string saManifestUrl = LambdaUtilities.GetManifestUrl(string.IsNullOrEmpty(saVersion)? "latest": saVersion, genomeAssembly, SaCommon.SchemaVersion);
var metrics = new PerformanceMetrics();
var annotationResources = new AnnotationResources(nirvanaS3Ref, cachePathPrefix,
saManifestUrl == null? null: new List<string> {saManifestUrl},
annotationConfig.customAnnotations,
annotationConfig.customStrUrl,
false,
false,
metrics);
using (var tabixStream = PersistentStreamUtils.GetReadStream(annotationConfig.tabixUrl))
{
annotationResources.InputStartVirtualPosition = GetTabixVirtualPosition(annotationConfig.annotationRange, tabixStream, annotationResources.SequenceProvider.RefNameToChromosome);
}
Logger.WriteLine($"Tabix position :{annotationResources.InputStartVirtualPosition}");
return annotationResources;
}
}
}
================================================
FILE: AnnotationLambda/AnnotationLambda.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net6.0</TargetFramework>
<GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
<AWSProjectType>Lambda</AWSProjectType>
<OutputPath>bin\$(Configuration)</OutputPath>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Amazon.Lambda.Core" Version="2.1.0" />
<PackageReference Include="Amazon.Lambda.Serialization.Json" Version="2.0.0" />
<PackageReference Include="AWSSDK.Lambda" Version="3.7.9.3" />
<PackageReference Include="AWSSDK.S3" Version="3.7.8.3" />
<PackageReference Include="AWSSDK.SimpleNotificationService" Version="3.7.3.31" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Cloud\Cloud.csproj" />
<ProjectReference Include="..\Compression\Compression.csproj" />
<ProjectReference Include="..\ErrorHandling\ErrorHandling.csproj" />
<ProjectReference Include="..\Genome\Genome.csproj" />
<ProjectReference Include="..\Nirvana\Nirvana.csproj" />
<ProjectReference Include="..\Tabix\Tabix.csproj" />
<ProjectReference Include="..\Vcf\Vcf.csproj" />
</ItemGroup>
<Import Project="..\CommonAssemblyInfo.props" />
</Project>
================================================
FILE: AnnotationLambda/AssemblyInfo.cs
================================================
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("UnitTests")]
================================================
FILE: AnnotationLambda/S3Utilities.cs
================================================
namespace AnnotationLambda
{
public static class S3Utilities
{
public static string GetKey(string outputDir, string filename)
{
outputDir = outputDir?.Trim('/');
if (string.IsNullOrEmpty(outputDir)) return filename;
return outputDir + '/' + filename;
}
}
}
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at mstromberg@illumina.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/
================================================
FILE: CONTRIBUTING.md
================================================
This guide provides:
* protocols for contributing new features or bug fixes
* high-level information about our development process
Information is added as pertinent questions/discussions come up in the contributor community,
so this guide is not intended to provide complete coverage of the above topics.
# Table of Contents
* [Scrum (agile development) ](#scrum-agile-development)
* [Developer environment](#developer-environment)
* [Coding conventions](#coding-conventions)
* [Branching model](#branching-model)
* [Unit testing](#unit-testing)
* [Continuous integration](#continuous-integration)
* [Portability](#portability)
# Scrum (agile development)
The development team uses Scrum agile development methodology. Our sprints are two weeks long and consistent of the four key ceremonies:
* sprint planning
* daily stand-ups
* sprint retrospective
* sprint review
For external developers interested in contributing to the project, we would be happy to invite you to these ceremonies. Please contact any of the team members and we'll make the necessary arrangements.
# Developer environment
## IDE
The development team is using Microsoft Visual Studio 2015 to develop Nirvana. Developers could in theory choose to use other C# IDEs such as [MonoDevelop](http://www.monodevelop.com/), [SharpDevelop](https://sourceforge.net/projects/sharpdevelop/), or [Project Rider](https://www.jetbrains.com/rider/). However, we have not evaluated those IDEs at the moment.
## Extensions
<p align="center">
<img src="https://www.jetbrains.com/resharper/img/screenshots/code-analysis.png" width="600" />
</p>
JetBrains makes an incredible Visual Studio extension called [ReSharper](https://www.jetbrains.com/resharper/). No other tool comes as close to helping developers produce clean C# code while offering powerful functionality to make refactoring a breeze. For our internal development team, we require the use of ReSharper.
# Coding conventions
We use the same coding conventions (naming, layout, and commenting conventions) as is used in Microsoft's [C# Coding Conventions Guide](https://msdn.microsoft.com/en-us/library/ff926074.aspx). The only exception to this is the variable naming scheme that ReSharper suggests (i.e. private class variables should begin with an underscore).
Here's a small example class that demonstrates most of these conventions:
```C#
using System;
using System.Collections.Generic;
namespace Demo
{
public class Fibonacci
{
#region members
private readonly List<int> _fibonacciSeries;
public readonly string Description;
#endregion
/// <summary>
/// constructor
/// </summary>
public Fibonacci(string description, int numValues)
{
Description = description;
_fibonacciSeries = new List<int>(numValues);
Calculate(numValues);
}
/// <summary>
/// iteratively calculates the first n values of the Fibonacci series
/// </summary>
private void Calculate(int numValues)
{
int a = 1, b = 1;
_fibonacciSeries.Add(a);
_fibonacciSeries.Add(b);
for (int i = 2; i < numValues; i++)
{
int sum = a + b;
_fibonacciSeries.Add(sum);
a = b;
b = sum;
}
}
/// <summary>
/// displays all the calculated values of our fibonacci series
/// </summary>
public void Display()
{
Console.WriteLine($"{Description}:");
foreach(var value in _fibonacciSeries) Console.Write($"{value} ");
Console.WriteLine();
}
/// <summary>
/// displays the nth calculated value of our fibonacci series
/// </summary>
public void Display(int index)
{
if ((index < 1) || (index > _fibonacciSeries.Count))
{
throw new ArgumentOutOfRangeException(nameof(index));
}
Console.WriteLine($"{Description}: {_fibonacciSeries[index - 1]}");
}
}
}
```
# Branching model
<img src="https://github.com/Illumina/Nirvana/wiki/images/GitFlow.png" width="400" align="right" />
The development team uses [GitFlow](http://nvie.com/posts/a-successful-git-branching-model/) to organize all of our branches.
## Feature branches
In essence, all of our day-to-day work is on the **develop branch**. When work begins on a new **story** or **bug fix**, we will create a feature branch from the develop branch. When work on the feature branch has been completed, a **pull request is required** before it can be merged back to the develop branch.
When the feature has finished development, we typically go through the following steps:
1. pull the latest develop branch
1. merge the develop branch to the feature branch
1. ensure that all unit tests pass
1. ensure that all regression and integration tests pass (internal developers only)
1. create a pull request
1. once approved, merge the feature branch to the develop branch
Internal developers will also check the status of the Jenkins integration and regression tests before merging a feature branch back.
### Naming
Our feature branch names obey the following convention:
```
features/short_description_1234
bugfixes/short_description_1234
```
All feature branches are prefixed by either **features/** or **bugfixes/**. This naming scheme is exploited by our continuous integration framework. The number 1234 is used as a convenience to hold our JIRA ID (external developers are not required to add a numerical identifier).
## Builds and releases
When we're ready to issue a new build, the develop branch is merged to the **master branch** and an **annotated tag** is added to the master branch.
```
git tag -a v1.4.3 -m "Nirvana 1.4.3"
git push origin v1.4.3
```
## Release and hotfix branches
Our team typically creates releases and hotfix branches for internal projects. As such, they will only be visible on our internal GitHub Enterprise server.
# Unit testing
<img src="https://github.com/Illumina/Nirvana/wiki/images/UnitTesting.png" width="400" align="right" />
Our team strives to have high unit test code coverage of all Nirvana code. Currently, the code coverage of the Illumina.VariantAnnotation library is around **82%** and we aspire to increase that to 90% or greater within the next few months.
We prefer using a [TDD methodology](https://en.wikipedia.org/wiki/Test-driven_development), but we are not forcing developers to use it at this time. TDD has had a measured effect on improving our code quality.
Any time our continuous integration pipeline shows an annotation that deviates from the baseline, we create a unit test to demonstrate the correct behavior and to ensure that future regressions do not occur.
<br clear=all>
# Continuous integration
At Illumina, we have developed an extensive testing framework on top of the [Jenkins continuous integration framework](https://jenkins.io/). During our daily stand-ups, we check the status of every field in every variant for a few dozen data sets against the baseline. This translates to 100's of millions of variants (or billions of annotation fields) being checked on a daily basis.
Unfortunately, our Jenkins servers sits behind our corporate firewall at the moment; but here's a snapshot of the information provided by our CI framework. We run a full set of smoke tests on every git commit on the develop branch. Developers can trigger both smoke and regression tests on any of the branches:
<table>
<tr>
<td valign="top"><a href="https://github.com/Illumina/Nirvana/wiki/images/CI_AllCurrentBranches.png"><img src="https://github.com/Illumina/Nirvana/wiki/images/CI_AllCurrentBranches.png" /></a></td>
<td valign="top"><a href="https://github.com/Illumina/Nirvana/wiki/images/SmokeTests.png"><img src="https://github.com/Illumina/Nirvana/wiki/images/SmokeTests.png" /></a></td>
</tr>
</table>
For each smoke or regression test, our testing framework provides a wealth of information for each input VCF file:
<table>
<tr>
<td valign="top"><a href="https://github.com/Illumina/Nirvana/wiki/images/NA12877_GlobalAccuracy.png"><img src="https://github.com/Illumina/Nirvana/wiki/images/NA12877_GlobalAccuracy.png" height="500" /></a></td>
<td valign="top"><a href="https://github.com/Illumina/Nirvana/wiki/images/NA12877_GlobalStatistics.png"><img src="https://github.com/Illumina/Nirvana/wiki/images/NA12877_GlobalStatistics.png" height="500" /></a></td>
</tr>
</table>
In some cases, deviations from our baseline are found. When this happens, we add it as a bug in our JIRA project and prioritize it accordingly in our backlog until it's ready to committed for a sprint:
<p align="center"><a href="https://github.com/Illumina/Nirvana/wiki/images/NA12877_TranscriptDeviations.png"><img src="https://github.com/Illumina/Nirvana/wiki/images/NA12877_TranscriptDeviations.png" /></a></p>
# Portability
While development is mainly performed in a Windows environment, Nirvana is expected to run on multiple platforms (Windows and Linux) reliably. We test Nirvana on a daily basis on both platforms.
================================================
FILE: CacheUtils/AssemblyInfo.cs
================================================
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("UnitTests")]
================================================
FILE: CacheUtils/BuildCache.sh
================================================
#!/bin/sh
# =============
# configuration
# =============
DOTNET=dotnet
RELEASE_DIR=/d/Projects/NirvanaCacheUtils/bin/Release/netcoreapp2.0
CACHE_UTILS=$RELEASE_DIR/CacheUtils.dll
VEP_VERSION=90
CACHE_VERSION=25
DATA_ROOT=/e/Data/Nirvana
INTERMEDIATE_CACHE_DIR=$DATA_ROOT/IntermediateCache/$VEP_VERSION
CACHE_DIR=$DATA_ROOT/Cache/$CACHE_VERSION
REFERENCE_DIR=$DATA_ROOT/References/5
ENSEMBL37_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/Ensembl${VEP_VERSION}_GRCh37.transcripts.gz
ENSEMBL38_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/Ensembl${VEP_VERSION}_GRCh38.transcripts.gz
REFSEQ37_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/RefSeq${VEP_VERSION}_GRCh37.transcripts.gz
REFSEQ38_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/RefSeq${VEP_VERSION}_GRCh38.transcripts.gz
ENSEMBL37_CACHE_PATH=$CACHE_DIR/GRCh37/Ensembl${VEP_VERSION}.transcripts.ndb
ENSEMBL38_CACHE_PATH=$CACHE_DIR/GRCh38/Ensembl${VEP_VERSION}.transcripts.ndb
REFSEQ37_CACHE_PATH=$CACHE_DIR/GRCh37/RefSeq${VEP_VERSION}.transcripts.ndb
REFSEQ38_CACHE_PATH=$CACHE_DIR/GRCh38/RefSeq${VEP_VERSION}.transcripts.ndb
ENSEMBL38_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/Ensembl${VEP_VERSION}_GRCh38.transcripts.gz
REFSEQ37_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/RefSeq${VEP_VERSION}_GRCh37.transcripts.gz
REFSEQ38_TRANSCRIPT_PATH=$INTERMEDIATE_CACHE_DIR/RefSeq${VEP_VERSION}_GRCh38.transcripts.gz
ENSEMBL37_URL="ftp://ftp.ensembl.org/pub/release-${VEP_VERSION}/variation/VEP/homo_sapiens_vep_${VEP_VERSION}_GRCh37.tar.gz"
ENSEMBL38_URL="ftp://ftp.ensembl.org/pub/release-${VEP_VERSION}/variation/VEP/homo_sapiens_vep_${VEP_VERSION}_GRCh38.tar.gz"
REFSEQ37_URL="ftp://ftp.ensembl.org/pub/release-${VEP_VERSION}/variation/VEP/homo_sapiens_refseq_vep_${VEP_VERSION}_GRCh37.tar.gz"
REFSEQ38_URL="ftp://ftp.ensembl.org/pub/release-${VEP_VERSION}/variation/VEP/homo_sapiens_refseq_vep_${VEP_VERSION}_GRCh38.tar.gz"
# =========
# functions
# =========
CreateCache() {
GA=$1
TS=$2
$DOTNET $CACHE_UTILS create -i $INTERMEDIATE_CACHE_DIR/${TS}${VEP_VERSION}_${GA} -r $REFERENCE_DIR/Homo_sapiens.${GA}.Nirvana.dat -o $CACHE_DIR/${GA}/${TS}${VEP_VERSION}
if [ ! $? -eq 0 ]; then
echo "ERROR: Unable to generate the cache successfully (Genome assembly: ${GA}, transcript source: ${TS})"
exit 1
fi
}
export -f CreateCache
# =============
# main workflow
# =============
# download all the required files for building the cache
$DOTNET $CACHE_UTILS download
# create the intermediate cache files for each configuration
# if [ ! -f ENSEMBL37_TRANSCRIPT_PATH ]
# then
# echo "Not implemented yet."
# exit 1
# fi
# if [ ! -f ENSEMBL38_TRANSCRIPT_PATH ]
# then
# echo "Not implemented yet."
# exit 1
# fi
# if [ ! -f REFSEQ37_TRANSCRIPT_PATH ]
# then
# echo "Not implemented yet."
# exit 1
# fi
# if [ ! -f REFSEQ38_TRANSCRIPT_PATH ]
# then
# echo "Not implemented yet."
# exit 1
# fi
# create the universal gene archive
$DOTNET $CACHE_UTILS gene -r $REFERENCE_DIR -i $INTERMEDIATE_CACHE_DIR
# create the actual cache files
CACHE_LIST=""
if [ ! -f ENSEMBL37_CACHE_PATH ]
then
CACHE_LIST="$CACHE_LIST GRCh37 Ensembl"
fi
if [ ! -f ENSEMBL38_CACHE_PATH ]
then
CACHE_LIST="$CACHE_LIST GRCh38 Ensembl"
fi
if [ ! -f REFSEQ37_CACHE_PATH ]
then
CACHE_LIST="$CACHE_LIST GRCh37 RefSeq"
fi
if [ ! -f REFSEQ38_CACHE_PATH ]
then
CACHE_LIST="$CACHE_LIST GRCh38 RefSeq"
fi
if [ ! -z "$CACHE_LIST" ]
then
echo "- creating cache files in parallel... "
echo $CACHE_LIST | xargs -n 2 -P 8 bash -c 'CreateCache "$@"' --
echo "finished."
fi
================================================
FILE: CacheUtils/CacheUtils.cs
================================================
using System.Collections.Generic;
using CacheUtils.Commands.CombineCacheDirectories;
using CacheUtils.Commands.CreateCache;
using CacheUtils.Commands.Download;
using CacheUtils.Commands.ExtractTranscripts;
using CacheUtils.Commands.GFF;
using CacheUtils.Commands.Header;
using CacheUtils.Commands.ParseVepCacheDirectory;
using CacheUtils.Commands.RegulatoryGFF;
using CacheUtils.Commands.UniversalGeneArchive;
using CommandLine.Builders;
using VariantAnnotation.Interface;
namespace CacheUtils
{
internal static class CacheUtilsMain
{
private static int Main(string[] args)
{
var ops = new Dictionary<string, TopLevelOption>
{
["combine"] = new TopLevelOption("combine cache directories", CombineCacheDirectoriesMain.Run),
["create"] = new TopLevelOption("create Nirvana cache files", CreateNirvanaDatabaseMain.Run),
["download"] = new TopLevelOption("downloads required files", DownloadMain.Run),
["extract"] = new TopLevelOption("extracts transcripts", ExtractTranscriptsMain.Run),
["gene"] = new TopLevelOption("updates the universal gene archive", UniversalGeneArchiveMain.Run),
["gff"] = new TopLevelOption("export transcripts to GFF", CreateGffMain.Run),
["header"] = new TopLevelOption("displays the header information", HeaderMain.Run),
["parse"] = new TopLevelOption("parses the VEP cache files", ParseVepCacheDirectoryMain.Run),
["rgff"] = new TopLevelOption("export regulatory regions to GFF", CreateRegulatoryGffMain.Run)
};
var exitCode = new TopLevelAppBuilder(args, ops)
.Parse()
.ShowBanner(Constants.Authors)
.ShowHelpMenu("Utilities focused on querying the cache directory")
.ShowErrors()
.Execute();
return (int)exitCode;
}
}
}
================================================
FILE: CacheUtils/CacheUtils.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<OutputPath>..\bin\$(Configuration)</OutputPath>
</PropertyGroup>
<Import Project="..\CommonAssemblyInfo.props" />
<ItemGroup>
<Content Include="CacheUtils.dll.gene.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="6.0.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\CommandLine\CommandLine.csproj" />
<ProjectReference Include="..\Compression\Compression.csproj" />
<ProjectReference Include="..\ReferenceSequence\ReferenceSequence.csproj" />
<ProjectReference Include="..\VariantAnnotation.Interface\VariantAnnotation.Interface.csproj" />
<ProjectReference Include="..\VariantAnnotation\VariantAnnotation.csproj" />
</ItemGroup>
</Project>
================================================
FILE: CacheUtils/CacheUtils.dll.gene.json
================================================
{
"GRCh37":{
"ReferencePath":"Homo_sapiens.GRCh37.Nirvana.dat",
"EnsemblCachePath":"Ensembl_GRCh37.transcripts.gz",
"RefSeqCachePath":"RefSeq_GRCh37.transcripts.gz"
},
"GRCh38": {
"ReferencePath": "Homo_sapiens.GRCh38.Nirvana.dat",
"EnsemblCachePath": "Ensembl_GRCh38.transcripts.gz",
"RefSeqCachePath": "RefSeq_GRCh38.transcripts.gz"
}
}
================================================
FILE: CacheUtils/Commands/CombineCacheDirectories/CombineCacheDirectoriesMain.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using CacheUtils.PredictionCache;
using CacheUtils.TranscriptCache;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using Compression.Algorithms;
using Compression.FileHandling;
using ErrorHandling;
using Genome;
using Intervals;
using IO;
using ReferenceSequence.Utilities;
using VariantAnnotation.Caches;
using VariantAnnotation.Caches.DataStructures;
using VariantAnnotation.Interface.AnnotatedPositions;
using VariantAnnotation.IO.Caches;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.CombineCacheDirectories
{
public static class CombineCacheDirectoriesMain
{
private static string _inputPrefix;
private static string _inputPrefix2;
private static string _outputPrefix;
private static string _refSequencePath;
private static ExitCodes ProgramExecution()
{
var sequenceData = SequenceHelper.GetDictionaries(_refSequencePath);
var caches = LoadTranscriptCaches(CacheConstants.TranscriptPath(_inputPrefix),
CacheConstants.TranscriptPath(_inputPrefix2), sequenceData.refIndexToChromosome);
if (caches.Cache.TranscriptIntervalArrays.Length != caches.Cache2.TranscriptIntervalArrays.Length)
throw new InvalidDataException($"Expected the number of reference sequences in cache 1 ({caches.Cache.TranscriptIntervalArrays.Length}) and cache 2 ({caches.Cache2.TranscriptIntervalArrays.Length}) to be the same.");
int numRefSeqs = caches.Cache.TranscriptIntervalArrays.Length;
var combinedIntervalArrays = new IntervalArray<ITranscript>[numRefSeqs];
var siftPredictionsPerRef = new Prediction[numRefSeqs][];
var polyphenPredictionsPerRef = new Prediction[numRefSeqs][];
PredictionHeader siftHeader;
PredictionHeader polyphenHeader;
using (var siftReader = new PredictionCacheReader(FileUtilities.GetReadStream(CacheConstants.SiftPath(_inputPrefix)), PredictionCacheReader.SiftDescriptions))
using (var siftReader2 = new PredictionCacheReader(FileUtilities.GetReadStream(CacheConstants.SiftPath(_inputPrefix2)), PredictionCacheReader.SiftDescriptions))
using (var polyphenReader = new PredictionCacheReader(FileUtilities.GetReadStream(CacheConstants.PolyPhenPath(_inputPrefix)), PredictionCacheReader.PolyphenDescriptions))
using (var polyphenReader2 = new PredictionCacheReader(FileUtilities.GetReadStream(CacheConstants.PolyPhenPath(_inputPrefix2)), PredictionCacheReader.PolyphenDescriptions))
{
siftHeader = siftReader.Header;
polyphenHeader = polyphenReader.Header;
for (ushort refIndex = 0; refIndex < numRefSeqs; refIndex++)
{
var chromosome = sequenceData.refIndexToChromosome[refIndex];
Console.ForegroundColor = ConsoleColor.Yellow;
Logger.WriteLine($"\n{chromosome.UcscName}:");
Console.ResetColor();
var sift = CombinePredictions(chromosome, "SIFT", siftReader, siftReader2);
siftPredictionsPerRef[refIndex] = sift.Predictions;
var polyphen = CombinePredictions(chromosome, "PolyPhen", polyphenReader, polyphenReader2);
polyphenPredictionsPerRef[refIndex] = polyphen.Predictions;
var transcriptIntervalArray = caches.Cache.TranscriptIntervalArrays[refIndex];
var transcriptIntervalArray2 = caches.Cache2.TranscriptIntervalArrays[refIndex];
combinedIntervalArrays[refIndex] = CombineTranscripts(transcriptIntervalArray,
transcriptIntervalArray2, sift.Offset, polyphen.Offset);
}
}
Logger.WriteLine("");
WritePredictions("SIFT", CacheConstants.SiftPath(_outputPrefix), siftHeader, siftPredictionsPerRef);
WritePredictions("PolyPhen", CacheConstants.PolyPhenPath(_outputPrefix), polyphenHeader, polyphenPredictionsPerRef);
WriteTranscripts(CloneHeader(caches.Cache.Header), combinedIntervalArrays,
caches.Cache.RegulatoryRegionIntervalArrays);
return ExitCodes.Success;
}
private static void WriteTranscripts(CacheHeader header,
IntervalArray<ITranscript>[] transcriptIntervalArrays,
IntervalArray<IRegulatoryRegion>[] regulatoryRegionIntervalArrays)
{
var staging = TranscriptCacheStaging.GetStaging(header, transcriptIntervalArrays, regulatoryRegionIntervalArrays);
Logger.Write("- writing transcripts... ");
staging.Write(FileUtilities.GetCreateStream(CacheConstants.TranscriptPath(_outputPrefix)));
Logger.WriteLine("finished.");
}
private static void WritePredictions(string description, string filePath,
PredictionHeader header, Prediction[][] predictionsPerRef)
{
Logger.Write($"- writing {description} predictions... ");
using (var stream = new BlockStream(new Zstandard(), FileUtilities.GetCreateStream(filePath), CompressionMode.Compress))
using (var writer = new PredictionCacheWriter(stream, CloneHeader(header)))
{
writer.Write(header.LookupTable, predictionsPerRef);
}
Logger.WriteLine("finished.");
}
private static IntervalArray<ITranscript> CombineTranscripts(IntervalArray<ITranscript> intervalArray,
IntervalArray<ITranscript> intervalArray2, int siftOffset, int polyphenOffset)
{
Logger.Write("- combine transcripts... ");
int numCombinedTranscripts = GetNumCombinedTranscripts(intervalArray, intervalArray2);
var combinedIntervals = new Interval<ITranscript>[numCombinedTranscripts];
var combinedIndex = 0;
CopyItems(intervalArray?.Array, combinedIntervals, ref combinedIndex, interval => interval);
CopyItems(intervalArray2?.Array, combinedIntervals, ref combinedIndex, interval => GetUpdatedTranscript(interval, siftOffset, polyphenOffset));
Logger.WriteLine("finished.");
return new IntervalArray<ITranscript>(combinedIntervals.OrderBy(x => x.Begin).ThenBy(x => x.End).ToArray());
}
private static int GetNumCombinedTranscripts<T>(IntervalArray<T> intervalArray,
IntervalArray<T> intervalArray2)
{
int numIntervals = intervalArray?.Array.Length ?? 0;
int numIntervals2 = intervalArray2?.Array.Length ?? 0;
return numIntervals + numIntervals2;
}
// ReSharper disable SuggestBaseTypeForParameter
private static void CopyItems<T>(T[] src, T[] dest, ref int destIndex, Func<T, T> updateFunc)
// ReSharper restore SuggestBaseTypeForParameter
{
if (src == null) return;
foreach (var item in src) dest[destIndex++] = updateFunc(item);
}
private static Interval<ITranscript> GetUpdatedTranscript(Interval<ITranscript> interval, int siftOffset,
int polyphenOffset)
{
var transcript = interval.Value;
if (transcript.SiftIndex == -1 && transcript.PolyPhenIndex == -1) return interval;
int newSiftIndex = transcript.SiftIndex == -1 ? -1 : transcript.SiftIndex + siftOffset;
int newPolyphenIndex = transcript.PolyPhenIndex == -1 ? -1 : transcript.PolyPhenIndex + polyphenOffset;
var updatedTranscript = transcript.UpdatePredictions(newSiftIndex, newPolyphenIndex);
return new Interval<ITranscript>(transcript.Start, transcript.End, updatedTranscript);
}
private static VariantAnnotation.IO.Caches.Header CloneBaseHeader(VariantAnnotation.IO.Caches.Header header) =>
new VariantAnnotation.IO.Caches.Header(CacheConstants.Identifier, header.SchemaVersion, header.DataVersion,
Source.BothRefSeqAndEnsembl, DateTime.Now.Ticks, header.Assembly);
private static PredictionHeader CloneHeader(PredictionHeader header) =>
new PredictionHeader(CloneBaseHeader(header), header.Custom, header.LookupTable);
private static CacheHeader CloneHeader(CacheHeader header) =>
new CacheHeader(CloneBaseHeader(header), header.Custom);
private static (Prediction[] Predictions, int Offset) CombinePredictions(Chromosome chromosome,
string description, PredictionCacheReader reader, PredictionCacheReader reader2)
{
Logger.Write($"- load {description} predictions... ");
var predictions = reader.GetPredictions(chromosome.Index);
var predictions2 = reader2.GetPredictions(chromosome.Index);
Logger.WriteLine("finished.");
var combinedPredictions = CombinePredictions(description, predictions, predictions2);
return (combinedPredictions, predictions.Length);
}
private static Prediction[] CombinePredictions(string description, Prediction[] predictions,
Prediction[] predictions2)
{
Logger.Write($"- combine {description} predictions... ");
int numCombinedPredictions = predictions.Length + predictions2.Length;
var combinedPredictions = new Prediction[numCombinedPredictions];
var combinedIndex = 0;
CopyItems(predictions, combinedPredictions, ref combinedIndex, x => x);
CopyItems(predictions2, combinedPredictions, ref combinedIndex, x => x);
Logger.WriteLine("finished.");
return combinedPredictions;
}
private static (TranscriptCacheData Cache, TranscriptCacheData Cache2) LoadTranscriptCaches(
string transcriptPath, string transcriptPath2, Dictionary<ushort, Chromosome> refIndexToChromosome)
{
TranscriptCacheData cache;
TranscriptCacheData cache2;
Logger.Write("- loading transcript caches... ");
using (var transcriptReader = new TranscriptCacheReader(FileUtilities.GetReadStream(transcriptPath)))
using (var transcriptReader2 = new TranscriptCacheReader(FileUtilities.GetReadStream(transcriptPath2)))
{
cache = transcriptReader.Read(refIndexToChromosome);
cache2 = transcriptReader2.Read(refIndexToChromosome);
}
Logger.WriteLine("finished.");
return (cache, cache2);
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"in|1=",
"input cache {prefix}",
v => _inputPrefix = v
},
{
"in2|2=",
"input cache 2 {prefix}",
v => _inputPrefix2 = v
},
{
"out|o=",
"output cache {prefix}",
v => _outputPrefix = v
},
{
"ref|r=",
"input reference {path}",
v => _refSequencePath = v
}
};
string commandLineExample = $"{command} --in <cache prefix> --in2 <cache prefix> --out <cache prefix> --ref <reference path>";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.CheckInputFilenameExists(_refSequencePath, "reference sequence", "--ref")
.HasRequiredParameter(_inputPrefix, "input cache", "--in")
.HasRequiredParameter(_inputPrefix2, "input cache 2", "--in2")
.HasRequiredParameter(_outputPrefix, "output cache", "--out")
.SkipBanner()
.ShowHelpMenu("Combines two cache sets into one cache.", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/Commands/CreateCache/CreateNirvanaDatabaseMain.cs
================================================
using System.Collections.Generic;
using System.Linq;
using CacheUtils.Commands.Download;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using CacheUtils.Genes.DataStructures;
using CacheUtils.Genes.IO;
using CacheUtils.Genes.Utilities;
using CacheUtils.IntermediateIO;
using CacheUtils.PredictionCache;
using CacheUtils.TranscriptCache;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using Compression.Utilities;
using ErrorHandling;
using Genome;
using Intervals;
using IO;
using ReferenceSequence.Utilities;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.CreateCache
{
public static class CreateNirvanaDatabaseMain
{
private static string _inputPrefix;
private static string _inputReferencePath;
private static string _outputCacheFilePrefix;
private static ExitCodes ProgramExecution()
{
string transcriptPath = _inputPrefix + ".transcripts.gz";
string siftPath = _inputPrefix + ".sift.gz";
string polyphenPath = _inputPrefix + ".polyphen.gz";
string regulatoryPath = _inputPrefix + ".regulatory.gz";
(var refIndexToChromosome, var refNameToChromosome, int numRefSeqs) = SequenceHelper.GetDictionaries(_inputReferencePath);
using (var transcriptReader = new MutableTranscriptReader(GZipUtilities.GetAppropriateReadStream(transcriptPath), refIndexToChromosome))
using (var regulatoryReader = new RegulatoryRegionReader(GZipUtilities.GetAppropriateReadStream(regulatoryPath), refIndexToChromosome))
using (var siftReader = new PredictionReader(GZipUtilities.GetAppropriateReadStream(siftPath), refIndexToChromosome, IntermediateIoCommon.FileType.Sift))
using (var polyphenReader = new PredictionReader(GZipUtilities.GetAppropriateReadStream(polyphenPath), refIndexToChromosome, IntermediateIoCommon.FileType.Polyphen))
using (var geneReader = new UgaGeneReader(GZipUtilities.GetAppropriateReadStream(ExternalFiles.UniversalGeneFilePath), refNameToChromosome))
{
var genomeAssembly = transcriptReader.Header.Assembly;
var source = transcriptReader.Header.Source;
long vepReleaseTicks = transcriptReader.Header.VepReleaseTicks;
ushort vepVersion = transcriptReader.Header.VepVersion;
Logger.Write("- loading universal gene archive file... ");
var genes = geneReader.GetGenes();
var geneForest = CreateGeneForest(genes, numRefSeqs, genomeAssembly);
Logger.WriteLine($"{genes.Length:N0} loaded.");
Logger.Write("- loading regulatory region file... ");
var regulatoryRegions = regulatoryReader.GetRegulatoryRegions();
Logger.WriteLine($"{regulatoryRegions.Length:N0} loaded.");
Logger.Write("- loading transcript file... ");
var transcripts = transcriptReader.GetTranscripts();
var transcriptsByRefIndex = transcripts.GetMultiValueDict(x => x.Chromosome.Index);
Logger.WriteLine($"{transcripts.Length:N0} loaded.");
MarkCanonicalTranscripts(transcripts);
var predictionBuilder = new PredictionCacheBuilder(genomeAssembly);
var predictionCaches = predictionBuilder.CreatePredictionCaches(transcriptsByRefIndex, siftReader, polyphenReader, numRefSeqs);
Logger.Write("- writing SIFT prediction cache... ");
predictionCaches.Sift.Write(FileUtilities.GetCreateStream(CacheConstants.SiftPath(_outputCacheFilePrefix)));
Logger.WriteLine("finished.");
Logger.Write("- writing PolyPhen prediction cache... ");
predictionCaches.PolyPhen.Write(FileUtilities.GetCreateStream(CacheConstants.PolyPhenPath(_outputCacheFilePrefix)));
Logger.WriteLine("finished.");
var transcriptBuilder = new TranscriptCacheBuilder(genomeAssembly, source, vepReleaseTicks, vepVersion);
var transcriptStaging = transcriptBuilder.CreateTranscriptCache(transcripts, regulatoryRegions, geneForest, numRefSeqs);
Logger.Write("- writing transcript cache... ");
transcriptStaging.Write(FileUtilities.GetCreateStream(CacheConstants.TranscriptPath(_outputCacheFilePrefix)));
Logger.WriteLine("finished.");
}
return ExitCodes.Success;
}
private static IIntervalForest<UgaGene> CreateGeneForest(IEnumerable<UgaGene> genes, int numRefSeqs, GenomeAssembly genomeAssembly)
{
bool useGrch37 = genomeAssembly == GenomeAssembly.GRCh37;
var intervalLists = new List<Interval<UgaGene>>[numRefSeqs];
for (var i = 0; i < numRefSeqs; i++) intervalLists[i] = new List<Interval<UgaGene>>();
foreach (var gene in genes)
{
var coords = useGrch37 ? gene.GRCh37 : gene.GRCh38;
if (coords.Start == -1 && coords.End == -1) continue;
intervalLists[gene.Chromosome.Index].Add(new Interval<UgaGene>(coords.Start, coords.End, gene));
}
var refIntervalArrays = new IntervalArray<UgaGene>[numRefSeqs];
for (var i = 0; i < numRefSeqs; i++)
{
refIntervalArrays[i] = new IntervalArray<UgaGene>(intervalLists[i].OrderBy(x => x.Begin).ThenBy(x => x.End).ToArray());
}
return new IntervalForest<UgaGene>(refIntervalArrays);
}
private static void MarkCanonicalTranscripts(MutableTranscript[] transcripts)
{
var ccdsIdToEnsemblId = CcdsReader.GetCcdsIdToEnsemblId(ExternalFiles.CcdsFile.FilePath);
var lrgTranscriptIds = LrgReader.GetTranscriptIds(ExternalFiles.LrgFile.FilePath, ccdsIdToEnsemblId);
Logger.Write("- marking canonical transcripts... ");
var canonical = new CanonicalTranscriptMarker(lrgTranscriptIds);
int numCanonicalTranscripts = canonical.MarkTranscripts(transcripts);
Logger.WriteLine($"{numCanonicalTranscripts:N0} marked.");
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"in|i=",
"input filename {prefix}",
v => _inputPrefix = v
},
{
"out|o=",
"output cache file {prefix}",
v => _outputCacheFilePrefix = v
},
{
"ref|r=",
"input reference {filename}",
v => _inputReferencePath = v
}
};
string commandLineExample = $"{command} --in <prefix> --out <prefix> --ref <path>";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.HasRequiredParameter(_inputPrefix, "intermediate cache", "--in")
.CheckInputFilenameExists(_inputReferencePath, "compressed reference", "--ref")
.HasRequiredParameter(_outputCacheFilePrefix, "Nirvana", "--out")
.SkipBanner()
.ShowHelpMenu("Converts *deserialized* VEP cache files to Nirvana cache format.", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/Commands/Download/DownloadMain.cs
================================================
using ErrorHandling;
namespace CacheUtils.Commands.Download
{
public static class DownloadMain
{
private static ExitCodes ProgramExecution()
{
ExternalFiles.Download();
return ExitCodes.Success;
}
public static ExitCodes Run(string command, string[] args)
{
return ProgramExecution();
}
}
}
================================================
FILE: CacheUtils/Commands/Download/ExternalFiles.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using CacheUtils.Genbank;
using CacheUtils.IntermediateIO;
using CacheUtils.Utilities;
using Compression.Utilities;
using Genome;
using IO;
using OptimizedCore;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.Commands.Download
{
public static class ExternalFiles
{
public static readonly RemoteFile CcdsFile = new RemoteFile("CCDS file (2016-09-08)", "ftp://ftp.ncbi.nlm.nih.gov/pub/CCDS/current_human/CCDS2Sequence.20160908.txt", false);
public static readonly RemoteFile LrgFile = new RemoteFile("latest LRG file", "http://ftp.ebi.ac.uk/pub/databases/lrgex/list_LRGs_transcripts_xrefs.txt");
public static readonly RemoteFile HgncFile = new RemoteFile("latest HGNC gene symbols", "ftp://ftp.ebi.ac.uk/pub/databases/genenames/new/tsv/hgnc_complete_set.txt");
public static readonly RemoteFile GeneInfoFile = new RemoteFile("latest gene_info", "ftp://ftp.ncbi.nlm.nih.gov/gene/DATA/gene_info.gz");
private static readonly RemoteFile AssemblyFile37 = new RemoteFile("assembly report (GRCh37.p13)", "ftp://ftp.ncbi.nih.gov/genomes/refseq/vertebrate_mammalian/Homo_sapiens/all_assembly_versions/GCF_000001405.25_GRCh37.p13/GCF_000001405.25_GRCh37.p13_assembly_report.txt", false);
public static readonly RemoteFile EnsemblGtfFile37 = new RemoteFile("Ensembl 75 GTF (GRCh37)", "ftp://ftp.ensembl.org/pub/release-75/gtf/homo_sapiens/Homo_sapiens.GRCh37.75.gtf.gz", false);
public static readonly RemoteFile RefSeqGenomeGffFile37 = new RemoteFile("RefSeq genomic GFF (GRCh37.p13)", "ftp://ftp.ncbi.nih.gov/genomes/refseq/vertebrate_mammalian/Homo_sapiens/all_assembly_versions/GCF_000001405.25_GRCh37.p13/GCF_000001405.25_GRCh37.p13_genomic.gff.gz", false);
public static readonly RemoteFile RefSeqGffFile37 = new RemoteFile("RefSeq GFF3 (GRCh37.p13)", "ftp://ftp.ncbi.nih.gov/genomes/H_sapiens/ARCHIVE/ANNOTATION_RELEASE.105/GFF/ref_GRCh37.p13_top_level.gff3.gz", false);
private static readonly RemoteFile AssemblyFile38 = new RemoteFile("assembly report (GRCh38.p11)", "ftp://ftp.ncbi.nih.gov/genomes/refseq/vertebrate_mammalian/Homo_sapiens/all_assembly_versions/GCF_000001405.37_GRCh38.p11/GCF_000001405.37_GRCh38.p11_assembly_report.txt", false);
public static readonly RemoteFile EnsemblGtfFile38 = new RemoteFile("Ensembl 90 GTF (GRCh38)", "ftp://ftp.ensembl.org/pub/release-90/gtf/homo_sapiens/Homo_sapiens.GRCh38.90.gtf.gz", false);
public static readonly RemoteFile RefSeqGenomeGffFile38 = new RemoteFile("RefSeq genomic GFF (GRCh38.p11)", "ftp://ftp.ncbi.nih.gov/genomes/refseq/vertebrate_mammalian/Homo_sapiens/all_assembly_versions/GCF_000001405.37_GRCh38.p11/GCF_000001405.37_GRCh38.p11_genomic.gff.gz", false);
public static readonly RemoteFile RefSeqGffFile38 = new RemoteFile("RefSeq GFF3 (GRCh38.p7)", "ftp://ftp.ncbi.nih.gov/genomes/H_sapiens/GFF/ref_GRCh38.p7_top_level.gff3.gz", false);
public static readonly string GenbankFilePath = Path.Combine(Path.GetTempPath(), RemoteFile.GetFilename("Genbank.tsv.gz", false));
public static readonly string UniversalGeneFilePath = Path.Combine(Path.GetTempPath(), RemoteFile.GetFilename("UGA.tsv.gz", false));
public static void Download()
{
var fileList = new List<RemoteFile>
{
CcdsFile,
LrgFile,
HgncFile,
GeneInfoFile,
AssemblyFile37,
AssemblyFile38,
EnsemblGtfFile37,
EnsemblGtfFile38,
RefSeqGenomeGffFile37,
RefSeqGenomeGffFile38,
RefSeqGffFile37,
RefSeqGffFile38
};
var genbankFiles = GetGenbankFiles(fileList);
fileList.Execute("downloads", file => file.Download());
if (genbankFiles == null) return;
genbankFiles.Execute("file parsing", file => file.Parse());
var genbankEntries = GetIdToGenbankEntryDict(genbankFiles);
WriteDictionary(genbankEntries);
}
private static IEnumerable<GenbankEntry> GetIdToGenbankEntryDict(IEnumerable<GenbankFile> files) =>
files.SelectMany(file => file.GenbankDict.Values).OrderBy(x => x.TranscriptId).ToList();
private static List<GenbankFile> GetGenbankFiles(ICollection<RemoteFile> fileList)
{
var genbankFileInfo = new FileInfo(GenbankFilePath);
if (genbankFileInfo.Exists && GetElapsedDays(genbankFileInfo.CreationTime) < 30.0) return null;
int numGenbankFiles = GetNumGenbankFiles();
var genbankFiles = new List<GenbankFile>(numGenbankFiles);
for (var i = 0; i < numGenbankFiles; i++)
{
var genbankFile = new GenbankFile(i + 1);
fileList.Add(genbankFile.RemoteFile);
genbankFiles.Add(genbankFile);
}
return genbankFiles;
}
public static double GetElapsedDays(DateTime creationTime) => DateTime.Now.Subtract(creationTime).TotalDays;
private static int GetNumGenbankFiles()
{
var fileList = new RemoteFile("RefSeq filelist", "ftp://ftp.ncbi.nlm.nih.gov/refseq/H_sapiens/mRNA_Prot/human.files.installed");
fileList.Download();
var maxNum = 0;
using (var reader = FileUtilities.GetStreamReader(FileUtilities.GetReadStream(fileList.FilePath)))
{
while (true)
{
string line = reader.ReadLine();
if (line == null) break;
string filename = line.OptimizedSplit('\t')[1];
if (!filename.EndsWith(".rna.gbff.gz")) continue;
int num = int.Parse(filename.Substring(6, filename.Length - 18));
if (num > maxNum) maxNum = num;
}
}
return maxNum;
}
private static void WriteDictionary(IEnumerable<GenbankEntry> entries)
{
var header = new IntermediateIoHeader(0, 0, Source.None, GenomeAssembly.Unknown, 0);
Logger.Write($"- writing Genbank file ({Path.GetFileName(GenbankFilePath)})... ");
using (var writer = new GenbankWriter(GZipUtilities.GetStreamWriter(GenbankFilePath), header))
{
foreach (var entry in entries) writer.Write(entry);
}
Logger.WriteLine("finished.");
}
}
}
================================================
FILE: CacheUtils/Commands/Download/GenbankFile.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.Genbank;
using CacheUtils.Utilities;
using Compression.Utilities;
using IO;
namespace CacheUtils.Commands.Download
{
public sealed class GenbankFile
{
public readonly RemoteFile RemoteFile;
public readonly Dictionary<string, GenbankEntry> GenbankDict;
public GenbankFile(int num)
{
RemoteFile = new RemoteFile($"RefSeq Genbank {num} gbff", $"ftp://ftp.ncbi.nlm.nih.gov/refseq/H_sapiens/mRNA_Prot/human.{num}.rna.gbff.gz", false);
GenbankDict = new Dictionary<string, GenbankEntry>();
}
public void Parse()
{
Logger.WriteLine($"- parsing {Path.GetFileName(RemoteFile.FilePath)}");
using (var reader = new GenbankReader(GZipUtilities.GetAppropriateStreamReader(RemoteFile.FilePath)))
{
while (true)
{
var entry = reader.GetGenbankEntry();
if (entry == null) break;
GenbankDict[entry.TranscriptId] = entry;
}
}
}
}
}
================================================
FILE: CacheUtils/Commands/ExtractTranscripts/ExtractTranscriptsMain.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using CacheUtils.MiniCache;
using CacheUtils.PredictionCache;
using CacheUtils.TranscriptCache;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using ErrorHandling;
using Genome;
using Intervals;
using IO;
using VariantAnnotation.Caches.DataStructures;
using VariantAnnotation.Interface.AnnotatedPositions;
using VariantAnnotation.Interface.Caches;
using VariantAnnotation.IO.Caches;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.ExtractTranscripts
{
public static class ExtractTranscriptsMain
{
private static string _inputPrefix;
private static string _inputReferencePath;
private static string _outputDirectory;
private static string _referenceName;
private static int _referencePosition = -1;
private static int _referenceEndPosition = -1;
private static ExitCodes ProgramExecution()
{
var bundle = DataBundle.GetDataBundle(_inputReferencePath, _inputPrefix);
int numRefSeqs = bundle.SequenceReader.NumRefSeqs;
var chromosome = ReferenceNameUtilities.GetChromosome(bundle.SequenceReader.RefNameToChromosome, _referenceName);
bundle.Load(chromosome);
string outputStub = GetOutputStub(chromosome, bundle.Source);
var interval = new ChromosomeInterval(chromosome, _referencePosition, _referenceEndPosition);
var transcripts = GetTranscripts(bundle, interval);
var sift = GetPredictionStaging("SIFT", transcripts, chromosome, bundle.SiftPredictions, bundle.SiftReader, x => x.SiftIndex, numRefSeqs);
var polyphen = GetPredictionStaging("PolyPhen", transcripts, chromosome, bundle.PolyPhenPredictions, bundle.PolyPhenReader, x => x.PolyPhenIndex, numRefSeqs);
var regulatoryRegionIntervalArrays = GetRegulatoryRegionIntervalArrays(bundle.TranscriptCache, interval, numRefSeqs);
var transcriptIntervalArrays = PredictionUtilities.UpdateTranscripts(transcripts, bundle.SiftPredictions,
sift.Predictions, bundle.PolyPhenPredictions, polyphen.Predictions, numRefSeqs);
var transcriptStaging = GetTranscriptStaging(bundle.TranscriptCacheData.Header, transcriptIntervalArrays, regulatoryRegionIntervalArrays);
WriteCache(FileUtilities.GetCreateStream(CacheConstants.TranscriptPath(outputStub)), transcriptStaging, "transcript");
WriteCache(FileUtilities.GetCreateStream(CacheConstants.SiftPath(outputStub)), sift.Staging, "SIFT");
WriteCache(FileUtilities.GetCreateStream(CacheConstants.PolyPhenPath(outputStub)), polyphen.Staging, "PolyPhen");
return ExitCodes.Success;
}
private static TranscriptCacheStaging GetTranscriptStaging(CacheHeader header,
IntervalArray<ITranscript>[] transcriptIntervalArrays,
IntervalArray<IRegulatoryRegion>[] regulatoryRegionIntervalArrays) =>
TranscriptCacheStaging.GetStaging(header, transcriptIntervalArrays, regulatoryRegionIntervalArrays);
private static void WriteCache(Stream stream, IStaging staging, string description)
{
Logger.Write($"- writing {description} cache... ");
staging.Write(stream);
Logger.WriteLine("finished.");
}
private static string GetOutputStub(Chromosome chromosome, Source source) => Path.Combine(_outputDirectory,
$"{chromosome.UcscName}_{_referencePosition}_{_referenceEndPosition}_{GetSource(source)}");
private static string GetSource(Source source) =>
source != Source.BothRefSeqAndEnsembl ? source.ToString() : "Both";
private static (PredictionCacheStaging Staging, Prediction[] Predictions) GetPredictionStaging(
string description, IEnumerable<ITranscript> transcripts, Chromosome chromosome, IReadOnlyList<Prediction> oldPredictions,
PredictionCacheReader reader, Func<ITranscript, int> indexFunc, int numRefSeqs)
{
Logger.Write($"- retrieving {description} predictions... ");
var indexSet = GetUniqueIndices(transcripts, indexFunc);
var predictionsPerRef = GetPredictions(indexSet, chromosome, numRefSeqs, oldPredictions);
var staging = new PredictionCacheStaging(reader.Header, predictionsPerRef);
Logger.WriteLine($"found {indexSet.Count} predictions.");
return (staging, predictionsPerRef[chromosome.Index]);
}
private static Prediction[][] GetPredictions(ICollection<int> indexSet, Chromosome chromosome, int numRefSeqs,
IReadOnlyList<Prediction> oldPredictions)
{
var refPredictions = new Prediction[indexSet.Count];
var predIdx = 0;
foreach (int index in indexSet) refPredictions[predIdx++] = oldPredictions[index];
var predictions = new Prediction[numRefSeqs][];
predictions[chromosome.Index] = refPredictions;
return predictions;
}
private static HashSet<int> GetUniqueIndices(IEnumerable<ITranscript> transcripts, Func<ITranscript, int> indexFunc)
{
var indexSet = new HashSet<int>();
foreach (var transcript in transcripts)
{
int index = indexFunc(transcript);
if (index == -1) continue;
indexSet.Add(index);
}
return indexSet;
}
private static IntervalArray<IRegulatoryRegion>[] GetRegulatoryRegionIntervalArrays(
ITranscriptCache cache, ChromosomeInterval interval, int numRefSeqs)
{
Logger.Write("- retrieving regulatory regions... ");
var regulatoryIntervalForest = cache.RegulatoryIntervalForest;
var regulatoryRegions =
regulatoryIntervalForest.GetAllOverlappingValues(interval.Chromosome.Index, interval.Start,
interval.End);
Logger.WriteLine($"found {regulatoryRegions.Length} regulatory regions.");
return regulatoryRegions.ToIntervalArrays(numRefSeqs);
}
private static List<ITranscript> GetTranscripts(DataBundle bundle, ChromosomeInterval interval)
{
Logger.Write("- retrieving transcripts... ");
var transcripts = TranscriptCacheUtilities.GetTranscripts(bundle, interval);
Logger.WriteLine($"found {transcripts.Count} transcripts.");
if (transcripts.Count == 0) throw new InvalidDataException("Expected at least one transcript, but found none.");
return transcripts;
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"in|i=",
"input cache {prefix}",
v => _inputPrefix = v
},
{
"name|n=",
"reference {name}",
v => _referenceName = v
},
{
"out|o=",
"output {directory}",
v => _outputDirectory = v
},
{
"pos|p=",
"reference {position}",
(int v) => _referencePosition = v
},
{
"endpos=",
"reference end {position}",
(int v) => _referenceEndPosition = v
},
{
"ref|r=",
"input reference {filename}",
v => _inputReferencePath = v
}
};
string commandLineExample = $"{command} --in <prefix> --out <dir> -r <ref path> --chr <name> -p <pos> --endpos <pos>\n";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.HasRequiredParameter(_inputPrefix, "Nirvana cache", "--in")
.CheckInputFilenameExists(_inputReferencePath, "compressed reference sequence", "--ref")
.CheckDirectoryExists(_outputDirectory, "output cache", "--out")
.SkipBanner()
.ShowHelpMenu("Extracts transcripts from Nirvana cache files.", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/Commands/GFF/CreateGffMain.cs
================================================
using System.Collections.Generic;
using CacheUtils.Commands.ParseVepCacheDirectory;
using CacheUtils.GFF;
using CacheUtils.Helpers;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using Compression.Utilities;
using ErrorHandling;
using Genome;
using IO;
using ReferenceSequence.Utilities;
using VariantAnnotation.Caches;
using VariantAnnotation.Interface.AnnotatedPositions;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.GFF
{
public static class CreateGffMain
{
private static string _compressedReferencePath;
private static string _inputPrefix;
private static string _outputFileName;
private static string _transcriptSource;
private static ExitCodes ProgramExecution()
{
Source transcriptSource = ParseVepCacheDirectoryMain.GetSource(_transcriptSource);
string cachePath = CacheConstants.TranscriptPath(_inputPrefix);
Dictionary<ushort, Chromosome> refIndexToChromosome =
SequenceHelper.GetDictionaries(_compressedReferencePath).refIndexToChromosome;
TranscriptCacheData cache = TranscriptCacheHelper.GetCache(cachePath, refIndexToChromosome);
Dictionary<IGene, int> geneToInternalId = InternalGenes.CreateDictionary(cache.Genes);
using (var writer = new GffWriter(GZipUtilities.GetStreamWriter(_outputFileName)))
{
var creator = new GffCreator(writer, geneToInternalId, transcriptSource);
creator.Create(cache.TranscriptIntervalArrays);
}
return ExitCodes.Success;
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"in|i=",
"input cache {prefix}",
v => _inputPrefix = v
},
{
"out|o=",
"output {file name}",
v => _outputFileName = v
},
{
"source|s=",
"transcript {source}",
v => _transcriptSource = v
},
{
"ref|r=",
"reference {file}",
v => _compressedReferencePath = v
}
};
string commandLineExample = $"{command} --in <cache prefix> --out <GFF path>";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.HasRequiredParameter(_inputPrefix, "input cache prefix", "--in")
.CheckOutputFilenameSuffix(_outputFileName, ".gz", "GFF")
.SkipBanner()
.ShowHelpMenu("Outputs exon coordinates for all transcripts in a database.", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/Commands/GFF/InternalGenes.cs
================================================
using System.Collections.Generic;
using CacheUtils.TranscriptCache.Comparers;
using ErrorHandling.Exceptions;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.Commands.GFF
{
public static class InternalGenes
{
public static Dictionary<IGene, int> CreateDictionary(IGene[] genes)
{
var geneComparer = new GeneComparer();
var geneToInternalId = new Dictionary<IGene, int>(geneComparer);
for (var geneIndex = 0; geneIndex < genes.Length; geneIndex++)
{
var gene = genes[geneIndex];
if (geneToInternalId.TryGetValue(gene, out int oldGeneIndex))
{
throw new UserErrorException($"Found a duplicate gene in the dictionary: {genes[geneIndex]} ({geneIndex} vs {oldGeneIndex})");
}
geneToInternalId[gene] = geneIndex;
}
return geneToInternalId;
}
}
}
================================================
FILE: CacheUtils/Commands/Header/HeaderMain.cs
================================================
using System;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using ErrorHandling;
using ErrorHandling.Exceptions;
using IO;
using VariantAnnotation.IO.Caches;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.Header
{
public static class HeaderMain
{
private static string _inputPrefix;
private static ExitCodes ProgramExecution()
{
string cachePath = CacheConstants.TranscriptPath(_inputPrefix);
var header = GetHeaderInformation(cachePath);
Console.WriteLine($"Versions: Schema: {header.Schema}, Data: {header.Data}, VEP: {header.Vep}");
return ExitCodes.Success;
}
private static (ushort Schema, ushort Data, ushort Vep) GetHeaderInformation(string cachePath)
{
CacheHeader header;
using (var stream = FileUtilities.GetReadStream(cachePath))
{
header = CacheHeader.Read(stream);
}
if (header == null) throw new InvalidFileFormatException($"Could not parse the header information correctly for {cachePath}");
return (header.SchemaVersion, header.DataVersion, header.Custom.VepVersion);
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"in|i=",
"input cache {prefix}",
v => _inputPrefix = v
}
};
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.HasRequiredParameter(_inputPrefix, "input cache prefix", "--in")
.SkipBanner()
.ShowHelpMenu("Displays the cache header information.", $"{command} --in <cache prefix>")
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/ParseVepCacheDirectoryMain.cs
================================================
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using CacheUtils.IntermediateIO;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using Compression.Utilities;
using ErrorHandling;
using System;
using System.Collections.Generic;
using CacheUtils.Commands.Download;
using CacheUtils.Genbank;
using Genome;
using IO;
using ReferenceSequence.IO;
using VariantAnnotation.Interface.AnnotatedPositions;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public static class ParseVepCacheDirectoryMain
{
private static string _inputVepDirectory;
private static string _inputReferencePath;
private static string _outputStub;
private static string _vepReleaseDate;
private static string _genomeAssembly;
private static string _transcriptSource;
private static ushort _vepVersion;
private static ExitCodes ProgramExecution()
{
var transcriptSource = GetSource(_transcriptSource);
var sequenceReader = new CompressedSequenceReader(FileUtilities.GetReadStream(_inputReferencePath));
var vepRootDirectory = new VepRootDirectory(sequenceReader.RefNameToChromosome);
var refIndexToVepDir = vepRootDirectory.GetRefIndexToVepDir(_inputVepDirectory);
var genomeAssembly = GenomeAssemblyHelper.Convert(_genomeAssembly);
long vepReleaseTicks = DateTime.Parse(_vepReleaseDate).Ticks;
var idToGenbank = GetIdToGenbank(genomeAssembly, transcriptSource);
// =========================
// create the pre-cache file
// =========================
// process each VEP directory
int numRefSeqs = sequenceReader.NumRefSeqs;
var header = new IntermediateIoHeader(_vepVersion, vepReleaseTicks, transcriptSource, genomeAssembly, numRefSeqs);
string siftPath = _outputStub + ".sift.gz";
string polyphenPath = _outputStub + ".polyphen.gz";
string transcriptPath = _outputStub + ".transcripts.gz";
string regulatoryPath = _outputStub + ".regulatory.gz";
using (var mergeLogger = new TranscriptMergerLogger(FileUtilities.GetCreateStream(_outputStub + ".merge_transcripts.log")))
using (var siftWriter = new PredictionWriter(GZipUtilities.GetStreamWriter(siftPath), header, IntermediateIoCommon.FileType.Sift))
using (var polyphenWriter = new PredictionWriter(GZipUtilities.GetStreamWriter(polyphenPath), header, IntermediateIoCommon.FileType.Polyphen))
using (var transcriptWriter = new MutableTranscriptWriter(GZipUtilities.GetStreamWriter(transcriptPath), header))
using (var regulatoryRegionWriter = new RegulatoryRegionWriter(GZipUtilities.GetStreamWriter(regulatoryPath), header))
{
var converter = new VepCacheParser(transcriptSource);
var emptyPredictionDict = new Dictionary<string, List<int>>();
for (ushort refIndex = 0; refIndex < numRefSeqs; refIndex++)
{
var chromosome = sequenceReader.RefIndexToChromosome[refIndex];
if (!refIndexToVepDir.TryGetValue(refIndex, out string vepSubDir))
{
siftWriter.Write(chromosome, emptyPredictionDict);
polyphenWriter.Write(chromosome, emptyPredictionDict);
continue;
}
Console.WriteLine("Parsing reference sequence [{0}]:", chromosome.UcscName);
var rawData = converter.ParseDumpDirectory(chromosome, vepSubDir);
var mergedTranscripts = TranscriptMerger.Merge(mergeLogger, rawData.Transcripts, idToGenbank);
var mergedRegulatoryRegions = RegulatoryRegionMerger.Merge(rawData.RegulatoryRegions);
int numRawTranscripts = rawData.Transcripts.Count;
int numMergedTranscripts = mergedTranscripts.Count;
Console.WriteLine($"- # merged transcripts: {numMergedTranscripts}, # total transcripts: {numRawTranscripts}");
WriteTranscripts(transcriptWriter, mergedTranscripts);
WriteRegulatoryRegions(regulatoryRegionWriter, mergedRegulatoryRegions);
WritePredictions(siftWriter, mergedTranscripts, x => x.SiftData, chromosome);
WritePredictions(polyphenWriter, mergedTranscripts, x => x.PolyphenData, chromosome);
}
}
Console.WriteLine("\n{0} directories processed.", refIndexToVepDir.Count);
return ExitCodes.Success;
}
private static Dictionary<string, GenbankEntry> GetIdToGenbank(GenomeAssembly assembly, Source source)
{
if (assembly != GenomeAssembly.GRCh37 || source != Source.RefSeq) return null;
Logger.Write("- loading the intermediate Genbank file... ");
Dictionary<string, GenbankEntry> genbankDict;
using (var reader = new IntermediateIO.GenbankReader(GZipUtilities.GetAppropriateReadStream(ExternalFiles.GenbankFilePath)))
{
genbankDict = reader.GetIdToGenbank();
}
Logger.WriteLine($"{genbankDict.Count} entries loaded.");
return genbankDict;
}
private static void WriteRegulatoryRegions(RegulatoryRegionWriter writer, IEnumerable<IRegulatoryRegion> regulatoryRegions)
{
foreach (var regulatoryRegion in regulatoryRegions) writer.Write(regulatoryRegion);
}
private static void WriteTranscripts(MutableTranscriptWriter writer, IEnumerable<MutableTranscript> transcripts)
{
foreach (var transcript in transcripts) writer.Write(transcript);
}
private static void WritePredictions(PredictionWriter writer, IReadOnlyList<MutableTranscript> transcripts,
Func<MutableTranscript, string> predictionFunc, Chromosome chromosome)
{
var predictionDict = new Dictionary<string, List<int>>(StringComparer.Ordinal);
for (var transcriptIndex = 0; transcriptIndex < transcripts.Count; transcriptIndex++)
{
var transcript = transcripts[transcriptIndex];
string predictionData = predictionFunc(transcript);
if (predictionData == null) continue;
if (predictionDict.TryGetValue(predictionData, out var transcriptIdList)) transcriptIdList.Add(transcriptIndex);
else predictionDict[predictionData] = new List<int> { transcriptIndex };
}
writer.Write(chromosome, predictionDict);
}
public static Source GetSource(string source)
{
source = source.ToLower();
if (source.StartsWith("ensembl")) return Source.Ensembl;
if (source.StartsWith("refseq")) return Source.RefSeq;
return source.StartsWith("both") ? Source.BothRefSeqAndEnsembl : Source.None;
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"date=",
"VEP release {date}",
v => _vepReleaseDate = v
},
{
"source|s=",
"transcript {source}",
v => _transcriptSource = v
},
{
"ga=",
"genome assembly {version}",
v => _genomeAssembly = v
},
{
"in|i=",
"input VEP {directory}",
v => _inputVepDirectory = v
},
{
"out|o=",
"output filename {stub}",
v => _outputStub = v
},
{
"ref|r=",
"input reference {filename}",
v => _inputReferencePath = v
},
{
"vep=",
"VEP {version}",
(ushort v) => _vepVersion = v
}
};
string commandLineExample = $"{command} --in <VEP directory> --out <Nirvana pre-cache file> --vep <VEP version>";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.CheckDirectoryExists(_inputVepDirectory, "VEP", "--in")
.CheckInputFilenameExists(_inputReferencePath, "compressed reference sequence", "--ref")
.HasRequiredParameter(_outputStub, "output stub", "--out")
.HasRequiredParameter(_vepVersion, "VEP version", "--vep")
.HasRequiredParameter(_genomeAssembly, "genome assembly", "--ga")
.HasRequiredDate(_vepReleaseDate, "VEP release date", "--date")
.HasRequiredParameter(_transcriptSource, "transcript source", "--source")
.SkipBanner()
.ShowHelpMenu("Converts *deserialized* VEP cache files to a Nirvana pre-cache file.", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/RegulatoryRegionMerger.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using CacheUtils.TranscriptCache.Comparers;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public static class RegulatoryRegionMerger
{
public static IEnumerable<IRegulatoryRegion> Merge(IEnumerable<IRegulatoryRegion> regulatoryRegions)
{
var regulatoryDict = new Dictionary<string, IRegulatoryRegion>();
var comparer = new RegulatoryRegionComparer();
foreach (var currentRegion in regulatoryRegions)
{
if (currentRegion.Id.IsEmpty()) throw new InvalidOperationException("Found a regulatory region without an ID.");
string regulatoryKey = $"{currentRegion.Id}.{currentRegion.Start}.{currentRegion.End}";
if (regulatoryDict.TryGetValue(regulatoryKey, out var previousRegion))
{
MergeRegulatoryRegion(previousRegion, currentRegion, comparer);
}
else
{
regulatoryDict[regulatoryKey] = currentRegion;
}
}
return regulatoryDict.Values.OrderBy(x => x.Chromosome.Index).ThenBy(x => x.Start).ThenBy(x => x.End)
.ToList();
}
private static void MergeRegulatoryRegion(IRegulatoryRegion previous, IRegulatoryRegion current,
RegulatoryRegionComparer comparer)
{
if (comparer.Equals(previous, current)) return;
throw new InvalidDataException("Found different regulatory regions");
}
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptFilter.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using CacheUtils.DataDumperImport.DataStructures;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using CacheUtils.DataDumperImport.Utilities;
using CacheUtils.Genbank;
using CacheUtils.Genes.Utilities;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public static class TranscriptFilter
{
private static readonly MutableTranscriptComparer Comparer = new MutableTranscriptComparer();
private static void Log(this TranscriptMergerLogger logger, string transcriptId, string description) =>
logger.WriteLine($"{transcriptId}\t{description}");
public static List<MutableTranscript> PickSpecificTranscript(
this List<MutableTranscript> transcripts, TranscriptMergerLogger logger, string transcriptId)
{
if (transcripts.Count == 1) return transcripts;
List<MutableTranscript> filteredTranscripts;
string logMessage;
switch (transcriptId)
{
case "NM_001005786":
filteredTranscripts = transcripts.Where(transcript => transcript.CdnaMaps[9].Start == 25419007).ToList();
logMessage = $"Filtered on exon 9 start: {transcriptId}";
break;
case "NM_001278597":
case "NM_001278596":
filteredTranscripts = transcripts.Where(transcript => transcript.CdnaMaps.Length == 26).ToList();
logMessage = $"Filtered on exon count (26): {transcriptId}";
break;
case "NM_016152":
filteredTranscripts = transcripts.Where(transcript => transcript.Exons[0].Phase == 0).ToList();
logMessage = $"Filtered on exon phase (0): {transcriptId}";
break;
default:
return transcripts;
}
if (filteredTranscripts.Count == 0) return transcripts;
logger.Log(transcriptId, logMessage);
return filteredTranscripts.Unique();
}
public static List<MutableTranscript> InvestigateInconsistentCdnaMaps(this List<MutableTranscript> transcripts,
TranscriptMergerLogger logger, string transcriptId)
{
var index = 0;
foreach (var transcript in transcripts)
{
string onReverseStrand = transcript.Gene.OnReverseStrand ? "R" : "F";
if (transcript.Exons.Length != transcript.CdnaMaps.Length)
{
logger.Log(transcriptId, $"Found different exon & cDNA maps counts ({transcript.Exons.Length} vs {transcript.CdnaMaps.Length}) (index: {index}, {onReverseStrand})");
}
if (transcript.Exons.Length == transcript.CdnaMaps.Length &&
DiffExonsAndCdnaMaps(transcript.Exons, transcript.CdnaMaps))
{
logger.Log(transcriptId, $"Found different start/end coordinates between exons & cDNA maps. (index: {index}, {onReverseStrand})");
}
index++;
}
return transcripts;
}
private static bool DiffExonsAndCdnaMaps(IReadOnlyList<MutableExon> exons,
IReadOnlyList<MutableTranscriptRegion> cdnaMaps)
{
int numExons = exons.Count;
for (var i = 0; i < numExons; i++)
{
var exon = exons[i];
var cdnaMap = cdnaMaps[i];
if (exon.Start != cdnaMap.Start || exon.End != cdnaMap.End) return false;
}
return false;
}
public static List<MutableTranscript> ChooseEditedTranscripts(
this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var filteredTranscripts = transcripts.Where(transcript => transcript.RnaEdits != null || transcript.BamEditStatus == "ok").ToList();
if (filteredTranscripts.Count == 0) return transcripts;
logger.Log(transcripts[0].Id, "Filtered transcripts without RNA edits or BAM edit status");
return filteredTranscripts.Unique();
}
public static List<MutableTranscript> RemoveFailedTranscripts(
this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var filteredTranscripts = transcripts.Where(transcript => transcript.BamEditStatus != "failed").ToList();
if (filteredTranscripts.Count == 0) return transcripts;
logger.Log(transcripts[0].Id, "Filtered transcripts with failed BAM status.");
return filteredTranscripts.Unique();
}
public static List<MutableTranscript> RemoveTranscriptsWithLowestVersion(
this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var versionToTranscript = transcripts.GetMultiValueDict(x => x.Version);
if (versionToTranscript.Count == 1) return transcripts;
byte maxVersion = versionToTranscript.Keys.Max();
transcripts.RemoveAll(x => x.Version != maxVersion);
logger.Log(transcripts[0].Id, "Filtered transcripts with lower versions");
return transcripts.Unique();
}
public static List<MutableTranscript> Unique(this IEnumerable<MutableTranscript> transcripts)
{
var set = new HashSet<MutableTranscript>(Comparer);
foreach (var transcript in transcripts) set.Add(transcript);
return set.ToList();
}
public static List<MutableTranscript> FixCodingRegionCdnaStart(this List<MutableTranscript> transcripts,
TranscriptMergerLogger logger, IReadOnlyDictionary<string, GenbankEntry> idToGenbankEntry, string transcriptId)
{
if (transcripts.Count == 1 || idToGenbankEntry == null || !idToGenbankEntry.TryGetValue(transcriptId, out var genbankEntry)) return transcripts;
var cdnaStartToTranscript = transcripts.GetMultiValueDict(x => x.CodingRegion.CdnaStart);
if (cdnaStartToTranscript.Count == 1) return transcripts;
if (!cdnaStartToTranscript.TryGetValue(genbankEntry.CodingRegion.Start, out var filteredTranscripts))
return transcripts;
logger.Log(transcripts[0].Id, "Filtered transcripts by coding region cDNA start");
return filteredTranscripts.Unique();
}
public static List<MutableTranscript> FixCodingRegionCdnaEnd(this List<MutableTranscript> transcripts,
TranscriptMergerLogger logger, IReadOnlyDictionary<string, GenbankEntry> idToGenbankEntry, string transcriptId)
{
if (transcripts.Count == 1 || idToGenbankEntry == null || !idToGenbankEntry.TryGetValue(transcriptId, out var genbankEntry)) return transcripts;
var cdnaEndToTranscript = transcripts.GetMultiValueDict(x => x.CodingRegion.CdnaEnd);
if (cdnaEndToTranscript.Count == 1) return transcripts;
if (!cdnaEndToTranscript.TryGetValue(genbankEntry.CodingRegion.End, out var filteredTranscripts))
return transcripts;
logger.Log(transcripts[0].Id, "Filtered transcripts by coding region cDNA end");
return filteredTranscripts.Unique();
}
public static List<MutableTranscript> FixGeneSymbolSource(this List<MutableTranscript> transcripts,
TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var symbolSources = transcripts.GetSet(x => x.Gene.SymbolSource);
if (symbolSources.Count == 1) return transcripts;
if (symbolSources.Contains(GeneSymbolSource.Unknown)) symbolSources.Remove(GeneSymbolSource.Unknown);
if (symbolSources.Count != 1) throw new NotImplementedException("Cannot handle multiple gene symbol sources at this time");
var targetSymbolSource = symbolSources.First();
foreach (var transcript in transcripts) transcript.Gene.SymbolSource = targetSymbolSource;
logger.Log(transcripts[0].Id, "Normalized gene symbol source");
return transcripts.Unique();
}
public static List<MutableTranscript> FixBioType(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var biotypes = transcripts.GetSet(x => x.BioType);
if (biotypes.Count != 2) return transcripts;
var biotype = GetDesiredBioType(biotypes);
if (biotype == BioType.other) return transcripts;
foreach (var transcript in transcripts) transcript.BioType = biotype;
logger.Log(transcripts[0].Id, "Normalized biotype");
return transcripts.Unique();
}
private static readonly BioType[] MiscRnaBioTypes =
{
BioType.antisense_RNA,
BioType.miRNA,
BioType.pseudogene,
BioType.lncRNA,
BioType.protein_coding,
BioType.rRNA,
BioType.SRP_RNA,
BioType.vaultRNA,
BioType.Y_RNA
};
private static readonly BioType[] LncRnaBioTypes =
{
BioType.antisense_RNA,
BioType.pseudogene
};
private static BioType GetDesiredBioType(ICollection<BioType> biotypes)
{
if (biotypes.Contains(BioType.misc_RNA))
{
foreach (var biotype in MiscRnaBioTypes)
if (biotypes.Contains(biotype))
return biotype;
}
if (biotypes.Contains(BioType.lncRNA) && LncRnaBioTypes.Any(biotypes.Contains)) return BioType.lncRNA;
if (biotypes.Contains(BioType.mRNA) && biotypes.Contains(BioType.protein_coding))
return BioType.protein_coding;
return BioType.other;
}
public static List<MutableTranscript> FixGeneId(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger,
Dictionary<string, GenbankEntry> idToGenbankEntry, string transcriptId)
{
if (transcripts.Count == 1 || idToGenbankEntry == null || !idToGenbankEntry.TryGetValue(transcriptId, out var genbankEntry)) return transcripts;
var geneIds = transcripts.GetSet(x => x.Gene.GeneId);
if (geneIds.Count == 1) return transcripts;
if (!geneIds.Contains(genbankEntry.GeneId)) throw new InvalidDataException($"Could not find the Genbank gene ID ({genbankEntry.GeneId}) within the transcripts.");
foreach (var transcript in transcripts) transcript.Gene.GeneId = genbankEntry.GeneId;
logger.Log(transcripts[0].Id, "Normalized gene ID");
return transcripts.Unique();
}
public static List<MutableTranscript> UnsupervisedFixGeneId(this List<MutableTranscript> transcripts,
TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var geneIds = transcripts.GetSet(x => x.Gene.GeneId).ToList();
if (geneIds.Count == 1) return transcripts;
string geneId = geneIds[0];
foreach (var transcript in transcripts) transcript.Gene.GeneId = geneId;
logger.Log(transcripts[0].Id, "Normalized gene ID (unsupervised)");
return transcripts.Unique();
}
public static List<MutableTranscript> FixGeneSymbols(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger,
Dictionary<string, GenbankEntry> idToGenbankEntry, string transcriptId)
{
if (transcripts.Count == 1) return transcripts;
var symbols = transcripts.GetSet(x => x.Gene.Symbol);
if (symbols.Count == 1) return transcripts;
if (symbols.Contains(null)) symbols.Remove(null);
if (idToGenbankEntry == null || !idToGenbankEntry.TryGetValue(transcriptId, out var genbankEntry))
return transcripts.UnsupervisedFixGeneSymbols(logger, symbols.ToList());
if (!symbols.Contains(genbankEntry.Symbol)) return transcripts.UnsupervisedFixGeneSymbols(logger, symbols.ToList());
foreach (var transcript in transcripts) transcript.Gene.Symbol = genbankEntry.Symbol;
logger.Log(transcripts[0].Id, "Normalized gene symbol");
return transcripts.Unique();
}
public static List<MutableTranscript> FixCanonical(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var canonicals = transcripts.GetSet(x => x.IsCanonical);
if (canonicals.Count == 1) return transcripts;
foreach (var transcript in transcripts) transcript.IsCanonical = false;
logger.Log(transcripts[0].Id, "Normalized canonical flag");
return transcripts.Unique();
}
public static List<MutableTranscript> FixHgncId(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var hgncIds = transcripts.GetSet(x => x.Gene.HgncId);
if (hgncIds.Count == 1) return transcripts;
if (hgncIds.Contains(-1)) hgncIds.Remove(-1);
int hgncId = hgncIds.First();
foreach (var transcript in transcripts) transcript.Gene.HgncId = hgncId;
logger.Log(transcripts[0].Id, "Normalized HGNC ID");
return transcripts.Unique();
}
public static List<MutableTranscript> FixGeneStart(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var geneStarts = transcripts.GetSet(x => x.Gene.Start);
if (geneStarts.Count == 1) return transcripts;
var transcriptStarts = transcripts.GetSet(x => x.Start).ToArray();
if (transcriptStarts.Length > 1) return transcripts;
int closestStart = GetClosest(geneStarts, transcriptStarts[0]);
foreach (var transcript in transcripts) transcript.Gene.Start = closestStart;
logger.Log(transcripts[0].Id, "Normalized gene start");
return transcripts.Unique();
}
public static List<MutableTranscript> FixGeneEnd(this List<MutableTranscript> transcripts, TranscriptMergerLogger logger)
{
if (transcripts.Count == 1) return transcripts;
var geneEnds = transcripts.GetSet(x => x.Gene.End);
if (geneEnds.Count == 1) return transcripts;
var transcriptEnds = transcripts.GetSet(x => x.End).ToArray();
if (transcriptEnds.Length > 1) return transcripts;
int closestEnd = GetClosest(geneEnds, transcriptEnds[0]);
foreach (var transcript in transcripts) transcript.Gene.End = closestEnd;
logger.Log(transcripts[0].Id, "Normalized gene end");
return transcripts.Unique();
}
private static List<MutableTranscript> UnsupervisedFixGeneSymbols(this IReadOnlyList<MutableTranscript> transcripts,
TranscriptMergerLogger logger, List<string> symbols)
{
var nonLocGeneSymbols = symbols.FindAll(x => !string.IsNullOrEmpty(x) && !x.StartsWith("LOC"));
string symbol = nonLocGeneSymbols.Count > 0 ? nonLocGeneSymbols[0] : symbols[0];
foreach (var transcript in transcripts) transcript.Gene.Symbol = symbol;
logger.Log(transcripts[0].Id, "Normalized gene symbol (unsupervised)");
return transcripts.Unique();
}
private static int GetClosest(IEnumerable<int> values, int targetValue)
{
int bestDelta = int.MaxValue;
int bestValue = -1;
foreach (int value in values)
{
int delta = Math.Abs(value - targetValue);
if (delta >= bestDelta) continue;
bestDelta = delta;
bestValue = value;
}
return bestValue;
}
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptIdFilter.cs
================================================
using System.IO;
using System.Linq;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public sealed class TranscriptIdFilter
{
private readonly string[] _whitelist;
public TranscriptIdFilter(Source source)
{
// ReSharper disable once SwitchStatementMissingSomeCases
switch (source)
{
case Source.Ensembl:
_whitelist = new[] { "ENSE0", "ENSG0", "ENSP0", "ENST0" };
break;
case Source.RefSeq:
_whitelist = new[] { "NG_", "NM_", "NP_", "NR_", "XM_", "XP_", "XR_", "YP_" };
break;
default:
throw new InvalidDataException($"Unhandled import mode found: {source}");
}
}
public bool Pass(MutableTranscript transcript) => _whitelist.Any(prefix => transcript.Id.StartsWith(prefix)) && !transcript.Id.Contains("dupl");
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptMerger.cs
================================================
using System;
using System.Collections.Generic;
using System.Linq;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using CacheUtils.Genbank;
using CacheUtils.Genes.Utilities;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public static class TranscriptMerger
{
/// <summary>
/// separates the transcripts by ID and clusters the transcripts into overlapping
/// islands. From there we can resolve differences and return a unique transcript
/// for each cluster.
/// </summary>
public static List<MutableTranscript> Merge(TranscriptMergerLogger logger, IEnumerable<MutableTranscript> transcripts,
Dictionary<string, GenbankEntry> idToGenbankEntry)
{
var idToTranscripts = transcripts.GetMultiValueDict(x => x.Id + "|" + x.Start + "|" + x.End);
var mergedTranscripts = idToTranscripts.Select(kvp => Merge(logger, kvp.Value, idToGenbankEntry)).ToList();
return mergedTranscripts.OrderBy(x => x.Start).ThenBy(x => x.End).ToList();
}
private static MutableTranscript Merge(TranscriptMergerLogger logger, IReadOnlyList<MutableTranscript> transcripts,
Dictionary<string, GenbankEntry> idToGenbankEntry)
{
string transcriptId = transcripts[0].Id;
if (transcripts.Count == 1)
{
transcripts.Unique().InvestigateInconsistentCdnaMaps(logger, transcriptId);
return transcripts[0];
}
var filteredTranscripts = transcripts
.Unique()
.InvestigateInconsistentCdnaMaps(logger, transcriptId)
.RemoveFailedTranscripts(logger)
.ChooseEditedTranscripts(logger)
.RemoveTranscriptsWithLowestVersion(logger)
.FixCodingRegionCdnaStart(logger, idToGenbankEntry, transcriptId)
.FixCodingRegionCdnaEnd(logger, idToGenbankEntry, transcriptId)
.FixGeneSymbolSource(logger)
.FixBioType(logger)
.FixGeneId(logger, idToGenbankEntry, transcriptId)
.FixCanonical(logger)
.FixHgncId(logger)
.FixGeneStart(logger)
.FixGeneEnd(logger)
.FixGeneSymbols(logger, idToGenbankEntry, transcriptId)
.UnsupervisedFixGeneId(logger)
.PickSpecificTranscript(logger, transcriptId);
if (filteredTranscripts.Count == 1) return filteredTranscripts[0];
throw new NotImplementedException($"Could not merge down to one transcript: {filteredTranscripts.Count} transcripts ({transcriptId})");
}
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptMergerLogger.cs
================================================
using System;
using System.IO;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public sealed class TranscriptMergerLogger : IDisposable
{
private readonly StreamWriter _writer;
public TranscriptMergerLogger(Stream stream) => _writer = new StreamWriter(stream);
public void WriteLine() => _writer.WriteLine();
public void WriteLine(string s) => _writer.WriteLine(s);
public void Write(string s) => _writer.Write(s);
public void SetBold() {
// not used
}
public void ResetColor()
{
// not used
}
public void Dispose() => _writer.Dispose();
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/VepCacheParser.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using CacheUtils.DataDumperImport.Import;
using CacheUtils.DataDumperImport.IO;
using Compression.Utilities;
using Genome;
using IO;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public sealed class VepCacheParser
{
private readonly Source _source;
private readonly TranscriptIdFilter _filter;
public VepCacheParser(Source source)
{
_source = source;
_filter = new TranscriptIdFilter(source);
}
public (List<IRegulatoryRegion> RegulatoryRegions, List<MutableTranscript> Transcripts) ParseDumpDirectory(
Chromosome chromosome, string dirPath)
{
var regulatoryRegions = ParseRegulatoryFiles(chromosome, dirPath);
var transcripts = ParseTranscriptFiles(chromosome, dirPath);
return (regulatoryRegions, transcripts);
}
private static List<IRegulatoryRegion> ParseRegulatoryFiles(Chromosome chromosome, string dirPath)
{
var regulatoryRegions = new List<IRegulatoryRegion>();
var files = FileUtilities.GetFileNamesInDir(dirPath, "*_reg_regulatory_regions_data_dumper.txt.gz")
.ToArray();
foreach (string dumpPath in VepRootDirectory.GetSortedFiles(files))
{
ParseRegulatoryDumpFile(chromosome, dumpPath, regulatoryRegions);
}
return regulatoryRegions;
}
private List<MutableTranscript> ParseTranscriptFiles(Chromosome chromosome, string dirPath)
{
var transcripts = new List<MutableTranscript>();
var files = FileUtilities.GetFileNamesInDir(dirPath, "*_transcripts_data_dumper.txt.gz").ToArray();
foreach (string dumpPath in VepRootDirectory.GetSortedFiles(files))
{
ParseTranscriptDumpFile(chromosome, dumpPath, transcripts);
}
return transcripts;
}
private static void ParseRegulatoryDumpFile(Chromosome chromosome, string filePath,
ICollection<IRegulatoryRegion> regulatoryRegions)
{
Console.WriteLine("- processing {0}", Path.GetFileName(filePath));
using (var reader = new DataDumperReader(GZipUtilities.GetAppropriateReadStream(filePath)))
{
foreach (var ad in reader.GetRootNode().Value.Values)
{
if (!(ad is ObjectKeyValueNode objectKeyValue)) continue;
foreach (var featureGroup in objectKeyValue.Value.Values)
{
switch (featureGroup.Key)
{
case "MotifFeature":
// not used
break;
case "RegulatoryFeature":
ParseRegulatoryRegions(chromosome, featureGroup, regulatoryRegions);
break;
default:
throw new InvalidDataException("Found an unexpected feature group (" + featureGroup.Key + ") in the regulatory regions file.");
}
}
}
}
}
private void ParseTranscriptDumpFile(Chromosome chromosome, string filePath,
ICollection<MutableTranscript> transcripts)
{
Console.WriteLine("- processing {0}", Path.GetFileName(filePath));
using (var reader = new DataDumperReader(GZipUtilities.GetAppropriateReadStream(filePath)))
{
foreach (var node in reader.GetRootNode().Value.Values)
{
if (!(node is ListObjectKeyValueNode transcriptNodes)) continue;
foreach (var tNode in transcriptNodes.Values)
{
if (!(tNode is ObjectValueNode transcriptNode)) throw new InvalidOperationException("Expected a transcript object value node, but the current node is not an object value.");
if (transcriptNode.Type != "Bio::EnsEMBL::Transcript") throw new InvalidOperationException($"Expected a transcript node, but the current data type is: [{transcriptNode.Type}]");
var transcript = ImportTranscript.Parse(transcriptNode, chromosome, _source);
if (_filter.Pass(transcript)) transcripts.Add(transcript);
}
}
}
}
private static void ParseRegulatoryRegions(Chromosome chromosome, IImportNode featureGroupNode,
ICollection<IRegulatoryRegion> regulatoryRegions)
{
if (!(featureGroupNode is ListObjectKeyValueNode regulatoryFeatureNodes)) return;
foreach (var node in regulatoryFeatureNodes.Values)
{
if (!(node is ObjectValueNode regulatoryFeatureNode)) throw new InvalidOperationException("Expected a regulatory region object value node, but the current node is not an object value.");
if (regulatoryFeatureNode.Type != "Bio::EnsEMBL::Funcgen::RegulatoryFeature") throw new InvalidOperationException($"Expected a regulatory region node, but the current data type is: [{regulatoryFeatureNode.Type}]");
var regulatoryRegion = ImportRegulatoryFeature.Parse(regulatoryFeatureNode, chromosome);
regulatoryRegions.Add(regulatoryRegion);
}
}
}
}
================================================
FILE: CacheUtils/Commands/ParseVepCacheDirectory/VepRootDirectory.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Genome;
namespace CacheUtils.Commands.ParseVepCacheDirectory
{
public sealed class VepRootDirectory
{
private readonly Dictionary<string, Chromosome> _refNameToChromosome;
public VepRootDirectory(Dictionary<string, Chromosome> refNameToChromosome)
{
_refNameToChromosome = refNameToChromosome;
}
public Dictionary<ushort, string> GetRefIndexToVepDir(string dirPath)
{
var vepDirectories = Directory.GetDirectories(dirPath);
var referenceDict = new Dictionary<ushort, string>();
foreach (string dir in vepDirectories)
{
string referenceName = Path.GetFileName(dir);
var chromosome = ReferenceNameUtilities.GetChromosome(_refNameToChromosome, referenceName);
if (chromosome.IsEmpty()) continue;
referenceDict[chromosome.Index] = dir;
}
return referenceDict;
}
public static IEnumerable<string> GetSortedFiles(IEnumerable<string> filePaths)
{
var sortedPaths = new SortedDictionary<int, string>();
foreach (string filePath in filePaths)
{
string fileName = Path.GetFileName(filePath);
if (fileName == null) continue;
int hyphenPos = fileName.IndexOf("-", StringComparison.Ordinal);
if (hyphenPos == -1) throw new InvalidDataException($"Could not find the hyphen in: [{fileName}]");
int position = int.Parse(fileName.Substring(0, hyphenPos));
sortedPaths[position] = filePath;
}
return sortedPaths.Values.ToArray();
}
}
}
================================================
FILE: CacheUtils/Commands/RegulatoryGFF/CreateRegulatoryGffMain.cs
================================================
using System;
using System.IO;
using CacheUtils.Helpers;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using Compression.Utilities;
using ErrorHandling;
using IO;
using ReferenceSequence.Utilities;
using VariantAnnotation.Interface.AnnotatedPositions;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.RegulatoryGFF
{
public static class CreateRegulatoryGffMain
{
private static string _referencePath;
private static string _inputPrefix;
private static string _outputFileName;
private static ExitCodes ProgramExecution()
{
using (var writer = GZipUtilities.GetStreamWriter(_outputFileName))
{
string cachePath = CacheConstants.TranscriptPath(_inputPrefix);
var sequenceData = SequenceHelper.GetDictionaries(_referencePath);
// load the cache
Console.Write("- reading {0}... ", Path.GetFileName(cachePath));
var cache = TranscriptCacheHelper.GetCache(cachePath, sequenceData.refIndexToChromosome);
Console.WriteLine("found {0:N0} reference sequences. ", cache.RegulatoryRegionIntervalArrays.Length);
Console.Write("- writing GFF entries... ");
foreach (var intervalArray in cache.RegulatoryRegionIntervalArrays)
{
if (intervalArray == null) continue;
foreach (var interval in intervalArray.Array) WriteRegulatoryFeature(writer, interval.Value);
}
Console.WriteLine("finished.");
}
return ExitCodes.Success;
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"in|i=",
"input cache {prefix}",
v => _inputPrefix = v
},
{
"out|o=",
"output {file name}",
v => _outputFileName = v
},
{
"ref|r=",
"reference {file}",
v => _referencePath = v
}
};
string commandLineExample = $"{command} --in <cache prefix> --out <GFF path>";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.HasRequiredParameter(_inputPrefix, "input cache prefix", "--in")
.CheckOutputFilenameSuffix(_outputFileName, ".gz", "GFF")
.SkipBanner()
.ShowHelpMenu("Outputs regulatory regions in a database.", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
private static void WriteRegulatoryFeature(TextWriter writer, IRegulatoryRegion regulatoryRegion)
{
writer.Write($"{regulatoryRegion.Chromosome.UcscName}\t.\tregulatory feature\t{regulatoryRegion.Start}\t{regulatoryRegion.End}\t.\t.\t.\t");
WriteGeneralAttributes(writer, regulatoryRegion);
writer.WriteLine();
}
private static void WriteGeneralAttributes(TextWriter writer, IRegulatoryRegion regulatoryRegion)
{
if (!regulatoryRegion.Id.IsEmpty()) writer.Write($"regulatory_feature_id \"{regulatoryRegion.Id}\"; ");
writer.Write($"regulatory_feature_type \"{regulatoryRegion.Type}\"; ");
}
}
}
================================================
FILE: CacheUtils/Commands/UniversalGeneArchive/FilePaths.cs
================================================
namespace CacheUtils.Commands.UniversalGeneArchive
{
// ReSharper disable UnusedAutoPropertyAccessor.Global
public sealed class FilePaths
{
public AssemblySpecificPaths GRCh37 { get; set; }
public AssemblySpecificPaths GRCh38 { get; set; }
// ReSharper disable once ClassNeverInstantiated.Global
public class AssemblySpecificPaths
{
public string ReferencePath { get; set; }
public string EnsemblCachePath { get; set; }
public string RefSeqCachePath { get; set; }
}
}
// ReSharper restore UnusedAutoPropertyAccessor.Global
}
================================================
FILE: CacheUtils/Commands/UniversalGeneArchive/UniversalGeneArchiveMain.cs
================================================
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using CacheUtils.Commands.Download;
using CacheUtils.Genes;
using CacheUtils.Genes.DataStores;
using CacheUtils.Genes.DataStructures;
using CacheUtils.Genes.IO;
using CommandLine.Builders;
using CommandLine.NDesk.Options;
using CommandLine.Utilities;
using Compression.FileHandling;
using ErrorHandling;
using IO;
using Microsoft.Extensions.Configuration;
using ReferenceSequence.Utilities;
using VariantAnnotation.Providers;
namespace CacheUtils.Commands.UniversalGeneArchive
{
public static class UniversalGeneArchiveMain
{
private static string _referencesPath;
private static string _intermediateCachePath;
private static ExitCodes ProgramExecution()
{
if (UniversalGeneArchiveCurrent())
{
Logger.WriteLine("- universal gene archive is already up-to-date.");
return ExitCodes.Success;
}
const string jsonPath = "CacheUtils.dll.gene.json";
var filePaths = GetFilePaths(jsonPath);
var ds = LoadDataStores(filePaths);
var grch37GenesByRef = ds.Assembly37.UpdateHgncIds(ds.Hgnc).MergeByHgnc(true);
var grch38GenesByRef = ds.Assembly38.UpdateHgncIds(ds.Hgnc).MergeByHgnc(false);
var universalGenes = CombineGenomeAssemblies(grch37GenesByRef, grch38GenesByRef).UpdateGeneSymbols(
ds.Hgnc.HgncIdToSymbol, ds.GeneInfoData.EntrezGeneIdToSymbol,
ds.Assembly38.EnsemblGtf.EnsemblIdToSymbol, ds.Assembly37.RefSeqGff.EntrezGeneIdToSymbol);
WriteGenes(universalGenes);
return ExitCodes.Success;
}
private static bool UniversalGeneArchiveCurrent()
{
var fileInfo = new FileInfo(ExternalFiles.UniversalGeneFilePath);
return fileInfo.Exists && ExternalFiles.GetElapsedDays(fileInfo.CreationTime) < 1.0;
}
private static (GeneInfoData GeneInfoData, AssemblyDataStore Assembly37, AssemblyDataStore Assembly38, Hgnc Hgnc)
LoadDataStores(FilePaths filePaths)
{
Logger.Write("- loading datastores... ");
var loadBenchmark = new Benchmark();
var (_, refNameToChromosome, _) = SequenceHelper.GetDictionaries(filePaths.GRCh38.ReferencePath);
var geneInfoData = GeneInfoData.Create(ExternalFiles.GeneInfoFile.FilePath);
var dataStore37 = AssemblyDataStore.Create("GRCh37", filePaths.GRCh37, refNameToChromosome, true);
var dataStore38 = AssemblyDataStore.Create("GRCh38", filePaths.GRCh38, refNameToChromosome, false);
var hgnc = Hgnc.Create(ExternalFiles.HgncFile.FilePath, refNameToChromosome);
Logger.WriteLine($"{Benchmark.ToHumanReadable(loadBenchmark.GetElapsedTime())}");
return (geneInfoData, dataStore37, dataStore38, hgnc);
}
private static UgaGene[] CombineGenomeAssemblies(Dictionary<ushort, List<UgaGene>> genesByRef37, Dictionary<ushort, List<UgaGene>> genesByRef38)
{
Logger.WriteLine("\n*** Global ***");
Logger.Write("- combining genes from GRCh37 and GRCh38... ");
var combinedGenes = UgaAssemblyCombiner.Combine(genesByRef37, genesByRef38);
Logger.WriteLine($"{combinedGenes.Length} genes.");
return combinedGenes;
}
private static UgaGene[] UpdateGeneSymbols(this UgaGene[] genes, Dictionary<int, string> hgncIdToSymbol, Dictionary<string, string> entrezGeneIdToSymbol,
Dictionary<string, string> ensemblIdToSymbol, Dictionary<string, string> refseqGeneIdToSymbol)
{
var updater = new GeneSymbolUpdater(hgncIdToSymbol, entrezGeneIdToSymbol, ensemblIdToSymbol, refseqGeneIdToSymbol);
updater.Update(genes);
return genes;
}
private static void WriteGenes(UgaGene[] genes)
{
Logger.Write($"- writing genes to {Path.GetFileName(ExternalFiles.UniversalGeneFilePath)}... ");
using (var stream = new BlockGZipStream(FileUtilities.GetCreateStream(ExternalFiles.UniversalGeneFilePath), CompressionMode.Compress))
using (var writer = new UgaGeneWriter(stream))
{
writer.Write(genes);
}
Logger.WriteLine("finished");
}
private static FilePaths GetFilePaths(string jsonPath)
{
var builder = new ConfigurationBuilder();
builder.AddJsonFile(jsonPath);
var configuration = builder.Build();
var filePaths = new FilePaths();
configuration.Bind(filePaths);
UpdatePaths(filePaths.GRCh37);
UpdatePaths(filePaths.GRCh38);
CheckPaths(filePaths.GRCh37);
CheckPaths(filePaths.GRCh38);
return filePaths;
}
private static void UpdatePaths(FilePaths.AssemblySpecificPaths paths)
{
paths.EnsemblCachePath = Path.Combine(_intermediateCachePath, paths.EnsemblCachePath);
paths.RefSeqCachePath = Path.Combine(_intermediateCachePath, paths.RefSeqCachePath);
paths.ReferencePath = Path.Combine(_referencesPath, paths.ReferencePath);
}
private static void CheckPath(string filePath, string description)
{
if (string.IsNullOrEmpty(filePath)) throw new InvalidDataException($"No value was found for the {description} key.");
if (!File.Exists(filePath)) throw new FileNotFoundException($"Unable to find the following file: {filePath}");
}
private static void CheckPaths(FilePaths.AssemblySpecificPaths paths)
{
CheckPath(paths.EnsemblCachePath, "Ensembl intermediate cache");
CheckPath(paths.RefSeqCachePath, "RefSeq intermediate cache");
CheckPath(paths.ReferencePath, "reference");
}
public static ExitCodes Run(string command, string[] args)
{
var ops = new OptionSet
{
{
"icache|i=",
"intermediate cache {dir}",
v => _intermediateCachePath = v
},
{
"ref|r=",
"reference {dir}",
v => _referencesPath = v
}
};
string commandLineExample = $"{command} -i <intermediate cache dir> -r <reference dir>";
return new ConsoleAppBuilder(args, ops)
.UseVersionProvider(new VersionProvider())
.Parse()
.CheckDirectoryExists(_intermediateCachePath, "intermediate cache", "--icache")
.CheckDirectoryExists(_referencesPath, "reference", "--ref")
.SkipBanner()
.ShowHelpMenu("Creates the universal gene archive", commandLineExample)
.ShowErrors()
.Execute(ProgramExecution);
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/GenomeSymbolSource.cs
================================================
namespace CacheUtils.DataDumperImport.DataStructures
{
public enum GeneSymbolSource : byte
{
// ReSharper disable InconsistentNaming
Unknown,
CloneBasedEnsemblGene,
CloneBasedVegaGene,
EntrezGene,
HGNC,
LRG,
NCBI,
miRBase,
RFAM,
UniProtGeneName
// ReSharper restore InconsistentNaming
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/IImportNode.cs
================================================
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public interface IImportNode
{
string Key { get; }
}
public interface IListMember : IImportNode { }
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ImportNodeExtensions.cs
================================================
using System.IO;
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public static class ImportNodeExtensions
{
public static int GetInt32(this IImportNode node)
{
string s = GetString(node);
if (s == null) return -1;
if (!int.TryParse(s, out int ret))
{
throw new InvalidDataException($"Unable to convert the string ({s}) to an integer.");
}
return ret;
}
public static bool GetBool(this IImportNode node)
{
int num = GetInt32(node);
return num == 1;
}
public static string GetString(this IImportNode node)
{
if (!(node is StringKeyValueNode stringKeyValue))
{
throw new InvalidDataException($"Unable to convert the AbstractData type to a StringKeyValue type: [{node.Key}]");
}
string s = stringKeyValue.Value;
if (s == "" || s == "-") s = null;
return s;
}
public static bool IsUndefined(this IImportNode node)
{
if (!(node is StringKeyValueNode stringKeyValue)) return false;
return stringKeyValue.Value == null;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ListObjectKeyValueNode.cs
================================================
using System.Collections.Generic;
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public sealed class ListObjectKeyValueNode : IImportNode
{
public string Key { get; }
public List<IListMember> Values { get; } = new List<IListMember>();
public ListObjectKeyValueNode(string key) => Key = key;
public void Add(IListMember node) => Values.Add(node);
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ObjectKeyValueNode.cs
================================================
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public sealed class ObjectKeyValueNode : IImportNode
{
public string Key { get; }
public ObjectValueNode Value { get; }
public ObjectKeyValueNode(string key, ObjectValueNode value)
{
Key = key;
Value = value;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ObjectValueNode.cs
================================================
using System.Collections.Generic;
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public sealed class ObjectValueNode : IListMember
{
public string Type { get; }
public string Key { get; }
public List<IImportNode> Values { get; }
internal ObjectValueNode(string type, List<IImportNode> values)
{
Key = null;
Type = type;
Values = values;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/StringKeyValueNode.cs
================================================
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public sealed class StringKeyValueNode : IImportNode
{
public string Key { get; }
public string Value { get; }
public StringKeyValueNode(string key, string value)
{
Key = key;
Value = value;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Import/StringValueNode.cs
================================================
namespace CacheUtils.DataDumperImport.DataStructures.Import
{
public sealed class StringValueNode : IListMember
{
public string Key { get; }
public StringValueNode(string key) => Key = key;
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableExon.cs
================================================
using System;
using Genome;
using Intervals;
namespace CacheUtils.DataDumperImport.DataStructures.Mutable
{
public sealed class MutableExon : IEquatable<MutableExon>, IInterval
{
private readonly Chromosome _chromosome;
public readonly int Phase;
public int Start { get; }
public int End { get; }
public MutableExon(Chromosome chromosome, int start, int end, int phase)
{
_chromosome = chromosome;
Start = start;
End = end;
Phase = phase;
}
public bool Equals(MutableExon other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return _chromosome.Index == other._chromosome.Index && Start == other.Start && End == other.End &&
Phase == other.Phase;
}
public override int GetHashCode()
{
unchecked
{
int hashCode = _chromosome.Index.GetHashCode();
hashCode = (hashCode * 397) ^ Start;
hashCode = (hashCode * 397) ^ End;
hashCode = (hashCode * 397) ^ Phase.GetHashCode();
return hashCode;
}
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableGene.cs
================================================
using System;
using CacheUtils.Genes.DataStructures;
using Genome;
using Intervals;
namespace CacheUtils.DataDumperImport.DataStructures.Mutable
{
public sealed class MutableGene : IEquatable<MutableGene>, IFlatGene<MutableGene>
{
public Chromosome Chromosome { get; set; }
public int Start { get; set; }
public int End { get; set; }
public bool OnReverseStrand { get; }
public string GeneId { get; set; }
public string Symbol { get; set; }
public int HgncId { get; set; }
public GeneSymbolSource SymbolSource { get; set; }
public MutableGene(Chromosome chromosome, int start, int end, bool onReverseStrand, string symbol,
GeneSymbolSource symbolSource, string geneId, int hgncId)
{
Chromosome = chromosome;
Start = start;
End = end;
OnReverseStrand = onReverseStrand;
Symbol = symbol;
SymbolSource = symbolSource;
GeneId = geneId;
HgncId = hgncId;
}
public override string ToString()
{
string strand = OnReverseStrand ? "R" : "F";
return $"{GeneId}: {Chromosome.UcscName} {Start}-{End} {strand} symbol: {Symbol} ({SymbolSource}), HGNC ID: {HgncId}";
}
public bool Equals(MutableGene other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return Chromosome.Index == other.Chromosome.Index &&
Start == other.Start &&
End == other.End &&
OnReverseStrand == other.OnReverseStrand &&
Symbol == other.Symbol &&
GeneId == other.GeneId;
}
public override int GetHashCode()
{
unchecked
{
// ReSharper disable NonReadonlyMemberInGetHashCode
int hashCode = Chromosome.Index.GetHashCode();
hashCode = (hashCode * 397) ^ Start;
hashCode = (hashCode * 397) ^ End;
hashCode = (hashCode * 397) ^ OnReverseStrand.GetHashCode();
hashCode = (hashCode * 397) ^ Symbol.GetHashCode();
hashCode = (hashCode * 397) ^ GeneId.GetHashCode();
// ReSharper restore NonReadonlyMemberInGetHashCode
return hashCode;
}
}
public MutableGene Clone() => new MutableGene(Chromosome, Start, End, OnReverseStrand, Symbol, SymbolSource,
GeneId, HgncId);
public UgaGene ToUgaGene(bool isGrch37)
{
(string ensemblGeneId, string entrezGeneId) = GeneId.StartsWith("ENSG") ? (GeneId, null as string) : (null as string, GeneId);
IInterval interval = new Interval(Start, End);
(IInterval grch37, IInterval grch38) = isGrch37 ? (interval, null as IInterval) : (null as IInterval, interval);
return new UgaGene(Chromosome, grch37, grch38, OnReverseStrand, entrezGeneId, ensemblGeneId, Symbol,
HgncId);
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableTranscript.cs
================================================
using System;
using Genome;
using Intervals;
using VariantAnnotation.Caches.DataStructures;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.DataDumperImport.DataStructures.Mutable
{
public sealed class MutableTranscript : IEquatable<MutableTranscript>
{
public readonly Chromosome Chromosome;
public readonly int Start;
public readonly int End;
public readonly string Id;
public readonly byte Version;
public readonly string CcdsId;
public readonly string RefSeqId;
public readonly Source Source;
public readonly MutableGene Gene;
public readonly IInterval[] MicroRnas;
public readonly bool CdsStartNotFound;
public readonly bool CdsEndNotFound;
public readonly int[] SelenocysteinePositions;
public readonly int StartExonPhase;
public readonly IRnaEdit[] RnaEdits;
public readonly string ProteinId;
public readonly byte ProteinVersion;
public readonly string PeptideSequence;
public readonly MutableExon[] Exons;
public readonly int TotalExonLength;
public readonly IInterval[] Introns;
public readonly string TranslateableSequence;
public readonly MutableTranscriptRegion[] CdnaMaps;
public readonly string BamEditStatus;
// mutable
public BioType BioType;
public bool IsCanonical;
public Gene UpdatedGene;
public int CdsLength;
public ITranscriptRegion[] TranscriptRegions;
public byte NewStartExonPhase;
public ICodingRegion CodingRegion;
public readonly string SiftData;
public readonly string PolyphenData;
public int SiftIndex = -1;
public int PolyPhenIndex = -1;
public MutableTranscript(Chromosome chromosome, int start, int end, string id, byte version, string ccdsId,
string refSeqId, BioType bioType, bool isCanonical, ICodingRegion codingRegion, string proteinId,
byte proteinVersion, string peptideSequence, Source source, MutableGene gene, MutableExon[] exons,
int startExonPhase, int totalExonLength, IInterval[] introns, MutableTranscriptRegion[] cdnaMaps,
string siftData, string polyphenData, string translateableSequence, IInterval[] microRnas,
bool cdsStartNotFound, bool cdsEndNotFound, int[] selenocysteinePositions, IRnaEdit[] rnaEdits,
string bamEditStatus)
{
Chromosome = chromosome;
Start = start;
End = end;
Id = id;
Version = version;
CcdsId = ccdsId;
RefSeqId = refSeqId;
BioType = bioType;
IsCanonical = isCanonical;
CodingRegion = codingRegion;
ProteinId = proteinId;
ProteinVersion = proteinVersion;
PeptideSequence = peptideSequence;
Source = source;
Gene = gene;
Exons = exons;
StartExonPhase = startExonPhase;
TotalExonLength = totalExonLength;
Introns = introns;
CdnaMaps = cdnaMaps;
SiftData = siftData;
PolyphenData = polyphenData;
TranslateableSequence = translateableSequence;
MicroRnas = microRnas;
CdsStartNotFound = cdsStartNotFound;
CdsEndNotFound = cdsEndNotFound;
SelenocysteinePositions = selenocysteinePositions;
RnaEdits = rnaEdits;
BamEditStatus = bamEditStatus;
}
public bool Equals(MutableTranscript other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return Chromosome.Index == other.Chromosome.Index &&
Start == other.Start &&
End == other.End &&
Id == other.Id &&
Version == other.Version &&
BioType == other.BioType &&
Source == other.Source;
}
public override int GetHashCode()
{
unchecked
{
// ReSharper disable NonReadonlyMemberInGetHashCode
int hashCode = Chromosome.Index.GetHashCode();
hashCode = (hashCode * 397) ^ Start;
hashCode = (hashCode * 397) ^ End;
hashCode = (hashCode * 397) ^ Id.GetHashCode();
hashCode = (hashCode * 397) ^ Version.GetHashCode();
hashCode = (hashCode * 397) ^ (int) BioType;
hashCode = (hashCode * 397) ^ (int) Source;
return hashCode;
// ReSharper restore NonReadonlyMemberInGetHashCode
}
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableTranscriptRegion.cs
================================================
using IO;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.DataDumperImport.DataStructures.Mutable
{
public sealed class MutableTranscriptRegion : ITranscriptRegion
{
public int Start { get; }
public int End { get; }
public TranscriptRegionType Type { get; set; }
public ushort Id { get; set; }
public int CdnaStart { get; set; }
public int CdnaEnd { get; set; }
public MutableTranscriptRegion(TranscriptRegionType type, ushort id, int start, int end, int cdnaStart = -1,
int cdnaEnd = -1)
{
Type = type;
Id = id;
Start = start;
End = end;
CdnaStart = cdnaStart;
CdnaEnd = cdnaEnd;
}
public void Write(IExtendedBinaryWriter writer) => throw new System.NotImplementedException();
}
}
================================================
FILE: CacheUtils/DataDumperImport/FauxRegex/RegexDecisionTree.cs
================================================
using System;
using System.Linq;
using CacheUtils.DataDumperImport.IO;
namespace CacheUtils.DataDumperImport.FauxRegex
{
internal static class RegexDecisionTree
{
internal static (EntryType Type, string Key, string Value) GetEntryType(string s)
{
s = s.Trim().TrimEnd(',');
int fatArrowPos = s.IndexOf("=>", StringComparison.Ordinal);
return fatArrowPos != -1
? GetEntryTypeFatArrow(s, fatArrowPos)
: GetEntryTypeNoArrow(s);
}
private static (EntryType Type, string Key, string Value) GetEntryTypeNoArrow(string s)
{
int varPos = s.IndexOf("$VAR", StringComparison.Ordinal);
return varPos != -1 ? GetEntryTypeVar(s) : GetEntryTypeNoVar(s);
}
private static (EntryType Type, string Key, string Value) GetEntryTypeNoVar(string s)
{
s = s.TrimEnd(';');
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (s == "}") return (EntryType.EndBraces, null, null);
if (s == "bless( {") return (EntryType.OpenBraces, null, null);
int endBracePos = s.IndexOf("}, 'Bio::", StringComparison.Ordinal);
if (endBracePos != -1) return GetEntryTypeDataPos(s, endBracePos + 4);
s = s.Trim('\'');
if (OnlyDigits(s)) return (EntryType.DigitKey, s, null);
throw new NotImplementedException($"Unable to match the non-$VAR regexes: [{s}]");
}
private static (EntryType Type, string Key, string Value) GetEntryTypeDataPos(string s,
int afterFirstQuote)
{
return (EntryType.EndBracesWithDataType, GetForwardString(s, afterFirstQuote), null);
}
private static (EntryType Type, string Key, string Value) GetEntryTypeVar(string s)
{
if (!s.EndsWith(" = {")) throw new NotImplementedException("Unable to match the $VAR regexes: [{s}]");
int spacePos = s.IndexOf(' ');
return (EntryType.RootObjectKeyValue, s.Substring(0, spacePos), null);
}
private static (EntryType, string Key, string Value) GetEntryTypeFatArrow(string s, int fatArrowPos)
{
string key = GetKey(s, fatArrowPos - 2);
int firstPosAfterFatArrow = fatArrowPos + 3;
if (s[firstPosAfterFatArrow] == '\'') return GetEntryTypeStringKeyValue(s, firstPosAfterFatArrow + 1, key);
if (s[s.Length - 1] == '{') return (EntryType.ObjectKeyValue, key, null);
string afterFatArrow = s.Substring(firstPosAfterFatArrow);
// ReSharper disable once ConvertIfStatementToSwitchStatement
if (afterFatArrow == "undef") return (EntryType.UndefKeyValue, key, null);
if (afterFatArrow == "{}") return (EntryType.EmptyValueKeyValue, key, null);
if (afterFatArrow == "[]") return (EntryType.EmptyListKeyValue, key, null);
if (afterFatArrow.StartsWith("$VAR")) return (EntryType.ReferenceStringKeyValue, key, afterFatArrow);
if (s[firstPosAfterFatArrow] == '[') return (EntryType.ListObjectKeyValue, key, null);
if (OnlyDigits(afterFatArrow)) return (EntryType.DigitKeyValue, key, afterFatArrow);
throw new NotImplementedException();
}
private static (EntryType, string Key, string Value) GetEntryTypeStringKeyValue(string s, int afterFirstQuote, string key)
{
int secondQuotePos = s.IndexOf('\'', afterFirstQuote);
return secondQuotePos == -1
? (EntryType.MultiLineKeyValue, key, s.Substring(afterFirstQuote))
: (EntryType.StringKeyValue, key, s.Substring(afterFirstQuote,
secondQuotePos - afterFirstQuote));
}
private static string GetKey(string s, int secondQuotePos)
{
int afterFirstQuote = s.LastIndexOf('\'', secondQuotePos - 1) + 1;
return s.Substring(afterFirstQuote, secondQuotePos - afterFirstQuote);
}
private static string GetForwardString(string s, int afterFirstQuote)
{
int secondQuotePos = s.IndexOf('\'', afterFirstQuote);
string result = s.Substring(afterFirstQuote, secondQuotePos - afterFirstQuote);
return result;
}
internal static bool OnlyDigits(string s) => s.All(c => char.IsDigit(c) || c == '-');
}
}
================================================
FILE: CacheUtils/DataDumperImport/IO/DataDumperReader.cs
================================================
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.FauxRegex;
using IO;
using OptimizedCore;
namespace CacheUtils.DataDumperImport.IO
{
public sealed class DataDumperReader : IDisposable
{
private readonly StreamReader _reader;
private readonly StringBuilder _sb = new StringBuilder();
public DataDumperReader(Stream stream) => _reader = FileUtilities.GetStreamReader(stream);
private string GetNextLine() => _reader.ReadLine();
public ObjectKeyValueNode GetRootNode()
{
string line = GetNextLine();
if (line == null) throw new InvalidDataException("Expected a root object node, but no data was found.");
var results = RegexDecisionTree.GetEntryType(line);
if (results.Type != EntryType.RootObjectKeyValue) throw new InvalidDataException($"Expected a root object node, but found a {results.Type} node.");
return new ObjectKeyValueNode(results.Key, GetObjectValue());
}
private static StringValueNode GetDigitKey(string key) => new StringValueNode(key);
private ListObjectKeyValueNode GetListObjectKeyValue(string key)
{
var listObjectKeyValue = new ListObjectKeyValueNode(key);
while (true)
{
string line = GetNextLine().Trim().TrimEnd(',');
if (line == "]") break;
var results = RegexDecisionTree.GetEntryType(line);
// ReSharper disable once SwitchStatementMissingSomeCases
switch (results.Type)
{
case EntryType.OpenBraces:
listObjectKeyValue.Add(GetObjectValue());
break;
case EntryType.DigitKey:
listObjectKeyValue.Add(GetDigitKey(line));
break;
default:
throw new InvalidDataException($"Unhandled entry type encountered: {results.Type}");
}
}
return listObjectKeyValue;
}
private StringKeyValueNode GetMultiLineKeyValue(string key, string value)
{
_sb.Clear();
_sb.Append(value);
while (true)
{
string line = GetNextLine().Trim();
if (line.OptimizedStartsWith('\'')) break;
_sb.Append(' ');
_sb.Append(line);
}
return new StringKeyValueNode(key, _sb.ToString());
}
private ObjectValueNode GetObjectValue()
{
var type = "(unknown)";
var nodes = new List<IImportNode>();
while (true)
{
string line = GetNextLine();
var results = RegexDecisionTree.GetEntryType(line);
if (results.Type == EntryType.EndBraces || results.Type == EntryType.EndBracesWithDataType)
{
if (results.Type == EntryType.EndBracesWithDataType) type = results.Key;
break;
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (results.Type)
{
case EntryType.ObjectKeyValue:
nodes.Add(new ObjectKeyValueNode(results.Key, GetObjectValue()));
break;
case EntryType.ListObjectKeyValue:
nodes.Add(GetListObjectKeyValue(results.Key));
break;
case EntryType.DigitKeyValue:
case EntryType.StringKeyValue:
case EntryType.ReferenceStringKeyValue:
nodes.Add(new StringKeyValueNode(results.Key, results.Value));
break;
case EntryType.UndefKeyValue:
case EntryType.EmptyListKeyValue:
case EntryType.EmptyValueKeyValue:
nodes.Add(new StringKeyValueNode(results.Key, null));
break;
case EntryType.MultiLineKeyValue:
nodes.Add(GetMultiLineKeyValue(results.Key, results.Value));
break;
default:
throw new InvalidDataException($"Unhandled entry type encountered in GetObjectValue: {results.Type}: [{line}]");
}
}
return new ObjectValueNode(type, nodes);
}
public void Dispose() => _reader.Dispose();
}
}
================================================
FILE: CacheUtils/DataDumperImport/IO/EntryType.cs
================================================
namespace CacheUtils.DataDumperImport.IO
{
internal enum EntryType
{
DigitKeyValue,
DigitKey,
EmptyListKeyValue,
EmptyValueKeyValue,
EndBraces,
EndBracesWithDataType,
ListObjectKeyValue,
MultiLineKeyValue,
ObjectKeyValue,
OpenBraces,
ReferenceStringKeyValue,
RootObjectKeyValue,
StringKeyValue,
UndefKeyValue
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/Attribute.cs
================================================
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.Utilities;
using Intervals;
using OptimizedCore;
using VariantAnnotation.Caches.DataStructures;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.DataDumperImport.Import
{
internal static class Attribute
{
private static readonly HashSet<string> KnownKeys;
private static readonly Regex RangeRegex;
static Attribute()
{
KnownKeys = new HashSet<string>
{
ImportKeys.Name,
ImportKeys.Description,
ImportKeys.Code,
ImportKeys.Value
};
RangeRegex = new Regex("(\\d+)-(\\d+)", RegexOptions.Compiled);
}
/// <summary>
/// returns an array of miRNAs given a list of ObjectValues (AbstractData)
/// </summary>
public static (IInterval[] MicroRnas, IRnaEdit[] RnaEdits, bool CdsStartNotFound, bool CdsEndNotFound) ParseList(
IImportNode importNode)
{
var listMembers = importNode.GetListMembers();
if (listMembers == null) throw new InvalidDataException("Encountered an attribute node that could not be converted to a member list.");
var microRnaList = new List<IInterval>();
var rnaEditList = new List<IRnaEdit>();
var cdsStartNotFound = false;
var cdsEndNotFound = false;
foreach (var node in listMembers)
{
if (!(node is ObjectValueNode objectValue))
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectValue: [{node.GetType()}]");
(string key, string value) = ParseKeyValue(objectValue);
if (key == null) continue;
// ReSharper disable once SwitchStatementMissingSomeCases
switch (key)
{
case "miRNA":
microRnaList.Add(GetInterval(value));
break;
case "_rna_edit":
rnaEditList.Add(GetRnaEdit(value));
break;
case "cds_start_NF":
cdsStartNotFound = true;
break;
case "cds_end_NF":
cdsEndNotFound = true;
break;
}
}
var microRnas = microRnaList.Count == 0 ? null : microRnaList.ToArray();
var rnaEdits = rnaEditList.Count == 0 ? null : rnaEditList.ToArray();
return (microRnas, rnaEdits, cdsStartNotFound, cdsEndNotFound);
}
private static IInterval GetInterval(string s)
{
var rangeMatch = RangeRegex.Match(s);
if (!rangeMatch.Success) throw new InvalidDataException($"Unable to convert the Attribute to a miRNA object. The value string failed the regex: {s}");
int start = int.Parse(rangeMatch.Groups[1].Value);
int end = int.Parse(rangeMatch.Groups[2].Value);
return new Interval(start, end);
}
private static RnaEdit GetRnaEdit(string s)
{
var cols = s.OptimizedSplit(' ');
if (cols.Length != 3) throw new InvalidDataException($"Expected 3 columns but found {cols.Length} when parsing RNA edit");
int start = int.Parse(cols[0]);
int end = int.Parse(cols[1]);
string bases = cols[2];
return new RnaEdit(start, end, bases);
}
private static (string Key, string Value) ParseKeyValue(ObjectValueNode objectValue)
{
string key = null;
string value = null;
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 attribute object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.Name:
case ImportKeys.Description:
// not used
break;
case ImportKeys.Code:
key = node.GetString();
break;
case ImportKeys.Value:
value = node.GetString();
break;
default:
throw new InvalidDataException($"Unknown key found: {node.Key}");
}
}
return (key, value);
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportExon.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using CacheUtils.DataDumperImport.Utilities;
using Genome;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportExon
{
private static readonly HashSet<string> KnownKeys;
static ImportExon()
{
KnownKeys = new HashSet<string>
{
ImportKeys.End,
ImportKeys.EndPhase,
ImportKeys.Phase,
ImportKeys.StableId,
ImportKeys.Start,
ImportKeys.Strand
};
}
/// <summary>
/// returns a new exon given an ObjectValue
/// </summary>
public static MutableExon Parse(ObjectValueNode objectValue, Chromosome currentChromosome)
{
int start = -1;
int end = -1;
int phase = int.MinValue;
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 mapper object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.Strand:
case ImportKeys.StableId:
case ImportKeys.EndPhase:
// not used
break;
case ImportKeys.End:
end = node.GetInt32();
break;
case ImportKeys.Phase:
phase = node.GetInt32();
break;
case ImportKeys.Start:
start = node.GetInt32();
break;
default:
throw new InvalidDataException($"Unknown key found: {node.Key}");
}
}
return new MutableExon(currentChromosome, start, end, phase);
}
/// <summary>
/// returns an array of exons given a list of ObjectValues (AbstractData)
/// </summary>
public static MutableExon[] ParseList(IImportNode importNode, Chromosome chromosome)
{
var listMembers = importNode.GetListMembers();
if (listMembers == null) throw new InvalidDataException("Encountered an exon node that could not be converted to a member list.");
var exons = new MutableExon[listMembers.Count];
for (var exonIndex = 0; exonIndex < listMembers.Count; exonIndex++)
{
if (listMembers[exonIndex] is ObjectValueNode objectValue)
{
exons[exonIndex] = Parse(objectValue, chromosome);
}
else
{
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectValue: [{listMembers[exonIndex].GetType()}]");
}
}
return exons;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportGene.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.Utilities;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportGene
{
private static readonly HashSet<string> KnownKeys;
static ImportGene()
{
KnownKeys = new HashSet<string>
{
ImportKeys.End,
ImportKeys.StableId,
ImportKeys.Start,
ImportKeys.Strand
};
}
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);
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportIntron.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using Intervals;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportIntron
{
private static readonly HashSet<string> KnownKeys;
static ImportIntron()
{
KnownKeys = new HashSet<string>
{
ImportKeys.Analysis,
ImportKeys.Adaptor,
ImportKeys.DbId,
ImportKeys.End,
ImportKeys.Next,
ImportKeys.Prev,
ImportKeys.SeqName,
ImportKeys.Slice,
ImportKeys.Start,
ImportKeys.Strand
};
}
/// <summary>
/// returns a new exon given an ObjectValue
/// </summary>
private static IInterval Parse(ObjectValueNode objectValue)
{
int start = -1;
int end = -1;
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 mapper object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.Analysis:
case ImportKeys.Adaptor:
case ImportKeys.DbId:
case ImportKeys.Next:
case ImportKeys.Prev:
case ImportKeys.SeqName:
case ImportKeys.Strand:
case ImportKeys.Slice:
// not used
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 new Interval(start, end);
}
/// <summary>
/// parses the relevant data from each intron object
/// </summary>
public static IInterval[] ParseList(List<IListMember> members)
{
var introns = new IInterval[members.Count];
for (var intronIndex = 0; intronIndex < members.Count; intronIndex++)
{
if (!(members[intronIndex] is ObjectValueNode objectValue))
{
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectValue: [{members[intronIndex].GetType()}]");
}
introns[intronIndex] = Parse(objectValue);
}
return introns;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportKeys.cs
================================================
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportKeys
{
internal const string Adaptor = "adaptor";
internal const string AltSeq = "alt_seq";
internal const string Analysis = "analysis";
internal const string AnalysisId = "_analysis_id";
internal const string Attributes = "attributes";
internal const string BamEditStatus = "_bam_edit_status";
internal const string Biotype = "biotype";
internal const string BoundLengths = "_bound_lengths";
internal const string Ccds = "_ccds";
internal const string CdnaCodingEnd = "cdna_coding_end";
internal const string CdnaCodingStart = "cdna_coding_start";
internal const string CellTypeCount = "cell_type_count";
internal const string CellTypes = "cell_types";
internal const string Code = "code";
internal const string CodingDnaCodingEnd = "cdna_coding_end";
internal const string CodingDnaCodingStart = "cdna_coding_start";
internal const string CodingRegionEnd = "coding_region_end";
internal const string CodingRegionStart = "coding_region_start";
internal const string CodonTable = "codon_table";
internal const string CreatedDate = "created_date";
internal const string DbId = "dbID";
internal const string Description = "description";
internal const string DisplayLabel = "display_label";
internal const string DisplayXref = "display_xref";
internal const string End = "end";
internal const string EndExon = "end_exon";
internal const string EndPhase = "end_phase";
internal const string EpigenomeCount = "epigenome_count";
internal const string ExonCoordinateMapper = "exon_coord_mapper";
internal const string ExternalDb = "external_db";
internal const string ExternalDisplayName = "external_display_name";
internal const string ExternalName = "external_name";
internal const string ExternalStatus = "external_status";
internal const string FeatureType = "feature_type";
internal const string FivePrimeUtr = "five_prime_utr";
internal const string From = "from";
internal const string FromCoordSystem = "from_cs";
internal const string FromName = "from";
internal const string Gene = "_gene";
internal const string GeneHgnc = "_gene_hgnc";
internal const string GeneHgncId = "_gene_hgnc_id";
internal const string GenePhenotype = "_gene_phenotype";
internal const string GeneStableId = "_gene_stable_id";
internal const string GeneSymbol = "_gene_symbol";
internal const string GeneSymbolSource = "_gene_symbol_source";
internal const string Genomic = "GENOME";
internal const string HasEvidence = "has_evidence";
internal const string Id = "id";
internal const string Introns = "introns";
internal const string IsCanonical = "is_canonical";
internal const string IsMatrixCompressed = "matrix_compressed";
internal const string IsSorted = "_is_sorted";
internal const string Mapper = "mapper";
internal const string Matrix = "matrix";
internal const string ModifiedDate = "modified_date";
internal const string Name = "name";
internal const string Next = "next";
internal const string Ori = "ori";
internal const string PairCodingDna = "_pair_cdna";
internal const string PairCount = "pair_count";
internal const string PairGenomic = "_pair_genomic";
internal const string Peptide = "peptide";
internal const string PeptideLength = "peptide_length";
internal const string Phase = "phase";
internal const string PolyPhen = "polyphen";
internal const string PolyPhenHumDiv = "polyphen_humdiv";
internal const string PolyPhenHumVar = "polyphen_humvar";
internal const string Prev = "prev";
internal const string Projected = "projected";
internal const string Protein = "_protein";
internal const string ProteinFeatures = "protein_features";
internal const string ProteinFunctionPredictions = "protein_function_predictions";
internal const string Refseq = "_refseq";
internal const string RegulatoryBuildId = "regulatory_build_id";
internal const string Selenocysteines = "selenocysteines";
internal const string SeqEdits = "seq_edits";
internal const string SeqName = "seqname";
internal const string Sequence = "seq";
internal const string Set = "set";
internal const string Sift = "sift";
internal const string Slice = "slice";
internal const string SortedExons = "sorted_exons";
internal const string Source = "source";
internal const string SplicedSequence = "spliced_seq";
internal const string StableId = "stable_id";
internal const string Start = "start";
internal const string StartExon = "start_exon";
internal const string StartPhase = "start_phase";
internal const string Strand = "strand";
internal const string SubAnalysis = "sub_analysis";
internal const string SwissProt = "_swissprot";
internal const string ThreePrimeUtr = "three_prime_utr";
internal const string To = "to";
internal const string ToCoordSystem = "to_cs";
internal const string ToName = "to";
internal const string TransExonArray = "_trans_exon_array";
internal const string Transcript = "transcript";
internal const string TranslateableSeq = "translateable_seq";
internal const string Translation = "translation";
internal const string TranslationMd5 = "translation_md5";
internal const string Trembl = "_trembl";
internal const string UniParc = "_uniparc";
internal const string Value = "value";
internal const string VariationEffectFeatureCache = "_variation_effect_feature_cache";
internal const string VepFeatureType = "_vep_feature_type";
internal const string VepLazyLoaded = "_vep_lazy_loaded";
internal const string Version = "version";
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportMapper.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportMapper
{
private static readonly HashSet<string> KnownKeys;
static ImportMapper()
{
KnownKeys = new HashSet<string>
{
ImportKeys.FromCoordSystem,
ImportKeys.FromName,
ImportKeys.IsSorted,
ImportKeys.PairCodingDna,
ImportKeys.PairCount,
ImportKeys.PairGenomic,
ImportKeys.ToCoordSystem,
ImportKeys.ToName
};
}
/// <summary>
/// parses the relevant data from each exon coordinate mapper object
/// </summary>
public static MutableTranscriptRegion[] Parse(ObjectValueNode objectValue)
{
MutableTranscriptRegion[] cdnaMaps = null;
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 mapper object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.ToName:
case ImportKeys.PairCount:
case ImportKeys.PairCodingDna:
case ImportKeys.FromCoordSystem:
case ImportKeys.FromName:
case ImportKeys.IsSorted:
case ImportKeys.ToCoordSystem:
// not used
break;
case ImportKeys.PairGenomic:
if (node is ObjectKeyValueNode pairGenomicNode)
{
cdnaMaps = ImportPairGenomic.Parse(pairGenomicNode.Value);
}
else if (!node.IsUndefined())
{
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectKeyValue: [{node.GetType()}]");
}
break;
default:
throw new InvalidDataException($"Unknown key found: {node.Key}");
}
}
return cdnaMaps;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportMapperPair.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
using VariantAnnotation.Interface.AnnotatedPositions;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportMapperPair
{
private static readonly HashSet<string> KnownKeys;
static ImportMapperPair()
{
KnownKeys = new HashSet<string>
{
ImportKeys.From,
ImportKeys.Ori,
ImportKeys.To
};
}
/// <summary>
/// parses the relevant data from each mapper pairs object
/// </summary>
private static MutableTranscriptRegion Parse(ObjectValueNode objectValue)
{
int fromStart = -1;
int fromEnd = -1;
var fromType = MapperUnitType.Unknown;
int toStart = -1;
int toEnd = -1;
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 pair object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.Ori:
// not used
break;
case ImportKeys.From:
if (node is ObjectKeyValueNode fromKeyNode)
{
(fromStart, fromEnd, fromType) = ImportMapperUnit.Parse(fromKeyNode.Value);
}
else
{
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectKeyValue: [{node.GetType()}]");
}
break;
case ImportKeys.To:
if (node is ObjectKeyValueNode toKeyNode)
{
(toStart, toEnd, _) = ImportMapperUnit.Parse(toKeyNode.Value);
}
else
{
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectKeyValue: [{node.GetType()}]");
}
break;
default:
throw new InvalidDataException($"Unknown key found: {node.Key}");
}
}
return GetCdnaMap(fromStart, fromEnd, fromType, toStart, toEnd);
}
private static MutableTranscriptRegion GetCdnaMap(int fromStart, int fromEnd, MapperUnitType fromType, int toStart, int toEnd)
{
return fromType == MapperUnitType.Genomic
? new MutableTranscriptRegion(TranscriptRegionType.Exon, 0, fromStart, fromEnd, toStart, toEnd)
: new MutableTranscriptRegion(TranscriptRegionType.Exon, 0, toStart, toEnd, fromStart, fromEnd);
}
/// <summary>
/// parses the relevant data from each mapper pairs object
/// </summary>
public static MutableTranscriptRegion[] ParseList(List<IListMember> listMembers)
{
var cdnaMaps = new List<MutableTranscriptRegion>(listMembers.Count);
foreach (var entry in listMembers)
{
if (!(entry is ObjectValueNode mapperPairNode)) throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectValue: [{entry.GetType()}]");
if (mapperPairNode.Type != "Bio::EnsEMBL::Mapper::Pair") throw new InvalidDataException($"Expected a mapper pair data type, but found the following data type: [{mapperPairNode.Type}]");
cdnaMaps.Add(Parse(mapperPairNode));
}
return cdnaMaps.ToArray();
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportMapperUnit.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.Utilities;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportMapperUnit
{
private static readonly HashSet<string> KnownKeys;
static ImportMapperUnit()
{
KnownKeys = new HashSet<string>
{
ImportKeys.End,
ImportKeys.Id,
ImportKeys.Start
};
}
/// <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 enum MapperUnitType : byte
{
Unknown,
CodingDna,
Genomic
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportPairGenomic.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
using CacheUtils.DataDumperImport.DataStructures.Mutable;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportPairGenomic
{
private static readonly HashSet<string> KnownKeys;
static ImportPairGenomic()
{
KnownKeys = new HashSet<string>
{
ImportKeys.Genomic
};
}
/// <summary>
/// parses the relevant data from each pair genomic object
/// </summary>
public static MutableTranscriptRegion[] Parse(ObjectValueNode objectValue)
{
MutableTranscriptRegion[] cdnaMaps = null;
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 pair genomic object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.Genomic:
if (node is ListObjectKeyValueNode genomicNode)
{
cdnaMaps = ImportMapperPair.ParseList(genomicNode.Values);
}
else if (!node.IsUndefined())
{
throw new InvalidDataException($"Could not transform the AbstractData object into an ObjectKeyValue: [{node.GetType()}]");
}
break;
default:
throw new InvalidDataException($"Unknown key found: {node.Key}");
}
}
return cdnaMaps;
}
}
}
================================================
FILE: CacheUtils/DataDumperImport/Import/ImportPrediction.cs
================================================
using System.Collections.Generic;
using System.IO;
using CacheUtils.DataDumperImport.DataStructures.Import;
namespace CacheUtils.DataDumperImport.Import
{
internal static class ImportPrediction
{
private static readonly HashSet<string> KnownKeys;
static ImportPrediction()
{
KnownKeys = new HashSet<string>
{
ImportKeys.Analysis,
ImportKeys.IsMatrixCompressed,
ImportKeys.Matrix,
ImportKeys.PeptideLength,
ImportKeys.SubAnalysis,
ImportKeys.TranslationMd5
};
}
/// <summary>
/// parses the relevant data from each prediction object
/// </summary>
public static string Parse(ObjectValueNode objectValue)
{
string predictionData = null;
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 prediction object: {node.Key}");
}
switch (node.Key)
{
case ImportKeys.Analysis:
case ImportKeys.IsMatrixCompressed:
case ImportKeys.PeptideLength:
case ImportKeys.SubAnalysis:
case ImportKeys.TranslationMd5:
break;
case ImportKeys.Matrix:
predictionData = node.GetString();
break;
default:
throw new InvalidDataException($"Unknown key found: {node.Key}");
}
}
return predictionData;
}
gitextract_hj0kftnn/
├── .gitattributes
├── .gitignore
├── AnnotationLambda/
│ ├── AnnotationLambda.cs
│ ├── AnnotationLambda.csproj
│ ├── AssemblyInfo.cs
│ └── S3Utilities.cs
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── CacheUtils/
│ ├── AssemblyInfo.cs
│ ├── BuildCache.sh
│ ├── CacheUtils.cs
│ ├── CacheUtils.csproj
│ ├── CacheUtils.dll.gene.json
│ ├── Commands/
│ │ ├── CombineCacheDirectories/
│ │ │ └── CombineCacheDirectoriesMain.cs
│ │ ├── CreateCache/
│ │ │ └── CreateNirvanaDatabaseMain.cs
│ │ ├── Download/
│ │ │ ├── DownloadMain.cs
│ │ │ ├── ExternalFiles.cs
│ │ │ └── GenbankFile.cs
│ │ ├── ExtractTranscripts/
│ │ │ └── ExtractTranscriptsMain.cs
│ │ ├── GFF/
│ │ │ ├── CreateGffMain.cs
│ │ │ └── InternalGenes.cs
│ │ ├── Header/
│ │ │ └── HeaderMain.cs
│ │ ├── ParseVepCacheDirectory/
│ │ │ ├── ParseVepCacheDirectoryMain.cs
│ │ │ ├── RegulatoryRegionMerger.cs
│ │ │ ├── TranscriptFilter.cs
│ │ │ ├── TranscriptIdFilter.cs
│ │ │ ├── TranscriptMerger.cs
│ │ │ ├── TranscriptMergerLogger.cs
│ │ │ ├── VepCacheParser.cs
│ │ │ └── VepRootDirectory.cs
│ │ ├── RegulatoryGFF/
│ │ │ └── CreateRegulatoryGffMain.cs
│ │ └── UniversalGeneArchive/
│ │ ├── FilePaths.cs
│ │ └── UniversalGeneArchiveMain.cs
│ ├── DataDumperImport/
│ │ ├── DataStructures/
│ │ │ ├── GenomeSymbolSource.cs
│ │ │ ├── Import/
│ │ │ │ ├── IImportNode.cs
│ │ │ │ ├── ImportNodeExtensions.cs
│ │ │ │ ├── ListObjectKeyValueNode.cs
│ │ │ │ ├── ObjectKeyValueNode.cs
│ │ │ │ ├── ObjectValueNode.cs
│ │ │ │ ├── StringKeyValueNode.cs
│ │ │ │ └── StringValueNode.cs
│ │ │ └── Mutable/
│ │ │ ├── MutableExon.cs
│ │ │ ├── MutableGene.cs
│ │ │ ├── MutableTranscript.cs
│ │ │ └── MutableTranscriptRegion.cs
│ │ ├── FauxRegex/
│ │ │ └── RegexDecisionTree.cs
│ │ ├── IO/
│ │ │ ├── DataDumperReader.cs
│ │ │ └── EntryType.cs
│ │ ├── Import/
│ │ │ ├── Attribute.cs
│ │ │ ├── ImportExon.cs
│ │ │ ├── ImportGene.cs
│ │ │ ├── ImportIntron.cs
│ │ │ ├── ImportKeys.cs
│ │ │ ├── ImportMapper.cs
│ │ │ ├── ImportMapperPair.cs
│ │ │ ├── ImportMapperUnit.cs
│ │ │ ├── ImportPairGenomic.cs
│ │ │ ├── ImportPrediction.cs
│ │ │ ├── ImportProteinFunctionPredictions.cs
│ │ │ ├── ImportRegulatoryFeature.cs
│ │ │ ├── ImportSeqEdits.cs
│ │ │ ├── ImportTranscript.cs
│ │ │ ├── ImportTranscriptMapper.cs
│ │ │ ├── ImportTranslation.cs
│ │ │ └── ImportVariantEffectFeatureCache.cs
│ │ └── Utilities/
│ │ ├── ImportUtilities.cs
│ │ ├── MutableTranscriptComparer.cs
│ │ └── TranscriptUtilities.cs
│ ├── GFF/
│ │ ├── GeneralAttributes.cs
│ │ ├── GffCreator.cs
│ │ ├── GffGene.cs
│ │ ├── GffUtilities.cs
│ │ ├── GffWriter.cs
│ │ ├── IGeneralAttributes.cs
│ │ ├── IGffGene.cs
│ │ ├── IRequiredFields.cs
│ │ └── RequiredFields.cs
│ ├── Genbank/
│ │ ├── GenbankEntry.cs
│ │ ├── GenbankReader.cs
│ │ └── GenbankState.cs
│ ├── Genes/
│ │ ├── Combiners/
│ │ │ ├── CombinerUtils.cs
│ │ │ ├── HgncIdCombiner.cs
│ │ │ ├── ICombiner.cs
│ │ │ └── PartitionCombiner.cs
│ │ ├── DataStores/
│ │ │ ├── AssemblyDataStore.cs
│ │ │ ├── EnsemblGtf.cs
│ │ │ ├── GeneInfoData.cs
│ │ │ ├── GlobalCache.cs
│ │ │ ├── Hgnc.cs
│ │ │ ├── IUpdateHgncData.cs
│ │ │ ├── RefSeqGff.cs
│ │ │ └── UpdateHgncData.cs
│ │ ├── DataStructures/
│ │ │ ├── EnsemblGene.cs
│ │ │ ├── GeneInfo.cs
│ │ │ ├── HgncGene.cs
│ │ │ ├── IFlatGene.cs
│ │ │ ├── RefSeqGene.cs
│ │ │ └── UgaGene.cs
│ │ ├── GeneFlattener.cs
│ │ ├── GeneMerger.cs
│ │ ├── GeneSymbolUpdater.cs
│ │ ├── HgncIdConsolidator.cs
│ │ ├── HgncIdUpdater.cs
│ │ ├── IO/
│ │ │ ├── EnsemblGtfReader.cs
│ │ │ ├── GeneInfoReader.cs
│ │ │ ├── HgncReader.cs
│ │ │ ├── RefSeqGffReader.cs
│ │ │ ├── UgaGeneReader.cs
│ │ │ └── UgaGeneWriter.cs
│ │ ├── UgaAssemblyCombiner.cs
│ │ └── Utilities/
│ │ └── DictionaryUtilities.cs
│ ├── Helpers/
│ │ ├── BioTypeHelper.cs
│ │ ├── GeneSymbolSourceHelper.cs
│ │ ├── RegulatoryRegionTypeHelper.cs
│ │ └── TranscriptCacheHelper.cs
│ ├── IntermediateIO/
│ │ ├── CcdsReader.cs
│ │ ├── GenbankReader.cs
│ │ ├── GenbankWriter.cs
│ │ ├── IntermediateIoCommon.cs
│ │ ├── IntermediateIoHeader.cs
│ │ ├── LrgReader.cs
│ │ ├── MutableTranscriptReader.cs
│ │ ├── MutableTranscriptWriter.cs
│ │ ├── PredictionReader.cs
│ │ ├── PredictionWriter.cs
│ │ ├── RegulatoryRegionReader.cs
│ │ └── RegulatoryRegionWriter.cs
│ ├── MiniCache/
│ │ ├── DataBundle.cs
│ │ └── IStaging.cs
│ ├── PredictionCache/
│ │ ├── PredictionCacheBuilder.cs
│ │ ├── PredictionCacheStaging.cs
│ │ ├── PredictionCacheWriter.cs
│ │ ├── PredictionExtensions.cs
│ │ ├── PredictionUtilities.cs
│ │ ├── RoundedEntry.cs
│ │ └── RoundedEntryPrediction.cs
│ ├── TranscriptCache/
│ │ ├── CanonicalTranscriptMarker.cs
│ │ ├── Comparers/
│ │ │ ├── GeneComparer.cs
│ │ │ ├── IntervalComparer.cs
│ │ │ ├── RegulatoryRegionComparer.cs
│ │ │ ├── TranscriptRegionComparer.cs
│ │ │ └── UgaGeneComparer.cs
│ │ ├── NSequence.cs
│ │ ├── SortExtensions.cs
│ │ ├── TranscriptCacheBuilder.cs
│ │ ├── TranscriptCacheStaging.cs
│ │ ├── TranscriptCacheUtilities.cs
│ │ ├── TranscriptCacheWriter.cs
│ │ ├── TranscriptConversionExtensions.cs
│ │ ├── TranscriptRegionMerger.cs
│ │ └── TranscriptRegionValidater.cs
│ └── Utilities/
│ ├── AccessionUtilities.cs
│ ├── HeaderUtilities.cs
│ ├── RemoteFile.cs
│ └── TaskExtensions.cs
├── Cloud/
│ ├── AmazonS3ClientWrapper.cs
│ ├── AssemblyInfo.cs
│ ├── Cloud.appsettings.json
│ ├── Cloud.csproj
│ ├── Configuration.cs
│ ├── LambdaUrlHelper.cs
│ ├── Messages/
│ │ ├── Annotation/
│ │ │ ├── AnnotationConfig.cs
│ │ │ ├── AnnotationPosition.cs
│ │ │ ├── AnnotationRange.cs
│ │ │ └── AnnotationResult.cs
│ │ ├── Custom/
│ │ │ ├── CustomConfig.cs
│ │ │ └── CustomResult.cs
│ │ ├── FileList.cs
│ │ ├── Gene/
│ │ │ └── GeneConfig.cs
│ │ ├── JwtFields.cs
│ │ ├── Nirvana/
│ │ │ ├── NirvanaConfig.cs
│ │ │ └── NirvanaResult.cs
│ │ ├── S3Path.cs
│ │ ├── SaUrls.cs
│ │ ├── Single/
│ │ │ ├── SingleConfig.cs
│ │ │ └── SingleVariant.cs
│ │ └── StrValidation/
│ │ ├── ValidationConfig.cs
│ │ └── ValidationResult.cs
│ ├── Notifications/
│ │ └── SNS.cs
│ ├── RedactionUtilities.cs
│ └── Utilities/
│ ├── AwsExceptionUtilities.cs
│ ├── JsonUtilities.cs
│ ├── LambdaUtilities.cs
│ ├── LogUtilities.cs
│ └── UploadUtilities.cs
├── CommandLine/
│ ├── AssemblyInfo.cs
│ ├── Builders/
│ │ ├── ConsoleAppBuilder.cs
│ │ ├── IConsoleAppBuilder.cs
│ │ ├── ITopLevelAppBuilder.cs
│ │ ├── TopLevelAppBuilder.cs
│ │ ├── TopLevelOption.cs
│ │ └── ValidationExtensions.cs
│ ├── CommandLine.csproj
│ ├── NDesk.Options/
│ │ └── Options.cs
│ ├── Utilities/
│ │ ├── Benchmark.cs
│ │ ├── CommandLineUtilities.cs
│ │ ├── Help.cs
│ │ ├── MemoryUtilities.cs
│ │ └── OutputHelper.cs
│ └── VersionProviders/
│ ├── DefaultVersionProvider.cs
│ └── IVersionProvider.cs
├── CommonAssemblyInfo.props
├── Compression/
│ ├── Algorithms/
│ │ ├── ICompressionAlgorithm.cs
│ │ ├── Zlib.cs
│ │ └── Zstandard.cs
│ ├── AssemblyInfo.cs
│ ├── Compression.csproj
│ ├── DataStructures/
│ │ └── Block.cs
│ ├── FileHandling/
│ │ ├── BgzBlockReader.cs
│ │ ├── BgzfBlock.cs
│ │ ├── BgzipTextReader.cs
│ │ ├── BgzipTextWriter.cs
│ │ ├── BlockGZipStream.cs
│ │ ├── BlockHeader.cs
│ │ └── BlockStream.cs
│ └── Utilities/
│ ├── BlockExtensions.cs
│ ├── GZipUtilities.cs
│ └── LibraryUtilities.cs
├── CreateLambdaZips.sh
├── CustomAnnotationLambda/
│ ├── CustomAnnotationLambda.cs
│ ├── CustomAnnotationLambda.csproj
│ ├── CustomConfigExtensions.cs
│ ├── GeneAnnotationCreator.cs
│ └── VariantAnnotationCreator.cs
├── CustomStrValidationLambda/
│ ├── CustomStrValidationLambda.cs
│ └── CustomStrValidationLambda.csproj
├── Downloader/
│ ├── AnnotationRepository.cs
│ ├── AssemblyInfo.cs
│ ├── Client.cs
│ ├── Configuration.cs
│ ├── Downloader.appsettings.json
│ ├── Downloader.csproj
│ ├── DownloaderMain.cs
│ ├── FileExtensions/
│ │ ├── CacheFileExtensions.cs
│ │ ├── ReferencesFileExtensions.cs
│ │ └── SupplementaryAnnotationFileExtensions.cs
│ ├── IClient.cs
│ ├── Manifest.cs
│ ├── OutputDirectory.cs
│ ├── RemoteFile.cs
│ └── Utilities/
│ ├── ConsoleEmbellishments.cs
│ ├── DiskSpaceUtilities.cs
│ ├── GenomeAssemblyHelper.cs
│ ├── ParallelUtilities.cs
│ └── SyncUtilities.cs
├── ErrorHandling/
│ ├── AssemblyInfo.cs
│ ├── ErrorCategory.cs
│ ├── ErrorHandling.csproj
│ ├── ExceptionUtilities.cs
│ ├── Exceptions/
│ │ ├── CompressionException.cs
│ │ ├── DeploymentErrorException.cs
│ │ ├── FileNotSortedException.cs
│ │ ├── InvalidFileFormatException.cs
│ │ ├── MissingCompressionLibraryException.cs
│ │ ├── ProcessLockedFileException.cs
│ │ └── UserErrorException.cs
│ ├── ExitCodeUtilities.cs
│ └── ExitCodes.cs
├── GeneAnnotationLambda/
│ ├── GeneAnnotationLambda.cs
│ ├── GeneAnnotationLambda.csproj
│ └── GeneResult.cs
├── Genome/
│ ├── Band.cs
│ ├── Chromosome.cs
│ ├── ChromosomeInterval.cs
│ ├── ContigInfo.cs
│ ├── CytogeneticBands.cs
│ ├── Genome.csproj
│ ├── GenomeAssembly.cs
│ ├── GenomeAssemblyHelper.cs
│ ├── GenomicPosition.cs
│ ├── GenomicRange.cs
│ ├── GenomicRangeChecker.cs
│ ├── IChromosomeInterval.cs
│ ├── ISequence.cs
│ ├── ReferenceNameUtilities.cs
│ └── SequenceUtilities.cs
├── IO/
│ ├── BufferedBinaryReader.cs
│ ├── CacheConstants.cs
│ ├── ExtendedBinaryReader.cs
│ ├── ExtendedBinaryWriter.cs
│ ├── FilePathUtilities.cs
│ ├── FileUtilities.cs
│ ├── HttpUtilities.cs
│ ├── IBufferedBinaryReader.cs
│ ├── IConnect.cs
│ ├── IExtendedBinaryWriter.cs
│ ├── IO.csproj
│ ├── IS3Client.cs
│ ├── ISerializable.cs
│ ├── LengthStream.cs
│ ├── Logger.cs
│ ├── MD5Stream.cs
│ ├── PersistentConnect.cs
│ ├── PersistentStream.cs
│ ├── PersistentStreamUtils.cs
│ ├── SpanBufferBinaryReader.cs
│ ├── UrlUtilities.cs
│ └── v2/
│ ├── FileType.cs
│ └── Header.cs
├── Intervals/
│ ├── Extensions.cs
│ ├── IInterval.cs
│ ├── IIntervalForest.cs
│ ├── IIntervalSearch.cs
│ ├── Interval.cs
│ ├── IntervalArray.cs
│ ├── IntervalForest.cs
│ ├── Intervals.csproj
│ ├── NullIntervalSearch.cs
│ ├── OverlapType.cs
│ └── Utilities.cs
├── Jasix/
│ ├── AssemblyInfo.cs
│ ├── DataStructures/
│ │ ├── JasixChrIndex.cs
│ │ ├── JasixCommons.cs
│ │ ├── JasixIndex.cs
│ │ ├── JasixNode.cs
│ │ ├── JsonSchema.cs
│ │ └── Utilities.cs
│ ├── IndexCreator.cs
│ ├── Jasix.csproj
│ ├── JasixMain.cs
│ ├── OnTheFlyIndexCreator.cs
│ └── QueryProcessor.cs
├── Jist/
│ ├── Jist.csproj
│ ├── JistMain.cs
│ ├── JistUtilities.cs
│ └── JsonStitcher.cs
├── LICENSE
├── MitoHeteroplasmy/
│ ├── MitoHeteroplasmy.csproj
│ ├── MitoHeteroplasmyProvider.cs
│ └── MitoHeteroplasmyReader.cs
├── Nirvana/
│ ├── AnnotationFiles.cs
│ ├── AnnotationResources.cs
│ ├── Nirvana.cs
│ ├── Nirvana.csproj
│ ├── PreLoadUtilities.cs
│ ├── ProviderUtilities.cs
│ └── StreamAnnotation.cs
├── Nirvana.sln
├── Nirvana.sln.DotSettings
├── NirvanaLambda/
│ ├── AnnotationJob.cs
│ ├── AnnotationResultSummary.cs
│ ├── AssemblyInfo.cs
│ ├── NirvanaLambda.cs
│ ├── NirvanaLambda.csproj
│ └── PartitionUtilities.cs
├── OptimizedCore/
│ ├── ExpandableArray.cs
│ ├── NullSequenceEqual.cs
│ ├── OptimizedCore.csproj
│ ├── StringBuilderPool.cs
│ └── StringExtensions.cs
├── Phantom/
│ ├── AssemblyInfo.cs
│ └── Phantom.csproj
├── README.md
├── ReferenceSequence/
│ ├── AssemblyInfo.cs
│ ├── Commands/
│ │ ├── CreateReferenceMain.cs
│ │ ├── CreateSubstringMain.cs
│ │ └── CreateTestSeqMain.cs
│ ├── Common/
│ │ ├── IndexEntry.cs
│ │ ├── MaskedEntry.cs
│ │ └── Sequence.cs
│ ├── Compression/
│ │ └── TwoBitCompressor.cs
│ ├── Creation/
│ │ ├── FastaSequence.cs
│ │ ├── ReferenceBuffer.cs
│ │ ├── ReferenceDictionaryUtils.cs
│ │ └── ReferenceSequence.cs
│ ├── IO/
│ │ ├── AssemblyReader.cs
│ │ ├── CytogeneticBandsReader.cs
│ │ ├── FastaReader.cs
│ │ ├── ReferenceNamesReader.cs
│ │ ├── ReferenceSequenceReader.cs
│ │ └── ReferenceSequenceWriter.cs
│ ├── ReferenceSequence.csproj
│ ├── ReferenceSequenceCommon.cs
│ ├── ReferenceUtilsMain.cs
│ └── Utilities/
│ └── SequenceHelper.cs
├── RepeatExpansions/
│ ├── AssemblyInfo.cs
│ ├── IO/
│ │ └── RepeatExpansionReader.cs
│ ├── IRepeatExpansionProvider.cs
│ ├── Matcher.cs
│ ├── PercentileUtilities.cs
│ ├── RepeatExpansionPhenotype.cs
│ ├── RepeatExpansionProvider.cs
│ ├── RepeatExpansionSupplementaryAnnotation.cs
│ ├── RepeatExpansions.csproj
│ └── Resources/
│ ├── RepeatExpansions.GRCh37.tsv
│ └── RepeatExpansions.GRCh38.tsv
├── SAUtils/
│ ├── AAConservation/
│ │ ├── AaConservationMain.cs
│ │ ├── AaConservationUtilities.cs
│ │ ├── ProteinConservationParser.cs
│ │ └── ProteinConservationWriter.cs
│ ├── AssemblyInfo.cs
│ ├── ClinGen/
│ │ ├── DosageMapRegionItem.cs
│ │ ├── DosageMapRegionParser.cs
│ │ ├── DosageMapRegions.cs
│ │ ├── DosageSensitivity.cs
│ │ ├── DosageSensitivityItem.cs
│ │ ├── DosageSensitivityParser.cs
│ │ ├── GeneDiseaseValidity.cs
│ │ ├── GeneDiseaseValidityItem.cs
│ │ ├── GeneDiseaseValidityParser.cs
│ │ └── ScoreToDescription.cs
│ ├── CosmicGeneFusions/
│ │ ├── Cache/
│ │ │ ├── ReferenceLoader.cs
│ │ │ └── TranscriptCache.cs
│ │ ├── Conversion/
│ │ │ ├── CosmicConverter.cs
│ │ │ ├── CosmicGeneFusion.cs
│ │ │ ├── HgvsRnaFixer.cs
│ │ │ ├── HgvsRnaParser.cs
│ │ │ ├── Histology.cs
│ │ │ ├── RawCosmicGeneFusion.cs
│ │ │ └── Site.cs
│ │ ├── CreateCosmicGeneFusions.cs
│ │ ├── IO/
│ │ │ ├── CosmicGeneFusionParser.cs
│ │ │ └── GeneFusionJsonWriter.cs
│ │ └── Utilities/
│ │ └── CosmicCountUtilities.cs
│ ├── CreateClinvarDb/
│ │ ├── ClinVarMain.cs
│ │ └── ClinVarStats.cs
│ ├── CreateCosmicDb/
│ │ └── Main.cs
│ ├── CreateDbsnpDb/
│ │ └── Main.cs
│ ├── CreateDecipherDb/
│ │ └── Main.cs
│ ├── CreateGlobalAllelesDb/
│ │ └── Main.cs
│ ├── CreateGmeDb/
│ │ └── Main.cs
│ ├── CreateOneKgDb/
│ │ └── Main.cs
│ ├── CreateTopMedDb/
│ │ └── Main.cs
│ ├── Custom/
│ │ ├── AllowedValues.cs
│ │ ├── CaUtilities.cs
│ │ ├── CustomGene.cs
│ │ ├── GeneAnnotationsParser.cs
│ │ ├── GeneMain.cs
│ │ ├── ParserUtilities.cs
│ │ ├── VariantAnnotationsParser.cs
│ │ └── VariantMain.cs
│ ├── Dann/
│ │ └── Create.cs
│ ├── DataStructures/
│ │ ├── AlleleFrequencyItem.cs
│ │ ├── AncestralAlleleItem.cs
│ │ ├── ClinGenItem.cs
│ │ ├── ClinVarItem.cs
│ │ ├── ComputingUtilities.cs
│ │ ├── ConservationItem.cs
│ │ ├── CosmicItem.cs
│ │ ├── CounterDictionary.cs
│ │ ├── CustomInterval.cs
│ │ ├── CustomItem.cs
│ │ ├── DbSnpItem.cs
│ │ ├── DecipherItem.cs
│ │ ├── DgvItem.cs
│ │ ├── GlobalMinorItem.cs
│ │ ├── GmeItem.cs
│ │ ├── GnomadItem.cs
│ │ ├── GnomadSvItem.cs
│ │ ├── KeyCounts.cs
│ │ ├── MinHeap.cs
│ │ ├── OmimItem.cs
│ │ ├── OneKGenItem.cs
│ │ ├── OnekGenSvItem.cs
│ │ ├── RefMinorItem.cs
│ │ ├── SuppDataUtilities.cs
│ │ └── TopMedItem.cs
│ ├── DbSnpRemapper/
│ │ ├── ChromMapper.cs
│ │ ├── DbSnpRemapperMain.cs
│ │ ├── GenomicLocation.cs
│ │ ├── LeftoverMapper.cs
│ │ └── Utilities.cs
│ ├── DegenerateBaseUtilities.cs
│ ├── ExtractCosmicSvs/
│ │ ├── CosmicCnvItem.cs
│ │ ├── CosmicCnvReader.cs
│ │ ├── CosmicSvReader.cs
│ │ └── ExtractCosmicSvsMain.cs
│ ├── ExtractMiniSa/
│ │ ├── ExtractMiniSaMain.cs
│ │ └── MiniSaExtractor.cs
│ ├── ExtractMiniXml/
│ │ ├── ExtractMiniXmlMain.cs
│ │ ├── RcvXmlExtractor.cs
│ │ └── VcvXmlExtractor.cs
│ ├── FusionCatcher/
│ │ ├── CollectionType.cs
│ │ ├── CreateFusionCatcher.cs
│ │ ├── FusionCatcherDataSource.cs
│ │ ├── FusionCatcherOncogenes.cs
│ │ ├── GeneFusionSourceBuilder.cs
│ │ ├── GeneFusionSourceWriter.cs
│ │ └── IndexBuilder.cs
│ ├── GERP/
│ │ └── GerpMain.cs
│ ├── GeneIdentifiers/
│ │ ├── GeneSymbolUpdater.cs
│ │ └── GeneUtilities.cs
│ ├── GenericScore/
│ │ ├── GenericScoreParser/
│ │ │ ├── GenericScoreItem.cs
│ │ │ ├── GenericScoreParser.cs
│ │ │ └── SaItemValidator.cs
│ │ ├── ParserSettings.cs
│ │ ├── ScoreFileWriter.cs
│ │ └── WriterSettings.cs
│ ├── GnomadGeneScores/
│ │ ├── GnomadGeneItem.cs
│ │ ├── GnomadGeneParser.cs
│ │ └── GnomadGenesMain.cs
│ ├── InputFileParsers/
│ │ ├── AncestralAlleleReader.cs
│ │ ├── ClinGen/
│ │ │ └── ClinGenReader.cs
│ │ ├── ClinVar/
│ │ │ ├── ClinVarCommon.cs
│ │ │ ├── ClinVarParser.cs
│ │ │ ├── ClinVarSchema.cs
│ │ │ ├── ClinVarVariationReader.cs
│ │ │ ├── ClinvarVariant.cs
│ │ │ ├── IClinVarSaItem.cs
│ │ │ ├── VariantAligner.cs
│ │ │ ├── VcvItem.cs
│ │ │ └── VcvSaItem.cs
│ │ ├── Cosmic/
│ │ │ └── MergedCosmicReader.cs
│ │ ├── DGV/
│ │ │ └── DgvReader.cs
│ │ ├── DataSourceVersionReader.cs
│ │ ├── DbSnp/
│ │ │ ├── DbSnpReader.cs
│ │ │ └── GlobalMinorReader.cs
│ │ ├── Decipher/
│ │ │ └── DecipherParser.cs
│ │ ├── Gme/
│ │ │ └── GmeParser.cs
│ │ ├── OneKGen/
│ │ │ ├── OneKGenReader.cs
│ │ │ ├── RefMinorReader.cs
│ │ │ └── oneKGenSvReader.cs
│ │ ├── SequenceExtensions.cs
│ │ └── TOPMed/
│ │ └── TopMedReader.cs
│ ├── MakeAaDb/
│ │ └── Main.cs
│ ├── MakeClinGenDb/
│ │ └── Main.cs
│ ├── MitoHeteroplasmy/
│ │ ├── MitoHeteroplasmyDb.cs
│ │ ├── MitoHeteroplasmyParser.cs
│ │ └── StatClasses.cs
│ ├── MitoMap/
│ │ ├── CircularGenomeModel.cs
│ │ ├── MitoMapDatabaseUtilities.cs
│ │ ├── MitoMapInputDb.cs
│ │ ├── MitoMapItem.cs
│ │ ├── MitoMapSvItem.cs
│ │ ├── MitoMapSvReader.cs
│ │ ├── MitoMapVariantReader.cs
│ │ ├── ParsingUtilities.cs
│ │ ├── SmallVarDb.cs
│ │ └── StructVarDb.cs
│ ├── NgaWriter.cs
│ ├── NsaConcatenator/
│ │ ├── ConcatUtilities.cs
│ │ └── NsaConcatenator.cs
│ ├── NsaIndexUpdater/
│ │ └── UpdateIndex.cs
│ ├── NsaWriter.cs
│ ├── Omim/
│ │ ├── Downloader.cs
│ │ ├── EntryApiResponse/
│ │ │ ├── EntryResponse.cs
│ │ │ └── GeneMap.cs
│ │ ├── Main.cs
│ │ ├── OmimParser.cs
│ │ ├── OmimPhenotypeSchema.cs
│ │ ├── OmimQuery.cs
│ │ ├── OmimSchema.cs
│ │ ├── OmimStatistics.cs
│ │ ├── OmimUtilities.cs
│ │ └── OmimVersion.cs
│ ├── OneKGenSvDb/
│ │ ├── Create.cs
│ │ └── VcfToBed.cs
│ ├── ParseUtils/
│ │ ├── SAParseUtilities.cs
│ │ ├── SplitLine.cs
│ │ └── TsvIndices.cs
│ ├── PhyloP/
│ │ ├── Main.cs
│ │ ├── NpdWriter.cs
│ │ └── PhylopParser.cs
│ ├── PrimateAi/
│ │ ├── PrimateAiDb.cs
│ │ ├── PrimateAiItem.cs
│ │ ├── PrimateAiParser.cs
│ │ └── PrimateAiUtilities.cs
│ ├── ProcessSpliceNetTsv/
│ │ ├── PredictionFilter.cs
│ │ └── SpliceNetPredictionFilterMain.cs
│ ├── RefMinorDb/
│ │ ├── Main.cs
│ │ └── RefMinorDbWriter.cs
│ ├── RegionUtilities.cs
│ ├── Revel/
│ │ └── Create.cs
│ ├── SAUtils.cs
│ ├── SAUtils.csproj
│ ├── SaUtilsCommon.cs
│ ├── Schema/
│ │ ├── SaJsonKeyAnnotation.cs
│ │ ├── SaJsonKeyProperties.cs
│ │ ├── SaJsonSchema.cs
│ │ └── SaJsonValueType.cs
│ ├── SpliceAi/
│ │ ├── SpliceAiDb.cs
│ │ ├── SpliceAiItem.cs
│ │ ├── SpliceAiParser.cs
│ │ └── SpliceUtilities.cs
│ ├── gnomAD/
│ │ ├── GnomadSnvMain.cs
│ │ ├── GnomadSnvReader.cs
│ │ ├── GnomadSvBedParser.cs
│ │ ├── GnomadSvMain.cs
│ │ ├── GnomadSvParser.cs
│ │ ├── GnomadSvTsvParser.cs
│ │ ├── GnomadUtilities.cs
│ │ ├── LcrInterval.cs
│ │ ├── LcrRegionParser.cs
│ │ └── LcrRegionsMain.cs
│ └── makeDgvDb/
│ └── Main.cs
├── Sandbox/
│ ├── AminoAcidAligner/
│ │ ├── AlignmentBuilder.cs
│ │ ├── AminoAcidAligner.csproj
│ │ ├── ExonToTranscript.cs
│ │ └── Utilities.cs
│ ├── GenerateMustGenotypeVcf/
│ │ ├── ConfigurationSettings.cs
│ │ ├── GenerateMustGenotypeVcf.csproj
│ │ ├── GenerateMustGenotypeVcfsMain.cs
│ │ └── MustGenotypeExtractor.cs
│ ├── Piano/
│ │ ├── ConfigurationSettings.cs
│ │ ├── Piano.cs
│ │ ├── Piano.csproj
│ │ ├── PianoAnnotatedTranscript.cs
│ │ ├── PianoAnnotationProvider.cs
│ │ ├── PianoAnnotationUtils.cs
│ │ ├── PianoAnnotator.cs
│ │ ├── PianoTranscriptAnnotator.cs
│ │ └── ProviderUtilities.cs
│ ├── Sandbox.sln
│ ├── Sandbox.sln.DotSettings
│ ├── Scripts/
│ │ ├── ConvertCacheMatrix.pl
│ │ ├── StressTestUnitTests.ps1
│ │ ├── UpdateCacheFiles.ps1
│ │ ├── UpdateMiniSaFiles.ps1
│ │ └── updateSA.ps1
│ └── UnitTests/
│ ├── Piano/
│ │ ├── PianoAnnotatedTranscriptTests.cs
│ │ ├── PianoTests.cs
│ │ └── SimpleSequence.cs
│ ├── Resources/
│ │ ├── ConflicitingEntries1000G.vcf
│ │ ├── RefMinorAllele.vcf
│ │ ├── Test1000GFile.vcf
│ │ ├── TestCosmicParser.Coding.vcf
│ │ ├── TestCosmicParser.NonCoding.vcf
│ │ ├── TestCosmicParser.tsv
│ │ ├── TestWigParser.wig
│ │ ├── chr1.npd
│ │ ├── chr1_10918_150000.npd
│ │ ├── mini.WigFix
│ │ ├── missingLastVariantHgmd.vcf
│ │ ├── testClinGenUnifier.txt
│ │ ├── tmpPopInfo.txt
│ │ └── tmpSampleInfo.txt
│ ├── UnitTests.csproj
│ └── Utilities/
│ ├── ResourceUtilities.cs
│ └── Resources.cs
├── SingleAnnotationLambda/
│ ├── CacheConfiguration.cs
│ ├── CacheUtilities.cs
│ ├── ExceptionHandler.cs
│ ├── SingleAnnotationLambda.cs
│ ├── SingleAnnotationLambda.csproj
│ ├── SingleConfigExtensions.cs
│ ├── SingleResult.cs
│ └── SupplementaryAnnotationUtilities.cs
├── Tabix/
│ ├── AssemblyInfo.cs
│ ├── BgzfBlockVcfReader.cs
│ ├── BinUtilities.cs
│ ├── Constants.cs
│ ├── Index.cs
│ ├── Interval.cs
│ ├── Reader.cs
│ ├── ReferenceIndex.cs
│ ├── Search.cs
│ ├── SearchUtilities.cs
│ ├── Tabix.csproj
│ └── VirtualPosition.cs
├── UnitTests/
│ ├── AnnotationLambda/
│ │ ├── AnnotationLambdaTests.cs
│ │ └── S3UtilitiesTests.cs
│ ├── CacheUtils/
│ │ ├── DataDumperImport/
│ │ │ ├── DataStructures/
│ │ │ │ └── Import/
│ │ │ │ └── ImportNodeExtensionsTests.cs
│ │ │ ├── FauxRegex/
│ │ │ │ └── RegexDecisionTreeTests.cs
│ │ │ ├── FileHandling/
│ │ │ │ └── DataDumperReaderTests.cs
│ │ │ └── Import/
│ │ │ ├── ImportRegulatoryFeatureTests.cs
│ │ │ └── ImportTranscriptTests.cs
│ │ ├── Genes/
│ │ │ ├── Combiners/
│ │ │ │ ├── CombinerUtilsTests.cs
│ │ │ │ ├── HgncIdCombinerTests.cs
│ │ │ │ └── PartitionCombinerTests.cs
│ │ │ ├── GeneFlattenerTests.cs
│ │ │ └── Utilities/
│ │ │ └── DictionaryUtilitiesTests.cs
│ │ ├── IO/
│ │ │ └── Caches/
│ │ │ └── TranscriptCacheWriterTests.cs
│ │ ├── TranscriptCache/
│ │ │ └── TranscriptRegionMergerTests.cs
│ │ └── Utilities/
│ │ ├── AccessionUtilitiesTests.cs
│ │ └── RemoteFileTests.cs
│ ├── Cloud/
│ │ ├── ConsistencyTests.cs
│ │ ├── JsonUtilitiesTests.cs
│ │ ├── LambdaUrlHelperTests.cs
│ │ ├── RedactionUtilitiesTests.cs
│ │ ├── S3PathTests.cs
│ │ ├── SaUrlsTests.cs
│ │ └── UploadUtilitiesTests.cs
│ ├── CommandLine/
│ │ ├── Builders/
│ │ │ ├── ConsoleAppBuilderDataTests.cs
│ │ │ ├── ConsoleAppBuilderTests.cs
│ │ │ ├── TopLevelAppBuilderTests.cs
│ │ │ └── ValidationExtensionsTests.cs
│ │ ├── NDesk.Options/
│ │ │ ├── OptionContextTests.cs
│ │ │ ├── OptionSetTests.cs
│ │ │ └── OptionsTests.cs
│ │ ├── Utilities/
│ │ │ ├── BenchmarkTests.cs
│ │ │ └── MemoryUtilitiesTests.cs
│ │ └── VersionProviders/
│ │ └── DefaultVersionProviderTests.cs
│ ├── Compression/
│ │ ├── CompressionAlgorithmTests.cs
│ │ ├── DataStructures/
│ │ │ └── BlockTests.cs
│ │ ├── FileHandling/
│ │ │ ├── BgzipTextWriterTests.cs
│ │ │ ├── BlockGZipStreamTests.cs
│ │ │ ├── BlockHeaderTests.cs
│ │ │ └── BlockStreamTests.cs
│ │ └── Utilities/
│ │ ├── GZipUtilitiesTests.cs
│ │ └── LibraryUtilitiesTests.cs
│ ├── CustomAnnotationLambda/
│ │ └── CustomAnnotationConfigTests.cs
│ ├── Downloader/
│ │ ├── AnnotationRepositoryTests.cs
│ │ ├── ConfigurationTests.cs
│ │ ├── FileExtensions/
│ │ │ ├── CacheFileExtensionsTests.cs
│ │ │ ├── ReferencesFileExtensionTests.cs
│ │ │ └── SupplementaryAnnotationFileExtensionsTests.cs
│ │ ├── GenomeAssemblyHelperTests.cs
│ │ ├── ManifestTests.cs
│ │ └── RemoteFileComparer.cs
│ ├── EndToEndTests.cs
│ ├── ErrorHandling/
│ │ ├── ExceptionUtilitiesTests.cs
│ │ ├── Exceptions/
│ │ │ └── ExceptionsTests.cs
│ │ ├── ExitCodeUtilitiesTests.cs
│ │ └── ExitCodesTests.cs
│ ├── GeneAnnotationLambda/
│ │ ├── GeneAnnotationLambdaTests.cs
│ │ └── GeneConfigTests.cs
│ ├── Genome/
│ │ ├── ChromosomeIntervalTests.cs
│ │ ├── CytogeneticBandTests.cs
│ │ ├── EmptyChromosomeTests.cs
│ │ ├── GenomeAssemblyHelperTests.cs
│ │ ├── ReferenceNameUtilitiesTests.cs
│ │ └── SequenceUtilitiesTests.cs
│ ├── IO/
│ │ ├── BufferedBinaryReaderTests.cs
│ │ ├── ExtendedBinaryReaderTests.cs
│ │ ├── FilePathUtilitiesTests.cs
│ │ ├── FileUtilitiesTests.cs
│ │ ├── HttpUtilitiesTests.cs
│ │ ├── LengthStreamTests.cs
│ │ ├── MD5StreamTests.cs
│ │ ├── PersistentStreamTests.cs
│ │ └── UrlUtilitiesTests.cs
│ ├── Intervals/
│ │ ├── IntervalArrayTests.cs
│ │ ├── IntervalExtensionsTests.cs
│ │ ├── IntervalForestTests.cs
│ │ ├── IntervalOperationsTests.cs
│ │ ├── NullIntervalSearchTests.cs
│ │ └── OverlapTypeTests.cs
│ ├── Jasix/
│ │ ├── IndexTests.cs
│ │ ├── JasixFunctionalityTests.cs
│ │ ├── JasixQueryProcessingTests.cs
│ │ └── OtfIndexCreatorTests.cs
│ ├── Jist/
│ │ └── JiSTtests.cs
│ ├── MitoHeteroplasmy/
│ │ └── MitoHeteroplasmyProviderTests.cs
│ ├── MockedData/
│ │ ├── Genes.cs
│ │ ├── TranscriptRegions.cs
│ │ ├── Transcripts.cs
│ │ └── Translations.cs
│ ├── Nirvana/
│ │ ├── AnnotationFilesTests.cs
│ │ ├── PreLoadUtilitiesTests.cs
│ │ └── ProviderUtilitiesTests.cs
│ ├── NirvanaLambda/
│ │ ├── AnnotationJobTests.cs
│ │ ├── NirvanaConfigTests.cs
│ │ ├── NirvanaLambdaTests.cs
│ │ └── PartitionUtilitiesTests.cs
│ ├── OptimizedCore/
│ │ ├── StringBuilderCacheTests.cs
│ │ └── StringExtensionsTests.cs
│ ├── RepeatExpansions/
│ │ ├── MatcherTests.cs
│ │ ├── PercentileUtilitiesTests.cs
│ │ └── RepeatExpansionProviderTests.cs
│ ├── Resources/
│ │ ├── COSM18152.tsv
│ │ ├── COSM18152.vcf
│ │ ├── COSM983708.tsv
│ │ ├── COSM983708.vcf
│ │ ├── ClinGen_Dosage_Sensitivity_Map_20190507.nga
│ │ ├── ClinVarXmlFiles/
│ │ │ ├── RCV000000101.xml
│ │ │ ├── RCV000000734.xml
│ │ │ ├── RCV000001054.xml
│ │ │ ├── RCV000001373.xml
│ │ │ ├── RCV000001752.xml
│ │ │ ├── RCV000003254.xml
│ │ │ ├── RCV000005426.xml
│ │ │ ├── RCV000007484.xml
│ │ │ ├── RCV000010551.xml
│ │ │ ├── RCV000016673.xml
│ │ │ ├── RCV000017510.xml
│ │ │ ├── RCV000021819.xml
│ │ │ ├── RCV000030349.xml
│ │ │ ├── RCV000032548.xml
│ │ │ ├── RCV000032707.xml
│ │ │ ├── RCV000038438.xml
│ │ │ ├── RCV000050055.xml
│ │ │ ├── RCV000073701.xml
│ │ │ ├── RCV000077146.xml
│ │ │ ├── RCV000080071.xml
│ │ │ ├── RCV000083638.xml
│ │ │ ├── RCV000087262.xml
│ │ │ ├── RCV000112977.xml
│ │ │ ├── RCV000113363.xml
│ │ │ ├── RCV000120902.xml
│ │ │ ├── RCV000124712.xml
│ │ │ ├── RCV000144179.xml
│ │ │ ├── RCV000152657.xml
│ │ │ ├── RCV000153339.xml
│ │ │ ├── RCV000167792.xml
│ │ │ ├── RCV000169296.xml
│ │ │ ├── RCV000170338.xml
│ │ │ ├── RCV000171474.xml
│ │ │ ├── RCV000179026.xml
│ │ │ ├── RCV000194003.xml
│ │ │ ├── RCV000203290.xml
│ │ │ ├── RCV000205418.xml
│ │ │ ├── RCV000207071.xml
│ │ │ ├── RCV000207504.xml
│ │ │ ├── RCV000235027.xml
│ │ │ ├── RCV000267121.xml
│ │ │ ├── RCV000342164.xml
│ │ │ ├── RCV000373191.xml
│ │ │ ├── RCV000401212.xml
│ │ │ ├── RCV000406351.xml
│ │ │ ├── RCV000435546.xml
│ │ │ ├── RCV000485802.xml
│ │ │ ├── RCV000537563.xml
│ │ │ ├── RCV000724338.xml
│ │ │ ├── Two_RCVs.xml
│ │ │ └── VCVs/
│ │ │ ├── TwoRecords.xml
│ │ │ ├── VCV000000081.xml
│ │ │ ├── VCV000137106.xml
│ │ │ ├── VCV000431749.xml
│ │ │ ├── VCV000476472.xml
│ │ │ └── VCV000618791.xml
│ │ ├── Clinvar20150901.json.gz.jsi
│ │ ├── EndToEnd/
│ │ │ └── GRCh37/
│ │ │ ├── chr12_7018490_7086889_Both.bases
│ │ │ ├── chr12_7018490_7086889_Both.polyphen.ndb
│ │ │ ├── chr12_7018490_7086889_Both.sift.ndb
│ │ │ └── chr12_7018490_7086889_Both.transcripts.ndb
│ │ ├── JasixTest.json.gz.jsi
│ │ ├── Mother_chr22.genome.vcf.gz.tbi
│ │ ├── OMIM_20190812.nga
│ │ ├── SA/
│ │ │ ├── CosmicCNV.tsv
│ │ │ └── MockSaFiles/
│ │ │ ├── not_sa.txt
│ │ │ ├── sa1.nsa
│ │ │ ├── sa1.nsa.idx
│ │ │ ├── sa2.nsa
│ │ │ ├── sa2.nsa.idx
│ │ │ ├── sa3.nsi
│ │ │ ├── sa4.nsi
│ │ │ ├── sa5.npd
│ │ │ ├── sa5.npd.idx
│ │ │ ├── sa6.nga
│ │ │ ├── sa7.nga
│ │ │ ├── sa8.rma
│ │ │ └── sa8.rma.idx
│ │ ├── TinyAnnotated.json
│ │ ├── clinvar.dict
│ │ ├── cosm5428243.tsv
│ │ ├── cosm5428243.vcf
│ │ ├── cosmicv72.indels.json.gz.jsi
│ │ ├── custom_gene.nga
│ │ ├── dbSNP.version
│ │ ├── gnomAD_gene_scores_2.1.nga
│ │ ├── manifest.txt
│ │ ├── mini.WigFix
│ │ ├── miniHEXA_minimal.vcf.gz.tbi
│ │ └── testDgvParser.txt
│ ├── SAUtils/
│ │ ├── AnnotationItems/
│ │ │ └── CosmicCnvItemTests.cs
│ │ ├── ClinGen/
│ │ │ └── GeneDiseaseValidityTests.cs
│ │ ├── CosmicGeneFusions/
│ │ │ ├── Cache/
│ │ │ │ └── TranscriptCacheTests.cs
│ │ │ ├── Conversion/
│ │ │ │ ├── CosmicConverterTests.cs
│ │ │ │ ├── HgvsRnaFixerTests.cs
│ │ │ │ ├── HgvsRnaParserTests.cs
│ │ │ │ ├── HistologyTests.cs
│ │ │ │ └── SiteTests.cs
│ │ │ ├── CreateCosmicGeneFusionsTests.cs
│ │ │ └── IO/
│ │ │ ├── CosmicGeneFusionParserTests.cs
│ │ │ └── GeneFusionJsonWriterTests.cs
│ │ ├── CustomAnnotations/
│ │ │ ├── AllowedValuesTests.cs
│ │ │ ├── GeneAnnotationParserTests.cs
│ │ │ ├── ParserUtilitiesTests.cs
│ │ │ └── VariantAnnotationsParserTests.cs
│ │ ├── Dann/
│ │ │ └── DannParserTests.cs
│ │ ├── DataStructures/
│ │ │ └── CounterDictionaryTests.cs
│ │ ├── DbVar/
│ │ │ ├── DosageMapRegionParserTests.cs
│ │ │ └── DosageSensitivityParserTests.cs
│ │ ├── FusionCatcher/
│ │ │ ├── FusionCatcherDataSourceTests.cs
│ │ │ ├── GeneFusionSourceWriterTests.cs
│ │ │ └── IndexBuilderTests.cs
│ │ ├── GERP/
│ │ │ ├── GerpParserTests.cs
│ │ │ └── GerpReaderTests.cs
│ │ ├── GeneAnnotationsTest.cs
│ │ ├── GenericScoreParserTests/
│ │ │ └── GenericScoreParserTests.cs
│ │ ├── InputFileParsers/
│ │ │ ├── AlleleReaderTests.cs
│ │ │ ├── ClinGenTests.cs
│ │ │ ├── ClinVarXmlReaderTests.cs
│ │ │ ├── ClinvarVariationParserTests.cs
│ │ │ ├── CosmicCnvReaderTests.cs
│ │ │ ├── CosmicItemTests.cs
│ │ │ ├── DataSourceVersionTests.cs
│ │ │ ├── DbSnpReaderTests.cs
│ │ │ ├── DecipherReaderTest.cs
│ │ │ ├── DgvReaderTests.cs
│ │ │ ├── DgvTests.cs
│ │ │ ├── GlobalMinorReaderTests.cs
│ │ │ ├── GmeReaderTests.cs
│ │ │ ├── MergedCosmicReaderTests.cs
│ │ │ ├── OneKGenTests.cs
│ │ │ ├── ParserTestUtils.cs
│ │ │ ├── RefMinorTests.cs
│ │ │ └── TopMedReaderTests.cs
│ │ ├── MitoHeteroplasmy/
│ │ │ └── MitoHeteroplasmyTests.cs
│ │ ├── MitoMap/
│ │ │ ├── MitoMapSvReaderTests.cs
│ │ │ ├── MitoMapVariantReaderTests.cs
│ │ │ └── ParsingUtilitiesTests.cs
│ │ ├── NsaWriters/
│ │ │ ├── IntervalWriterReaderTests.cs
│ │ │ ├── NsaUtilitiesTests.cs
│ │ │ └── WriterReaderTests.cs
│ │ ├── Omim/
│ │ │ └── OmimUtilitiesTests.cs
│ │ ├── ParseUtils/
│ │ │ ├── SplitLineTests.cs
│ │ │ └── TsvIndicesTests.cs
│ │ ├── PhylopTests.cs
│ │ ├── PrimateAi/
│ │ │ └── PrimateAiTests.cs
│ │ ├── ProteinConservation/
│ │ │ └── ParserTests.cs
│ │ ├── Revel/
│ │ │ └── RevelParserTests.cs
│ │ ├── SaJsonSchemaTests.cs
│ │ ├── SpliceAi/
│ │ │ └── SpliceAiTests.cs
│ │ └── gnomAD/
│ │ ├── GnomadGeneScoreTests.cs
│ │ ├── GnomadReaderTests.cs
│ │ ├── GnomadSvBedParserTests.cs
│ │ ├── GnomadSvItemTests.cs
│ │ ├── GnomadSvTsvParserTests.cs
│ │ └── LcrParserTests.cs
│ ├── SingleAnnotationLambda/
│ │ ├── SingleConfigTests.cs
│ │ └── SingleVariantTests.cs
│ ├── Tabix/
│ │ ├── BgzfBlockVcfReaderTests.cs
│ │ ├── BinUtilitiesTests.cs
│ │ ├── ReaderTests.cs
│ │ ├── SearchTests.cs
│ │ ├── SearchTestsLocalMother.cs
│ │ ├── SearchTestsRemoteMother.cs
│ │ ├── SearchUtilitiesTests.cs
│ │ └── VirtualPositionTests.cs
│ ├── TestDataStructures/
│ │ └── SimpleSequence.cs
│ ├── TestUtilities/
│ │ ├── AnnotationUtilities.cs
│ │ ├── ByteUtilities.cs
│ │ ├── ChromosomeUtilities.cs
│ │ ├── RandomPath.cs
│ │ ├── ResourceUtilities.cs
│ │ ├── Resources.cs
│ │ └── TestDataGenerator.cs
│ ├── UnitTests.csproj
│ ├── VariantAnnotation/
│ │ ├── Algorithms/
│ │ │ └── SwapTests.cs
│ │ ├── AnnotatedPositions/
│ │ │ ├── AnnotatedPositionTests.cs
│ │ │ ├── AnnotatedVariantTests.cs
│ │ │ ├── ConsequenceTests.cs
│ │ │ ├── HgvsCodingNomenclatureTests.cs
│ │ │ ├── HgvsProteinNomenclatureTests.cs
│ │ │ ├── HgvsUtilitiesTests.cs
│ │ │ ├── HgvscNotationTests.cs
│ │ │ ├── HgvsgNotationTests.cs
│ │ │ ├── HgvspNotationTests.cs
│ │ │ ├── ProteinChangeTests.cs
│ │ │ ├── RegulatoryRegionAnnotatorTests.cs
│ │ │ └── Transcript/
│ │ │ ├── AminoAcidTests.cs
│ │ │ ├── AnnotatedTranscriptTests.cs
│ │ │ ├── CdnaSequenceTests.cs
│ │ │ ├── CodingSequenceTests.cs
│ │ │ ├── CodonsTests.cs
│ │ │ ├── CompactIdTests.cs
│ │ │ ├── FeatureVariantEffectsTests.cs
│ │ │ ├── MappedPositionUtilitiesTests.cs
│ │ │ ├── StringExtensionsTests.cs
│ │ │ ├── TranscriptPositionalEffectTests.cs
│ │ │ ├── TranscriptUtilitiesTests.cs
│ │ │ └── VariantEffectTests.cs
│ │ ├── AnnotatorTests.cs
│ │ ├── Caches/
│ │ │ ├── DataStructures/
│ │ │ │ ├── EncodedTranscriptDataTests.cs
│ │ │ │ ├── GeneTests.cs
│ │ │ │ ├── RegulatoryRegionTests.cs
│ │ │ │ ├── TranscriptRegionExtensionsTests.cs
│ │ │ │ ├── TranscriptRegionTests.cs
│ │ │ │ ├── TranscriptTests.cs
│ │ │ │ └── TranslationTests.cs
│ │ │ ├── TranscriptCacheTests.cs
│ │ │ └── Utilities/
│ │ │ ├── RnaEditUtilitiesTests.cs
│ │ │ └── TranscriptUtilitiesTests.cs
│ │ ├── GeneFusions/
│ │ │ ├── Calling/
│ │ │ │ └── GeneFusionCallerTests.cs
│ │ │ ├── IO/
│ │ │ │ ├── GeneFusionIndexEntryTests.cs
│ │ │ │ └── GeneFusionSourceReaderTests.cs
│ │ │ ├── SA/
│ │ │ │ ├── GeneFusionPairTests.cs
│ │ │ │ ├── GeneFusionSourceCollectionTests.cs
│ │ │ │ └── GeneFusionSourceUtilitiesTests.cs
│ │ │ └── Utilities/
│ │ │ ├── GeneFusionKeyTests.cs
│ │ │ └── IndexEntryExtensionsTests.cs
│ │ ├── IO/
│ │ │ ├── Caches/
│ │ │ │ ├── CacheConstantsTests.cs
│ │ │ │ ├── CacheHeaderTests.cs
│ │ │ │ └── TranscriptCacheReaderTests.cs
│ │ │ ├── JsonObjectTests.cs
│ │ │ ├── JsonWriterTests.cs
│ │ │ └── SampleExtensionsTests.cs
│ │ ├── NSA/
│ │ │ ├── NsaIndexTests.cs
│ │ │ ├── RefMinorIndexTests.cs
│ │ │ ├── SuppAnnotationsOutputTests.cs
│ │ │ └── SuppIntervalUtilitiesTests.cs
│ │ ├── ProviderTests/
│ │ │ ├── GsaProviderTests.cs
│ │ │ ├── LcrProviderTests.cs
│ │ │ └── NsaProviderTests.cs
│ │ ├── ScoreFile/
│ │ │ ├── GenericScoreEncoderTests.cs
│ │ │ ├── GenericScoreEndToEndTests.cs
│ │ │ ├── GenericScoreTests.cs
│ │ │ ├── HeaderTests.cs
│ │ │ ├── ReaderSettingsTests.cs
│ │ │ ├── SaItemValidatorTests.cs
│ │ │ ├── ScoreEncoderTests.cs
│ │ │ ├── ScoreIndexTests.cs
│ │ │ └── ScoreJsonEncoderTests.cs
│ │ ├── Sequence/
│ │ │ ├── CompressedSequenceReaderTests.cs
│ │ │ └── CompressedSequenceTests.cs
│ │ ├── TranscriptAnnotation/
│ │ │ ├── BreakEndUtilitiesTests.cs
│ │ │ ├── FullTranscriptAnnotatorTests.cs
│ │ │ └── TranscriptAnnotationFactoryTests.cs
│ │ └── Utilities/
│ │ ├── DateTests.cs
│ │ ├── FormatUtilitiesTests.cs
│ │ └── GeneComparerTests.cs
│ ├── Variants/
│ │ ├── BiDirectionalTrimmerTests.cs
│ │ ├── SimpleVariantTests.cs
│ │ ├── VariantRotatorTests.cs
│ │ └── VariantTests.cs
│ └── Vcf/
│ ├── Samples/
│ │ ├── BooleanExtensionsTests.cs
│ │ ├── FormatIndicesTests.cs
│ │ ├── Legacy/
│ │ │ └── LegacySampleFieldExtractorTests.cs
│ │ ├── SampleFieldExtractorTests.cs
│ │ ├── SampleParsingExtensionsTests.cs
│ │ ├── SampleTests.cs
│ │ ├── TestUtilities.cs
│ │ └── VariantFrequencyTests.cs
│ ├── StringExtensionsTests.cs
│ ├── VariantCreator/
│ │ ├── CnvCreatorTests.cs
│ │ ├── LegacyVariantIdTests.cs
│ │ ├── ReferenceVariantCreatorTests.cs
│ │ ├── SmallVariantCreatorTests.cs
│ │ ├── VariantFactoryTests.cs
│ │ ├── VariantFactoryTestsWithLegacyVids.cs
│ │ └── VariantIdTests.cs
│ ├── VcfFilterTests.cs
│ ├── VcfInfoParserTests.cs
│ ├── VcfReaderTests.cs
│ └── VcfReaderUtilsTests.cs
├── VariantAnnotation/
│ ├── Algorithms/
│ │ └── Swap.cs
│ ├── AnnotatedPositions/
│ │ ├── AnnotatedPosition.cs
│ │ ├── AnnotatedRegulatoryRegion.cs
│ │ ├── AnnotatedVariant.cs
│ │ ├── Consequence/
│ │ │ └── Consequences.cs
│ │ ├── HgvsCodingNomenclature.cs
│ │ ├── HgvsProteinNomenclature.cs
│ │ ├── HgvsUtilities.cs
│ │ ├── HgvscNotation.cs
│ │ ├── HgvsgNotation.cs
│ │ ├── HgvspNotation.cs
│ │ ├── PositionOffset.cs
│ │ ├── RegulatoryRegionAnnotator.cs
│ │ └── Transcript/
│ │ ├── AminoAcids.cs
│ │ ├── AnnotatedConservationScore.cs
│ │ ├── AnnotatedGeneFusion.cs
│ │ ├── AnnotatedTranscript.cs
│ │ ├── CdnaSequence.cs
│ │ ├── CodingSequence.cs
│ │ ├── Codons.cs
│ │ ├── CompactId.cs
│ │ ├── FeatureVariantEffects.cs
│ │ ├── MappedPosition.cs
│ │ ├── MappedPositionUtilities.cs
│ │ ├── StringExtensions.cs
│ │ ├── TranscriptPositionalEffect.cs
│ │ ├── TranscriptUtilities.cs
│ │ ├── VariantEffect.cs
│ │ └── VariantEffectCache.cs
│ ├── Annotator.cs
│ ├── AssemblyInfo.cs
│ ├── Caches/
│ │ ├── DataStructures/
│ │ │ ├── CodingRegion.cs
│ │ │ ├── EncodedTranscriptData.cs
│ │ │ ├── Gene.cs
│ │ │ ├── IndexEntry.cs
│ │ │ ├── Prediction.cs
│ │ │ ├── RegulatoryRegion.cs
│ │ │ ├── RnaEdit.cs
│ │ │ ├── Transcript.cs
│ │ │ ├── TranscriptRegion.cs
│ │ │ ├── TranscriptRegionExtensions.cs
│ │ │ └── Translation.cs
│ │ ├── PredictionCache.cs
│ │ ├── TranscriptCache.cs
│ │ ├── TranscriptCacheData.cs
│ │ ├── TranscriptIntervalForestExtensions.cs
│ │ └── Utilities/
│ │ ├── ExonUtilities.cs
│ │ ├── GeneForestGenerator.cs
│ │ └── RnaEditUtilities.cs
│ ├── GeneAnnotation/
│ │ └── GeneAnnotationProvider.cs
│ ├── GeneFusions/
│ │ ├── Calling/
│ │ │ ├── BreakEndAdjacency.cs
│ │ │ ├── BreakEndAdjacencyFactory.cs
│ │ │ ├── BreakPoint.cs
│ │ │ ├── BreakPointTranscript.cs
│ │ │ └── GeneFusionCaller.cs
│ │ ├── HGVS/
│ │ │ └── HgvsRnaNomenclature.cs
│ │ ├── IO/
│ │ │ ├── GeneFusionIndexEntry.cs
│ │ │ ├── GeneFusionJsonReader.cs
│ │ │ ├── GeneFusionSourceReader.cs
│ │ │ └── IGeneFusionSaReader.cs
│ │ ├── SA/
│ │ │ ├── GeneFusionPair.cs
│ │ │ ├── GeneFusionSource.cs
│ │ │ ├── GeneFusionSourceCollection.cs
│ │ │ └── GeneFusionSourceUtilities.cs
│ │ └── Utilities/
│ │ ├── GeneFusionKey.cs
│ │ └── IndexEntryExtensions.cs
│ ├── GenericScore/
│ │ ├── ChromosomeBlock.cs
│ │ ├── EncoderType.cs
│ │ ├── GenericScoreEncoder.cs
│ │ ├── IScoreEncoder.cs
│ │ ├── MetaData.cs
│ │ ├── ReaderSettings.cs
│ │ ├── ScoreBlock.cs
│ │ ├── ScoreIndex.cs
│ │ ├── ScoreIndexBlock.cs
│ │ ├── ScoreJsonEncoder.cs
│ │ ├── ScoreReader.cs
│ │ └── ZeroToOneScoreEncoder.cs
│ ├── IO/
│ │ ├── Caches/
│ │ │ ├── CacheHeader.cs
│ │ │ ├── Header.cs
│ │ │ ├── PredictionCacheCustomHeader.cs
│ │ │ ├── PredictionCacheReader.cs
│ │ │ ├── PredictionHeader.cs
│ │ │ ├── TranscriptCacheCustomHeader.cs
│ │ │ └── TranscriptCacheReader.cs
│ │ ├── IntervalExtensions.cs
│ │ ├── JsonCommon.cs
│ │ ├── JsonObject.cs
│ │ ├── JsonWriter.cs
│ │ └── SampleExtensions.cs
│ ├── NSA/
│ │ ├── NgaReader.cs
│ │ ├── NsaBlock.cs
│ │ ├── NsaIndex.cs
│ │ ├── NsaIndexBlock.cs
│ │ ├── NsaReader.cs
│ │ ├── NsiReader.cs
│ │ ├── NsiWriter.cs
│ │ ├── RefMinorDbReader.cs
│ │ ├── RefMinorIndex.cs
│ │ ├── SuppInterval.cs
│ │ ├── SuppIntervalUtilities.cs
│ │ └── SupplementaryAnnotation.cs
│ ├── PerformanceMetrics.cs
│ ├── PhyloP/
│ │ ├── NpdIndex.cs
│ │ └── NpdReader.cs
│ ├── Pools/
│ │ ├── AnnotatedPositionPool.cs
│ │ ├── AnnotatedTranscriptPool.cs
│ │ ├── AnnotatedVariantPool.cs
│ │ └── VariantPool.cs
│ ├── ProteinConservation/
│ │ ├── ProteinConservationCommon.cs
│ │ ├── ProteinConservationItem.cs
│ │ ├── ProteinConservationReader.cs
│ │ └── TranscriptConservationScores.cs
│ ├── Providers/
│ │ ├── ConservationScoreProvider.cs
│ │ ├── DataSourceVersion.cs
│ │ ├── LcrProvider.cs
│ │ ├── NsaProvider.cs
│ │ ├── ProteinConservationProvider.cs
│ │ ├── RefMinorProvider.cs
│ │ ├── ReferenceSequenceProvider.cs
│ │ ├── ScoreProvider.cs
│ │ ├── TranscriptAnnotationProvider.cs
│ │ └── VersionProvider.cs
│ ├── SA/
│ │ ├── CustomAnnotationCategories.cs
│ │ ├── JsonDataType.cs
│ │ └── SaCommon.cs
│ ├── TranscriptAnnotation/
│ │ ├── FlankingTranscriptAnnotator.cs
│ │ ├── FullTranscriptAnnotator.cs
│ │ ├── ReducedTranscriptAnnotator.cs
│ │ ├── RohTranscriptAnnotator.cs
│ │ ├── SequenceChange.cs
│ │ └── TranscriptAnnotationFactory.cs
│ ├── Utilities/
│ │ ├── BaseFormatting.cs
│ │ ├── Date.cs
│ │ ├── FormatUtilities.cs
│ │ └── GeneComparer.cs
│ └── VariantAnnotation.csproj
├── VariantAnnotation.Interface/
│ ├── AnnotatedPositions/
│ │ ├── BioType.cs
│ │ ├── ConsequenceTag.cs
│ │ ├── IAnnotatedGeneFusion.cs
│ │ ├── IAnnotatedPosition.cs
│ │ ├── IAnnotatedRegulatoryRegion.cs
│ │ ├── IAnnotatedTranscript.cs
│ │ ├── IAnnotatedVariant.cs
│ │ ├── ICodingRegion.cs
│ │ ├── ICompactId.cs
│ │ ├── IFeatureVariantEffects.cs
│ │ ├── IGene.cs
│ │ ├── IGeneFusion.cs
│ │ ├── IGeneFusionPair.cs
│ │ ├── IMappedPosition.cs
│ │ ├── IRegulatoryRegion.cs
│ │ ├── IRnaEdit.cs
│ │ ├── ITranscript.cs
│ │ ├── ITranscriptRegion.cs
│ │ ├── ITranslation.cs
│ │ ├── IVariantEffect.cs
│ │ └── PredictionScore.cs
│ ├── Caches/
│ │ ├── IPredictionCache.cs
│ │ ├── ITranscriptCache.cs
│ │ └── RegulatoryRegionType.cs
│ ├── Constants.cs
│ ├── GeneAnnotation/
│ │ └── IGeneAnnotationProvider.cs
│ ├── IAnnotationResources.cs
│ ├── IAnnotator.cs
│ ├── IO/
│ │ ├── IJsonSerializer.cs
│ │ ├── IJsonWriter.cs
│ │ ├── IVcfReader.cs
│ │ └── VcfCommon.cs
│ ├── IVariantIdCreator.cs
│ ├── Positions/
│ │ ├── ICustomFields.cs
│ │ ├── IInfoData.cs
│ │ ├── IPosition.cs
│ │ ├── ISample.cs
│ │ └── ISimplePosition.cs
│ ├── Providers/
│ │ ├── IAnnotationProvider.cs
│ │ ├── IDataSourceVersion.cs
│ │ ├── IMitoHeteroplasmyProvider.cs
│ │ ├── IProvider.cs
│ │ ├── IRefMinorProvider.cs
│ │ ├── ISequenceProvider.cs
│ │ └── ITranscriptAnnotationProvider.cs
│ ├── SA/
│ │ ├── INsaReader.cs
│ │ ├── INsiReader.cs
│ │ ├── ISaMetadata.cs
│ │ ├── ISupplementaryAnnotation.cs
│ │ ├── ISupplementaryDataItem.cs
│ │ ├── ISupplementaryInterval.cs
│ │ ├── IsuppGeneItem.cs
│ │ └── IsuppIntervalItem.cs
│ ├── VariantAnnotation.Interface.csproj
│ └── VariantCategory.cs
├── Variants/
│ ├── AnnotationBehavior.cs
│ ├── BiDirectionalTrimmer.cs
│ ├── ISimpleVariant.cs
│ ├── IVariant.cs
│ ├── RepeatExpansion.cs
│ ├── SimpleVariant.cs
│ ├── Variant.cs
│ ├── VariantRotator.cs
│ ├── VariantType.cs
│ ├── VariantUtils.cs
│ └── Variants.csproj
└── Vcf/
├── AssemblyInfo.cs
├── IVcfFilter.cs
├── Info/
│ ├── CustomFields.cs
│ ├── InfoData.cs
│ └── VcfInfoParser.cs
├── NullVcfFilter.cs
├── Position.cs
├── PositionPool.cs
├── Sample/
│ ├── BooleanExtensions.cs
│ ├── FormatIndices.cs
│ ├── Legacy/
│ │ ├── AlleleDepths.cs
│ │ ├── FailedFilter.cs
│ │ ├── Genotype.cs
│ │ ├── GenotypeQuality.cs
│ │ ├── IntermediateSampleFields.cs
│ │ ├── LegacySampleFieldExtractor.cs
│ │ ├── LegacyVariantFrequency.cs
│ │ ├── ReadCounts.cs
│ │ └── TotalDepth.cs
│ ├── Sample.cs
│ ├── SampleFieldExtractor.cs
│ ├── SampleParsingExtensions.cs
│ └── VariantFrequency.cs
├── SimplePosition.cs
├── StringExtensions.cs
├── VariantCreator/
│ ├── CnvCreator.cs
│ ├── LegacyVariantId.cs
│ ├── ReferenceVariantCreator.cs
│ ├── RepeatExpansionCreator.cs
│ ├── RohVariantCreator.cs
│ ├── SmallVariantCreator.cs
│ ├── StructuralVariantCreator.cs
│ ├── VariantFactory.cs
│ └── VariantId.cs
├── Vcf.csproj
├── VcfFilter.cs
└── VcfReader.cs
Showing preview only (556K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (5812 symbols across 1083 files)
FILE: AnnotationLambda/AnnotationLambda.cs
class AnnotationLambda (line 29) | public sealed class AnnotationLambda
method Run (line 32) | public AnnotationResult Run(AnnotationConfig config, ILambdaContext co...
method GetSuccessOutput (line 125) | private static AnnotationResult GetSuccessOutput(AnnotationResult result)
method HandleException (line 132) | private static AnnotationResult HandleException(StringBuilder runLog, ...
method GetTabixVirtualPosition (line 150) | internal static long GetTabixVirtualPosition(AnnotationRange annotatio...
method GetAnnotationResources (line 159) | private static AnnotationResources GetAnnotationResources(AnnotationCo...
FILE: AnnotationLambda/S3Utilities.cs
class S3Utilities (line 3) | public static class S3Utilities
method GetKey (line 5) | public static string GetKey(string outputDir, string filename)
FILE: CacheUtils/CacheUtils.cs
class CacheUtilsMain (line 16) | internal static class CacheUtilsMain
method Main (line 18) | private static int Main(string[] args)
FILE: CacheUtils/Commands/CombineCacheDirectories/CombineCacheDirectoriesMain.cs
class CombineCacheDirectoriesMain (line 25) | public static class CombineCacheDirectoriesMain
method ProgramExecution (line 32) | private static ExitCodes ProgramExecution()
method WriteTranscripts (line 89) | private static void WriteTranscripts(CacheHeader header,
method WritePredictions (line 100) | private static void WritePredictions(string description, string filePath,
method CombineTranscripts (line 114) | private static IntervalArray<ITranscript> CombineTranscripts(IntervalA...
method GetNumCombinedTranscripts (line 131) | private static int GetNumCombinedTranscripts<T>(IntervalArray<T> inter...
method CopyItems (line 140) | private static void CopyItems<T>(T[] src, T[] dest, ref int destIndex,...
method GetUpdatedTranscript (line 147) | private static Interval<ITranscript> GetUpdatedTranscript(Interval<ITr...
method CloneBaseHeader (line 160) | private static VariantAnnotation.IO.Caches.Header CloneBaseHeader(Vari...
method CloneHeader (line 164) | private static PredictionHeader CloneHeader(PredictionHeader header) =>
method CloneHeader (line 167) | private static CacheHeader CloneHeader(CacheHeader header) =>
method CombinePredictions (line 170) | private static (Prediction[] Predictions, int Offset) CombinePredictio...
method CombinePredictions (line 182) | private static Prediction[] CombinePredictions(string description, Pre...
method LoadTranscriptCaches (line 199) | private static (TranscriptCacheData Cache, TranscriptCacheData Cache2)...
method Run (line 218) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/CreateCache/CreateNirvanaDatabaseMain.cs
class CreateNirvanaDatabaseMain (line 23) | public static class CreateNirvanaDatabaseMain
method ProgramExecution (line 30) | private static ExitCodes ProgramExecution()
method CreateGeneForest (line 88) | private static IIntervalForest<UgaGene> CreateGeneForest(IEnumerable<U...
method MarkCanonicalTranscripts (line 111) | private static void MarkCanonicalTranscripts(MutableTranscript[] trans...
method Run (line 122) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/Download/DownloadMain.cs
class DownloadMain (line 5) | public static class DownloadMain
method ProgramExecution (line 7) | private static ExitCodes ProgramExecution()
method Run (line 13) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/Download/ExternalFiles.cs
class ExternalFiles (line 16) | public static class ExternalFiles
method Download (line 37) | public static void Download()
method GetIdToGenbankEntryDict (line 66) | private static IEnumerable<GenbankEntry> GetIdToGenbankEntryDict(IEnum...
method GetGenbankFiles (line 69) | private static List<GenbankFile> GetGenbankFiles(ICollection<RemoteFil...
method GetElapsedDays (line 87) | public static double GetElapsedDays(DateTime creationTime) => DateTime...
method GetNumGenbankFiles (line 89) | private static int GetNumGenbankFiles()
method WriteDictionary (line 114) | private static void WriteDictionary(IEnumerable<GenbankEntry> entries)
FILE: CacheUtils/Commands/Download/GenbankFile.cs
class GenbankFile (line 10) | public sealed class GenbankFile
method GenbankFile (line 15) | public GenbankFile(int num)
method Parse (line 21) | public void Parse()
FILE: CacheUtils/Commands/ExtractTranscripts/ExtractTranscriptsMain.cs
class ExtractTranscriptsMain (line 21) | public static class ExtractTranscriptsMain
method ProgramExecution (line 32) | private static ExitCodes ProgramExecution()
method GetTranscriptStaging (line 59) | private static TranscriptCacheStaging GetTranscriptStaging(CacheHeader...
method WriteCache (line 65) | private static void WriteCache(Stream stream, IStaging staging, string...
method GetOutputStub (line 72) | private static string GetOutputStub(Chromosome chromosome, Source sour...
method GetSource (line 75) | private static string GetSource(Source source) =>
method GetPredictionStaging (line 78) | private static (PredictionCacheStaging Staging, Prediction[] Predictio...
method GetPredictions (line 92) | private static Prediction[][] GetPredictions(ICollection<int> indexSet...
method GetUniqueIndices (line 105) | private static HashSet<int> GetUniqueIndices(IEnumerable<ITranscript> ...
method GetRegulatoryRegionIntervalArrays (line 117) | private static IntervalArray<IRegulatoryRegion>[] GetRegulatoryRegionI...
method GetTranscripts (line 129) | private static List<ITranscript> GetTranscripts(DataBundle bundle, Chr...
method Run (line 139) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/GFF/CreateGffMain.cs
class CreateGffMain (line 18) | public static class CreateGffMain
method ProgramExecution (line 25) | private static ExitCodes ProgramExecution()
method Run (line 45) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/GFF/InternalGenes.cs
class InternalGenes (line 8) | public static class InternalGenes
method CreateDictionary (line 10) | public static Dictionary<IGene, int> CreateDictionary(IGene[] genes)
FILE: CacheUtils/Commands/Header/HeaderMain.cs
class HeaderMain (line 12) | public static class HeaderMain
method ProgramExecution (line 16) | private static ExitCodes ProgramExecution()
method GetHeaderInformation (line 25) | private static (ushort Schema, ushort Data, ushort Vep) GetHeaderInfor...
method Run (line 38) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/ParseVepCacheDirectory/ParseVepCacheDirectoryMain.cs
class ParseVepCacheDirectoryMain (line 19) | public static class ParseVepCacheDirectoryMain
method ProgramExecution (line 31) | private static ExitCodes ProgramExecution()
method GetIdToGenbank (line 97) | private static Dictionary<string, GenbankEntry> GetIdToGenbank(GenomeA...
method WriteRegulatoryRegions (line 113) | private static void WriteRegulatoryRegions(RegulatoryRegionWriter writ...
method WriteTranscripts (line 118) | private static void WriteTranscripts(MutableTranscriptWriter writer, I...
method WritePredictions (line 123) | private static void WritePredictions(PredictionWriter writer, IReadOnl...
method GetSource (line 141) | public static Source GetSource(string source)
method Run (line 149) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/Commands/ParseVepCacheDirectory/RegulatoryRegionMerger.cs
class RegulatoryRegionMerger (line 10) | public static class RegulatoryRegionMerger
method Merge (line 12) | public static IEnumerable<IRegulatoryRegion> Merge(IEnumerable<IRegula...
method MergeRegulatoryRegion (line 37) | private static void MergeRegulatoryRegion(IRegulatoryRegion previous, ...
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptFilter.cs
class TranscriptFilter (line 14) | public static class TranscriptFilter
method Log (line 18) | private static void Log(this TranscriptMergerLogger logger, string tra...
method PickSpecificTranscript (line 21) | public static List<MutableTranscript> PickSpecificTranscript(
method InvestigateInconsistentCdnaMaps (line 54) | public static List<MutableTranscript> InvestigateInconsistentCdnaMaps(...
method DiffExonsAndCdnaMaps (line 79) | private static bool DiffExonsAndCdnaMaps(IReadOnlyList<MutableExon> ex...
method ChooseEditedTranscripts (line 94) | public static List<MutableTranscript> ChooseEditedTranscripts(
method RemoveFailedTranscripts (line 106) | public static List<MutableTranscript> RemoveFailedTranscripts(
method RemoveTranscriptsWithLowestVersion (line 118) | public static List<MutableTranscript> RemoveTranscriptsWithLowestVersion(
method Unique (line 133) | public static List<MutableTranscript> Unique(this IEnumerable<MutableT...
method FixCodingRegionCdnaStart (line 140) | public static List<MutableTranscript> FixCodingRegionCdnaStart(this Li...
method FixCodingRegionCdnaEnd (line 155) | public static List<MutableTranscript> FixCodingRegionCdnaEnd(this List...
method FixGeneSymbolSource (line 170) | public static List<MutableTranscript> FixGeneSymbolSource(this List<Mu...
method FixBioType (line 187) | public static List<MutableTranscript> FixBioType(this List<MutableTran...
method GetDesiredBioType (line 221) | private static BioType GetDesiredBioType(ICollection<BioType> biotypes)
method FixGeneId (line 238) | public static List<MutableTranscript> FixGeneId(this List<MutableTrans...
method UnsupervisedFixGeneId (line 253) | public static List<MutableTranscript> UnsupervisedFixGeneId(this List<...
method FixGeneSymbols (line 267) | public static List<MutableTranscript> FixGeneSymbols(this List<Mutable...
method FixCanonical (line 286) | public static List<MutableTranscript> FixCanonical(this List<MutableTr...
method FixHgncId (line 298) | public static List<MutableTranscript> FixHgncId(this List<MutableTrans...
method FixGeneStart (line 313) | public static List<MutableTranscript> FixGeneStart(this List<MutableTr...
method FixGeneEnd (line 329) | public static List<MutableTranscript> FixGeneEnd(this List<MutableTran...
method UnsupervisedFixGeneSymbols (line 345) | private static List<MutableTranscript> UnsupervisedFixGeneSymbols(this...
method GetClosest (line 356) | private static int GetClosest(IEnumerable<int> values, int targetValue)
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptIdFilter.cs
class TranscriptIdFilter (line 8) | public sealed class TranscriptIdFilter
method TranscriptIdFilter (line 12) | public TranscriptIdFilter(Source source)
method Pass (line 28) | public bool Pass(MutableTranscript transcript) => _whitelist.Any(prefi...
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptMerger.cs
class TranscriptMerger (line 10) | public static class TranscriptMerger
method Merge (line 17) | public static List<MutableTranscript> Merge(TranscriptMergerLogger log...
method Merge (line 25) | private static MutableTranscript Merge(TranscriptMergerLogger logger, ...
FILE: CacheUtils/Commands/ParseVepCacheDirectory/TranscriptMergerLogger.cs
class TranscriptMergerLogger (line 6) | public sealed class TranscriptMergerLogger : IDisposable
method TranscriptMergerLogger (line 10) | public TranscriptMergerLogger(Stream stream) => _writer = new StreamWr...
method WriteLine (line 12) | public void WriteLine() => _writer.WriteLine();
method WriteLine (line 13) | public void WriteLine(string s) => _writer.WriteLine(s);
method Write (line 14) | public void Write(string s) => _writer.Write(s);
method SetBold (line 16) | public void SetBold() {
method ResetColor (line 20) | public void ResetColor()
method Dispose (line 25) | public void Dispose() => _writer.Dispose();
FILE: CacheUtils/Commands/ParseVepCacheDirectory/VepCacheParser.cs
class VepCacheParser (line 16) | public sealed class VepCacheParser
method VepCacheParser (line 21) | public VepCacheParser(Source source)
method ParseDumpDirectory (line 27) | public (List<IRegulatoryRegion> RegulatoryRegions, List<MutableTranscr...
method ParseRegulatoryFiles (line 35) | private static List<IRegulatoryRegion> ParseRegulatoryFiles(Chromosome...
method ParseTranscriptFiles (line 49) | private List<MutableTranscript> ParseTranscriptFiles(Chromosome chromo...
method ParseRegulatoryDumpFile (line 62) | private static void ParseRegulatoryDumpFile(Chromosome chromosome, str...
method ParseTranscriptDumpFile (line 91) | private void ParseTranscriptDumpFile(Chromosome chromosome, string fil...
method ParseRegulatoryRegions (line 114) | private static void ParseRegulatoryRegions(Chromosome chromosome, IImp...
FILE: CacheUtils/Commands/ParseVepCacheDirectory/VepRootDirectory.cs
class VepRootDirectory (line 9) | public sealed class VepRootDirectory
method VepRootDirectory (line 13) | public VepRootDirectory(Dictionary<string, Chromosome> refNameToChromo...
method GetRefIndexToVepDir (line 18) | public Dictionary<ushort, string> GetRefIndexToVepDir(string dirPath)
method GetSortedFiles (line 35) | public static IEnumerable<string> GetSortedFiles(IEnumerable<string> f...
FILE: CacheUtils/Commands/RegulatoryGFF/CreateRegulatoryGffMain.cs
class CreateRegulatoryGffMain (line 15) | public static class CreateRegulatoryGffMain
method ProgramExecution (line 21) | private static ExitCodes ProgramExecution()
method Run (line 45) | public static ExitCodes Run(string command, string[] args)
method WriteRegulatoryFeature (line 79) | private static void WriteRegulatoryFeature(TextWriter writer, IRegulat...
method WriteGeneralAttributes (line 86) | private static void WriteGeneralAttributes(TextWriter writer, IRegulat...
FILE: CacheUtils/Commands/UniversalGeneArchive/FilePaths.cs
class FilePaths (line 4) | public sealed class FilePaths
class AssemblySpecificPaths (line 10) | public class AssemblySpecificPaths
FILE: CacheUtils/Commands/UniversalGeneArchive/UniversalGeneArchiveMain.cs
class UniversalGeneArchiveMain (line 21) | public static class UniversalGeneArchiveMain
method ProgramExecution (line 26) | private static ExitCodes ProgramExecution()
method UniversalGeneArchiveCurrent (line 51) | private static bool UniversalGeneArchiveCurrent()
method LoadDataStores (line 57) | private static (GeneInfoData GeneInfoData, AssemblyDataStore Assembly3...
method CombineGenomeAssemblies (line 75) | private static UgaGene[] CombineGenomeAssemblies(Dictionary<ushort, Li...
method UpdateGeneSymbols (line 85) | private static UgaGene[] UpdateGeneSymbols(this UgaGene[] genes, Dicti...
method WriteGenes (line 93) | private static void WriteGenes(UgaGene[] genes)
method GetFilePaths (line 106) | private static FilePaths GetFilePaths(string jsonPath)
method UpdatePaths (line 125) | private static void UpdatePaths(FilePaths.AssemblySpecificPaths paths)
method CheckPath (line 132) | private static void CheckPath(string filePath, string description)
method CheckPaths (line 138) | private static void CheckPaths(FilePaths.AssemblySpecificPaths paths)
method Run (line 145) | public static ExitCodes Run(string command, string[] args)
FILE: CacheUtils/DataDumperImport/DataStructures/GenomeSymbolSource.cs
type GeneSymbolSource (line 3) | public enum GeneSymbolSource : byte
FILE: CacheUtils/DataDumperImport/DataStructures/Import/IImportNode.cs
type IImportNode (line 3) | public interface IImportNode
type IListMember (line 8) | public interface IListMember : IImportNode { }
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ImportNodeExtensions.cs
class ImportNodeExtensions (line 5) | public static class ImportNodeExtensions
method GetInt32 (line 7) | public static int GetInt32(this IImportNode node)
method GetBool (line 20) | public static bool GetBool(this IImportNode node)
method GetString (line 26) | public static string GetString(this IImportNode node)
method IsUndefined (line 38) | public static bool IsUndefined(this IImportNode node)
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ListObjectKeyValueNode.cs
class ListObjectKeyValueNode (line 5) | public sealed class ListObjectKeyValueNode : IImportNode
method ListObjectKeyValueNode (line 10) | public ListObjectKeyValueNode(string key) => Key = key;
method Add (line 11) | public void Add(IListMember node) => Values.Add(node);
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ObjectKeyValueNode.cs
class ObjectKeyValueNode (line 3) | public sealed class ObjectKeyValueNode : IImportNode
method ObjectKeyValueNode (line 8) | public ObjectKeyValueNode(string key, ObjectValueNode value)
FILE: CacheUtils/DataDumperImport/DataStructures/Import/ObjectValueNode.cs
class ObjectValueNode (line 5) | public sealed class ObjectValueNode : IListMember
method ObjectValueNode (line 11) | internal ObjectValueNode(string type, List<IImportNode> values)
FILE: CacheUtils/DataDumperImport/DataStructures/Import/StringKeyValueNode.cs
class StringKeyValueNode (line 3) | public sealed class StringKeyValueNode : IImportNode
method StringKeyValueNode (line 8) | public StringKeyValueNode(string key, string value)
FILE: CacheUtils/DataDumperImport/DataStructures/Import/StringValueNode.cs
class StringValueNode (line 3) | public sealed class StringValueNode : IListMember
method StringValueNode (line 6) | public StringValueNode(string key) => Key = key;
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableExon.cs
class MutableExon (line 7) | public sealed class MutableExon : IEquatable<MutableExon>, IInterval
method MutableExon (line 14) | public MutableExon(Chromosome chromosome, int start, int end, int phase)
method Equals (line 22) | public bool Equals(MutableExon other)
method GetHashCode (line 30) | public override int GetHashCode()
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableGene.cs
class MutableGene (line 8) | public sealed class MutableGene : IEquatable<MutableGene>, IFlatGene<Mut...
method MutableGene (line 19) | public MutableGene(Chromosome chromosome, int start, int end, bool onR...
method ToString (line 32) | public override string ToString()
method Equals (line 38) | public bool Equals(MutableGene other)
method GetHashCode (line 51) | public override int GetHashCode()
method Clone (line 67) | public MutableGene Clone() => new MutableGene(Chromosome, Start, End, ...
method ToUgaGene (line 70) | public UgaGene ToUgaGene(bool isGrch37)
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableTranscript.cs
class MutableTranscript (line 9) | public sealed class MutableTranscript : IEquatable<MutableTranscript>
method MutableTranscript (line 52) | public MutableTranscript(Chromosome chromosome, int start, int end, st...
method Equals (line 91) | public bool Equals(MutableTranscript other)
method GetHashCode (line 105) | public override int GetHashCode()
FILE: CacheUtils/DataDumperImport/DataStructures/Mutable/MutableTranscriptRegion.cs
class MutableTranscriptRegion (line 6) | public sealed class MutableTranscriptRegion : ITranscriptRegion
method MutableTranscriptRegion (line 15) | public MutableTranscriptRegion(TranscriptRegionType type, ushort id, i...
method Write (line 26) | public void Write(IExtendedBinaryWriter writer) => throw new System.No...
FILE: CacheUtils/DataDumperImport/FauxRegex/RegexDecisionTree.cs
class RegexDecisionTree (line 7) | internal static class RegexDecisionTree
method GetEntryType (line 9) | internal static (EntryType Type, string Key, string Value) GetEntryTyp...
method GetEntryTypeNoArrow (line 19) | private static (EntryType Type, string Key, string Value) GetEntryType...
method GetEntryTypeNoVar (line 25) | private static (EntryType Type, string Key, string Value) GetEntryType...
method GetEntryTypeDataPos (line 42) | private static (EntryType Type, string Key, string Value) GetEntryType...
method GetEntryTypeVar (line 48) | private static (EntryType Type, string Key, string Value) GetEntryType...
method GetEntryTypeFatArrow (line 56) | private static (EntryType, string Key, string Value) GetEntryTypeFatAr...
method GetEntryTypeStringKeyValue (line 78) | private static (EntryType, string Key, string Value) GetEntryTypeStrin...
method GetKey (line 88) | private static string GetKey(string s, int secondQuotePos)
method GetForwardString (line 94) | private static string GetForwardString(string s, int afterFirstQuote)
method OnlyDigits (line 101) | internal static bool OnlyDigits(string s) => s.All(c => char.IsDigit(c...
FILE: CacheUtils/DataDumperImport/IO/DataDumperReader.cs
class DataDumperReader (line 12) | public sealed class DataDumperReader : IDisposable
method DataDumperReader (line 17) | public DataDumperReader(Stream stream) => _reader = FileUtilities.GetS...
method GetNextLine (line 19) | private string GetNextLine() => _reader.ReadLine();
method GetRootNode (line 21) | public ObjectKeyValueNode GetRootNode()
method GetDigitKey (line 32) | private static StringValueNode GetDigitKey(string key) => new StringVa...
method GetListObjectKeyValue (line 34) | private ListObjectKeyValueNode GetListObjectKeyValue(string key)
method GetMultiLineKeyValue (line 62) | private StringKeyValueNode GetMultiLineKeyValue(string key, string value)
method GetObjectValue (line 78) | private ObjectValueNode GetObjectValue()
method Dispose (line 124) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/DataDumperImport/IO/EntryType.cs
type EntryType (line 3) | internal enum EntryType
FILE: CacheUtils/DataDumperImport/Import/Attribute.cs
class Attribute (line 13) | internal static class Attribute
method Attribute (line 18) | static Attribute()
method ParseList (line 34) | public static (IInterval[] MicroRnas, IRnaEdit[] RnaEdits, bool CdsSta...
method GetInterval (line 76) | private static IInterval GetInterval(string s)
method GetRnaEdit (line 87) | private static RnaEdit GetRnaEdit(string s)
method ParseKeyValue (line 99) | private static (string Key, string Value) ParseKeyValue(ObjectValueNod...
FILE: CacheUtils/DataDumperImport/Import/ImportExon.cs
class ImportExon (line 10) | internal static class ImportExon
method ImportExon (line 14) | static ImportExon()
method Parse (line 30) | public static MutableExon Parse(ObjectValueNode objectValue, Chromosom...
method ParseList (line 71) | public static MutableExon[] ParseList(IImportNode importNode, Chromoso...
FILE: CacheUtils/DataDumperImport/Import/ImportGene.cs
class ImportGene (line 8) | internal static class ImportGene
method ImportGene (line 12) | static ImportGene()
method Parse (line 23) | public static (int Start, int End, string Id, bool OnReverseStrand) Pa...
FILE: CacheUtils/DataDumperImport/Import/ImportIntron.cs
class ImportIntron (line 8) | internal static class ImportIntron
method ImportIntron (line 12) | static ImportIntron()
method Parse (line 32) | private static IInterval Parse(ObjectValueNode objectValue)
method ParseList (line 74) | public static IInterval[] ParseList(List<IListMember> members)
FILE: CacheUtils/DataDumperImport/Import/ImportKeys.cs
class ImportKeys (line 3) | internal static class ImportKeys
FILE: CacheUtils/DataDumperImport/Import/ImportMapper.cs
class ImportMapper (line 8) | internal static class ImportMapper
method ImportMapper (line 12) | static ImportMapper()
method Parse (line 30) | public static MutableTranscriptRegion[] Parse(ObjectValueNode objectVa...
FILE: CacheUtils/DataDumperImport/Import/ImportMapperPair.cs
class ImportMapperPair (line 9) | internal static class ImportMapperPair
method ImportMapperPair (line 13) | static ImportMapperPair()
method Parse (line 26) | private static MutableTranscriptRegion Parse(ObjectValueNode objectValue)
method GetCdnaMap (line 75) | private static MutableTranscriptRegion GetCdnaMap(int fromStart, int f...
method ParseList (line 85) | public static MutableTranscriptRegion[] ParseList(List<IListMember> li...
FILE: CacheUtils/DataDumperImport/Import/ImportMapperUnit.cs
class ImportMapperUnit (line 8) | internal static class ImportMapperUnit
method ImportMapperUnit (line 12) | static ImportMapperUnit()
method Parse (line 25) | public static (int Start, int End, MapperUnitType Type) Parse(ObjectVa...
type MapperUnitType (line 59) | public enum MapperUnitType : byte
FILE: CacheUtils/DataDumperImport/Import/ImportPairGenomic.cs
class ImportPairGenomic (line 8) | internal static class ImportPairGenomic
method ImportPairGenomic (line 12) | static ImportPairGenomic()
method Parse (line 23) | public static MutableTranscriptRegion[] Parse(ObjectValueNode objectVa...
FILE: CacheUtils/DataDumperImport/Import/ImportPrediction.cs
class ImportPrediction (line 7) | internal static class ImportPrediction
method ImportPrediction (line 11) | static ImportPrediction()
method Parse (line 27) | public static string Parse(ObjectValueNode objectValue)
FILE: CacheUtils/DataDumperImport/Import/ImportProteinFunctionPredictions.cs
class ImportProteinFunctionPredictions (line 8) | internal static class ImportProteinFunctionPredictions
method ImportProteinFunctionPredictions (line 12) | static ImportProteinFunctionPredictions()
method Parse (line 23) | public static (string SiftMatrix, string PolyphenMatrix) Parse(ObjectV...
FILE: CacheUtils/DataDumperImport/Import/ImportRegulatoryFeature.cs
class ImportRegulatoryFeature (line 12) | public static class ImportRegulatoryFeature
method ImportRegulatoryFeature (line 16) | static ImportRegulatoryFeature()
method Parse (line 44) | public static IRegulatoryRegion Parse(ObjectValueNode objectValue, Chr...
FILE: CacheUtils/DataDumperImport/Import/ImportSeqEdits.cs
class ImportSeqEdits (line 7) | internal static class ImportSeqEdits
method ImportSeqEdits (line 11) | static ImportSeqEdits()
method Parse (line 27) | public static int[] Parse(List<IListMember> members)
FILE: CacheUtils/DataDumperImport/Import/ImportTranscript.cs
class ImportTranscript (line 18) | public static class ImportTranscript
method ImportTranscript (line 22) | static ImportTranscript()
method Parse (line 73) | public static MutableTranscript Parse(ObjectValueNode objectValue, Chr...
method GetCodingRegionStart (line 240) | private static int GetCodingRegionStart(bool onReverseStrand, IInterva...
method GetCodingRegionEnd (line 252) | private static int GetCodingRegionEnd(bool onReverseStrand, IInterval ...
method GetTotalExonLength (line 264) | private static int GetTotalExonLength(IEnumerable<MutableExon> exons) ...
FILE: CacheUtils/DataDumperImport/Import/ImportTranscriptMapper.cs
class ImportTranscriptMapper (line 8) | internal static class ImportTranscriptMapper
method ImportTranscriptMapper (line 12) | static ImportTranscriptMapper()
method Parse (line 26) | public static MutableTranscriptRegion[] Parse(ObjectValueNode objectVa...
FILE: CacheUtils/DataDumperImport/Import/ImportTranslation.cs
class ImportTranslation (line 10) | internal static class ImportTranslation
method ImportTranslation (line 14) | static ImportTranslation()
method Parse (line 34) | public static (int Start, int End, string ProteinId, byte ProteinVersi...
FILE: CacheUtils/DataDumperImport/Import/ImportVariantEffectFeatureCache.cs
class ImportVariantEffectFeatureCache (line 10) | internal static class ImportVariantEffectFeatureCache
method ImportVariantEffectFeatureCache (line 14) | static ImportVariantEffectFeatureCache()
method Parse (line 37) | public static (MutableTranscriptRegion[] CdnaMaps, IInterval[] Introns...
FILE: CacheUtils/DataDumperImport/Utilities/ImportUtilities.cs
class ImportUtilities (line 9) | public static class ImportUtilities
method GetPredictionData (line 11) | public static string GetPredictionData(this IImportNode node)
method ParseObjectKeyValueNode (line 27) | public static T[] ParseObjectKeyValueNode<T>(this IImportNode node, Fu...
method ParseListObjectKeyValueNode (line 43) | public static T[] ParseListObjectKeyValueNode<T>(this IImportNode node...
FILE: CacheUtils/DataDumperImport/Utilities/MutableTranscriptComparer.cs
class MutableTranscriptComparer (line 9) | internal sealed class MutableTranscriptComparer : EqualityComparer<Mutab...
method GeneEquals (line 11) | private static bool GeneEquals(MutableGene x, MutableGene y)
method ExonEquals (line 23) | private static bool ExonEquals(MutableExon x, MutableExon y)
method IntervalEquals (line 30) | private static bool IntervalEquals(IInterval x, IInterval y)
method TranscriptRegionEquals (line 36) | private static bool TranscriptRegionEquals(ITranscriptRegion x, ITrans...
method CodingRegionEquals (line 44) | private static bool CodingRegionEquals(ICodingRegion x, ICodingRegion y)
method ArrayEquals (line 54) | private static bool ArrayEquals<T>(T[] x, T[] y, Func<T, T, bool> equals)
method IntEquals (line 65) | private static bool IntEquals(int x, int y) => x == y;
method Equals (line 67) | public override bool Equals(MutableTranscript x, MutableTranscript y)
method GetHashCode (line 98) | public override int GetHashCode(MutableTranscript obj)
FILE: CacheUtils/DataDumperImport/Utilities/TranscriptUtilities.cs
class TranscriptUtilities (line 10) | public static class TranscriptUtilities
method TranscriptUtilities (line 17) | static TranscriptUtilities()
method GetBiotype (line 26) | public static BioType GetBiotype(IImportNode node) => BioTypeHelper.Ge...
method GetMapperUnitType (line 28) | public static MapperUnitType GetMapperUnitType(IImportNode node)
method GetObjectValueNode (line 40) | public static ObjectValueNode GetObjectValueNode(this IImportNode node)
method GetListMembers (line 46) | public static List<IListMember> GetListMembers(this IImportNode node)
method GetStrand (line 52) | public static bool GetStrand(IImportNode node)
method GetHgncId (line 65) | public static int GetHgncId(this IImportNode node)
FILE: CacheUtils/GFF/GeneralAttributes.cs
class GeneralAttributes (line 3) | public sealed class GeneralAttributes : IGeneralAttributes
method GeneralAttributes (line 13) | public GeneralAttributes(string geneId, string geneSymbol, string tran...
FILE: CacheUtils/GFF/GffCreator.cs
class GffCreator (line 9) | public sealed class GffCreator
method GffCreator (line 16) | public GffCreator(GffWriter writer, Dictionary<IGene, int> geneToInter...
method Create (line 24) | public void Create(IEnumerable<IntervalArray<ITranscript>> transcriptI...
method Write (line 35) | private void Write(ITranscript transcript)
method WriteTranscript (line 51) | private void WriteTranscript(IInterval interval, IRequiredFields requi...
method WriteGene (line 54) | private void WriteGene(IGene gene, IRequiredFields requiredFields, str...
method WriteExon (line 63) | private void WriteExon(ITranscriptRegion exon, IRequiredFields require...
method WriteUtr (line 71) | private void WriteUtr(IInterval codingRegion, ITranscriptRegion exon, ...
method Write5PrimeUtr (line 79) | private void Write5PrimeUtr(IInterval codingRegion, ITranscriptRegion ...
method Write3PrimeUtr (line 87) | private void Write3PrimeUtr(IInterval codingRegion, ITranscriptRegion ...
method WriteCds (line 95) | private void WriteCds(IInterval codingRegion, ITranscriptRegion exon, ...
method GetGene (line 102) | private static IGffGene GetGene(IGene gene, string id) => new GffGene(...
method GetRequiredFields (line 105) | private static IRequiredFields GetRequiredFields(ITranscript transcript)
method GetGeneralAttributes (line 111) | private IGeneralAttributes GetGeneralAttributes(ITranscript transcript)
FILE: CacheUtils/GFF/GffGene.cs
class GffGene (line 3) | public sealed class GffGene : IGffGene
method GffGene (line 12) | public GffGene(int start, int end, string id, string entrezGeneId, str...
FILE: CacheUtils/GFF/GffUtilities.cs
class GffUtilities (line 11) | public static class GffUtilities
method HasCds (line 13) | public static bool HasCds(IInterval codingRegion, IInterval exon)
method GetCdsCoordinates (line 19) | public static IInterval GetCdsCoordinates(IInterval codingRegion, ITra...
method HasUtr (line 30) | public static bool HasUtr(IInterval codingRegion, IInterval exon)
method GetExons (line 36) | public static IEnumerable<ITranscriptRegion> GetExons(this ITranscript...
method FilterNonExons (line 39) | private static ITranscriptRegion[] FilterNonExons(this IEnumerable<ITr...
method Merge (line 42) | private static IEnumerable<ITranscriptRegion> Merge(this IReadOnlyColl...
method MergeTranscriptRegions (line 57) | private static ITranscriptRegion MergeTranscriptRegions(ushort exonId,...
FILE: CacheUtils/GFF/GffWriter.cs
class GffWriter (line 7) | public sealed class GffWriter : IDisposable
method GffWriter (line 11) | public GffWriter(StreamWriter writer) => _writer = writer;
method Dispose (line 13) | public void Dispose() => _writer.Dispose();
method WriteRequiredFields (line 15) | private void WriteRequiredFields(IInterval interval, IRequiredFields f...
method NotEmpty (line 21) | private static bool NotEmpty(string s) => !string.IsNullOrEmpty(s);
method WriteGeneralAttributes (line 23) | private void WriteGeneralAttributes(IGeneralAttributes attribs)
method WriteGene (line 35) | public void WriteGene(IGffGene gene, IRequiredFields requiredFields, i...
method WriteInternalGeneId (line 45) | private void WriteInternalGeneId(int geneId) => _writer.WriteLine($"in...
method WriteTranscript (line 47) | public void WriteTranscript(IInterval interval, IRequiredFields requir...
method WriteExonicRegion (line 54) | public void WriteExonicRegion(IInterval interval, IRequiredFields requ...
FILE: CacheUtils/GFF/IGeneralAttributes.cs
type IGeneralAttributes (line 3) | public interface IGeneralAttributes
FILE: CacheUtils/GFF/IGffGene.cs
type IGffGene (line 5) | public interface IGffGene : IInterval
FILE: CacheUtils/GFF/IRequiredFields.cs
type IRequiredFields (line 3) | public interface IRequiredFields
FILE: CacheUtils/GFF/RequiredFields.cs
class RequiredFields (line 3) | public sealed class RequiredFields : IRequiredFields
method RequiredFields (line 9) | public RequiredFields(string ucscName, string source, bool onReverseSt...
FILE: CacheUtils/Genbank/GenbankEntry.cs
class GenbankEntry (line 5) | public sealed class GenbankEntry
method GenbankEntry (line 16) | public GenbankEntry(string transcriptId, byte transcriptVersion, strin...
FILE: CacheUtils/Genbank/GenbankReader.cs
class GenbankReader (line 10) | public sealed class GenbankReader : IDisposable
method GenbankReader (line 31) | public GenbankReader(StreamReader reader) => _reader = reader;
method GetGenbankEntry (line 33) | public GenbankEntry GetGenbankEntry()
method ParseOrigin (line 50) | private void ParseOrigin()
method GetNextLine (line 59) | private string GetNextLine()
method ParseFeatures (line 66) | private FeatureData ParseFeatures()
method ParseExonFeature (line 98) | private static void ParseExonFeature(bool isNewState, FeatureData feat...
method ParseCdsFeature (line 103) | private static void ParseCdsFeature(bool isNewState, FeatureData featu...
method ParseGeneFeature (line 109) | private static void ParseGeneFeature(string info, FeatureData featureD...
method ParseHeader (line 115) | private (string TranscriptId, byte TranscriptVersion) ParseHeader()
method ParseGeneSymbol (line 131) | private static string ParseGeneSymbol(string info) => info.Substring(G...
method ParseGeneId (line 132) | private static string ParseGeneId(string info) => info.Substring(G...
method ParseProteinId (line 134) | private static void ParseProteinId(FeatureData featureData, string info)
method GetInterval (line 140) | private static IInterval GetInterval(string info)
method GetJoinInterval (line 152) | private static IInterval GetJoinInterval(string info)
method GetFeatureState (line 160) | private static (FeaturesState State, bool IsNewState) GetFeatureState(...
method HasLocus (line 170) | private bool HasLocus()
method ParseVersion (line 176) | private static (string TranscriptId, byte TranscriptVersion) ParseVers...
method Dispose (line 182) | public void Dispose() => _reader.Dispose();
class FeatureData (line 184) | private sealed class FeatureData
FILE: CacheUtils/Genbank/GenbankState.cs
type FeaturesState (line 3) | internal enum FeaturesState : byte
FILE: CacheUtils/Genes/Combiners/CombinerUtils.cs
class CombinerUtils (line 7) | public static class CombinerUtils
method Merge (line 9) | public static UgaGene Merge(UgaGene gene37, UgaGene gene38)
method CombineField (line 18) | private static T CombineField<T>(T grch37, T grch38)
method RemoveGenes (line 26) | internal static void RemoveGenes(IEnumerable<UgaGene> genes, ICollecti...
method AddOrphans (line 31) | internal static void AddOrphans(ICollection<UgaGene> combinedGenes, IE...
FILE: CacheUtils/Genes/Combiners/HgncIdCombiner.cs
class HgncIdCombiner (line 7) | public sealed class HgncIdCombiner : ICombiner
method Combine (line 9) | public void Combine(List<UgaGene> combinedGenes, HashSet<UgaGene> rema...
method GetGenesByHgncId (line 46) | private static List<UgaGene> GetGenesByHgncId(IReadOnlyDictionary<int,...
method GetHgncIds (line 49) | private static IEnumerable<int> GetHgncIds(IEnumerable<UgaGene> remain...
FILE: CacheUtils/Genes/Combiners/ICombiner.cs
type ICombiner (line 6) | public interface ICombiner
method Combine (line 8) | void Combine(List<UgaGene> combinedGenes, HashSet<UgaGene> remainingGe...
FILE: CacheUtils/Genes/Combiners/PartitionCombiner.cs
class PartitionCombiner (line 7) | public sealed class PartitionCombiner : ICombiner
method Combine (line 9) | public void Combine(List<UgaGene> combinedGenes, HashSet<UgaGene> rema...
method CombineSet (line 20) | private static void CombineSet(ICollection<UgaGene> combinedGenes, IEn...
method GetGenesByKey (line 54) | private static List<UgaGene> GetGenesByKey(IReadOnlyDictionary<string,...
method GetAllKeys (line 57) | private static IEnumerable<string> GetAllKeys(IEnumerable<string> keys...
method GetKey (line 65) | private static string GetKey(UgaGene gene) =>
method Partition (line 68) | private static (List<UgaGene> EnsemblOnly, List<UgaGene> Both, List<Ug...
FILE: CacheUtils/Genes/DataStores/AssemblyDataStore.cs
class AssemblyDataStore (line 10) | public sealed class AssemblyDataStore
method AssemblyDataStore (line 17) | private AssemblyDataStore(string description, EnsemblGtf ensemblGtf, R...
method Create (line 25) | public static AssemblyDataStore Create(string description, FilePaths.A...
method UpdateHgncIds (line 41) | public IUpdateHgncData UpdateHgncIds(Hgnc oldHgnc)
FILE: CacheUtils/Genes/DataStores/EnsemblGtf.cs
class EnsemblGtf (line 11) | public sealed class EnsemblGtf
method EnsemblGtf (line 16) | private EnsemblGtf(Dictionary<string, EnsemblGene> ensemblIdToGene, Di...
method Create (line 22) | public static EnsemblGtf Create(string filePath, Dictionary<string, Ch...
method LoadEnsemblGenes (line 30) | private static EnsemblGene[] LoadEnsemblGenes(StreamReader streamReader,
FILE: CacheUtils/Genes/DataStores/GeneInfoData.cs
class GeneInfoData (line 9) | public sealed class GeneInfoData
method GeneInfoData (line 13) | private GeneInfoData(Dictionary<string, string> entrezGeneIdToSymbol)
method Create (line 18) | public static GeneInfoData Create(string filePath)
method LoadGeneInfoGenes (line 25) | private static IEnumerable<GeneInfo> LoadGeneInfoGenes(string filePath)
FILE: CacheUtils/Genes/DataStores/GlobalCache.cs
class GlobalCache (line 12) | public sealed class GlobalCache
method GlobalCache (line 17) | private GlobalCache(Dictionary<ushort, List<MutableGene>> ensemblGenes...
method Create (line 24) | public static GlobalCache Create(string refSeqCachePath, string ensemb...
method FlattenGenes (line 33) | private static Dictionary<ushort, List<MutableGene>> FlattenGenes(IEnu...
method LoadGenes (line 46) | private static IEnumerable<MutableGene> LoadGenes(Stream stream,
method GetGeneKey (line 70) | private static string GetGeneKey(MutableGene gene) => gene.GeneId + '|...
FILE: CacheUtils/Genes/DataStores/Hgnc.cs
class Hgnc (line 13) | public sealed class Hgnc
method Hgnc (line 18) | private Hgnc(HgncGene[] hgncGenes, Dictionary<int, string> hgncIdToSym...
method Create (line 24) | public static Hgnc Create(string filePath, Dictionary<string, Chromoso...
method LoadHgncGenes (line 31) | private static HgncGene[] LoadHgncGenes(Stream stream, Dictionary<stri...
method AddCoordinates (line 38) | public int AddCoordinates(EnsemblGtf ensemblGtf, RefSeqGff refSeqGff)
method AddCoordinatesFromMultipleGenes (line 64) | private static void AddCoordinatesFromMultipleGenes(HgncGene hgncGene,...
method AddCoordinatesFromGene (line 77) | private static void AddCoordinatesFromGene<T>(HgncGene hgncGene, IFlat...
method GetGenes (line 83) | private static (List<RefSeqGene> RefSeqGenes, EnsemblGene EnsemblGene,...
method Clone (line 93) | public Hgnc Clone()
method GetEnsemblGene (line 100) | private static EnsemblGene GetEnsemblGene(string ensemblId, IReadOnlyD...
method GetRefSeqGenes (line 108) | private static List<RefSeqGene> GetRefSeqGenes(string entrezGeneId, IR...
method RemoveDuplicateEntries (line 114) | public (int NumEntrezGeneIdsRemoved, int NumEnsemblIdsRemoved) RemoveD...
method RemoveDuplicatesByTranscriptSource (line 121) | private static int RemoveDuplicatesByTranscriptSource(IEnumerable<Hgnc...
FILE: CacheUtils/Genes/DataStores/IUpdateHgncData.cs
type IUpdateHgncData (line 6) | public interface IUpdateHgncData
FILE: CacheUtils/Genes/DataStores/RefSeqGff.cs
class RefSeqGff (line 12) | public sealed class RefSeqGff
method RefSeqGff (line 17) | private RefSeqGff(Dictionary<string, List<RefSeqGene>> entrezGeneIdToG...
method Create (line 23) | public static RefSeqGff Create(string gcfGffPath, string refGffPath, D...
method LoadRefSeqGffGenes (line 38) | private static List<RefSeqGene> LoadRefSeqGffGenes(StreamReader gcfGff...
method LoadRefSeqGff (line 48) | private static void LoadRefSeqGff(StreamReader streamReader, List<RefS...
FILE: CacheUtils/Genes/DataStores/UpdateHgncData.cs
class UpdateHgncData (line 6) | public sealed class UpdateHgncData : IUpdateHgncData
method UpdateHgncData (line 11) | public UpdateHgncData(Dictionary<ushort, List<MutableGene>> ensemblGen...
FILE: CacheUtils/Genes/DataStructures/EnsemblGene.cs
class EnsemblGene (line 6) | public sealed class EnsemblGene : IFlatGene<EnsemblGene>
method EnsemblGene (line 14) | public EnsemblGene(Chromosome chromosome, int start, int end, string g...
method Clone (line 23) | public EnsemblGene Clone() => throw new NotImplementedException();
FILE: CacheUtils/Genes/DataStructures/GeneInfo.cs
class GeneInfo (line 3) | public sealed class GeneInfo
method GeneInfo (line 8) | public GeneInfo(string symbol, string entrezGeneId)
FILE: CacheUtils/Genes/DataStructures/HgncGene.cs
class HgncGene (line 6) | public sealed class HgncGene : IChromosomeInterval
method HgncGene (line 16) | public HgncGene(Chromosome chromosome, int start, int end, string symb...
method Clone (line 28) | public HgncGene Clone() => new HgncGene(Chromosome, -1, -1, Symbol, En...
FILE: CacheUtils/Genes/DataStructures/IFlatGene.cs
type IFlatGene (line 6) | public interface IFlatGene<out T>
method Clone (line 11) | T Clone();
FILE: CacheUtils/Genes/DataStructures/RefSeqGene.cs
class RefSeqGene (line 6) | public sealed class RefSeqGene : IFlatGene<RefSeqGene>
method RefSeqGene (line 16) | public RefSeqGene(Chromosome chromosome, int start, int end, bool onRe...
method Clone (line 28) | public RefSeqGene Clone() => new RefSeqGene(Chromosome, Start, End, On...
FILE: CacheUtils/Genes/DataStructures/UgaGene.cs
class UgaGene (line 8) | public sealed class UgaGene
method UgaGene (line 20) | public UgaGene(Chromosome chromosome, IInterval grch37, IInterval grch...
method ToString (line 33) | public override string ToString()
method GetInterval (line 41) | private static string GetInterval(IInterval interval) =>
method ToGene (line 44) | public Gene ToGene(GenomeAssembly genomeAssembly)
FILE: CacheUtils/Genes/GeneFlattener.cs
class GeneFlattener (line 8) | public static class GeneFlattener
method FlattenGeneList (line 10) | public static List<T> FlattenGeneList<T>(this Dictionary<string, List<...
method FlattenWithSameId (line 23) | internal static List<T> FlattenWithSameId<T>(List<T> genes) where T : ...
FILE: CacheUtils/Genes/GeneMerger.cs
class GeneMerger (line 13) | public static class GeneMerger
method MergeByHgnc (line 15) | public static Dictionary<ushort, List<UgaGene>> MergeByHgnc(this IUpda...
method AddGenes (line 44) | private static void AddGenes(Dictionary<ushort, List<MutableGene>> sou...
method GetMergedGenes (line 62) | private static (List<UgaGene> MergedGenes, int NumOrphanEntries, int N...
method ConvertToUgaGenes (line 87) | private static List<UgaGene> ConvertToUgaGenes(IEnumerable<MutableGene...
method GetMergedGene (line 101) | private static UgaGene GetMergedGene(MutableGene geneA, MutableGene ge...
method GetMergedInterval (line 115) | private static IInterval GetMergedInterval(MutableGene geneA, MutableG...
FILE: CacheUtils/Genes/GeneSymbolUpdater.cs
class GeneSymbolUpdater (line 10) | public sealed class GeneSymbolUpdater
method GeneSymbolUpdater (line 22) | public GeneSymbolUpdater(Dictionary<int, string> hgncIdToSymbol,
method Update (line 32) | public void Update(UgaGene[] mergedGenes)
method UpdateGeneSymbol (line 42) | private void UpdateGeneSymbol(UgaGene gene)
method UpdateBySymbolDict (line 75) | private static bool UpdateBySymbolDict<T>(UgaGene gene, Func<UgaGene, ...
FILE: CacheUtils/Genes/HgncIdConsolidator.cs
class HgncIdConsolidator (line 9) | public static class HgncIdConsolidator
method Consolidate (line 11) | public static int Consolidate(this Dictionary<ushort, List<MutableGene...
method CreateAggregateGene (line 31) | private static void CreateAggregateGene(IReadOnlyList<MutableGene> genes)
FILE: CacheUtils/Genes/HgncIdUpdater.cs
class HgncIdUpdater (line 9) | public static class HgncIdUpdater
method Update (line 11) | public static Dictionary<ushort, List<MutableGene>> Update(this IEnume...
method ReplaceHgncIds (line 19) | private static void ReplaceHgncIds(IEnumerable<MutableGene> genes, IRe...
FILE: CacheUtils/Genes/IO/EnsemblGtfReader.cs
class EnsemblGtfReader (line 11) | public sealed class EnsemblGtfReader : IDisposable
method EnsemblGtfReader (line 22) | public EnsemblGtfReader(StreamReader reader, Dictionary<string, Chromo...
method GetGenes (line 29) | public EnsemblGene[] GetGenes()
method AddGene (line 52) | private void AddGene(string[] cols, ICollection<EnsemblGene> genes)
method GetGffFields (line 76) | private static (string EnsemblGeneId, string Name) GetGffFields(string...
method Dispose (line 107) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/Genes/IO/GeneInfoReader.cs
class GeneInfoReader (line 9) | public sealed class GeneInfoReader : IDisposable
method GeneInfoReader (line 17) | public GeneInfoReader(StreamReader reader)
method SetColumnIndices (line 24) | private void SetColumnIndices(string line)
method Next (line 64) | private GeneInfo Next()
method GetGenes (line 89) | public GeneInfo[] GetGenes()
method Dispose (line 103) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/Genes/IO/HgncReader.cs
class HgncReader (line 11) | public sealed class HgncReader : IDisposable
method HgncReader (line 22) | public HgncReader(Stream stream, Dictionary<string, Chromosome> refNam...
method Next (line 32) | private HgncGene Next()
method GetGenes (line 58) | public HgncGene[] GetGenes()
method GetChromosome (line 72) | private Chromosome GetChromosome(string cytogeneticBand)
method GetArmPos (line 81) | private static int GetArmPos(string cytogeneticBand)
method GetId (line 90) | private static string GetId(string s) => string.IsNullOrEmpty(s) ? nul...
method Dispose (line 92) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/Genes/IO/RefSeqGffReader.cs
class RefSeqGffReader (line 10) | public sealed class RefSeqGffReader : IDisposable
method RefSeqGffReader (line 22) | public RefSeqGffReader(StreamReader reader, Dictionary<string, Chromos...
method AddGenes (line 29) | public void AddGenes(List<RefSeqGene> refSeqGenes)
method AddGene (line 46) | private void AddGene(string[] cols, ICollection<RefSeqGene> refSeqGenes)
method GetChromosome (line 71) | internal static Chromosome GetChromosome(string referenceName, Diction...
method GetGffFields (line 77) | private static (string Name, string EntrezGeneId, int HgncId)
method GetIds (line 104) | private static (string EntrezGeneId, int HgncId) GetIds(IEnumerable<st...
method Dispose (line 129) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/Genes/IO/UgaGeneReader.cs
class UgaGeneReader (line 12) | public sealed class UgaGeneReader : IDisposable
method UgaGeneReader (line 17) | public UgaGeneReader(Stream stream, Dictionary<string, Chromosome> ref...
method Dispose (line 24) | public void Dispose() => _reader.Dispose();
method GetGenes (line 26) | public UgaGene[] GetGenes()
method GetNextGene (line 40) | private UgaGene GetNextGene()
FILE: CacheUtils/Genes/IO/UgaGeneWriter.cs
class UgaGeneWriter (line 8) | public sealed class UgaGeneWriter : IDisposable
method UgaGeneWriter (line 12) | public UgaGeneWriter(Stream stream, bool leaveOpen = false)
method Dispose (line 17) | public void Dispose() => _writer.Dispose();
method Write (line 19) | public void Write(UgaGene[] genes)
FILE: CacheUtils/Genes/UgaAssemblyCombiner.cs
class UgaAssemblyCombiner (line 12) | public static class UgaAssemblyCombiner
method Combine (line 16) | public static UgaGene[] Combine(Dictionary<ushort, List<UgaGene>> gene...
method GetCombiners (line 35) | private static List<ICombiner> GetCombiners() =>
method GetReferenceIndices (line 38) | private static IEnumerable<ushort> GetReferenceIndices(IEnumerable<ush...
method CombineByReference (line 46) | private static IEnumerable<UgaGene> CombineByReference(IEnumerable<Uga...
method GetRemainingGenes (line 62) | private static HashSet<UgaGene> GetRemainingGenes(IEnumerable<UgaGene>...
method GetUgaGenesByRef (line 70) | private static IEnumerable<UgaGene> GetUgaGenesByRef(IReadOnlyDictiona...
method MinCoordinate (line 73) | private static int MinCoordinate(UgaGene gene, Func<IInterval, int> co...
FILE: CacheUtils/Genes/Utilities/DictionaryUtilities.cs
class DictionaryUtilities (line 7) | public static class DictionaryUtilities
method GetSingleValueDict (line 9) | public static Dictionary<TK, T> GetSingleValueDict<T, TK>(this IEnumer...
method GetMultiValueDict (line 22) | public static Dictionary<TK, List<T>> GetMultiValueDict<T, TK>(this IE...
method GetKeyValueDict (line 35) | public static Dictionary<TK, TV> GetKeyValueDict<T, TK, TV>(this IEnum...
method GetSet (line 48) | public static HashSet<TV> GetSet<T,TV>(this IEnumerable<T> elements, F...
method CreateIndex (line 59) | public static Dictionary<T, int> CreateIndex<T>(this IEnumerable<T> el...
FILE: CacheUtils/Helpers/BioTypeHelper.cs
class BioTypeHelper (line 7) | public static class BioTypeHelper
method BioTypeHelper (line 11) | static BioTypeHelper()
method GetBioType (line 83) | public static BioType GetBioType(string s)
FILE: CacheUtils/Helpers/GeneSymbolSourceHelper.cs
class GeneSymbolSourceHelper (line 7) | public static class GeneSymbolSourceHelper
method GeneSymbolSourceHelper (line 11) | static GeneSymbolSourceHelper()
method GetGeneSymbolSource (line 27) | public static GeneSymbolSource GetGeneSymbolSource(string s)
FILE: CacheUtils/Helpers/RegulatoryRegionTypeHelper.cs
class RegulatoryRegionTypeHelper (line 7) | public static class RegulatoryRegionTypeHelper
method RegulatoryRegionTypeHelper (line 11) | static RegulatoryRegionTypeHelper()
method GetRegulatoryRegionType (line 25) | public static RegulatoryRegionType GetRegulatoryRegionType(string s)
FILE: CacheUtils/Helpers/TranscriptCacheHelper.cs
class TranscriptCacheHelper (line 10) | public static class TranscriptCacheHelper
method GetCache (line 12) | public static TranscriptCacheData GetCache(string cachePath,
FILE: CacheUtils/IntermediateIO/CcdsReader.cs
class CcdsReader (line 9) | public static class CcdsReader
method GetCcdsIdToEnsemblId (line 14) | public static Dictionary<string, List<string>> GetCcdsIdToEnsemblId(st...
FILE: CacheUtils/IntermediateIO/GenbankReader.cs
class GenbankReader (line 11) | internal sealed class GenbankReader : IDisposable
method GenbankReader (line 15) | internal GenbankReader(Stream stream)
method GetIdToGenbank (line 21) | public Dictionary<string, GenbankEntry> GetIdToGenbank()
method GetNextEntry (line 35) | private GenbankEntry GetNextEntry()
method ReadExons (line 47) | private IInterval[] ReadExons(int numExons)
method ReadTranscriptInfo (line 70) | private static (string TranscriptId, byte TranscriptVersion, string Pr...
method Dispose (line 91) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/IntermediateIO/GenbankWriter.cs
class GenbankWriter (line 7) | internal sealed class GenbankWriter : IDisposable
method GenbankWriter (line 11) | internal GenbankWriter(StreamWriter writer, IntermediateIoHeader header)
method Write (line 18) | internal void Write(GenbankEntry entry)
method Dispose (line 36) | public void Dispose() => _writer.Dispose();
FILE: CacheUtils/IntermediateIO/IntermediateIoCommon.cs
class IntermediateIoCommon (line 5) | public static class IntermediateIoCommon
type FileType (line 9) | public enum FileType : byte
method ReadHeader (line 19) | public static IntermediateIoHeader ReadHeader(StreamReader reader, Fil...
FILE: CacheUtils/IntermediateIO/IntermediateIoHeader.cs
class IntermediateIoHeader (line 8) | public sealed class IntermediateIoHeader
method IntermediateIoHeader (line 16) | public IntermediateIoHeader(ushort vepVersion, long vepReleaseTicks, S...
method Write (line 26) | internal void Write(StreamWriter writer, IntermediateIoCommon.FileType...
method Read (line 32) | internal static (string Id, IntermediateIoCommon.FileType Type, Interm...
FILE: CacheUtils/IntermediateIO/LrgReader.cs
class LrgReader (line 9) | public static class LrgReader
method GetTranscriptIds (line 15) | public static HashSet<string> GetTranscriptIds(string lrgPath, Diction...
method GetEnsemblTranscriptIds (line 43) | private static List<string> GetEnsemblTranscriptIds(string ccdsId,
method Sanitize (line 51) | private static string Sanitize(string s) => s == "-" ? null : s;
FILE: CacheUtils/IntermediateIO/MutableTranscriptReader.cs
class MutableTranscriptReader (line 17) | internal sealed class MutableTranscriptReader : IDisposable
method MutableTranscriptReader (line 25) | internal MutableTranscriptReader(Stream stream, Dictionary<ushort, Chr...
method GetTranscripts (line 32) | public MutableTranscript[] GetTranscripts()
method GetNextTranscript (line 46) | private MutableTranscript GetNextTranscript()
method AddMutableContents (line 74) | private void AddMutableContents(MutableTranscript mt)
method ReadSelenocysteines (line 92) | private int[] ReadSelenocysteines()
method ReadRnaEdits (line 106) | private IRnaEdit[] ReadRnaEdits()
method ReadCdnaMaps (line 127) | private MutableTranscriptRegion[] ReadCdnaMaps()
method ReadIntervals (line 149) | private IInterval[] ReadIntervals(string description)
method ReadExons (line 169) | private MutableExon[] ReadExons(Chromosome chromosome)
method ReadTranslation (line 190) | private (string Id, byte Version, ICodingRegion CodingRegion, string P...
method ReadGene (line 209) | private MutableGene ReadGene(Chromosome chromosome)
method ReadTranscriptInfo (line 224) | private (string Id, byte Version, Chromosome Chromosome, int Start, in...
method GetColumns (line 254) | private string[] GetColumns(string keyword, string line = null)
method Dispose (line 263) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/IntermediateIO/MutableTranscriptWriter.cs
class MutableTranscriptWriter (line 10) | internal sealed class MutableTranscriptWriter : IDisposable
method MutableTranscriptWriter (line 14) | internal MutableTranscriptWriter(StreamWriter writer, IntermediateIoHe...
method Write (line 21) | internal void Write(MutableTranscript transcript)
method WriteRnaEdits (line 34) | private void WriteRnaEdits(IReadOnlyCollection<IRnaEdit> rnaEdits)
method WriteSelenocysteines (line 47) | private void WriteSelenocysteines(IReadOnlyCollection<int> positions)
method WriteCdnaMaps (line 60) | private void WriteCdnaMaps(IReadOnlyCollection<ITranscriptRegion> cdna...
method WriteIntervals (line 67) | private void WriteIntervals(IReadOnlyCollection<IInterval> intervals, ...
method WriteExons (line 80) | private void WriteExons(IReadOnlyCollection<MutableExon> exons)
method WriteTranslation (line 87) | private void WriteTranslation(ICodingRegion codingRegion, string prote...
method WriteGene (line 90) | private static void WriteGene(TextWriter writer, MutableGene gene)
method WriteTranscriptInfo (line 96) | private void WriteTranscriptInfo(MutableTranscript transcript)
method BoolToChar (line 102) | private static char BoolToChar(bool b) => b ? 'Y' : 'N';
method Dispose (line 104) | public void Dispose() => _writer.Dispose();
FILE: CacheUtils/IntermediateIO/PredictionReader.cs
class PredictionReader (line 11) | public sealed class PredictionReader : IDisposable
method PredictionReader (line 16) | public PredictionReader(Stream stream, Dictionary<ushort, Chromosome> ...
method GetPredictionData (line 24) | public (string[] PredictionData, Dictionary<int, int> TranscriptToPred...
method GetChromosomeHeader (line 42) | private (Chromosome Chromosome, int NumPredictions) GetChromosomeHeader()
method GetNextPrediction (line 56) | private (List<int> TranscriptIndices, string PredictionData) GetNextPr...
method GetTranscriptIndices (line 70) | private static List<int> GetTranscriptIndices(string s)
method Dispose (line 78) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/IntermediateIO/PredictionWriter.cs
class PredictionWriter (line 8) | internal sealed class PredictionWriter : IDisposable
method PredictionWriter (line 12) | internal PredictionWriter(StreamWriter writer, IntermediateIoHeader he...
method Write (line 20) | internal void Write(Chromosome chromosome, Dictionary<string, List<int...
method WritePrediction (line 26) | private void WritePrediction(IEnumerable<int> transcriptIds, string pr...
method Dispose (line 32) | public void Dispose() => _writer.Dispose();
FILE: CacheUtils/IntermediateIO/RegulatoryRegionReader.cs
class RegulatoryRegionReader (line 14) | internal sealed class RegulatoryRegionReader : IDisposable
method RegulatoryRegionReader (line 19) | internal RegulatoryRegionReader(Stream stream, Dictionary<ushort, Chro...
method GetRegulatoryRegions (line 26) | public IRegulatoryRegion[] GetRegulatoryRegions()
method GetNextRegulatoryRegion (line 40) | private IRegulatoryRegion GetNextRegulatoryRegion()
method Dispose (line 56) | public void Dispose() => _reader.Dispose();
FILE: CacheUtils/IntermediateIO/RegulatoryRegionWriter.cs
class RegulatoryRegionWriter (line 7) | internal sealed class RegulatoryRegionWriter : IDisposable
method RegulatoryRegionWriter (line 11) | internal RegulatoryRegionWriter(StreamWriter writer, IntermediateIoHea...
method Write (line 18) | internal void Write(IRegulatoryRegion region) => _writer.WriteLine(
method Dispose (line 21) | public void Dispose() => _writer.Dispose();
FILE: CacheUtils/MiniCache/DataBundle.cs
class DataBundle (line 15) | public sealed class DataBundle
method DataBundle (line 30) | private DataBundle(CompressedSequenceReader sequenceReader, Prediction...
method Load (line 42) | public void Load(Chromosome chromosome)
method GetDataBundle (line 51) | public static DataBundle GetDataBundle(string referencePath, string ca...
FILE: CacheUtils/MiniCache/IStaging.cs
type IStaging (line 5) | public interface IStaging
method Write (line 7) | void Write(Stream stream);
FILE: CacheUtils/PredictionCache/PredictionCacheBuilder.cs
class PredictionCacheBuilder (line 15) | public sealed class PredictionCacheBuilder
method PredictionCacheBuilder (line 19) | public PredictionCacheBuilder(GenomeAssembly genomeAssembly) => _genom...
method CreatePredictionCaches (line 21) | public (PredictionCacheStaging Sift, PredictionCacheStaging PolyPhen) ...
method BuildCacheStaging (line 57) | private PredictionCacheStaging BuildCacheStaging(string description,
method CreateHeader (line 72) | private PredictionHeader CreateHeader(int numReferenceSeqs, Prediction...
method ConvertPredictions (line 78) | private static Prediction[][] ConvertPredictions(IReadOnlyList<Rounded...
method ConvertReferencePredictions (line 92) | private static Prediction[] ConvertReferencePredictions(IReadOnlyList<...
method CreateLut (line 106) | private static (Prediction.Entry[] Lut, Dictionary<RoundedEntry, byte>...
method ProcessReference (line 140) | private static (RoundedEntryPrediction[] Sift, RoundedEntryPrediction[...
method AssignPredictionIndices (line 153) | private static void AssignPredictionIndices(IReadOnlyList<MutableTrans...
FILE: CacheUtils/PredictionCache/PredictionCacheStaging.cs
class PredictionCacheStaging (line 11) | public sealed class PredictionCacheStaging : IStaging
method PredictionCacheStaging (line 16) | internal PredictionCacheStaging(PredictionHeader header, Prediction[][...
method Write (line 22) | public void Write(Stream stream)
FILE: CacheUtils/PredictionCache/PredictionCacheWriter.cs
class PredictionCacheWriter (line 10) | public sealed class PredictionCacheWriter : IDisposable
method PredictionCacheWriter (line 17) | public PredictionCacheWriter(BlockStream blockStream, PredictionHeader...
method Dispose (line 25) | public void Dispose()
method Write (line 31) | internal void Write(Prediction.Entry[] lut, Prediction[][] predictions...
method WritePredictions (line 39) | private void WritePredictions(IReadOnlyList<Prediction[]> predictionsP...
method WriteLookupTable (line 60) | private static void WriteLookupTable(BinaryWriter writer, IReadOnlyCol...
FILE: CacheUtils/PredictionCache/PredictionExtensions.cs
class PredictionExtensions (line 6) | public static class PredictionExtensions
method GetRoundedEntryPredictions (line 8) | public static RoundedEntryPrediction[] GetRoundedEntryPredictions(this...
method GetRoundedEntryPrediction (line 16) | private static RoundedEntryPrediction GetRoundedEntryPrediction(this s...
FILE: CacheUtils/PredictionCache/PredictionUtilities.cs
class PredictionUtilities (line 11) | public static class PredictionUtilities
method UpdateTranscripts (line 13) | internal static IntervalArray<ITranscript>[] UpdateTranscripts(IEnumer...
method UpdatePredictions (line 32) | internal static ITranscript UpdatePredictions(this ITranscript t, int ...
method GetNewIndex (line 40) | private static int GetNewIndex(IReadOnlyList<Prediction> oldPrediction...
FILE: CacheUtils/PredictionCache/RoundedEntry.cs
type RoundedEntry (line 5) | public struct RoundedEntry : IEquatable<RoundedEntry>
method RoundedEntry (line 10) | public RoundedEntry(ushort data)
method Round (line 16) | private static ushort Round(ushort us) => (ushort)((ushort)Math.Round(...
method Equals (line 18) | public bool Equals(RoundedEntry other) => Score == other.Score && Enum...
method GetHashCode (line 20) | public override int GetHashCode()
FILE: CacheUtils/PredictionCache/RoundedEntryPrediction.cs
class RoundedEntryPrediction (line 6) | public sealed class RoundedEntryPrediction
method RoundedEntryPrediction (line 9) | public RoundedEntryPrediction(RoundedEntry[] entries) => Entries = ent...
method Convert (line 11) | public Prediction Convert(Dictionary<RoundedEntry, byte> lutDict, Pred...
FILE: CacheUtils/TranscriptCache/CanonicalTranscriptMarker.cs
class CanonicalTranscriptMarker (line 10) | public sealed class CanonicalTranscriptMarker
method CanonicalTranscriptMarker (line 14) | public CanonicalTranscriptMarker(HashSet<string> lrgTranscriptIds)
method MarkTranscripts (line 19) | public int MarkTranscripts(MutableTranscript[] transcripts)
method GetTranscriptsByEntrezGeneId (line 26) | private SortedDictionary<int, HashSet<TranscriptMetadata>> GetTranscri...
method GetCanonicalTranscriptsByGeneId (line 49) | private static SortedDictionary<int, string> GetCanonicalTranscriptsBy...
method ConvertGeneIdToInt (line 68) | private static int ConvertGeneIdToInt(string geneId)
method SetCanonicalFlags (line 76) | private static int SetCanonicalFlags(IReadOnlyDictionary<int, string> ...
method GetSortedTrustedTranscripts (line 101) | private static List<TranscriptMetadata> GetSortedTrustedTranscripts(IE...
class TranscriptMetadata (line 116) | public sealed class TranscriptMetadata : IEquatable<TranscriptMetadata>
method TranscriptMetadata (line 124) | public TranscriptMetadata(string transcriptId, int accession, int tr...
method Equals (line 133) | public bool Equals(TranscriptMetadata other)
method GetHashCode (line 142) | public override int GetHashCode()
FILE: CacheUtils/TranscriptCache/Comparers/GeneComparer.cs
class GeneComparer (line 6) | internal sealed class GeneComparer : EqualityComparer<IGene>
method Equals (line 8) | public override bool Equals(IGene x, IGene y)
method GetHashCode (line 20) | public override int GetHashCode(IGene obj)
FILE: CacheUtils/TranscriptCache/Comparers/IntervalComparer.cs
class IntervalComparer (line 6) | internal sealed class IntervalComparer : EqualityComparer<IInterval>
method Equals (line 8) | public override bool Equals(IInterval x, IInterval y) => x.Start == y....
method GetHashCode (line 10) | public override int GetHashCode(IInterval obj)
FILE: CacheUtils/TranscriptCache/Comparers/RegulatoryRegionComparer.cs
class RegulatoryRegionComparer (line 6) | internal sealed class RegulatoryRegionComparer : EqualityComparer<IRegul...
method Equals (line 8) | public override bool Equals(IRegulatoryRegion x, IRegulatoryRegion y)
method GetHashCode (line 17) | public override int GetHashCode(IRegulatoryRegion obj)
FILE: CacheUtils/TranscriptCache/Comparers/TranscriptRegionComparer.cs
class TranscriptRegionComparer (line 6) | internal sealed class TranscriptRegionComparer : EqualityComparer<ITrans...
method Equals (line 8) | public override bool Equals(ITranscriptRegion x, ITranscriptRegion y)
method GetHashCode (line 15) | public override int GetHashCode(ITranscriptRegion obj)
FILE: CacheUtils/TranscriptCache/Comparers/UgaGeneComparer.cs
class UgaGeneComparer (line 7) | public sealed class UgaGeneComparer : EqualityComparer<UgaGene>
method Equals (line 9) | public override bool Equals(UgaGene x, UgaGene y)
method Equals (line 23) | private static bool Equals(IInterval x, IInterval y)
method GetHashCode (line 30) | private static int GetHashCode(IInterval x)
method GetHashCode (line 36) | public override int GetHashCode(UgaGene obj)
FILE: CacheUtils/TranscriptCache/NSequence.cs
class NSequence (line 6) | public sealed class NSequence : ISequence
method Substring (line 9) | public string Substring(int offset, int length) => new string('N', len...
FILE: CacheUtils/TranscriptCache/SortExtensions.cs
class SortExtensions (line 8) | public static class SortExtensions
method Sort (line 10) | public static IOrderedEnumerable<T> Sort<T>(this IEnumerable<T> elemen...
method SortInterval (line 13) | public static IOrderedEnumerable<T> SortInterval<T>(this IEnumerable<T...
FILE: CacheUtils/TranscriptCache/TranscriptCacheBuilder.cs
class TranscriptCacheBuilder (line 15) | public sealed class TranscriptCacheBuilder
method TranscriptCacheBuilder (line 22) | public TranscriptCacheBuilder(GenomeAssembly genomeAssembly, Source so...
method CreateTranscriptCache (line 31) | public TranscriptCacheStaging CreateTranscriptCache(MutableTranscript[...
method AssignUgaGenesToTranscripts (line 47) | private void AssignUgaGenesToTranscripts(IEnumerable<MutableTranscript...
method PickGeneById (line 64) | private UgaGene PickGeneById(IReadOnlyList<UgaGene> genes, string geneId)
FILE: CacheUtils/TranscriptCache/TranscriptCacheStaging.cs
class TranscriptCacheStaging (line 13) | public sealed class TranscriptCacheStaging : IStaging
method TranscriptCacheStaging (line 17) | private TranscriptCacheStaging(TranscriptCacheData cacheData)
method Write (line 22) | public void Write(Stream stream)
method GetStaging (line 27) | public static TranscriptCacheStaging GetStaging(CacheHeader header,
method GetUniqueData (line 39) | private static (IGene[] Genes, ITranscriptRegion[] TranscriptRegions, ...
method AddIntervals (line 73) | private static void AddIntervals(ISet<IInterval> intervalSet, IInterva...
method AddTranscriptRegions (line 79) | private static void AddTranscriptRegions(ISet<ITranscriptRegion> trans...
method AddString (line 85) | private static void AddString(ISet<string> stringSet, string s)
method GetUniqueStrings (line 91) | private static string[] GetUniqueStrings(ICollection<string> peptideSet)
method GetUniqueIntervals (line 96) | private static IInterval[] GetUniqueIntervals(ICollection<IInterval> m...
method GetUniqueTranscriptRegions (line 101) | private static ITranscriptRegion[] GetUniqueTranscriptRegions(ICollect...
method GetUniqueGenes (line 106) | private static IGene[] GetUniqueGenes(ICollection<IGene> geneSet)
FILE: CacheUtils/TranscriptCache/TranscriptCacheUtilities.cs
class TranscriptCacheUtilities (line 11) | public static class TranscriptCacheUtilities
method GetTranscripts (line 13) | public static List<ITranscript> GetTranscripts(DataBundle bundle, Chro...
method ToIntervalArrays (line 21) | public static IntervalArray<T>[] ToIntervalArrays<T>(this IEnumerable<...
method ToIntervals (line 36) | private static Interval<T>[] ToIntervals<T>(this IEnumerable<T> items,...
FILE: CacheUtils/TranscriptCache/TranscriptCacheWriter.cs
class TranscriptCacheWriter (line 18) | public sealed class TranscriptCacheWriter : IDisposable
method TranscriptCacheWriter (line 25) | public TranscriptCacheWriter(Stream stream, CacheHeader header, bool l...
method Dispose (line 33) | public void Dispose()
method Write (line 42) | public void Write(TranscriptCacheData cacheData)
method WriteIntervals (line 64) | private static void WriteIntervals<T>(IExtendedBinaryWriter writer, IR...
method WriteItems (line 84) | internal static void WriteItems<T>(IExtendedBinaryWriter writer, IRead...
method CreateIndex (line 102) | internal static Dictionary<T, int> CreateIndex<T>(IReadOnlyList<T> arr...
FILE: CacheUtils/TranscriptCache/TranscriptConversionExtensions.cs
class TranscriptConversionExtensions (line 10) | public static class TranscriptConversionExtensions
method ToTranscripts (line 12) | public static IEnumerable<ITranscript> ToTranscripts(this MutableTrans...
method ToTranscript (line 19) | private static ITranscript ToTranscript(this MutableTranscript mt)
method GetTranslation (line 34) | private static ITranslation GetTranslation(ICodingRegion oldCodingRegi...
FILE: CacheUtils/TranscriptCache/TranscriptRegionMerger.cs
class TranscriptRegionMerger (line 11) | public static class TranscriptRegionMerger
method GetTranscriptRegions (line 13) | public static ITranscriptRegion[] GetTranscriptRegions(IEnumerable<Mut...
method AddCoords (line 34) | private static List<MutableTranscriptRegion> AddCoords(this List<Mutab...
method GetExonCoords (line 48) | private static (int CdnaStart, int CdnaEnd) GetExonCoords(this IReadOn...
method ToInterfaceArray (line 79) | private static ITranscriptRegion[] ToInterfaceArray(this IReadOnlyList...
method CreateIntervals (line 91) | private static IdInterval[] CreateIntervals(IEnumerable<IInterval> int...
method AddIds (line 108) | private static List<MutableTranscriptRegion> AddIds(this List<MutableT...
method BinarySearch (line 130) | private static int BinarySearch(this IReadOnlyList<IdInterval> interva...
method AddGaps (line 148) | private static List<MutableTranscriptRegion> AddGaps(this List<Mutable...
method CalculateGapLength (line 166) | private static int CalculateGapLength(IInterval prevRegion, IInterval ...
class IdInterval (line 168) | private sealed class IdInterval : IInterval, IComparable<IdInterval>
method IdInterval (line 174) | public IdInterval(int start, int end, ushort id)
method CompareTo (line 181) | public int CompareTo(IdInterval other)
FILE: CacheUtils/TranscriptCache/TranscriptRegionValidater.cs
class TranscriptRegionValidater (line 11) | public static class TranscriptRegionValidater
method Validate (line 13) | public static void Validate(string transcriptId, IEnumerable<MutableTr...
method CheckGenomicCoordinateContiguity (line 32) | private static void CheckGenomicCoordinateContiguity(string transcript...
method ValidateRegions (line 44) | private static void ValidateRegions(string transcriptId, IEnumerable<I...
method DumpTranscriptRegions (line 58) | private static void DumpTranscriptRegions(IEnumerable<ITranscriptRegio...
method DumpTranscriptRegion (line 64) | private static void DumpTranscriptRegion(ITranscriptRegion region) => ...
method DumpCdnaMaps (line 66) | private static void DumpCdnaMaps(IEnumerable<MutableTranscriptRegion> ...
method DumpCdnaMap (line 72) | private static void DumpCdnaMap(ITranscriptRegion cdnaMap) => Console....
method DumpIntrons (line 74) | private static void DumpIntrons(IEnumerable<IInterval> introns)
method DumpIntron (line 80) | private static void DumpIntron(IInterval intron) => Console.WriteLine(...
method DumpExons (line 82) | private static void DumpExons(IEnumerable<MutableExon> exons)
method DumpExon (line 88) | private static void DumpExon(IInterval exon) => Console.WriteLine($"{e...
FILE: CacheUtils/Utilities/AccessionUtilities.cs
class AccessionUtilities (line 7) | internal static class AccessionUtilities
method GetMaxVersion (line 9) | internal static (string Id, byte Version) GetMaxVersion(string origina...
method GetAccessionNumber (line 15) | public static int GetAccessionNumber(string s)
method GetRefSeqAccessionNumber (line 21) | private static int GetRefSeqAccessionNumber(string s)
method GetEnsemblAccessionNumber (line 30) | private static int GetEnsemblAccessionNumber(string s)
FILE: CacheUtils/Utilities/HeaderUtilities.cs
class HeaderUtilities (line 9) | public static class HeaderUtilities
method GetHeader (line 11) | public static Header GetHeader(Source source, GenomeAssembly genomeAss...
FILE: CacheUtils/Utilities/RemoteFile.cs
class RemoteFile (line 9) | public sealed class RemoteFile
method RemoteFile (line 15) | static RemoteFile() => ServicePointManager.DefaultConnectionLimit = in...
method RemoteFile (line 17) | public RemoteFile(string description, string url, bool addDate = true)
method GetFilename (line 24) | internal static string GetFilename(string url, bool addDate)
method Download (line 37) | public void Download()
method SuccessfulDownload (line 48) | private bool SuccessfulDownload()
FILE: CacheUtils/Utilities/TaskExtensions.cs
class TaskExtensions (line 10) | public static class TaskExtensions
method Execute (line 12) | public static void Execute<T>(this IReadOnlyList<T> items, string desc...
FILE: Cloud/AmazonS3ClientWrapper.cs
class AmazonS3ClientWrapper (line 8) | public sealed class AmazonS3ClientWrapper : IS3Client
method AmazonS3ClientWrapper (line 12) | public AmazonS3ClientWrapper(AmazonS3Client s3Client) => _s3Client = s...
method GetObjectAsync (line 14) | public Task<GetObjectResponse> GetObjectAsync(GetObjectRequest getRequ...
method PutObjectAsync (line 16) | public Task<PutObjectResponse> PutObjectAsync(PutObjectRequest putRequ...
FILE: Cloud/Configuration.cs
class Configuration (line 6) | public sealed class Configuration
method Configuration (line 14) | public Configuration()
FILE: Cloud/LambdaUrlHelper.cs
class LambdaUrlHelper (line 9) | public static class LambdaUrlHelper
method GetBaseUrl (line 31) | public static string GetBaseUrl()
method GetManifestBaseUrl (line 38) | public static string GetManifestBaseUrl() => GetBaseUrl() + Config.Man...
method GetCacheFolder (line 40) | public static string GetCacheFolder() => GetBaseUrl() + S3CacheFol...
method GetUgaUrl (line 41) | public static string GetUgaUrl() => GetCacheFolder() + UgaFileName;
method GetRefPrefix (line 42) | public static string GetRefPrefix() => GetBaseUrl() + S3RefPrefix;
method GetRefUrl (line 44) | public static string GetRefUrl(GenomeAssembly genomeAssembly) =>
FILE: Cloud/Messages/Annotation/AnnotationConfig.cs
class AnnotationConfig (line 5) | public sealed class AnnotationConfig
FILE: Cloud/Messages/Annotation/AnnotationPosition.cs
type AnnotationPosition (line 3) | public struct AnnotationPosition
method AnnotationPosition (line 8) | public AnnotationPosition(string chromosome, int position)
FILE: Cloud/Messages/Annotation/AnnotationRange.cs
class AnnotationRange (line 7) | public sealed class AnnotationRange
method AnnotationRange (line 12) | public AnnotationRange(AnnotationPosition start, AnnotationPosition? end)
method ToGenomicRange (line 18) | public GenomicRange ToGenomicRange(Dictionary<string, Chromosome> refN...
FILE: Cloud/Messages/Annotation/AnnotationResult.cs
class AnnotationResult (line 6) | public sealed class AnnotationResult
FILE: Cloud/Messages/Custom/CustomConfig.cs
class CustomConfig (line 5) | public sealed class CustomConfig
FILE: Cloud/Messages/Custom/CustomResult.cs
class CustomResult (line 5) | public sealed class CustomResult
FILE: Cloud/Messages/FileList.cs
class FileList (line 5) | public sealed class FileList
FILE: Cloud/Messages/Gene/GeneConfig.cs
class GeneConfig (line 6) | public sealed class GeneConfig
method Validate (line 14) | public void Validate()
FILE: Cloud/Messages/JwtFields.cs
class JwtFields (line 3) | public class JwtFields
FILE: Cloud/Messages/Nirvana/NirvanaConfig.cs
class NirvanaConfig (line 7) | public sealed class NirvanaConfig
method CheckRequiredFieldsNotNull (line 24) | internal void CheckRequiredFieldsNotNull()
method Validate (line 42) | public void Validate()
FILE: Cloud/Messages/Nirvana/NirvanaResult.cs
class NirvanaResult (line 3) | public sealed class NirvanaResult
FILE: Cloud/Messages/S3Path.cs
class S3Path (line 13) | public sealed class S3Path
method Validate (line 22) | public void Validate(bool isDirectory)
method CheckS3Region (line 33) | private void CheckS3Region()
method ValidateCredentials (line 40) | private void ValidateCredentials(IS3Client s3Client, bool isDirectory)
method ValidatePathFormat (line 84) | internal static void ValidatePathFormat(string path, bool isDirectory)
method FormatPath (line 93) | public static string FormatPath(string path) => path.TrimStart('/');
method GetS3Client (line 95) | public IS3Client GetS3Client(TimeSpan timeOut) => new AmazonS3ClientWr...
FILE: Cloud/Messages/SaUrls.cs
class SaUrls (line 10) | public sealed class SaUrls
method Validate (line 20) | public void Validate()
method GetSaType (line 38) | internal CustomSaType GetSaType()
method ToString (line 58) | public override string ToString()
type CustomSaType (line 74) | public enum CustomSaType
FILE: Cloud/Messages/Single/SingleConfig.cs
class SingleConfig (line 5) | public sealed class SingleConfig
FILE: Cloud/Messages/Single/SingleVariant.cs
class SingleVariant (line 6) | public sealed class SingleVariant
method Validate (line 23) | public void Validate()
method GetVcfFields (line 44) | public string[] GetVcfFields()
method GetStringFromNullableCollection (line 70) | private static string GetStringFromNullableCollection(string[] values,...
FILE: Cloud/Messages/StrValidation/ValidationConfig.cs
class ValidationConfig (line 5) | public sealed class ValidationConfig
method Validate (line 13) | public void Validate() => HttpUtilities.ValidateUrl(customStrUrl);
FILE: Cloud/Messages/StrValidation/ValidationResult.cs
class ValidationResult (line 3) | public class ValidationResult
FILE: Cloud/Notifications/SNS.cs
class SNS (line 6) | public static class SNS
method SendMessage (line 8) | public static void SendMessage(string snsTopicArn, string snsMessage)
method CreateMessage (line 24) | public static string CreateMessage(string message, string status, stri...
FILE: Cloud/RedactionUtilities.cs
class RedactionUtilities (line 5) | public static class RedactionUtilities
method Redact (line 13) | public static string Redact(this string s)
method Mask (line 29) | private static char[] Mask(this char[] charArray, MatchCollection matc...
FILE: Cloud/Utilities/AwsExceptionUtilities.cs
class AwsExceptionUtilities (line 8) | public static class AwsExceptionUtilities
method TryConvertUserException (line 10) | public static Exception TryConvertUserException(Exception exception, S...
FILE: Cloud/Utilities/JsonUtilities.cs
class JsonUtilities (line 7) | public static class JsonUtilities
method Stringify (line 11) | public static string Stringify(object obj) => Encoding.UTF8.GetString(...
method Serialize (line 13) | public static MemoryStream Serialize(object obj)
method Deserialize (line 21) | public static T Deserialize<T>(MemoryStream memoryStream) => JsonSeria...
FILE: Cloud/Utilities/LambdaUtilities.cs
class LambdaUtilities (line 8) | public static class LambdaUtilities
method GarbageCollect (line 13) | public static void GarbageCollect()
method GetEnvironmentVariable (line 19) | public static string GetEnvironmentVariable(string key)
method DeleteTempOutput (line 26) | public static void DeleteTempOutput()
method GetManifestUrl (line 33) | public static string GetManifestUrl(string version, GenomeAssembly gen...
method GetCachePathPrefix (line 50) | public static string GetCachePathPrefix(GenomeAssembly genomeAssembly)
FILE: Cloud/Utilities/LogUtilities.cs
class LogUtilities (line 10) | public static class LogUtilities
method LogLambdaInfo (line 12) | public static void LogLambdaInfo(ILambdaContext context, string versio...
method LogObject (line 15) | public static void LogObject<T>(string title, T config)
method Log (line 32) | public static void Log(IEnumerable<string> environmentVariables)
method UpdateLogger (line 47) | public static void UpdateLogger(ILambdaLogger logger, StringBuilder sb)
FILE: Cloud/Utilities/UploadUtilities.cs
class UploadUtilities (line 10) | public static class UploadUtilities
method DecryptUpload (line 12) | public static void DecryptUpload(this IS3Client s3Client, string bucke...
method TryDecryptUpload (line 24) | internal static bool TryDecryptUpload(this IS3Client s3Client, string ...
FILE: CommandLine/Builders/ConsoleAppBuilder.cs
class ConsoleAppBuilder (line 11) | public sealed class ConsoleAppBuilder : IConsoleAppBuilder
method ConsoleAppBuilder (line 16) | public ConsoleAppBuilder(string[] args, OptionSet ops)
method AddAdditionalOptions (line 28) | private void AddAdditionalOptions()
method Parse (line 34) | public IConsoleAppValidator Parse()
method UseVersionProvider (line 61) | public IConsoleAppBuilder UseVersionProvider(IVersionProvider versionP...
class ConsoleAppValidator (line 68) | public sealed class ConsoleAppValidator : IConsoleAppValidator
method ConsoleAppValidator (line 73) | public ConsoleAppValidator(IConsoleAppBuilderData data)
method DisableOutput (line 79) | public IConsoleAppValidator DisableOutput(bool condition = true)
method ShowBanner (line 85) | public IConsoleAppBanner ShowBanner(string authors)
method SkipBanner (line 92) | public IConsoleAppBanner SkipBanner() => new ConsoleAppBanner(Data);
class ConsoleAppBanner (line 95) | public sealed class ConsoleAppBanner : IConsoleAppBanner
method ConsoleAppBanner (line 99) | public ConsoleAppBanner(IConsoleAppBuilderData data) => _data = data;
method ShowHelpMenu (line 101) | public IConsoleAppHelpMenu ShowHelpMenu(string description, string com...
class ConsoleAppHelpMenu (line 114) | public sealed class ConsoleAppHelpMenu : IConsoleAppHelpMenu
method ConsoleAppHelpMenu (line 118) | public ConsoleAppHelpMenu(IConsoleAppBuilderData data) => _data = data;
method ShowErrors (line 120) | public IConsoleAppErrors ShowErrors()
method PrintErrors (line 133) | private void PrintErrors()
class ConsoleAppErrors (line 146) | public sealed class ConsoleAppErrors : IConsoleAppErrors
method ConsoleAppErrors (line 151) | public ConsoleAppErrors(IConsoleAppBuilderData data) => _data = data;
method Execute (line 153) | public ExitCodes Execute(Func<ExitCodes> executeMethod)
method ShowPerformanceData (line 173) | private void ShowPerformanceData(Benchmark benchmark)
class ConsoleAppBuilderData (line 186) | public sealed class ConsoleAppBuilderData : IConsoleAppBuilderData
method AddError (line 198) | public void AddError(string errorMessage, ExitCodes exitCode)
FILE: CommandLine/Builders/IConsoleAppBuilder.cs
type IConsoleAppBuilder (line 12) | public interface IConsoleAppBuilder
method UseVersionProvider (line 15) | IConsoleAppBuilder UseVersionProvider(IVersionProvider versionProvider);
method Parse (line 16) | IConsoleAppValidator Parse();
type IConsoleAppValidator (line 19) | public interface IConsoleAppValidator
method DisableOutput (line 21) | IConsoleAppValidator DisableOutput(bool condition = true);
method ShowBanner (line 22) | IConsoleAppBanner ShowBanner(string authors);
method SkipBanner (line 23) | IConsoleAppBanner SkipBanner();
type IConsoleAppBanner (line 28) | public interface IConsoleAppBanner
method ShowHelpMenu (line 30) | IConsoleAppHelpMenu ShowHelpMenu(string description, string commandLin...
type IConsoleAppHelpMenu (line 33) | public interface IConsoleAppHelpMenu
method ShowErrors (line 35) | IConsoleAppErrors ShowErrors();
type IConsoleAppErrors (line 38) | public interface IConsoleAppErrors
method Execute (line 40) | ExitCodes Execute(Func<ExitCodes> executeMethod);
type IConsoleAppBuilderData (line 43) | public interface IConsoleAppBuilderData
method AddError (line 54) | void AddError(string errorMessage, ExitCodes exitCode);
FILE: CommandLine/Builders/ITopLevelAppBuilder.cs
type ITopLevelAppBuilder (line 7) | public interface ITopLevelAppBuilder
method Parse (line 10) | ITopLevelAppValidator Parse();
type ITopLevelAppValidator (line 13) | public interface ITopLevelAppValidator
method ShowBanner (line 15) | ITopLevelAppBanner ShowBanner(string authors);
type ITopLevelAppBanner (line 19) | public interface ITopLevelAppBanner
method ShowHelpMenu (line 21) | ITopLevelAppHelpMenu ShowHelpMenu(string description);
type ITopLevelAppHelpMenu (line 24) | public interface ITopLevelAppHelpMenu
method ShowErrors (line 26) | ITopLevelAppErrors ShowErrors();
type ITopLevelAppErrors (line 29) | public interface ITopLevelAppErrors
method Execute (line 31) | ExitCodes Execute();
type ITopLevelAppBuilderData (line 34) | public interface ITopLevelAppBuilderData
method AddError (line 47) | void AddError(string errorMessage, ExitCodes exitCode);
FILE: CommandLine/Builders/TopLevelAppBuilder.cs
class TopLevelAppBuilder (line 9) | public sealed class TopLevelAppBuilder : ITopLevelAppBuilder
method TopLevelAppBuilder (line 13) | public TopLevelAppBuilder(string[] args, Dictionary<string, TopLevelOp...
method Parse (line 18) | public ITopLevelAppValidator Parse()
method GetExecuteMethod (line 32) | private Func<string, string[], ExitCodes> GetExecuteMethod(string comm...
class TopLevelAppValidator (line 44) | public sealed class TopLevelAppValidator : ITopLevelAppValidator
method TopLevelAppValidator (line 48) | public TopLevelAppValidator(ITopLevelAppBuilderData data) => Data = data;
method ShowBanner (line 50) | public ITopLevelAppBanner ShowBanner(string authors)
class TopLevelAppBanner (line 57) | public sealed class TopLevelAppBanner : ITopLevelAppBanner
method TopLevelAppBanner (line 61) | public TopLevelAppBanner(ITopLevelAppBuilderData data) => _data = data;
method ShowHelpMenu (line 63) | public ITopLevelAppHelpMenu ShowHelpMenu(string description)
method DisplayCommands (line 82) | private static void DisplayCommands(Dictionary<string, TopLevelOption>...
method GetMaxCommandLen (line 104) | private static int GetMaxCommandLen(IEnumerable<string> ops)
class TopLevelAppHelpMenu (line 110) | public sealed class TopLevelAppHelpMenu : ITopLevelAppHelpMenu
method TopLevelAppHelpMenu (line 114) | public TopLevelAppHelpMenu(ITopLevelAppBuilderData data) => _data = data;
method ShowErrors (line 116) | public ITopLevelAppErrors ShowErrors()
method PrintErrors (line 128) | private void PrintErrors()
class TopLevelAppErrors (line 141) | public sealed class TopLevelAppErrors : ITopLevelAppErrors
method TopLevelAppErrors (line 146) | public TopLevelAppErrors(ITopLevelAppBuilderData data) => _data = data;
method Execute (line 148) | public ExitCodes Execute()
class TopLevelAppBuilderData (line 168) | public sealed class TopLevelAppBuilderData : ITopLevelAppBuilderData
method TopLevelAppBuilderData (line 181) | public TopLevelAppBuilderData(string[] arguments, Dictionary<string, T...
method AddError (line 188) | public void AddError(string errorMessage, ExitCodes exitCode)
FILE: CommandLine/Builders/TopLevelOption.cs
class TopLevelOption (line 6) | public sealed class TopLevelOption
method TopLevelOption (line 11) | public TopLevelOption(string description, Func<string, string[], ExitC...
FILE: CommandLine/Builders/ValidationExtensions.cs
class ValidationExtensions (line 9) | public static class ValidationExtensions
method CheckEachFilenameExists (line 11) | public static IConsoleAppValidator CheckEachFilenameExists(this IConso...
method CheckInputFilenameExists (line 21) | public static IConsoleAppValidator CheckInputFilenameExists(this ICons...
method CheckUrlExist (line 40) | private static bool CheckUrlExist(string url)
method CheckOutputFilenameSuffix (line 54) | public static IConsoleAppValidator CheckOutputFilenameSuffix(this ICon...
method CheckDirectoryExists (line 67) | public static IConsoleAppValidator CheckDirectoryExists(this IConsoleA...
method HasRequiredParameter (line 86) | public static IConsoleAppValidator HasRequiredParameter<T>(this IConso...
method HasRequiredDate (line 100) | public static IConsoleAppValidator HasRequiredDate(this IConsoleAppVal...
FILE: CommandLine/NDesk.Options/Options.cs
class OptionValueCollection (line 47) | public sealed class OptionValueCollection
method OptionValueCollection (line 52) | internal OptionValueCollection(OptionContext c)
method Add (line 58) | public void Add(string item) { _values.Add(item); }
method Clear (line 59) | public void Clear() { _values.Clear(); }
method AssertValid (line 69) | private void AssertValid(int index)
class OptionContext (line 91) | public sealed class OptionContext
method OptionContext (line 93) | public OptionContext()
type OptionValueType (line 107) | public enum OptionValueType
class Option (line 114) | public abstract class Option
method Option (line 116) | protected Option(string prototype, string description, int maxValueCount)
method Parse (line 153) | protected static T Parse<T>(string value, OptionContext c)
method ParsePrototype (line 174) | private OptionValueType ParsePrototype()
method GetOptionValueType (line 216) | private static OptionValueType GetOptionValueType(char type) =>
method AddSeparators (line 219) | private static void AddSeparators(string name, int end, ICollection<st...
method Invoke (line 253) | public void Invoke(OptionContext c)
method OnParseComplete (line 261) | protected abstract void OnParseComplete(OptionContext c);
class OptionException (line 264) | public sealed class OptionException : Exception
method OptionException (line 266) | public OptionException(string message)
method OptionException (line 271) | public OptionException(string message, Exception innerException)
class OptionSet (line 277) | public sealed class OptionSet : KeyedCollection<string, Option>
method GetKeyForItem (line 279) | protected override string GetKeyForItem(Option item)
method InsertItem (line 290) | protected override void InsertItem(int index, Option item)
method AddImpl (line 296) | private void AddImpl(Option option)
method Add (line 318) | public new void Add(Option option)
class ActionOption (line 323) | private sealed class ActionOption : Option
method ActionOption (line 327) | public ActionOption(string prototype, string description, int count,...
method OnParseComplete (line 333) | protected override void OnParseComplete(OptionContext c)
method ActionOption (line 352) | public ActionOption(string prototype, string description, Action<T> ...
method OnParseComplete (line 358) | protected override void OnParseComplete(OptionContext c)
method Add (line 339) | public void Add(string prototype, string description, Action<string> a...
class ActionOption (line 348) | private sealed class ActionOption<T> : Option
method ActionOption (line 327) | public ActionOption(string prototype, string description, int count,...
method OnParseComplete (line 333) | protected override void OnParseComplete(OptionContext c)
method ActionOption (line 352) | public ActionOption(string prototype, string description, Action<T> ...
method OnParseComplete (line 358) | protected override void OnParseComplete(OptionContext c)
method Add (line 364) | public void Add<T>(string prototype, string description, Action<T> act...
method CreateOptionContext (line 369) | private static OptionContext CreateOptionContext()
method Parse (line 374) | public List<string> Parse(IEnumerable<string> arguments)
method Unprocessed (line 401) | private static void Unprocessed(ICollection<string> extra, Option def,...
method GetOptionParts (line 416) | private bool GetOptionParts(string argument, out string flag, out stri...
method Parse (line 438) | private bool Parse(string argument, OptionContext c)
method ParseValue (line 469) | private static void ParseValue(string option, OptionContext c)
method ParseBool (line 487) | private bool ParseBool(string option, string n, OptionContext c)
method ParseBundledValue (line 503) | private bool ParseBundledValue(string f, string n, OptionContext c)
method Invoke (line 539) | private static void Invoke(OptionContext c, string name, string value,...
method WriteOptionDescriptions (line 549) | public void WriteOptionDescriptions(TextWriter o)
method WriteOptionPrototype (line 577) | private static bool WriteOptionPrototype(TextWriter o, Option p, ref i...
method GetNextOptionIndex (line 626) | private static int GetNextOptionIndex(IReadOnlyList<string> names, int i)
method Write (line 635) | private static void Write(TextWriter o, ref int n, string s)
method GetArgumentName (line 641) | private static string GetArgumentName(int index, int maxIndex, string ...
method GetDescription (line 663) | private static string GetDescription(string description)
method ParseDescription (line 678) | private static int ParseDescription(string description, int position, ...
method GetLines (line 722) | private static IEnumerable<string> GetLines(string description)
method IsEolChar (line 750) | private static bool IsEolChar(char c)
method GetLineEnd (line 755) | private static int GetLineEnd(int start, int length, string description)
FILE: CommandLine/Utilities/Benchmark.cs
class Benchmark (line 5) | public sealed class Benchmark
method Benchmark (line 9) | public Benchmark() => Reset();
method GetElapsedTime (line 11) | public TimeSpan GetElapsedTime()
method ToHumanReadable (line 17) | public static string ToHumanReadable(TimeSpan span)
method GetElapsedIterationsPerSecond (line 24) | public static double GetElapsedIterationsPerSecond(TimeSpan span, int ...
method Reset (line 26) | public void Reset() => _startTime = DateTime.Now;
FILE: CommandLine/Utilities/CommandLineUtilities.cs
class CommandLineUtilities (line 7) | public static class CommandLineUtilities
method CommandLineUtilities (line 14) | static CommandLineUtilities()
method GetCopyright (line 27) | private static string GetCopyright(Assembly entryAssembly)
method GetVersion (line 33) | public static string GetVersion(Assembly entryAssembly)
method GetInformationalVersion (line 39) | private static string GetInformationalVersion(Assembly entryAssembly)
method GetTitle (line 45) | private static string GetTitle(Assembly entryAssembly)
method GetAssemblyAttributes (line 51) | private static T GetAssemblyAttributes<T>(Assembly entryAssembly)
method DisplayBanner (line 61) | public static void DisplayBanner(string author)
FILE: CommandLine/Utilities/Help.cs
class Help (line 6) | public static class Help
method Show (line 8) | public static void Show(OptionSet ops, string commonOptions, string de...
FILE: CommandLine/Utilities/MemoryUtilities.cs
class MemoryUtilities (line 5) | public static class MemoryUtilities
method GetPeakMemoryUsage (line 16) | public static long GetPeakMemoryUsage()
method ToHumanReadable (line 24) | public static string ToHumanReadable(long numBytes)
FILE: CommandLine/Utilities/OutputHelper.cs
class OutputHelper (line 6) | public static class OutputHelper
method WriteLabel (line 8) | public static void WriteLabel(string label)
method GetExecutableName (line 15) | public static string GetExecutableName()
FILE: CommandLine/VersionProviders/DefaultVersionProvider.cs
class DefaultVersionProvider (line 5) | public sealed class DefaultVersionProvider : IVersionProvider
FILE: CommandLine/VersionProviders/IVersionProvider.cs
type IVersionProvider (line 3) | public interface IVersionProvider
FILE: Compression/Algorithms/ICompressionAlgorithm.cs
type ICompressionAlgorithm (line 3) | public interface ICompressionAlgorithm
method Compress (line 5) | int Compress(byte[] source, int srcLength, byte[] destination, int des...
method Decompress (line 6) | int Decompress(byte[] source, int srcLength, byte[] destination, int d...
method GetDecompressedLength (line 7) | int GetDecompressedLength(byte[] source, int srcLength);
method GetCompressedBufferBounds (line 8) | int GetCompressedBufferBounds(int srcLength);
FILE: Compression/Algorithms/Zlib.cs
class Zlib (line 7) | public sealed class Zlib : ICompressionAlgorithm
method Zlib (line 11) | public Zlib(int compressionLevel = 1)
method Compress (line 17) | public int Compress(byte[] source, int srcLength, byte[] destination, ...
method Decompress (line 27) | public int Decompress(byte[] source, int srcLength, byte[] destination...
method GetDecompressedLength (line 37) | public int GetDecompressedLength(byte[] source, int srcLength)
method GetCompressedBufferBounds (line 43) | public int GetCompressedBufferBounds(int srcLength) => (int)(srcLength...
class SafeNativeMethods (line 45) | private static class SafeNativeMethods
method bgzf_decompress (line 47) | [DllImport("BlockCompression", CallingConvention = CallingConvention...
method bgzf_compress (line 50) | [DllImport("BlockCompression", CallingConvention = CallingConvention...
FILE: Compression/Algorithms/Zstandard.cs
class Zstandard (line 7) | public sealed class Zstandard : ICompressionAlgorithm
method Zstandard (line 11) | public Zstandard(int compressionLevel = 17)
method Compress (line 17) | public int Compress(byte[] source, int srcLength, byte[] destination, ...
method Decompress (line 27) | public int Decompress(byte[] source, int srcLength, byte[] destination...
method GetDecompressedLength (line 37) | public int GetDecompressedLength(byte[] source, int srcLength) => (int...
method GetCompressedBufferBounds (line 40) | public int GetCompressedBufferBounds(int srcLength) => srcLength + 32;
class SafeNativeMethods (line 42) | private static class SafeNativeMethods
method ZSTD_compress (line 44) | [DllImport("BlockCompression", CallingConvention = CallingConvention...
method ZSTD_decompress (line 47) | [DllImport("BlockCompression", CallingConvention = CallingConvention...
method ZSTD_getDecompressedSize (line 50) | [DllImport("BlockCompression", CallingConvention = CallingConvention...
FILE: Compression/DataStructures/Block.cs
class Block (line 9) | public sealed class Block
method Block (line 27) | public Block(ICompressionAlgorithm compressionAlgorithm, int size = De...
method CopyTo (line 39) | public int CopyTo(byte[] array, int offset, int count)
method CopyFrom (line 50) | public int CopyFrom(byte[] array, int offset, int count)
method Write (line 61) | public void Write(Stream stream)
method WriteEof (line 83) | public void WriteEof(Stream stream)
method Read (line 90) | public int Read(Stream stream)
method ReadCompressedBlock (line 106) | private int ReadCompressedBlock(Stream stream)
method ReadUncompressedBlock (line 123) | private int ReadUncompressedBlock(Stream stream)
FILE: Compression/FileHandling/BgzBlockReader.cs
class BgzBlockReader (line 7) | public sealed class BgzBlockReader:IDisposable
method BgzBlockReader (line 15) | public BgzBlockReader(Stream stream, bool leaveStreamOpen = false)
method ReadCompressedBlock (line 23) | public int ReadCompressedBlock(byte[] buffer)
method Dispose (line 52) | public void Dispose()
FILE: Compression/FileHandling/BgzfBlock.cs
class BgzfBlock (line 9) | public sealed class BgzfBlock
method Read (line 16) | public string Read(Stream stream)
FILE: Compression/FileHandling/BgzipTextReader.cs
class BgzipTextReader (line 8) | public sealed class BgzipTextReader : IDisposable
method BgzipTextReader (line 15) | public BgzipTextReader(BlockGZipStream stream, bool leaveOpen = false)
method ReadLine (line 35) | public string ReadLine() => _reader.ReadLine();
method Dispose (line 37) | public void Dispose()
FILE: Compression/FileHandling/BgzipTextWriter.cs
class BgzipTextWriter (line 8) | public sealed class BgzipTextWriter : StreamWriter, IDisposable
method BgzipTextWriter (line 24) | public BgzipTextWriter(BlockGZipStream stream) : base(stream, Utf8With...
method Flush (line 33) | public override void Flush()
method WriteLine (line 42) | public override void WriteLine() => Write("\n");
method WriteLine (line 44) | public override void WriteLine(string value) => Write(value + "\n");
method Write (line 46) | public override void Write(string value)
method Write (line 54) | public override void Write(StringBuilder sb)
method WriteBytes (line 70) | private void WriteBytes(byte[] lineBytes, int length)
method Dispose (line 100) | public new void Dispose()
FILE: Compression/FileHandling/BlockGZipStream.cs
class BlockGZipStream (line 20) | public sealed class BlockGZipStream : Stream
class BlockGZipFormatCommon (line 36) | public static class BlockGZipFormatCommon
method Seek (line 59) | public override long Seek(long offset, SeekOrigin origin) => throw new...
method SetLength (line 61) | public override void SetLength(long value) => throw new NotSupportedEx...
method Flush (line 63) | public override void Flush() => _stream.Flush();
method Dispose (line 65) | protected override void Dispose(bool disposing)
method BlockGZipStream (line 95) | public BlockGZipStream(Stream stream, CompressionMode compressionMode,...
method Flush (line 114) | private void Flush(int uncompressedSize)
method HasValidHeader (line 123) | public static bool HasValidHeader(int numHeaderBytes, IReadOnlyList<by...
method ReadBlock (line 135) | private void ReadBlock()
method Read (line 178) | public override int Read(byte[] buffer, int offset, int count)
method Write (line 216) | public override void Write(byte[] buffer, int offset, int count)
method CloseBlock (line 237) | public void CloseBlock() => Flush(_blockOffset);
method SeekVirtualFilePointer (line 239) | private void SeekVirtualFilePointer(ulong virtualPosition)
method GetCompressedOffset (line 255) | private static long GetCompressedOffset(ulong virtualPosition)
method GetUncompressedOffset (line 263) | private static int GetUncompressedOffset(ulong virtualPosition)
FILE: Compression/FileHandling/BlockHeader.cs
class BlockHeader (line 6) | public sealed class BlockHeader
method BlockHeader (line 18) | public BlockHeader() => _header = new byte[HeaderSize];
method GetInt (line 20) | private int GetInt(int offset) => _header[offset] | _header[offset + 1...
method Read (line 23) | public void Read(Stream stream)
method SetInt (line 43) | private void SetInt(int value, int offset)
method Write (line 51) | public void Write(Stream stream)
FILE: Compression/FileHandling/BlockStream.cs
class BlockStream (line 11) | public sealed class BlockStream : Stream
method Seek (line 30) | public override long Seek(long offset, SeekOrigin origin) => throw new...
method SetLength (line 31) | public override void SetLength(long value) => throw new...
method Flush (line 39) | public override void Flush()
method Dispose (line 44) | protected override void Dispose(bool disposing)
method BlockStream (line 82) | public BlockStream(ICompressionAlgorithm compressionAlgorithm, Stream ...
method WriteHeader (line 97) | public void WriteHeader(Action<BinaryWriter> headerWrite)
method Read (line 103) | public override int Read(byte[] buffer, int offset, int count)
method ValidateParameters (line 135) | private void ValidateParameters(byte[] array, int offset, int count)
method Write (line 143) | public override void Write(byte[] buffer, int offset, int count)
method GetBlockPosition (line 161) | public (long FileOffset, int InternalOffset) GetBlockPosition() => (_s...
method SetBlockPosition (line 163) | public void SetBlockPosition(long fileOffset, int internalOffset = 0)
FILE: Compression/Utilities/BlockExtensions.cs
class BlockExtensions (line 8) | public static class BlockExtensions
method ReadCompressedByteArray (line 12) | public static byte[] ReadCompressedByteArray(this BinaryReader reader,...
method WriteCompressedByteArray (line 27) | public static void WriteCompressedByteArray(this BinaryWriter writer, ...
FILE: Compression/Utilities/GZipUtilities.cs
class GZipUtilities (line 11) | public static class GZipUtilities
type CompressionAlgorithm (line 15) | private enum CompressionAlgorithm
method GetAppropriateStreamReader (line 22) | public static StreamReader GetAppropriateStreamReader(string filePath)...
method GetStreamWriter (line 23) | public static StreamWriter GetStreamWriter(string filePath) => new Str...
method GetWriteStream (line 24) | private static Stream GetWriteStream(string filePath) => new BlockGZip...
method GetAppropriateStream (line 26) | private static Stream GetAppropriateStream(Stream stream, CompressionA...
method GetAppropriateStream (line 49) | public static Stream GetAppropriateStream(Stream stream)
method GetAppropriateReadStream (line 58) | public static Stream GetAppropriateReadStream(string filePath)
method GetHeader (line 72) | private static byte[] GetHeader(Stream stream)
method IdentifyCompressionAlgorithm (line 95) | private static CompressionAlgorithm IdentifyCompressionAlgorithm(byte[...
FILE: Compression/Utilities/LibraryUtilities.cs
class LibraryUtilities (line 8) | public static class LibraryUtilities
method CheckLibrary (line 10) | public static void CheckLibrary()
class SafeNativeMethods (line 26) | private static class SafeNativeMethods
method get_library_id (line 28) | [DllImport("BlockCompression", CallingConvention = CallingConvention...
FILE: CustomAnnotationLambda/CustomAnnotationLambda.cs
class CustomAnnotationLambda (line 22) | public sealed class CustomAnnotationLambda
method Run (line 26) | public CustomResult Run(CustomConfig config, ILambdaContext context)
method IsGeneAnnotationTsv (line 65) | private static bool IsGeneAnnotationTsv(string tsvUrl)
method GetSuccessResult (line 78) | public static CustomResult GetSuccessResult(CustomConfig customSaConfi...
method HandleException (line 97) | private static CustomResult HandleException(StringBuilder runLog, Cust...
FILE: CustomAnnotationLambda/CustomConfigExtensions.cs
class CustomConfigExtensions (line 8) | public static class CustomConfigExtensions
method CheckRequiredFieldsNotNull (line 10) | public static void CheckRequiredFieldsNotNull(this CustomConfig config)
method CheckResourcesExist (line 25) | public static void CheckResourcesExist(this CustomConfig config)
FILE: CustomAnnotationLambda/GeneAnnotationCreator.cs
class GeneAnnotationCreator (line 16) | public static class GeneAnnotationCreator
method Create (line 19) | public static CustomResult Create(CustomConfig config, string inputFil...
method GetGeneAnnotationsParserFromCustomTsvStream (line 95) | private static GeneAnnotationsParser GetGeneAnnotationsParserFromCusto...
FILE: CustomAnnotationLambda/VariantAnnotationCreator.cs
class VariantAnnotationCreator (line 19) | public static class VariantAnnotationCreator
method Create (line 21) | public static CustomResult Create(CustomConfig config, string inputFil...
method GetVariantAnnotationsParserFromCustomTsvStream (line 139) | private static VariantAnnotationsParser GetVariantAnnotationsParserFro...
FILE: CustomStrValidationLambda/CustomStrValidationLambda.cs
class CustomStrValidationLambda (line 21) | public class CustomStrValidationLambda
method Run (line 23) | public ValidationResult Run(ValidationConfig config, ILambdaContext co...
method TryLoadStrFile (line 53) | private static void TryLoadStrFile(Stream stream, GenomeAssembly genom...
method HandleException (line 66) | private static ValidationResult HandleException(string id, Exception e...
method GetSuccessOutput (line 83) | private static ValidationResult GetSuccessOutput(string id) =>
FILE: Downloader/AnnotationRepository.cs
class AnnotationRepository (line 8) | public static class AnnotationRepository
method DownloadMetadata (line 10) | public static void DownloadMetadata(IClient client, List<RemoteFile> f...
method DownloadFiles (line 13) | public static void DownloadFiles(IClient client, List<RemoteFile> file...
method Retry (line 16) | private static void Retry(RemoteFile file, Func<RemoteFile, bool> clie...
FILE: Downloader/Client.cs
class Client (line 11) | public sealed class Client : IClient
method Client (line 15) | public Client(string hostName)
method DownloadLines (line 29) | public List<string> DownloadLines(string remotePath)
method SetMetadata (line 53) | public bool SetMetadata(RemoteFile file)
method DownloadFile (line 79) | public bool DownloadFile(RemoteFile file)
FILE: Downloader/Configuration.cs
class Configuration (line 10) | public static class Configuration
method Load (line 12) | public static (string HostName, string CacheDir, string ReferencesDir,...
FILE: Downloader/DownloaderMain.cs
class DownloaderMain (line 16) | public static class DownloaderMain
method ProgramExecution (line 23) | private static ExitCodes ProgramExecution()
method Main (line 77) | public static int Main(string[] args)
FILE: Downloader/FileExtensions/CacheFileExtensions.cs
class CacheFileExtensions (line 8) | public static class CacheFileExtensions
method AddCacheFiles (line 10) | public static List<RemoteFile> AddCacheFiles(this List<RemoteFile> files,
method AddCache (line 23) | private static void AddCache(this ICollection<RemoteFile> files, Genom...
FILE: Downloader/FileExtensions/ReferencesFileExtensions.cs
class ReferencesFileExtensions (line 8) | public static class ReferencesFileExtensions
method AddReferenceFiles (line 10) | public static List<RemoteFile> AddReferenceFiles(this List<RemoteFile>...
method GetFilename (line 25) | public static string GetFilename(GenomeAssembly genomeAssembly) => $"H...
FILE: Downloader/FileExtensions/SupplementaryAnnotationFileExtensions.cs
class SupplementaryAnnotationFileExtensions (line 7) | public static class SupplementaryAnnotationFileExtensions
method SupplementaryAnnotationFileExtensions (line 11) | static SupplementaryAnnotationFileExtensions()
method AddSupplementaryAnnotationFiles (line 19) | public static void AddSupplementaryAnnotationFiles(this List<RemoteFil...
method AddDataSources (line 28) | private static void AddDataSources(this ICollection<RemoteFile> files,...
method AddFile (line 38) | private static void AddFile(this ICollection<RemoteFile> files, Genome...
FILE: Downloader/IClient.cs
type IClient (line 8) | public interface IClient
method DownloadLines (line 10) | List<string> DownloadLines(string remotePath);
method SetMetadata (line 11) | bool SetMetadata(RemoteFile file);
method DownloadFile (line 12) | bool DownloadFile(RemoteFile file);
FILE: Downloader/Manifest.cs
class Manifest (line 7) | public static class Manifest
method GetRemotePaths (line 9) | public static Dictionary<GenomeAssembly, List<string>> GetRemotePaths(...
method CreateGenomeAssemblyPaths (line 26) | internal static IEnumerable<(GenomeAssembly GenomeAssembly, string Man...
FILE: Downloader/OutputDirectory.cs
class OutputDirectory (line 11) | public static class OutputDirectory
method Create (line 13) | public static (string Cache, string Reference, string SupplementaryAnn...
method CreateGenomeAssemblySubdirectories (line 28) | private static void CreateGenomeAssemblySubdirectories(string topLevel...
method Cleanup (line 38) | public static void Cleanup(IEnumerable<RemoteFile> files, IEnumerable<...
method GetReferenceFiles (line 58) | private static IEnumerable<string> GetReferenceFiles(string references...
method GetExistingFiles (line 64) | private static IEnumerable<string> GetExistingFiles(IEnumerable<string...
method RemoveOldFiles (line 82) | public static void RemoveOldFiles(IEnumerable<RemoteFile> files)
method HasOlderFile (line 114) | private static bool HasOlderFile(in DateTimeOffset localOffset, DateTi...
method HasDifferentFileSize (line 117) | private static bool HasDifferentFileSize(long localLength, long remote...
method GetNumDownloadBytes (line 119) | public static long GetNumDownloadBytes(IEnumerable<RemoteFile> files)
method RemoveSkippedFiles (line 126) | public static List<RemoteFile> RemoveSkippedFiles(List<RemoteFile> files)
method CheckFiles (line 139) | public static void CheckFiles(IEnumerable<RemoteFile> files)
method GetPaddedField (line 157) | private static string GetPaddedField(string s, int fieldLength)
method PrintStatus (line 163) | private static void PrintStatus(RemoteFile file)
FILE: Downloader/RemoteFile.cs
class RemoteFile (line 5) | public sealed class RemoteFile
method RemoteFile (line 17) | public RemoteFile(string remotePath, string localPath, string descript...
FILE: Downloader/Utilities/ConsoleEmbellishments.cs
class ConsoleEmbellishments (line 5) | public static class ConsoleEmbellishments
method PrintWarning (line 7) | public static void PrintWarning(string s) => Highlight(s, ConsoleColor...
method PrintError (line 9) | public static void PrintError(string s) => Highlight(s, ConsoleColor.R...
method PrintSuccess (line 11) | public static void PrintSuccess(string s) => Highlight(s, ConsoleColor...
method Highlight (line 13) | private static void Highlight(string s, ConsoleColor color)
FILE: Downloader/Utilities/DiskSpaceUtilities.cs
class DiskSpaceUtilities (line 7) | public static class DiskSpaceUtilities
method CheckAvailableDiskSpace (line 9) | public static void CheckAvailableDiskSpace(string outputDirectory, lon...
method GetAbsolutePath (line 28) | private static string GetAbsolutePath(string directoryPath)
method GetDriveWithLongestCommonPrefix (line 39) | private static DriveInfo GetDriveWithLongestCommonPrefix(string absolu...
FILE: Downloader/Utilities/GenomeAssemblyHelper.cs
class GenomeAssemblyHelper (line 7) | public static class GenomeAssemblyHelper
method GetGenomeAssemblies (line 9) | public static List<GenomeAssembly> GetGenomeAssemblies(string genomeAs...
FILE: Downloader/Utilities/ParallelUtilities.cs
class ParallelUtilities (line 10) | public static class ParallelUtilities
method ParallelExecute (line 14) | public static void ParallelExecute(this List<RemoteFile> files, Func<R...
FILE: Downloader/Utilities/SyncUtilities.cs
class SyncUtilities (line 5) | public static class SyncUtilities
method AsSync (line 7) | public static T AsSync<T>(this Task<T> task) => task.ConfigureAwait(fa...
FILE: ErrorHandling/ErrorCategory.cs
type ErrorCategory (line 3) | public enum ErrorCategory
FILE: ErrorHandling/ExceptionUtilities.cs
class ExceptionUtilities (line 7) | public static class ExceptionUtilities
method MakeUserError (line 11) | public static Exception MakeUserError(this Exception e)
method HasException (line 29) | public static bool HasException<T>(Exception e)
method HasErrorMessage (line 35) | public static bool HasErrorMessage(this Exception e, string errorMessage)
method GetInnermostException (line 41) | public static Exception GetInnermostException(Exception e)
method ExceptionToErrorCategory (line 47) | public static ErrorCategory ExceptionToErrorCategory(Exception excepti...
FILE: ErrorHandling/Exceptions/CompressionException.cs
class CompressionException (line 5) | public sealed class CompressionException : Exception
method CompressionException (line 8) | public CompressionException(string message) : base(message) { }
FILE: ErrorHandling/Exceptions/DeploymentErrorException.cs
class DeploymentErrorException (line 5) | public sealed class DeploymentErrorException : Exception
method DeploymentErrorException (line 7) | public DeploymentErrorException(string message) : base(message) { }
FILE: ErrorHandling/Exceptions/FileNotSortedException.cs
class FileNotSortedException (line 5) | public sealed class FileNotSortedException : Exception
method FileNotSortedException (line 8) | public FileNotSortedException(string message) : base(message) { }
FILE: ErrorHandling/Exceptions/InvalidFileFormatException.cs
class InvalidFileFormatException (line 5) | public sealed class InvalidFileFormatException : Exception
method InvalidFileFormatException (line 8) | public InvalidFileFormatException(string message) : base(message) { }
FILE: ErrorHandling/Exceptions/MissingCompressionLibraryException.cs
class MissingCompressionLibraryException (line 5) | public sealed class MissingCompressionLibraryException : Exception
method MissingCompressionLibraryException (line 8) | public MissingCompressionLibraryException(string missingLibraryFilenam...
method GetErrorMessage (line 13) | private static string GetErrorMessage(string missingLibraryFilename)
FILE: ErrorHandling/Exceptions/ProcessLockedFileException.cs
class ProcessLockedFileException (line 5) | public sealed class ProcessLockedFileException : Exception
method ProcessLockedFileException (line 8) | public ProcessLockedFileException(string message) : base(message) { }
FILE: ErrorHandling/Exceptions/UserErrorException.cs
class UserErrorException (line 5) | public sealed class UserErrorException : Exception
method UserErrorException (line 8) | public UserErrorException(string message) : base(message) { }
FILE: ErrorHandling/ExitCodeUtilities.cs
class ExitCodeUtilities (line 8) | public static class ExitCodeUtilities
method ExitCodeUtilities (line 15) | static ExitCodeUtilities()
method GetExitCode (line 39) | internal static ExitCodes GetExitCode(Type exceptionType)
method ShowException (line 49) | public static ExitCodes ShowException(Exception e)
FILE: ErrorHandling/ExitCodes.cs
type ExitCodes (line 7) | public enum ExitCodes
FILE: GeneAnnotationLambda/GeneAnnotationLambda.cs
class GeneAnnotationLambda (line 29) | public class GeneAnnotationLambda
method Run (line 34) | public Stream Run(GeneConfig config, ILambdaContext context)
method HandleException (line 64) | private static Stream HandleException(string id, string snsTopicArn, E...
method GetGeneAnnotation (line 74) | public static string GetGeneAnnotation(GeneConfig input, string saMani...
method GetHeader (line 100) | private static string GetHeader(IProvider geneAnnotationProvider)
method GetNgaFileList (line 115) | public static IEnumerable<string> GetNgaFileList(string saManifestPath...
FILE: GeneAnnotationLambda/GeneResult.cs
class LambdaResponse (line 10) | public static class LambdaResponse
method Create (line 15) | public static Stream Create(string id, string status, string nirvanaJson)
FILE: Genome/Band.cs
type Band (line 3) | public struct Band
method Band (line 9) | public Band(int begin, int end, string name)
method Compare (line 16) | public int Compare(int position)
FILE: Genome/Chromosome.cs
class Chromosome (line 7) | public sealed class Chromosome : IComparable<Chromosome>
method GetEmptyChromosome (line 20) | public static Chromosome GetEmptyChromosome(string name)
method Chromosome (line 29) | public Chromosome(string ucscName, string ensemblName, string refSeqAc...
method Write (line 46) | public void Write(ExtendedBinaryWriter writer)
method Read (line 56) | public static Chromosome Read(ExtendedBinaryReader reader)
method Equals (line 68) | public bool Equals(Chromosome other) => Index == other.Index && Length...
method CompareTo (line 70) | public int CompareTo(Chromosome other) => Index == other.Index ? Lengt...
method GetHashCode (line 72) | public override int GetHashCode()
FILE: Genome/ChromosomeInterval.cs
class ChromosomeInterval (line 3) | public sealed class ChromosomeInterval : IChromosomeInterval
method ChromosomeInterval (line 9) | public ChromosomeInterval(Chromosome chromosome, int start, int end)
FILE: Genome/ContigInfo.cs
class ContigInfo (line 6) | public static class ContigInfo
method GetChromLengthToAssembly (line 65) | private static Dictionary<string, Dictionary<int, GenomeAssembly>> Get...
method GetGenomeAssembly (line 81) | public static GenomeAssembly GetGenomeAssembly(Chromosome chromosome, ...
FILE: Genome/CytogeneticBands.cs
class CytogeneticBands (line 3) | public static class CytogeneticBands
method Find (line 5) | public static string Find(this Band[] bands, Chromosome chromosome, in...
method GetCytogeneticBand (line 23) | private static string GetCytogeneticBand(this Band[] bands, int pos)
method BinarySearch (line 29) | private static int BinarySearch(Band[] array, int position)
FILE: Genome/GenomeAssembly.cs
type GenomeAssembly (line 4) | public enum GenomeAssembly : byte
FILE: Genome/GenomeAssemblyHelper.cs
class GenomeAssemblyHelper (line 6) | public static class GenomeAssemblyHelper
method Convert (line 11) | public static GenomeAssembly Convert(string genomeAssembly)
FILE: Genome/GenomicPosition.cs
type GenomicPosition (line 3) | public struct GenomicPosition
method GenomicPosition (line 8) | public GenomicPosition(Chromosome chromosome, int position)
FILE: Genome/GenomicRange.cs
class GenomicRange (line 3) | public sealed class GenomicRange
method GenomicRange (line 8) | public GenomicRange(GenomicPosition start, GenomicPosition? end)
FILE: Genome/GenomicRangeChecker.cs
class GenomicRangeChecker (line 3) | public sealed class GenomicRangeChecker
method GenomicRangeChecker (line 8) | public GenomicRangeChecker(GenomicRange genomicRange)
method OutOfRange (line 13) | public bool OutOfRange(Chromosome chromosome, int position)
FILE: Genome/IChromosomeInterval.cs
type IChromosomeInterval (line 5) | public interface IChromosomeInterval : IInterval
FILE: Genome/ISequence.cs
type ISequence (line 3) | public interface ISequence
method Substring (line 7) | string Substring(int offset, int length);
FILE: Genome/ReferenceNameUtilities.cs
class ReferenceNameUtilities (line 6) | public static class ReferenceNameUtilities
method GetChromosome (line 8) | public static Chromosome GetChromosome(Dictionary<string, Chromosome> ...
method GetChromosome (line 18) | public static Chromosome GetChromosome(Dictionary<ushort, Chromosome> ...
method IsEmpty (line 28) | public static bool IsEmpty(this Chromosome chromosome) => chromosome.I...
FILE: Genome/SequenceUtilities.cs
class SequenceUtilities (line 6) | public static class SequenceUtilities
method SequenceUtilities (line 11) | static SequenceUtilities()
method GetReverseComplement (line 30) | public static string GetReverseComplement(string bases)
method HasNonCanonicalBase (line 49) | public static bool HasNonCanonicalBase(string bases) => !string.IsNull...
FILE: IO/BufferedBinaryReader.cs
class BufferedBinaryReader (line 7) | public sealed class BufferedBinaryReader : IBufferedBinaryReader
method BufferedBinaryReader (line 24) | public BufferedBinaryReader(Stream stream, bool leaveOpen = false, int...
method FillBuffer (line 37) | private void FillBuffer()
method ReadAsciiString (line 51) | public string ReadAsciiString()
method ReadBoolean (line 57) | public bool ReadBoolean()
method ReadByte (line 63) | public byte ReadByte()
method ReadBytes (line 69) | public byte[] ReadBytes(int numBytes)
method Read (line 78) | private void Read(byte[] buffer, int numBytes)
method ReadOptInt32 (line 102) | public int ReadOptInt32()
method ReadOptUInt16 (line 121) | public ushort ReadOptUInt16()
method ReadUInt16 (line 140) | public unsafe ushort ReadUInt16()
method ReadUInt32 (line 154) | public unsafe uint ReadUInt32()
method Dispose (line 168) | public void Dispose()
FILE: IO/CacheConstants.cs
class CacheConstants (line 4) | public static class CacheConstants
method TranscriptPath (line 18) | public static string TranscriptPath(string prefix) => Combine(prefix, ...
method SiftPath (line 19) | public static string SiftPath(string prefix) => Combine(prefix, ...
method PolyPhenPath (line 20) | public static string PolyPhenPath(string prefix) => Combine(prefix, ...
method BasesPath (line 21) | public static string BasesPath(string prefix) => Combine(prefix, ...
method Combine (line 23) | private static string Combine(string prefix, string suffix) => prefix ...
FILE: IO/ExtendedBinaryReader.cs
class ExtendedBinaryReader (line 7) | public sealed class ExtendedBinaryReader : BinaryReader
method ExtendedBinaryReader (line 9) | public ExtendedBinaryReader(Stream s) : this(s, new UTF8Encoding()) { }
method ExtendedBinaryReader (line 11) | public ExtendedBinaryReader(Stream input, Encoding encoding, bool leav...
method ReadOptUInt16 (line 18) | public ushort ReadOptUInt16()
method ReadOptInt32 (line 38) | public int ReadOptInt32()
method ReadOptInt64 (line 58) | public long ReadOptInt64()
method ReadAsciiString (line 78) | public string ReadAsciiString()
FILE: IO/ExtendedBinaryWriter.cs
class ExtendedBinaryWriter (line 6) | public sealed class ExtendedBinaryWriter : BinaryWriter, IExtendedBinary...
method ExtendedBinaryWriter (line 8) | public ExtendedBinaryWriter(Stream output) : this(output, new UTF8Enco...
method ExtendedBinaryWriter (line 10) | public ExtendedBinaryWriter(Stream output, Encoding encoding, bool lea...
method WriteOpt (line 18) | public void WriteOpt(ushort value)
method WriteOpt (line 34) | public void WriteOpt(int value)
method WriteOpt (line 47) | public void WriteOpt(uint value)
method WriteOpt (line 63) | public void WriteOpt(long value)
method WriteOptAscii (line 79) | public void WriteOptAscii(string s)
FILE: IO/FilePathUtilities.cs
class StringExtensions (line 5) | public static class StringExtensions
method TrimStartToLast (line 7) | public static string TrimStartToLast(this string s, string value, bool...
method TrimEndFromFirst (line 14) | public static string TrimEndFromFirst(this string s, string value, boo...
method GetFileSuffix (line 21) | public static string GetFileSuffix(this string s, bool includeDot) => ...
FILE: IO/FileUtilities.cs
class FileUtilities (line 6) | public static class FileUtilities
method GetReadStream (line 10) | public static FileStream GetReadStream(string path) => new FileStrea...
method GetCreateStream (line 11) | public static FileStream GetCreateStream(string path) => new FileStrea...
method GetStreamReader (line 13) | public static StreamReader GetStreamReader(Stream stream, bool leaveOp...
method GetFileNamesInDir (line 16) | public static string[] GetFileNamesInDir(string directory, string patt...
FILE: IO/HttpUtilities.cs
class HttpUtilities (line 12) | public static class HttpUtilities
method GetLength (line 18) | public static long GetLength(string url)
method TryGetResponse (line 27) | private static HttpWebResponse TryGetResponse(string url)
method ValidateUrl (line 60) | public static void ValidateUrl(string url, bool isUserProvided = true)
method IsWebProtocolErrorException (line 74) | public static bool IsWebProtocolErrorException(Exception exception)
method ProcessHttpRequestWebProtocolErrorException (line 81) | public static Exception ProcessHttpRequestWebProtocolErrorException(Ex...
method GetWebExceptionMessage (line 107) | private static (string Code, string Message) GetWebExceptionMessage(We...
method IsUrl (line 118) | public static bool IsUrl(string path) => path.StartsWith("http", true,...
FILE: IO/IBufferedBinaryReader.cs
type IBufferedBinaryReader (line 5) | public interface IBufferedBinaryReader : IDisposable
method ReadAsciiString (line 7) | string ReadAsciiString();
method ReadBoolean (line 8) | bool ReadBoolean();
method ReadByte (line 9) | byte ReadByte();
method ReadOptInt32 (line 10) | int ReadOptInt32();
method ReadOptUInt16 (line 11) | ushort ReadOptUInt16();
method ReadUInt32 (line 12) | uint ReadUInt32();
FILE: IO/IConnect.cs
type IConnect (line 6) | public interface IConnect
method Connect (line 8) | (HttpWebResponse Response, Stream Stream) Connect(long position);
FILE: IO/IExtendedBinaryWriter.cs
type IExtendedBinaryWriter (line 3) | public interface IExtendedBinaryWriter
method Write (line 5) | void Write(bool b);
method Write (line 6) | void Write(byte b);
method Write (line 7) | void Write(byte[] buffer);
method Write (line 8) | void Write(ushort value);
method Write (line 9) | void Write(uint value);
method WriteOpt (line 10) | void WriteOpt(ushort value);
method WriteOpt (line 11) | void WriteOpt(int value);
method WriteOpt (line 12) | void WriteOpt(long value);
method WriteOptAscii (line 13) | void WriteOptAscii(string s);
FILE: IO/IS3Client.cs
type IS3Client (line 6) | public interface IS3Client
method GetObjectAsync (line 8) | Task<GetObjectResponse> GetObjectAsync(GetObjectRequest getRequest);
method PutObjectAsync (line 9) | Task<PutObjectResponse> PutObjectAsync(PutObjectRequest putRequest);
FILE: IO/ISerializable.cs
type ISerializable (line 3) | public interface ISerializable
method Write (line 5) | void Write(IExtendedBinaryWriter writer);
FILE: IO/LengthStream.cs
class LengthStream (line 11) | public sealed class LengthStream : Stream
method LengthStream (line 16) | public LengthStream(Stream stream, long length)
method Read (line 22) | public override int Read(byte[] buffer, int offset, int count)
method Flush (line 34) | public override void Flush() => th...
method Seek (line 35) | public override long Seek(long offset, SeekOrigin origin) => th...
method SetLength (line 36) | public override void SetLength(long value) => th...
method Write (line 37) | public override void Write(byte[] buffer, int offset, int count) => th...
FILE: IO/Logger.cs
class Logger (line 6) | public static class Logger
method Logger (line 14) | static Logger()
method SetBold (line 20) | public static void SetBold() => Console.ForegroundColor = ConsoleCo...
method ResetColor (line 21) | public static void ResetColor() => Console.ResetColor();
method Silence (line 23) | public static void Silence()
method Log (line 29) | public static void Log(Exception e)
FILE: IO/MD5Stream.cs
class MD5Stream (line 7) | public sealed class MD5Stream : Stream
method MD5Stream (line 15) | public MD5Stream(Stream stream) => _stream = stream;
method Write (line 17) | public override void Write(byte[] buffer, int offset, int count)
method GetFileMetadata (line 24) | public FileMetadata GetFileMetadata()
method Flush (line 37) | public override void Flush() => _stream.Flush();
method Read (line 39) | public override int Read(byte[] buffer, int offset, int count) => thro...
method Seek (line 40) | public override long Seek(long offset, SeekOrigin origin) => thro...
method SetLength (line 41) | public override void SetLength(long value) => thro...
class FileMetadata (line 48) | public sealed class FileMetadata
method FileMetadata (line 53) | public FileMetadata(byte[] md5, long length)
FILE: IO/PersistentConnect.cs
class PersistentConnect (line 7) | public sealed class PersistentConnect : IConnect
method PersistentConnect (line 11) | public PersistentConnect(string url) => _url = url;
method Connect (line 13) | public (HttpWebResponse Response, Stream Stream) Connect(long position)
FILE: IO/PersistentStream.cs
class PersistentStream (line 9) | public sealed class PersistentStream : Stream
method Flush (line 23) | public override void Flush() => _s...
method Seek (line 24) | public override long Seek(long offset, SeekOrigin origin) => _s...
method SetLength (line 25) | public override void SetLength(long value) => _s...
method Write (line 26) | public override void Write(byte[] buffer, int offset, int count) => _s...
method PersistentStream (line 39) | public PersistentStream(IConnect connect, long position)
method ConnectWithRetries (line 46) | private void ConnectWithRetries(long position)
method Disconnect (line 72) | private void Disconnect()
method Read (line 77) | public override int Read(byte[] buffer, int offset, int count)
method PersistentRead (line 95) | private int PersistentRead(byte[] buffer, int offset, int count)
method Log (line 123) | private static void Log(string methodName, Exception e)
method MethodName (line 129) | private static string MethodName([CallerMemberName] string caller = nu...
method Dispose (line 131) | protected override void Dispose(bool disposing)
FILE: IO/PersistentStreamUtils.cs
class PersistentStreamUtils (line 7) | public static class PersistentStreamUtils
method GetReadStream (line 9) | public static Stream GetReadStream(string urlOrPath, long position = 0)
method GetStreams (line 19) | public static List<Stream> GetStreams(List<string> locations)
FILE: IO/SpanBufferBinaryReader.cs
class SpanBufferBinaryReader (line 8) | public static class SpanBufferBinaryReader
method ReadOptUInt16 (line 13) | public static ushort ReadOptUInt16(ref ReadOnlySpan<byte> byteSpan)
method ReadOptInt32 (line 36) | public static int ReadOptInt32(ref ReadOnlySpan<byte> byteSpan)
method ReadOptUInt32 (line 59) | public static uint ReadOptUInt32(ref ReadOnlySpan<byte> byteSpan)
method ReadOptInt64 (line 82) | public static long ReadOptInt64(ref ReadOnlySpan<byte> byteSpan)
method ReadOptUInt64 (line 105) | public static ulong ReadOptUInt64(ref ReadOnlySpan<byte> byteSpan)
method ReadUtf8String (line 128) | public static string ReadUtf8String(ref ReadOnlySpan<byte> byteSpan)
method ReadAsciiString (line 139) | public static string ReadAsciiString(ref ReadOnlySpan<byte> byteSpan)
method SkipString (line 150) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ReadByte (line 158) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ReadBytes (line 166) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ReadInt32 (line 174) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ReadUInt64 (line 182) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
method ReadUInt16 (line 190) | [MethodImpl(MethodImplOptions.AggressiveInlining)]
FILE: IO/UrlUtilities.cs
class UrlUtilities (line 6) | public static class UrlUtilities
method GetPath (line 10) | public static string GetPath(string url) => new Uri(url).LocalPath...
method GetFileName (line 11) | public static string GetFileName(string url) => Path.GetFileName(GetPa...
method UrlCombine (line 13) | public static string UrlCombine(this string prefix, string suffix) =>
FILE: IO/v2/FileType.cs
type FileType (line 3) | public enum FileType : ushort
FILE: IO/v2/Header.cs
type Header (line 8) | public sealed record Header(FileType FileType, ushort FileFormatVersion)
FILE: Intervals/Extensions.cs
class Extensions (line 3) | public static class Extensions
method Overlaps (line 8) | public static bool Overlaps(this IInterval interval1, IInterval interv...
method Overlaps (line 12) | public static bool Overlaps(this IInterval interval, int start, int en...
method Contains (line 15) | public static bool Contains(this IInterval interval1, IInterval interv...
method Intersects (line 18) | public static Interval Intersects(this IInterval interval1, IInterval ...
FILE: Intervals/IInterval.cs
type IInterval (line 3) | public interface IInterval
FILE: Intervals/IIntervalForest.cs
type IIntervalForest (line 3) | public interface IIntervalForest<out T>
method OverlapsAny (line 5) | bool OverlapsAny(ushort refIndex, int begin, int end);
method GetAllOverlappingValues (line 6) | T[] GetAllOverlappingValues(ushort refIndex, int begin, int end);
FILE: Intervals/IIntervalSearch.cs
type IIntervalSearch (line 3) | public interface IIntervalSearch<out T>
method GetAllOverlappingValues (line 5) | T[] GetAllOverlappingValues(int begin, int end);
type Interval (line 8) | public struct Interval<T>
method Interval (line 15) | public Interval(int begin, int end, T value)
method CompareMax (line 26) | public int CompareMax(int position)
method Overlaps (line 35) | public bool Overlaps(int intervalBegin, int intervalEnd)
FILE: Intervals/Interval.cs
type Interval (line 3) | public struct Interval : IInterval
method Interval (line 8) | public Interval(int start, int end)
FILE: Intervals/IntervalArray.cs
class IntervalArray (line 5) | public sealed class IntervalArray<T> : IIntervalSearch<T>
method IntervalArray (line 9) | public IntervalArray(Interval<T>[] array)
method OverlapsAny (line 18) | public bool OverlapsAny(int begin, int end) => GetFirstIndexAny(begin,...
method GetAllOverlappingValues (line 23) | public T[] GetAllOverlappingValues(int begin, int end)
method GetAllOverlappingIntervals (line 29) | public Interval<T>[] GetAllOverlappingIntervals(int begin, int end)
method AddOverlappingValues (line 47) | private T[] AddOverlappingValues(int firstIndex, int begin, int end)
method GetFirstIndex (line 62) | private int GetFirstIndex(int intervalBegin, int intervalEnd)
method GetFirstIndexAny (line 86) | private int GetFirstIndexAny(int intervalBegin, int intervalEnd)
method SetMaxIntervals (line 108) | private void SetMaxIntervals()
FILE: Intervals/IntervalForest.cs
class IntervalForest (line 3) | public sealed class IntervalForest<T> : IIntervalForest<T>
method IntervalForest (line 8) | public IntervalForest(IntervalArray<T>[] intervalArrays)
method OverlapsAny (line 17) | public bool OverlapsAny(ushort refIndex, int begin, int end)
method GetAllOverlappingValues (line 28) | public T[] GetAllOverlappingValues(ushort refIndex, int begin, int end)
method GetAllOverlappingIntervals (line 35) | public Interval<T>[] GetAllOverlappingIntervals(ushort refIndex, int b...
FILE: Intervals/NullIntervalSearch.cs
class NullIntervalSearch (line 3) | public sealed class NullIntervalSearch<T> : IIntervalForest<T>, IInterva...
method OverlapsAny (line 7) | public bool OverlapsAny(ushort refIndex, int begin, int end)
method GetAllOverlappingValues (line 12) | public T[] GetAllOverlappingValues(ushort refIndex, int begin, int end)
method GetAllOverlappingValues (line 21) | public T[] GetAllOverlappingValues(int begin, int end)
FILE: Intervals/OverlapType.cs
type OverlapType (line 3) | public enum OverlapType
type EndpointOverlapType (line 11) | public enum EndpointOverlapType
FILE: Intervals/Utilities.cs
class Utilities (line 5) | public static class Utilities
method Overlaps (line 7) | public static bool Overlaps(int firstStart, int firstEnd, int secondSt...
method Contains (line 10) | public static bool Contains(int firstStart, int firstEnd, int secondSt...
method GetOverlapType (line 14) | public static OverlapType GetOverlapType(int tStart, int tEnd, int vSt...
method GetEndpointOverlapType (line 24) | public static EndpointOverlapType GetEndpointOverlapType(int tStart, i...
method Intersects (line 34) | public static (int Start, int End) Intersects(int firstStart, int firs...
FILE: Jasix/DataStructures/JasixChrIndex.cs
class JasixChrIndex (line 9) | public sealed class JasixChrIndex
method JasixChrIndex (line 17) | public JasixChrIndex(string refName)
method JasixChrIndex (line 25) | public JasixChrIndex(ExtendedBinaryReader reader) : this("")
method ReadInterval (line 41) | private static Interval<long> ReadInterval(ExtendedBinaryReader reader)
method Write (line 50) | public void Write(IExtendedBinaryWriter writer)
method WriteInterval (line 71) | private static void WriteInterval(Interval<long> interval, IExtendedBi...
method Add (line 78) | public void Add(int begin, int end, long filePosition)
method Flush (line 100) | public void Flush()
method FindFirstSmallVariant (line 109) | public long FindFirstSmallVariant(int start, int end)
method FindFirstOverlappingNode (line 118) | private JasixNode FindFirstOverlappingNode(JasixNode searchNode)
method FindLargeVariants (line 144) | public long[] FindLargeVariants(int begin, int end)
FILE: Jasix/DataStructures/JasixCommons.cs
class JasixCommons (line 4) | public static class JasixCommons
FILE: Jasix/DataStructures/JasixIndex.cs
type FileRange (line 10) | public struct FileRange
method FileRange (line 15) | public FileRange(long begin, long end = long.MaxValue)
class JasixIndex (line 22) | public sealed class JasixIndex:IDisposable
method JasixIndex (line 31) | public JasixIndex()
method JasixIndex (line 39) | public JasixIndex(Stream stream) : this()
method Write (line 76) | public void Write(Stream writeStream)
method Flush (line 104) | public void Flush()
method Add (line 112) | public void Add(string chr, int start, int end, long fileLoc, string c...
method BeginSection (line 132) | public void BeginSection(string section, long fileLoc)
method EndSection (line 140) | public void EndSection(string section, long fileLoc)
method GetFirstVariantPosition (line 154) | public long GetFirstVariantPosition(string chr, int start, int end)
method LargeVariantPositions (line 170) | public long[] LargeVariantPositions(string chr, int begin, int end)
method GetChromosomeList (line 180) | public IEnumerable<string> GetChromosomeList()
method ContainsChr (line 185) | public bool ContainsChr(string chr)
method GetIndexChromName (line 190) | public string GetIndexChromName(string chromName)
method GetSectionBegin (line 196) | public long GetSectionBegin(string section)
method GetSectionEnd (line 200) | public long GetSectionEnd(string section)
method Dispose (line 205) | public void Dispose()
method GetSections (line 210) | public IEnumerable<string> GetSections() => _sectionRanges.Keys;
FILE: Jasix/DataStructures/JasixNode.cs
class JasixNode (line 5) | public sealed class JasixNode : IComparable<JasixNode>
method JasixNode (line 11) | public JasixNode(int start, int end, long location)
method JasixNode (line 19) | public JasixNode(ExtendedBinaryReader reader)
method Overlaps (line 27) | public bool Overlaps(JasixNode other)
method CompareTo (line 32) | public int CompareTo(JasixNode other)
method TryAdd (line 39) | public bool TryAdd(int start, int end)
method Write (line 50) | public void Write(IExtendedBinaryWriter writer)
FILE: Jasix/DataStructures/JsonSchema.cs
class JsonSchema (line 10) | public sealed class JsonSchema : IInterval
FILE: Jasix/DataStructures/Utilities.cs
class Utilities (line 11) | public static class Utilities
method ParseQuery (line 17) | public static (string Chromosome, int Start, int End) ParseQuery(strin...
method PrintQuerySectionOpening (line 39) | public static void PrintQuerySectionOpening(string sectionName, Stream...
method PrintQuerySectionClosing (line 44) | public static void PrintQuerySectionClosing(StreamWriter writer)
method PrintJsonEntry (line 49) | public static void PrintJsonEntry(string entry, bool needComma, Stream...
method IsLargeVariant (line 57) | public static bool IsLargeVariant(int start, int end)
method GetJsonEntryEnd (line 62) | public static int GetJsonEntryEnd(JsonSchema jsonEntry)
method IsNucleotideAllele (line 71) | public static bool IsNucleotideAllele(string altAllele)
FILE: Jasix/IndexCreator.cs
class IndexCreator (line 14) | public sealed class IndexCreator : IDisposable
method IndexCreator (line 22) | public IndexCreator(BlockGZipStream readStream, Stream writeStream)
method IndexCreator (line 30) | public IndexCreator(string fileName)
method CreateIndex (line 36) | public void CreateIndex()
method IndexPositions (line 56) | private string IndexPositions(JasixIndex index)
method IndexGenes (line 89) | private void IndexGenes(string lastLine, JasixIndex index)
method IndexHeader (line 111) | private void IndexHeader(JasixIndex index)
method CheckSorting (line 142) | private void CheckSorting(string chr, int pos, string previousChr, int...
method GetChromPosition (line 155) | internal static (string chr, int position, int end) GetChromPosition(s...
method Dispose (line 173) | public void Dispose()
FILE: Jasix/JasixMain.cs
class JasixMain (line 15) | public static class JasixMain
method Main (line 26) | public static int Main(string[] args)
method ProgramExecution (line 84) | private static ExitCodes ProgramExecution()
method ValidateIndexFile (line 135) | private static void ValidateIndexFile(string indexFileName)
FILE: Jasix/OnTheFlyIndexCreator.cs
class OnTheFlyIndexCreator (line 10) | public sealed class OnTheFlyIndexCreator : IDisposable
method OnTheFlyIndexCreator (line 18) | public OnTheFlyIndexCreator(Stream indexStream)
method Add (line 24) | public void Add(IPosition position, long fileLocation)
method BeginSection (line 49) | public void BeginSection(string sectionName, long fileLocation)
method EndSection (line 54) | public void EndSection(string sectionName, long fileLocation)
method Dispose (line 59) | public void Dispose()
method Flush (line 65) | public void Flush()
FILE: Jasix/QueryProcessor.cs
class QueryProcessor (line 13) | public sealed class QueryProcessor:IDisposable
method Dispose (line 24) | public void Dispose()
method QueryProcessor (line 32) | public QueryProcessor(StreamReader jsonReader, Stream indexStream, Str...
method ListChromosomesAndSections (line 42) | public void ListChromosomesAndSections()
method PrintHeaderOnly (line 55) | public void PrintHeaderOnly()
method PrintSection (line 63) | public void PrintSection(string section)
method ProcessQuery (line 75) | public int ProcessQuery(IEnumerable<string> queryStrings, bool printHe...
method PrintAllVariantsFromQueryBegin (line 106) | private int PrintAllVariantsFromQueryBegin((string, int, int) query, b...
method PrintLargeVariantsExtendingIntoQuery (line 118) | private int PrintLargeVariantsExtendingIntoQuery((string, int, int) qu...
method ReadJsonLinesExtendingInto (line 130) | internal IEnumerable<string> ReadJsonLinesExtendingInto((string Chr, i...
method RepositionReader (line 153) | private void RepositionReader(long location)
method GetHeader (line 159) | public string GetHeader()
method GetSectionLines (line 171) | public IEnumerable<string> GetSectionLines(string section)
method ReadOverlappingJsonLines (line 187) | internal IEnumerable<string> ReadOverlappingJsonLines((string Chr, int...
method ParseJsonEntry (line 217) | private static JsonSchema ParseJsonEntry(string line)
FILE: Jist/JistMain.cs
class JistMain (line 9) | public class JistMain
method Main (line 11) | public static int Main(string[] args)
FILE: Jist/JistUtilities.cs
class JistUtilities (line 7) | public static class JistUtilities
method GetCompressedBlock (line 9) | public static byte[] GetCompressedBlock(string s, int compressionLevel=1)
FILE: Jist/JsonStitcher.cs
class JsonStitcher (line 13) | public sealed class JsonStitcher:IDisposable
method JsonStitcher (line 21) | public JsonStitcher(Stream[] jsonStreams, Stream[] jasixStreams, Strea...
method Stitch (line 38) | public int Stitch()
method ReadGeneLines (line 70) | private int ReadGeneLines(Stream jsonStream)
method WriteGeneBlocks (line 90) | private void WriteGeneBlocks(Stream stream)
method WritePositionBlocks (line 114) | private int WritePositionBlocks(Stream jsonStream, Stream jasixStream,
method Dispose (line 164) | public void Dispose()
FILE: MitoHeteroplasmy/MitoHeteroplasmyProvider.cs
class MitoHeteroplasmyProvider (line 12) | public sealed class MitoHeteroplasmyProvider : IMitoHeteroplasmyProvider
method MitoHeteroplasmyProvider (line 27) | public MitoHeteroplasmyProvider()
method Add (line 33) | public void Add(int position, string altAllele, double[] vrfs, int[] a...
method GetVrfPercentiles (line 39) | public double?[] GetVrfPercentiles(IVariant[] variants, double[] vrfs)
method GetVrfPercentile (line 50) | private double? GetVrfPercentile(IVariant variant, double vrf)
method EncodeMitoPositionAndAltAllele (line 64) | private static int EncodeMitoPositionAndAltAllele(int position, string...
method ToRoundedVrf (line 66) | private static double ToRoundedVrf(double vrf) => Math.Round(vrf, 3, M...
FILE: MitoHeteroplasmy/MitoHeteroplasmyReader.cs
class MitoHeteroplasmyReader (line 10) | public static class MitoHeteroplasmyReader
method GetProvider (line 19) | public static MitoHeteroplasmyProvider GetProvider()
FILE: Nirvana/AnnotationFiles.cs
class AnnotationFiles (line 11) | public sealed class AnnotationFiles
method AddFiles (line 24) | public void AddFiles(string saDirectoryPath)
method AddFiles (line 65) | public void AddFiles(SaUrls saUrls)
method GetFiles (line 83) | private static IEnumerable<string> GetFiles(string directoryOrManifest...
FILE: Nirvana/AnnotationResources.cs
class AnnotationResources (line 22) | public sealed class AnnotationResources : IAnnotationResources
method AnnotationResources (line 45) | public AnnotationResources(string refSequencePath, string inputCachePr...
method GetRepeatExpansionProvider (line 107) | private static IRepeatExpansionProvider GetRepeatExpansionProvider(Gen...
method GetDataSourceVersions (line 114) | private static IEnumerable<IDataSourceVersion> GetDataSourceVersions(p...
method SingleVariantPreLoad (line 123) | public void SingleVariantPreLoad(IPosition position)
method GetVariantPositions (line 132) | public void GetVariantPositions(Stream vcfStream, GenomicRange genomic...
method PreLoad (line 143) | public void PreLoad(Chromosome chromosome)
method Dispose (line 151) | public void Dispose()
FILE: Nirvana/Nirvana.cs
class Nirvana (line 19) | public static class Nirvana
method ProgramExecution (line 35) | private static ExitCodes ProgramExecution()
method GetAnnotationResources (line 55) | private static AnnotationResources GetAnnotationResources()
method Main (line 73) | public static int Main(string[] args)
FILE: Nirvana/PreLoadUtilities.cs
class PreLoadUtilities (line 11) | public static class PreLoadUtilities
method GetPositions (line 13) | public static (Dictionary<Chromosome, List<int>> PositionsByChromosome...
method IsRefMinor (line 59) | private static bool IsRefMinor(IRefMinorProvider refMinorProvider, Chr...
method TryAddPosition (line 65) | public static void TryAddPosition(Dictionary<Chromosome, List<int>> ch...
method SortPositionsAndGetCount (line 80) | private static int SortPositionsAndGetCount(Dictionary<Chromosome, Lis...
FILE: Nirvana/ProviderUtilities.cs
class ProviderUtilities (line 18) | public static class ProviderUtilities
method GetSequenceProvider (line 20) | public static ISequenceProvider GetSequenceProvider(string compressedR...
method GetProteinConservationProvider (line 25) | public static ProteinConservationProvider GetProteinConservationProvid...
method GetConservationProvider (line 30) | public static IAnnotationProvider GetConservationProvider(AnnotationFi...
method GetDataAndIndexStreams (line 38) | private static (Stream, Stream) GetDataAndIndexStreams(string dataFile...
method GetLcrProvider (line 55) | public static IAnnotationProvider GetLcrProvider(AnnotationFiles files...
method GetRefMinorProvider (line 60) | public static IRefMinorProvider GetRefMinorProvider(AnnotationFiles fi...
method GetGeneAnnotationProvider (line 68) | public static IGeneAnnotationProvider GetGeneAnnotationProvider(Annota...
method GetNsaProvider (line 72) | public static IAnnotationProvider GetNsaProvider(AnnotationFiles files)
method GetNsaReaders (line 84) | private static INsaReader[] GetNsaReaders(IReadOnlyCollection<(string ...
method GetGsaProvider (line 95) | public static IAnnotationProvider GetGsaProvider(AnnotationFiles files)
method GetNsiReaders (line 116) | private static INsiReader[] GetNsiReaders(IReadOnlyCollection<string> ...
method GetGeneFusionReaders (line 123) | private static IGeneFusionSaReader[] GetGeneFusionReaders(IReadOnlyCol...
method SortByJsonKey (line 132) | private static T[] SortByJsonKey<T>(this IEnumerable<T> entries) where...
method GetTranscriptAnnotationProvider (line 135) | public static ITranscriptAnnotationProvider GetTranscriptAnnotationPro...
FILE: Nirvana/StreamAnnotation.cs
class StreamAnnotation (line 26) | public static class StreamAnnotation
method Annotate (line 28) | public static (int variantCount, ExitCodes exitCode) Annotate(Stream h...
method ReturnPoolObjects (line 99) | private static void ReturnPoolObjects(IAnnotatedPosition annotatedPosi...
method CheckGenomeAssembly (line 121) | private static void CheckGenomeAssembly(IAnnotationResources annotatio...
method SetMitochondrialAnnotationBehavior (line 127) | private static void SetMitochondrialAnnotationBehavior(IAnnotationReso...
method GetVcfReader (line 135) | private static VcfReader GetVcfReader(Stream headerStream, Stream vcfS...
FILE: NirvanaLambda/AnnotationJob.cs
class AnnotationJob (line 14) | public sealed class AnnotationJob
method AnnotationJob (line 27) | public AnnotationJob(ILambdaContext context, int jobIndex)
method Invoke (line 33) | public AnnotationResultSummary Invoke(string functionArn, string funct...
method InvokeAndRetryWhenThrottled (line 46) | private async Task<AnnotationResultSummary> InvokeAndRetryWhenThrottle...
method GetResultSummaryFromSuccessInvocation (line 82) | internal static AnnotationResultSummary GetResultSummaryFromSuccessInv...
method GetAnnotationResult (line 89) | private MemoryStream GetAnnotationResult(InvokeRequest invokeRequest)
method CheckRemainingTime (line 109) | private void CheckRemainingTime()
method CheckResponse (line 129) | internal void CheckResponse(InvokeResponse response)
method GetResultSummaryFromFailedInvocation (line 144) | internal AnnotationResultSummary GetResultSummaryFromFailedInvocation(...
FILE: NirvanaLambda/AnnotationResultSummary.cs
class AnnotationResultSummary (line 7) | public sealed class AnnotationResultSummary
method Create (line 14) | public static AnnotationResultSummary Create(AnnotationResult annotati...
FILE: NirvanaLambda/NirvanaLambda.cs
class NirvanaLambda (line 34) | public sealed class NirvanaLambda
method Run (line 46) | public NirvanaResult Run(NirvanaConfig config, ILambdaContext context)
method GetAnnotationRanges (line 84) | private static AnnotationRange[] GetAnnotationRanges(NirvanaConfig con...
method HandleException (line 110) | private static NirvanaResult HandleException(StringBuilder runLog, Nir...
method GetNirvanaFailResult (line 117) | private static NirvanaResult GetNirvanaFailResult(StringBuilder runLog...
method GetFailedRunStatus (line 137) | internal static string GetFailedRunStatus(ErrorCategory errorCategory,...
method GetNirvanaResult (line 155) | private static NirvanaResult GetNirvanaResult(AnnotationRange[] annota...
method GetMostSevereErrorCategoryAndMessage (line 182) | private static (ErrorCategory?, string) GetMostSevereErrorCategoryAndM...
method CallAnnotationLambdas (line 201) | private static Task<AnnotationResultSummary>[] CallAnnotationLambdas(N...
method RunAnnotationJob (line 206) | private static Task<AnnotationResultSummary> RunAnnotationJob(NirvanaC...
method DescribeAnnotationRegion (line 217) | private static string DescribeAnnotationRegion(AnnotationRange ar)
method GetAnnotationConfig (line 224) | private static AnnotationConfig GetAnnotationConfig(NirvanaConfig conf...
method GetIndexedPrefix (line 239) | internal static string GetIndexedPrefix(string inputVcfPath, int jobIn...
method FirstCharToLower (line 242) | private static string FirstCharToLower(string input) => string.IsNullO...
FILE: NirvanaLambda/PartitionUtilities.cs
class PartitionUtilities (line 17) | public static class PartitionUtilities
method GetFileOffsets (line 19) | public static List<long> GetFileOffsets(string vcfUrl, int numPartitio...
method GetBlockOffsets (line 26) | private static List<long> GetBlockOffsets(long[] sizeBasedOffsets, Tab...
method FindEqualOrClosestSmallerOffsets (line 33) | internal static List<long> FindEqualOrClosestSmallerOffsets(long[] siz...
method GetEqualSizeOffsets (line 54) | internal static long[] GetEqualSizeOffsets(long fileSize, int numParti...
method GetAllLinearFileOffsets (line 65) | private static long[] GetAllLinearFileOffsets(Tabix.Index tabixIndex)
method MergeConsecutiveEqualValues (line 72) | public static IEnumerable<T> MergeConsecutiveEqualValues<T>(IEnumerabl...
method GenerateAnnotationRanges (line 86) | public static AnnotationRange[] GenerateAnnotationRanges(List<long> bl...
method AdjustPartitionGenomicStarts (line 96) | private static AnnotationPosition[] AdjustPartitionGenomicStarts(IRead...
method GetRanges (line 117) | private static AnnotationRange[] GetRanges(AnnotationPosition[] adjust...
method GetFirstGenomicPosition (line 135) | private static AnnotationPosition GetFirstGenomicPosition(Stream vcfSt...
method FindProperStartPosition (line 161) | private static AnnotationPosition FindProperStartPosition(AnnotationPo...
FILE: OptimizedCore/ExpandableArray.cs
class ExpandableArray (line 5) | public static class ExpandableArray<T>
method Get (line 7) | public static T[] Get(int size)
method Resize (line 13) | public static T[] Resize(T[] array, int newSize)
method Return (line 21) | public static void Return(T[] array)
FILE: OptimizedCore/NullSequenceEqual.cs
class NullSequenceEqual (line 3) | public static class NullSequenceEqual
method ArrayEqual (line 5) | public static bool ArrayEqual<T>(this T[] first, T[] second)
FILE: OptimizedCore/StringBuilderPool.cs
class StringBuilderPool (line 6) | public static class StringBuilderPool
method Get (line 10) | public static StringBuilder Get()
method GetStringAndReturn (line 17) | public static string GetStringAndReturn(StringBuilder sb)
method Return (line 24) | public static void Return(StringBuilder sb)
FILE: OptimizedCore/StringExtensions.cs
class StringExtensions (line 5) | public static class StringExtensions
method OptimizedSplit (line 7) | public static unsafe string[] OptimizedSplit(this string s, char delim...
method OptimizedKeyValue (line 43) | public static (string Key, string Value) OptimizedKeyValue(this string s)
method OptimizedParseInt32 (line 52) | public static unsafe (int Number, bool FoundError) OptimizedParseInt32...
method OptimizedStartsWith (line 98) | public static bool OptimizedStartsWith(this string s, char ch) => s.Le...
method OptimizedEndsWith (line 100) | public static bool OptimizedEndsWith(this string s, char ch) => s.Leng...
FILE: ReferenceSequence/Commands/CreateReferenceMain.cs
class CreateReferenceMain (line 18) | public static class CreateReferenceMain
method ProgramExecution (line 28) | private static ExitCodes ProgramExecution()
method GetGenomeLength (line 75) | private static long GetGenomeLength(IEnumerable<FastaSequence> fastaSe...
method CreateReferenceSequences (line 78) | private static List<Creation.ReferenceSequence> CreateReferenceSequenc...
method CheckChrYPadding (line 94) | private static void CheckChrYPadding(IEnumerable<FastaSequence> fastaS...
method GetFastaSequences (line 108) | private static List<FastaSequence> GetFastaSequences(string fastaPrefi...
method CheckReferenceIndexContiguity (line 126) | private static void CheckReferenceIndexContiguity(IEnumerable<Chromoso...
method CreateReferenceSequenceFile (line 144) | private static void CreateReferenceSequenceFile(GenomeAssembly genomeA...
method CountNs (line 154) | private static int CountNs(string s)
method Run (line 161) | public static ExitCodes Run(string command, string[] args)
FILE: ReferenceSequence/Commands/CreateSubstringMain.cs
class CreateSubstringMain (line 18) | public static class CreateSubstringMain
method ProgramExecution (line 30) | private static ExitCodes ProgramExecution()
method GetCytogeneticBands (line 63) | private static List<Band> GetCytogeneticBands(ushort refIndex, int num...
method CreateReferenceSequenceFile (line 74) | private static void CreateReferenceSequenceFile(GenomeAssembly genomeA...
method CreateReferenceSequence (line 83) | private static Creation.ReferenceSequence CreateReferenceSequence(Fast...
method GetFastaSequence (line 90) | private static FastaSequence GetFastaSequence(string fastaPath, Dictio...
method Run (line 107) | public static ExitCodes Run(string command, string[] args)
FILE: ReferenceSequence/Commands/CreateTestSeqMain.cs
class CreateTestSeqMain (line 16) | public static class CreateTestSeqMain
method ProgramExecution (line 20) | private static ExitCodes ProgramExecution()
method CreateReferenceSequenceFile (line 41) | private static void CreateReferenceSequenceFile(GenomeAssembly genomeA...
method CreateReferenceSequence (line 50) | private static Creation.ReferenceSequence CreateReferenceSequence(Fast...
method Run (line 56) | public static ExitCodes Run(string command, string[] args)
FILE: ReferenceSequence/Common/IndexEntry.cs
class IndexEntry (line 3) | internal sealed class IndexEntry
method IndexEntry (line 10) | internal IndexEntry(ushort refIndex, long fileOffset)
FILE: ReferenceSequence/Common/MaskedEntry.cs
class MaskedEntry (line 3) | internal sealed class MaskedEntry
method MaskedEntry (line 8) | internal MaskedEntry(int begin, int end)
FILE: ReferenceSequence/Common/Sequence.cs
class Sequence (line 7) | public sealed class Sequence : ISequence
method Sequence (line 22) | public Sequence()
method GetBaseIndexAndShift (line 29) | private static (int BaseIndex, int Shift) GetBaseIndexAndShift(int ref...
method GetNumBufferBytes (line 37) | internal static int GetNumBufferBytes(int numBases) =>
method EnableNSequence (line 40) | public void EnableNSequence() => _useNSequence = true;
method Set (line 42) | internal void Set(int length, int sequenceOffset, byte[] twoBitBuffer,
method Substring (line 53) | public string Substring(int offset, int length)
method MaskBases (line 116) | private int MaskBases(int offset, int length, int baseIndex, MaskedEnt...
FILE: ReferenceSequence/Compression/TwoBitCompressor.cs
class TwoBitCompressor (line 6) | internal static class TwoBitCompressor
method TwoBitCompressor (line 11) | static TwoBitCompressor()
method GetNumBufferBytes (line 23) | private static int GetNumBufferBytes(int numBases) => (int)(numBases /...
method Compress (line 25) | public static (byte[] Buffer, MaskedEntry[] MaskedEntries) Compress(st...
FILE: ReferenceSequence/Creation/FastaSequence.cs
class FastaSequence (line 5) | internal sealed class FastaSequence
method FastaSequence (line 10) | internal FastaSequence(Chromosome chromosome, string bases)
FILE: ReferenceSequence/Creation/ReferenceBuffer.cs
class ReferenceBuffer (line 3) | public sealed class ReferenceBuffer
method ReferenceBuffer (line 9) | public ReferenceBuffer(ushort refIndex, byte[] buffer, int bufferSize)
FILE: ReferenceSequence/Creation/ReferenceDictionaryUtils.cs
class ReferenceDictionaryUtils (line 7) | internal static class ReferenceDictionaryUtils
method GetRefNameToChromosome (line 9) | internal static Dictionary<string, Chromosome> GetRefNameToChromosome(...
FILE: ReferenceSequence/Creation/ReferenceSequence.cs
class ReferenceSequence (line 9) | internal sealed class ReferenceSequence
method ReferenceSequence (line 17) | internal ReferenceSequence(byte[] buffer, MaskedEntry[] maskedEntries,...
method GetReferenceBuffer (line 27) | internal ReferenceBuffer GetReferenceBuffer(ushort refIndex)
method WriteMetadata (line 50) | private void WriteMetadata(IExtendedBinaryWriter writer)
method WriteCytogeneticBands (line 56) | private void WriteCytogeneticBands(IExtendedBinaryWriter writer)
method WriteMaskedEntries (line 68) | private void WriteMaskedEntries(IExtendedBinaryWriter writer)
method WriteBuffer (line 79) | private void WriteBuffer(IExtendedBinaryWriter writer)
FILE: ReferenceSequence/IO/AssemblyReader.cs
class AssemblyReader (line 9) | public static class AssemblyReader
method GetChromosomes (line 17) | public static List<Chromosome> GetChromosomes(Stream stream, Dictionar...
method Sanitize (line 46) | private static string Sanitize(this string s) => s == "na" ? null : s;
method GetRefIndex (line 48) | private static ushort GetRefIndex(Dictionary<string, Chromosome> refNa...
FILE: ReferenceSequence/IO/CytogeneticBandsReader.cs
class CytogeneticBandsReader (line 7) | public static class CytogeneticBandsReader
method GetCytogeneticBands (line 9) | public static List<Band>[] GetCytogeneticBands(Stream stream, int numR...
FILE: ReferenceSequence/IO/FastaReader.cs
class FastaReader (line 11) | internal static class FastaReader
method AddReferenceSequences (line 21) | internal static void AddReferenceSequences(Stream stream, Dictionary<s...
method GetBases (line 45) | private static string GetBases(StringBuilder sb, StreamReader reader, ...
method GetChromosome (line 66) | private static Chromosome GetChromosome(Dictionary<string, Chromosome>...
method GetName (line 78) | private static string GetName(string s)
FILE: ReferenceSequence/IO/ReferenceNamesReader.cs
class ReferenceNamesReader (line 9) | public static class ReferenceNamesReader
method GetReferenceNames (line 15) | public static List<Chromosome> GetReferenceNames(Stream stream)
FILE: ReferenceSequence/IO/ReferenceSequenceReader.cs
class CompressedSequenceReader (line 12) | public sealed class CompressedSequenceReader : IDisposable
method CompressedSequenceReader (line 31) | public CompressedSequenceReader(Stream stream)
method Dispose (line 42) | public void Dispose()
method CheckHeaderVersion (line 48) | private void CheckHeaderVersion()
method GetCompressedSequence (line 59) | public void GetCompressedSequence(Chromosome chromosome)
method GetMetadata (line 87) | private static (int SequenceOffset, int NumBases) GetMetadata(Extended...
method GetCytogeneticBands (line 94) | private static Band[] GetCytogeneticBands(ExtendedBinaryReader reader)
method GetMaskedEntries (line 111) | private static IntervalArray<MaskedEntry> GetMaskedEntries(ExtendedBin...
method GetTwoBitBuffer (line 127) | private static byte[] GetTwoBitBuffer(ExtendedBinaryReader reader)
method LoadHeader (line 133) | private void LoadHeader()
method AddChromosomes (line 140) | private void AddChromosomes()
method LoadIndex (line 149) | private IndexEntry[] LoadIndex()
method AddReferenceName (line 174) | private void AddReferenceName(Chromosome chromosome)
FILE: ReferenceSequence/IO/ReferenceSequenceWriter.cs
class ReferenceSequenceWriter (line 11) | internal sealed class ReferenceSequenceWriter : IDisposable
method ReferenceSequenceWriter (line 16) | internal ReferenceSequenceWriter(Stream stream, IReadOnlyCollection<Ch...
method Dispose (line 23) | public void Dispose() => _writer.Dispose();
method WriteHeader (line 25) | private void WriteHeader(GenomeAssembly genomeAssembly, byte patchLeve...
method Write (line 36) | internal void Write(List<Creation.ReferenceSequence> referenceSequences)
method CreateIndex (line 58) | private static IndexEntry[] CreateIndex(IReadOnlyCollection<ReferenceB...
method WriteIndex (line 74) | private void WriteIndex(IReadOnlyCollection<IndexEntry> indexEntries)
method WriteReferenceBuffers (line 86) | private void WriteReferenceBuffers(IEnumerable<ReferenceBuffer> refere...
FILE: ReferenceSequence/ReferenceSequenceCommon.cs
class ReferenceSequenceCommon (line 3) | public static class ReferenceSequenceCommon
FILE: ReferenceSequence/ReferenceUtilsMain.cs
class ReferenceUtilsMain (line 8) | internal static class ReferenceUtilsMain
method Main (line 10) | private static int Main(string[] args)
FILE: ReferenceSequence/Utilities/SequenceHelper.cs
class SequenceHelper (line 8) | public static class SequenceHelper
method GetDictionaries (line 10) | public static (Dictionary<ushort, Chromosome> refIndexToChromosome, Di...
FILE: RepeatExpansions/IO/RepeatExpansionReader.cs
class RepeatExpansionReader (line 13) | public static class RepeatExpansionReader
method Load (line 26) | public static IIntervalForest<RepeatExpansionPhenotype> Load(Stream st...
method GetPhenotype (line 69) | private static (ushort RefIndex, Interval<RepeatExpansionPhenotype> In...
method GetInterval (line 95) | private static Interval GetInterval(string s)
method CheckHeader (line 104) | private static void CheckHeader(TextReader reader, GenomeAssembly desi...
FILE: RepeatExpansions/IRepeatExpansionProvider.cs
type IRepeatExpansionProvider (line 5) | public interface IRepeatExpansionProvider
method Annotate (line 7) | void Annotate(IAnnotatedPosition annotatedPosition);
FILE: RepeatExpansions/Matcher.cs
class Matcher (line 8) | public sealed class Matcher
method Matcher (line 12) | public Matcher(IIntervalForest<RepeatExpansionPhenotype> phenotypeFore...
method GetMatchingAnnotations (line 14) | public ISupplementaryAnnotation GetMatchingAnnotations(RepeatExpansion...
method ExactMatch (line 34) | private static bool ExactMatch(IInterval variant, IInterval variantPhe...
FILE: RepeatExpansions/PercentileUtilities.cs
class PercentileUtilities (line 7) | public static class PercentileUtilities
method ComputePercentiles (line 9) | public static double[] ComputePercentiles(int valueCount, IReadOnlyLis...
method GetPercentile (line 26) | public static double GetPercentile<T>(T inputValue, T[] referenceValue...
FILE: RepeatExpansions/RepeatExpansionPhenotype.cs
class RepeatExpansionPhenotype (line 8) | public sealed class RepeatExpansionPhenotype
method RepeatExpansionPhenotype (line 22) | public RepeatExpansionPhenotype(ChromosomeInterval chromosomeInterval,...
method GetAnnotation (line 34) | public string GetAnnotation(int repeatNumber)
method GetJson (line 42) | private string GetJson(double percentile, IEnumerable<string> classifi...
method GetClassifications (line 53) | private IEnumerable<string> GetClassifications(int repeatNumber)
FILE: RepeatExpansions/RepeatExpansionProvider.cs
class RepeatExpansionProvider (line 13) | public sealed class RepeatExpansionProvider : IRepeatExpansionProvider
method RepeatExpansionProvider (line 17) | public RepeatExpansionProvider(GenomeAssembly genomeAssembly, Dictiona...
method GetTsvStream (line 27) | private static Stream GetTsvStream(GenomeAssembly genomeAssembly, stri...
method Annotate (line 40) | public void Annotate(IAnnotatedPosition annotatedPosition)
FILE: RepeatExpansions/RepeatExpansionSupplementaryAnnotation.cs
class RepeatExpansionSupplementaryAnnotation (line 7) | public sealed class RepeatExpansionSupplementaryAnnotation : ISupplement...
method RepeatExpansionSupplementaryAnnotation (line 12) | public RepeatExpansionSupplementaryAnnotation(List<string> jsonEntries...
method SerializeJson (line 14) | public void SerializeJson(StringBuilder sb) => sb.Append($"[{string.Jo...
FILE: SAUtils/AAConservation/AaConservationMain.cs
class AaConservationMain (line 14) | public static class AaConservationMain
method Run (line 21) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 64) | private static ExitCodes ProgramExecution()
FILE: SAUtils/AAConservation/AaConservationUtilities.cs
class AaConservationUtilities (line 9) | public static class AaConservationUtilities
method GetTranscriptData (line 11) | public static TranscriptCacheData GetTranscriptData(Dictionary<ushort,...
FILE: SAUtils/AAConservation/ProteinConservationParser.cs
class ProteinConservationParser (line 10) | public sealed class ProteinConservationParser:IDisposable
method ProteinConservationParser (line 24) | public ProteinConservationParser(Stream stream)
method GetItems (line 29) | public IEnumerable<ProteinConservationItem> GetItems()
method ParseHeader (line 55) | private void ParseHeader(string line)
method Dispose (line 65) | public void Dispose()=>_stream?.Dispose();
FILE: SAUtils/AAConservation/ProteinConservationWriter.cs
class ProteinConservationWriter (line 13) | public sealed class ProteinConservationWriter:IDisposable
method ProteinConservationWriter (line 25) | public ProteinConservationWriter(Stream stream, Stream groupStream, Tr...
method Write (line 33) | public void Write(IEnumerable<ProteinConservationItem> items)
method WriteTranscriptGroups (line 80) | private void WriteTranscriptGroups(Dictionary<string, List<string>> tr...
method CheckProteinSetOverlap (line 102) | private static void CheckProteinSetOverlap(Dictionary<string, byte[]> ...
method GetProteinWithUniqueScores (line 113) | private static Dictionary<string, byte[]> GetProteinWithUniqueScores(I...
method Dispose (line 142) | public void Dispose()=>_writer?.Dispose();
FILE: SAUtils/ClinGen/DosageMapRegionItem.cs
class DosageMapRegionItem (line 8) | public sealed class DosageMapRegionItem : ISuppIntervalItem
method DosageMapRegionItem (line 16) | public DosageMapRegionItem(Chromosome chromosome, int start, int end, ...
method GetJsonString (line 25) | public string GetJsonString()
FILE: SAUtils/ClinGen/DosageMapRegionParser.cs
class DosageMapRegionParser (line 13) | public sealed class DosageMapRegionParser : IDisposable
method DosageMapRegionParser (line 27) | public DosageMapRegionParser(Stream stream, Dictionary<string, Chromos...
method Dispose (line 33) | public void Dispose()
method GetItems (line 38) | public IEnumerable<DosageMapRegionItem> GetItems()
method GetDosageMapRegionItem (line 61) | private DosageMapRegionItem GetDosageMapRegionItem(string line, Dictio...
method ParseHeaderLine (line 79) | private void ParseHeaderLine(string line)
method GetColumnIndices (line 84) | private void GetColumnIndices(string line)
method ParseGenomeLocation (line 96) | private static (string chromName, int Start, int End) ParseGenomeLocat...
method ReportStatistics (line 112) | private void ReportStatistics(IEnumerable<DosageMapRegionItem> items)
FILE: SAUtils/ClinGen/DosageMapRegions.cs
class DosageMapRegions (line 16) | public static class DosageMapRegions
method Run (line 22) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 57) | private static ExitCodes ProgramExecution()
FILE: SAUtils/ClinGen/DosageSensitivity.cs
class DosageSensitivity (line 13) | public static class DosageSensitivity
method Run (line 18) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 49) | private static ExitCodes ProgramExecution()
FILE: SAUtils/ClinGen/DosageSensitivityItem.cs
class DosageSensitivityItem (line 8) | public sealed class DosageSensitivityItem : ISuppGeneItem
method DosageSensitivityItem (line 14) | public DosageSensitivityItem(string geneSymbol, int hiScore, int tsScore)
method GetJsonString (line 26) | public string GetJsonString()
FILE: SAUtils/ClinGen/DosageSensitivityParser.cs
class DosageSensitivityParser (line 12) | public sealed class DosageSensitivityParser:IDisposable
method DosageSensitivityParser (line 26) | public DosageSensitivityParser(Stream stream)
method Dispose (line 30) | public void Dispose()
method GetItems (line 35) | public Dictionary<string, List<ISuppGeneItem>> GetItems()
method GetGeneAndScores (line 72) | private ISuppGeneItem GetGeneAndScores(string line)
method MissingIndices (line 83) | private bool MissingIndices()
method ParseHeaderLine (line 91) | private void ParseHeaderLine(string line)
method GetColumnIndices (line 96) | private void GetColumnIndices(string line)
method ReportStatistics (line 106) | private void ReportStatistics(Dictionary<string, List<ISuppGeneItem>> ...
FILE: SAUtils/ClinGen/GeneDiseaseValidity.cs
class GeneDiseaseValidity (line 16) | public static class GeneDiseaseValidity
method Run (line 22) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 59) | private static ExitCodes ProgramExecution()
method GetHgncIdToGeneSymbols (line 82) | private static Dictionary<int, string> GetHgncIdToGeneSymbols()
FILE: SAUtils/ClinGen/GeneDiseaseValidityItem.cs
class GeneDiseaseValidityItem (line 9) | public sealed class GeneDiseaseValidityItem: ISuppGeneItem
method GeneDiseaseValidityItem (line 19) | public GeneDiseaseValidityItem(string geneSymbol, string diseaseId, st...
method GetJsonString (line 29) | public string GetJsonString()
method CompareDate (line 44) | public int CompareDate(GeneDiseaseValidityItem other)
FILE: SAUtils/ClinGen/GeneDiseaseValidityParser.cs
class GeneDiseaseValidityParser (line 11) | public sealed class GeneDiseaseValidityParser: IDisposable
method GeneDiseaseValidityParser (line 29) | public GeneDiseaseValidityParser(Stream stream, Dictionary<int, string...
method Dispose (line 34) | public void Dispose()
method GetItems (line 39) | public Dictionary<string, List<ISuppGeneItem>> GetItems()
method GetLatestAnnotations (line 85) | private static Dictionary<string, List<ISuppGeneItem>> GetLatestAnnota...
method AddLatest (line 102) | private static void AddLatest(Dictionary<string, GeneDiseaseValidityIt...
method GetAnnotationItem (line 112) | private GeneDiseaseValidityItem GetAnnotationItem(string line)
method ReportStatistics (line 136) | private void ReportStatistics(Dictionary<string, List<ISuppGeneItem>> ...
method MissingIndices (line 162) | private bool MissingIndices()
method ParseHeaderLine (line 171) | private void ParseHeaderLine(string line)
FILE: SAUtils/ClinGen/ScoreToDescription.cs
class Data (line 5) | public static class Data
FILE: SAUtils/CosmicGeneFusions/Cache/ReferenceLoader.cs
class ReferenceLoader (line 8) | public static class ReferenceLoader
method GetRefIndexToChromosome (line 10) | public static Dictionary<ushort, Chromosome> GetRefIndexToChromosome(s...
FILE: SAUtils/CosmicGeneFusions/Cache/TranscriptCache.cs
class TranscriptCache (line 12) | public sealed class TranscriptCache
method TranscriptCache (line 16) | public TranscriptCache(Dictionary<string, ITranscript> idToTranscript)...
method Create (line 18) | public static TranscriptCache Create(Stream stream, Dictionary<ushort,...
method GetTranscriptIdToTranscript (line 26) | internal static Dictionary<string, ITranscript> GetTranscriptIdToTrans...
method GetGene (line 50) | public (string GeneId, string GeneSymbol) GetGene(string transcriptId)
method HandleMissingTranscripts (line 62) | internal static (string GeneId, string GeneSymbol) HandleMissingTransc...
FILE: SAUtils/CosmicGeneFusions/Conversion/CosmicConverter.cs
class CosmicConverter (line 8) | public static class CosmicConverter
method Convert (line 10) | public static Dictionary<ulong, string[]> Convert(Dictionary<int, Hash...
method ToJsonArray (line 32) | internal static Dictionary<ulong, string[]> ToJsonArray(this Dictionar...
method GetCosmicGeneFusion (line 40) | internal static (ulong FusionKey, string Json) GetCosmicGeneFusion(int...
method AggregateRawCosmicGeneFusions (line 58) | internal static (int[] PubMedIds, int NumSamples, string HgvsNotation)...
FILE: SAUtils/CosmicGeneFusions/Conversion/CosmicGeneFusion.cs
type CosmicGeneFusion (line 8) | public sealed record CosmicGeneFusion(string id, int numSamples, string[...
type CosmicCount (line 18) | public sealed record CosmicCount(string name, int numSamples);
FILE: SAUtils/CosmicGeneFusions/Conversion/HgvsRnaFixer.cs
class HgvsRnaFixer (line 6) | public static class HgvsRnaFixer
method Fix (line 9) | public static string Fix(string hgvsNotation)
FILE: SAUtils/CosmicGeneFusions/Conversion/HgvsRnaParser.cs
class HgvsRnaParser (line 10) | public static class HgvsRnaParser
method GetTranscripts (line 14) | public static (string[] GeneSymbols, ulong FusionKey) GetTranscripts(s...
method Parse (line 26) | public static (string TranscriptId5, string TranscriptId3) Parse(strin...
FILE: SAUtils/CosmicGeneFusions/Conversion/Histology.cs
class Histology (line 8) | public static class Histology
method GetCounts (line 11) | public static CosmicCount[] GetCounts(HashSet<RawCosmicGeneFusion> fus...
method GetMostSpecificValue (line 34) | private static string GetMostSpecificValue(string primary, string subt...
FILE: SAUtils/CosmicGeneFusions/Conversion/RawCosmicGeneFusion.cs
type RawCosmicGeneFusion (line 3) | public sealed record RawCosmicGeneFusion(int SampleId, int FusionId, str...
FILE: SAUtils/CosmicGeneFusions/Conversion/Site.cs
class Site (line 8) | public static class Site
method GetCounts (line 11) | public static CosmicCount[] GetCounts(HashSet<RawCosmicGeneFusion> fus...
method CombineLevels (line 32) | private static string CombineLevels(string primary, string subtype1) =>
FILE: SAUtils/CosmicGeneFusions/CreateCosmicGeneFusions.cs
class CreateCosmicGeneFusions (line 18) | public static class CreateCosmicGeneFusions
method ProgramExecution (line 27) | private static ExitCodes ProgramExecution()
method WriteGeneFusions (line 57) | private static void WriteGeneFusions(string outputDirectory, Dictionar...
method CreateDataSourceVersion (line 66) | internal static DataSourceVersion CreateDataSourceVersion(string versi...
method Run (line 72) | public static ExitCodes Run(string command, string[] commandArgs)
FILE: SAUtils/CosmicGeneFusions/IO/CosmicGeneFusionParser.cs
class CosmicGeneFusionParser (line 7) | public static class CosmicGeneFusionParser
method Parse (line 11) | public static Dictionary<int, HashSet<RawCosmicGeneFusion>> Parse(Stre...
method GroupByFusionId (line 49) | private static Dictionary<int, HashSet<RawCosmicGeneFusion>> GroupByFu...
method RemoveUnderlines (line 67) | internal static string RemoveUnderlines(string s) => s.Replace('_', ' ');
FILE: SAUtils/CosmicGeneFusions/IO/GeneFusionJsonWriter.cs
class GeneFusionJsonWriter (line 13) | public sealed class GeneFusionJsonWriter : IDisposable
method GeneFusionJsonWriter (line 17) | public GeneFusionJsonWriter(Stream stream, string jsonKey, IDataSource...
method WriteHeader (line 25) | private void WriteHeader()
method Write (line 31) | public void Write(Dictionary<ulong, string[]> geneKeyToJson)
method Dispose (line 50) | public void Dispose() => _writer.Dispose();
FILE: SAUtils/CosmicGeneFusions/Utilities/CosmicCountUtilities.cs
class CosmicCountUtilities (line 6) | public static class CosmicCountUtilities
method GetCosmicCounts (line 8) | public static CosmicCount[] GetCosmicCounts(this Dictionary<string, in...
FILE: SAUtils/CreateClinvarDb/ClinVarMain.cs
class ClinVarMain (line 14) | public static class ClinVarMain
method Run (line 20) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 62) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateClinvarDb/ClinVarStats.cs
class ClinVarStats (line 15) | public class ClinVarStats
method GetClinvarSaItemsStats (line 25) | public void GetClinvarSaItemsStats(List<IClinVarSaItem> items)
method ToString (line 54) | public override string ToString()
FILE: SAUtils/CreateCosmicDb/Main.cs
class Main (line 13) | public static class Main
method Run (line 20) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 64) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateDbsnpDb/Main.cs
class Main (line 15) | public static class Main
method Run (line 20) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 58) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateDecipherDb/Main.cs
class Main (line 16) | public static class Main
method Run (line 22) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 60) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateGlobalAllelesDb/Main.cs
class Main (line 14) | public static class Main
method Run (line 19) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 57) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateGmeDb/Main.cs
class Main (line 14) | public static class Main
method Run (line 19) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 57) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateOneKgDb/Main.cs
class Main (line 14) | public static class Main
method Run (line 20) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 58) | private static ExitCodes ProgramExecution()
FILE: SAUtils/CreateTopMedDb/Main.cs
class Main (line 14) | public static class Main
method Run (line 19) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 57) | private static ExitCodes ProgramExecution()
FILE: SAUtils/Custom/AllowedValues.cs
class AllowedValues (line 7) | public static class AllowedValues
method ValidatePredictionValue (line 26) | public static void ValidatePredictionValue(string value, string line)
method ValidateFilterValue (line 32) | public static void ValidateFilterValue(string value, string line) => C...
method ValidateIdentifierValue (line 34) | public static void ValidateIdentifierValue(string value, string line) ...
method ValidateDescriptionValue (line 36) | public static void ValidateDescriptionValue(string value, string line)...
method ValidateScoreValue (line 38) | public static void ValidateScoreValue(string value, string line)
method IsEmptyValue (line 51) | public static bool IsEmptyValue(string value) => EmptyValues.Contains(...
method CheckValueLength (line 53) | private static void CheckValueLength(string value, string line, int ma...
FILE: SAUtils/Custom/CaUtilities.cs
class CaUtilities (line 16) | public static class CaUtilities
method GetNsaWriter (line 18) | public static NsaWriter GetNsaWriter(Stream nsaStream, Stream indexStr...
method GetNsiWriter (line 38) | public static NsiWriter GetNsiWriter(Stream nsiStream, DataSourceVersi...
method GetNgaWriter (line 40) | public static NgaWriter GetNgaWriter(Stream ngaStream, GeneAnnotations...
method WriteSmallVariants (line 47) | public static (string JsonTag, int NsaItemsCount, SaJsonSchema Interva...
method GetInputFileName (line 57) | public static string GetInputFileName(string inputFilePath)
FILE: SAUtils/Custom/CustomGene.cs
class CustomGene (line 9) | public sealed class CustomGene : ISuppGeneItem
method CustomGene (line 17) | public CustomGene(string geneSymbol, List<string[]> values, SaJsonSche...
method GetJsonString (line 25) | public string GetJsonString()
FILE: SAUtils/Custom/GeneAnnotationsParser.cs
class GeneAnnotationsParser (line 16) | public sealed class GeneAnnotationsParser : IDisposable
method GeneAnnotationsParser (line 41) | internal GeneAnnotationsParser(StreamReader reader, Dictionary<string,...
method Create (line 48) | public static GeneAnnotationsParser Create(StreamReader reader, Dictio...
method ParseHeaderLines (line 59) | internal void ParseHeaderLines()
method InitiateSchema (line 91) | private void InitiateSchema()
method CheckTagsAndSetJsonKeys (line 96) | private void CheckTagsAndSetJsonKeys()
method AddHeaderAnnotation (line 111) | private void AddHeaderAnnotation()
method GetItems (line 121) | public Dictionary<string, List<ISuppGeneItem>> GetItems(bool skipGeneI...
method AddItem (line 145) | private void AddItem(string line, Dictionary<string, List<ISuppGeneIte...
method GetUnknownGenes (line 179) | public IReadOnlyList<string> GetUnknownGenes() => _unknownGenes.OrderB...
method Dispose (line 180) | public void Dispose() => _reader?.Dispose();
FILE: SAUtils/Custom/GeneMain.cs
class GeneMain (line 13) | public static class GeneMain
method Run (line 20) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 61) | private static ExitCodes ProgramExecution()
method GetOutputPrefix (line 85) | private static string GetOutputPrefix(string inputFilePath)
method GetInputFileName (line 93) | private static string GetInputFileName(string inputFilePath)
FILE: SAUtils/Custom/ParserUtilities.cs
class ParserUtilities (line 10) | public static class ParserUtilities
method ParseMatchVariantsBy (line 12) | public static (bool MatchByAllele, bool IsArray, SaJsonValueType Prima...
method ParseTags (line 50) | public static string[] ParseTags(string line, string prefix, int numRe...
method ParseCategories (line 62) | public static CustomAnnotationCategories[] ParseCategories(string line...
method ParseDescriptions (line 117) | public static string[] ParseDescriptions(string line, int numRequiredC...
method ParseTypes (line 133) | public static SaJsonValueType[] ParseTypes(string line, int numRequire...
method CheckPrefix (line 162) | internal static void CheckPrefix(string line, string prefix)
method CheckJsonTagConflict (line 168) | public static bool CheckJsonTagConflict(string value)
FILE: SAUtils/Custom/VariantAnnotationsParser.cs
class VariantAnnotationsParser (line 19) | public sealed class VariantAnnotationsParser : IDisposable
method VariantAnnotationsParser (line 61) | internal VariantAnnotationsParser(StreamReader streamReader, ISequence...
method Create (line 68) | public static VariantAnnotationsParser Create(StreamReader streamReade...
method ParseHeaderLines (line 80) | internal void ParseHeaderLines()
method CheckRequiredFields (line 124) | private void CheckRequiredFields(bool hasMatchByLine)
method CheckTagsAndSetJsonKeys (line 137) | private void CheckTagsAndSetJsonKeys()
method CheckPosAndRefColumns (line 152) | internal void CheckPosAndRefColumns()
method CheckAltAndEndColumns (line 158) | internal void CheckAltAndEndColumns()
method GetItems (line 187) | public IEnumerable<CustomItem> GetItems()
method InitiateSchema (line 206) | private void InitiateSchema()
method AddPredefinedTypeAnnotation (line 212) | private void AddPredefinedTypeAnnotation()
method AddHeaderAnnotation (line 221) | private void AddHeaderAnnotation()
method ExtractItems (line 232) | internal CustomItem ExtractItems(string line)
method IsSymbolicAllele (line 286) | private bool IsSymbolicAllele(string altAllele)
method IsInterval (line 291) | private bool IsInterval(string[] splits) => _endColumnIndex != -1 && !...
method CheckAnnotationSorted (line 293) | private void CheckAnnotationSorted(Chromosome chrom, int position, str...
method GetCustomIntervals (line 307) | public List<CustomInterval> GetCustomIntervals() => _intervals.Count >...
method IsValidAltAllele (line 309) | internal static bool IsValidAltAllele(string sequence)
method Dispose (line 322) | public void Dispose()
FILE: SAUtils/Custom/VariantMain.cs
class VariantMain (line 16) | public static class VariantMain
method Run (line 23) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 64) | private static ExitCodes ProgramExecution()
method GetOutputPrefix (line 111) | private static string GetOutputPrefix(string inputFilePath)
FILE: SAUtils/Dann/Create.cs
class Create (line 16) | public static class Create
method Run (line 22) | public static ExitCodes Run(string command, string[] commandArgs)
method ProgramExecution (line 59) | private static ExitCodes ProgramExecution()
FILE: SAUtils/DataStructures/AlleleFrequencyItem.cs
class AlleleFrequencyItem (line 7) | public sealed class AlleleFrequencyItem:ISupplementaryDataItem
method AlleleFrequencyItem (line 16) | public AlleleFrequencyItem(Chromosome chromosome, int position, string...
method GetJsonString (line 26) | public string GetJsonString()
FILE: SAUtils/DataStructures/AncestralAlleleItem.cs
class AncestralAlleleItem (line 6) | public sealed class AncestralAlleleItem: ISupplementaryDataItem
method AncestralAlleleItem (line 15) | public AncestralAlleleItem(Chromosome chromosome, int position, string...
method GetJsonString (line 25) | public string GetJsonString()
FILE: SAUtils/DataStructures/ClinGenItem.cs
type ClinicalInterpretation (line 10) | public enum ClinicalInterpretation
class ClinGenItem (line 22) | public sealed class ClinGenItem:ISuppIntervalItem
method ClinGenItem (line 41) | public ClinGenItem(string id, Chromosome chromosome, int start, int en...
method GetJsonString (line 59) | public string GetJsonString()
method GetClinicalDescription (line 81) | private static string GetClinicalDescription(ClinicalInterpretation cl...
FILE: SAUtils/DataStructures/ClinVarItem.cs
class ClinVarItem (line 12) | public sealed class ClinVarItem : IClinVarSaItem
method ClinVarItem (line 38) | public ClinVarItem(Chromosome chromosome,
method GetJsonString (line 80) | public string GetJsonString()
method GetValues (line 85) | private List<string[]> GetValues()
method CompareTo (line 108) | public int CompareTo(IClinVarSaItem other)
FILE: SAUtils/DataStructures/ComputingUtilities.cs
class ComputingUtilities (line 6) | public static class ComputingUtilities
method ComputeFrequency (line 8) | public static string ComputeFrequency(int? alleleNumber, int? alleleCo...
method GetCoverage (line 15) | public static int GetCoverage(double depth, double allAlleleNumber)
FILE: SAUtil
Condensed preview — 1266 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,944K chars).
[
{
"path": ".gitattributes",
"chars": 16,
"preview": "*.dat binary"
},
{
"path": ".gitignore",
"chars": 4323,
"preview": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n\n# User"
},
{
"path": "AnnotationLambda/AnnotationLambda.cs",
"chars": 9617,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.IO.Compression;\r\nusing System.Security."
},
{
"path": "AnnotationLambda/AnnotationLambda.csproj",
"chars": 1239,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\r\n <PropertyGroup>\r\n <TargetFramework>net6.0</TargetFramework>\r\n <GenerateRunti"
},
{
"path": "AnnotationLambda/AssemblyInfo.cs",
"chars": 86,
"preview": "using System.Runtime.CompilerServices;\r\n\r\n[assembly: InternalsVisibleTo(\"UnitTests\")]"
},
{
"path": "AnnotationLambda/S3Utilities.cs",
"chars": 342,
"preview": "namespace AnnotationLambda\r\n{\r\n public static class S3Utilities\r\n {\r\n public static string GetKey(string o"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3220,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "CONTRIBUTING.md",
"chars": 9235,
"preview": "This guide provides:\n* protocols for contributing new features or bug fixes\n* high-level information about our developme"
},
{
"path": "CacheUtils/AssemblyInfo.cs",
"chars": 84,
"preview": "using System.Runtime.CompilerServices;\n\n[assembly: InternalsVisibleTo(\"UnitTests\")]"
},
{
"path": "CacheUtils/BuildCache.sh",
"chars": 3613,
"preview": "#!/bin/sh\r\n\r\n# =============\r\n# configuration\r\n# =============\r\n\r\nDOTNET=dotnet\r\nRELEASE_DIR=/d/Projects/NirvanaCacheUti"
},
{
"path": "CacheUtils/CacheUtils.cs",
"chars": 2034,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Commands.CombineCacheDirectories;\r\nusing CacheUtils.Commands.Create"
},
{
"path": "CacheUtils/CacheUtils.csproj",
"chars": 1185,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\r\n <PropertyGroup>\r\n <OutputType>Exe</OutputType>\r\n <TargetFramework>net6.0</Ta"
},
{
"path": "CacheUtils/CacheUtils.dll.gene.json",
"chars": 393,
"preview": "{ \r\n \"GRCh37\":{ \r\n \"ReferencePath\":\"Homo_sapiens.GRCh37.Nirvana.dat\",\r\n \"EnsemblCachePath\":\"Ensembl_GRCh37"
},
{
"path": "CacheUtils/Commands/CombineCacheDirectories/CombineCacheDirectoriesMain.cs",
"chars": 12623,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.IO.Compression;\r\nusing System.Linq;\r\nu"
},
{
"path": "CacheUtils/Commands/CreateCache/CreateNirvanaDatabaseMain.cs",
"chars": 7796,
"preview": "using System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.Commands.Download;\r\nusing CacheUtils.DataDumper"
},
{
"path": "CacheUtils/Commands/Download/DownloadMain.cs",
"chars": 408,
"preview": "using ErrorHandling;\r\n\r\nnamespace CacheUtils.Commands.Download\r\n{\r\n public static class DownloadMain\r\n {\r\n "
},
{
"path": "CacheUtils/Commands/Download/ExternalFiles.cs",
"chars": 6866,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.Genbank;\r\nusin"
},
{
"path": "CacheUtils/Commands/Download/GenbankFile.cs",
"chars": 1180,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genbank;\r\nusing CacheUtils.Utilities;\r\nusing Comp"
},
{
"path": "CacheUtils/Commands/ExtractTranscripts/ExtractTranscriptsMain.cs",
"chars": 8780,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.MiniCache;\r\nusing CacheUtils.Predi"
},
{
"path": "CacheUtils/Commands/GFF/CreateGffMain.cs",
"chars": 3052,
"preview": "using System.Collections.Generic;\nusing CacheUtils.Commands.ParseVepCacheDirectory;\nusing CacheUtils.GFF;\nusing CacheUt"
},
{
"path": "CacheUtils/Commands/GFF/InternalGenes.cs",
"chars": 1015,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.TranscriptCache.Comparers;\r\nusing ErrorHandling.Exceptions;\r\nusing "
},
{
"path": "CacheUtils/Commands/Header/HeaderMain.cs",
"chars": 1973,
"preview": "using System;\nusing CommandLine.Builders;\nusing CommandLine.NDesk.Options;\nusing ErrorHandling;\nusing ErrorHandling.Exc"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/ParseVepCacheDirectoryMain.cs",
"chars": 9788,
"preview": "using CacheUtils.DataDumperImport.DataStructures.Mutable;\r\nusing CacheUtils.IntermediateIO;\r\nusing CommandLine.Builders"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/RegulatoryRegionMerger.cs",
"chars": 1729,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.TranscriptCach"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/TranscriptFilter.cs",
"chars": 16983,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImpo"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/TranscriptIdFilter.cs",
"chars": 1112,
"preview": "using System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\nusing VariantAnnotatio"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/TranscriptMerger.cs",
"chars": 2772,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructures."
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/TranscriptMergerLogger.cs",
"chars": 722,
"preview": "using System;\r\nusing System.IO;\r\n\r\nnamespace CacheUtils.Commands.ParseVepCacheDirectory\r\n{\r\n public sealed class Tra"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/VepCacheParser.cs",
"chars": 5927,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImpo"
},
{
"path": "CacheUtils/Commands/ParseVepCacheDirectory/VepRootDirectory.cs",
"chars": 1890,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing Genome;\r\n\r\nnamespace Cach"
},
{
"path": "CacheUtils/Commands/RegulatoryGFF/CreateRegulatoryGffMain.cs",
"chars": 3588,
"preview": "using System;\nusing System.IO;\nusing CacheUtils.Helpers;\nusing CommandLine.Builders;\nusing CommandLine.NDesk.Options;\nu"
},
{
"path": "CacheUtils/Commands/UniversalGeneArchive/FilePaths.cs",
"chars": 657,
"preview": "namespace CacheUtils.Commands.UniversalGeneArchive\r\n{\r\n // ReSharper disable UnusedAutoPropertyAccessor.Global\r\n "
},
{
"path": "CacheUtils/Commands/UniversalGeneArchive/UniversalGeneArchiveMain.cs",
"chars": 7286,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.IO.Compression;\r\nusing CacheUtils.Commands.Download;\r"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/GenomeSymbolSource.cs",
"chars": 416,
"preview": "namespace CacheUtils.DataDumperImport.DataStructures\r\n{\r\n public enum GeneSymbolSource : byte\r\n {\r\n // ReS"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/IImportNode.cs",
"chars": 199,
"preview": "namespace CacheUtils.DataDumperImport.DataStructures.Import\r\n{\r\n public interface IImportNode\r\n {\r\n string"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/ImportNodeExtensions.cs",
"chars": 1272,
"preview": "using System.IO;\n\nnamespace CacheUtils.DataDumperImport.DataStructures.Import\n{\n public static class ImportNodeExten"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/ListObjectKeyValueNode.cs",
"chars": 425,
"preview": "using System.Collections.Generic;\r\n\r\nnamespace CacheUtils.DataDumperImport.DataStructures.Import\r\n{\r\n public sealed "
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/ObjectKeyValueNode.cs",
"chars": 371,
"preview": "namespace CacheUtils.DataDumperImport.DataStructures.Import\r\n{\r\n public sealed class ObjectKeyValueNode : IImportNod"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/ObjectValueNode.cs",
"chars": 480,
"preview": "using System.Collections.Generic;\r\n\r\nnamespace CacheUtils.DataDumperImport.DataStructures.Import\r\n{\r\n public sealed "
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/StringKeyValueNode.cs",
"chars": 353,
"preview": "namespace CacheUtils.DataDumperImport.DataStructures.Import\r\n{\r\n public sealed class StringKeyValueNode : IImportNod"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Import/StringValueNode.cs",
"chars": 231,
"preview": "namespace CacheUtils.DataDumperImport.DataStructures.Import\r\n{\r\n public sealed class StringValueNode : IListMember\r\n"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Mutable/MutableExon.cs",
"chars": 1345,
"preview": "using System;\r\nusing Genome;\r\nusing Intervals;\r\n\r\nnamespace CacheUtils.DataDumperImport.DataStructures.Mutable\r\n{\r\n "
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Mutable/MutableGene.cs",
"chars": 3361,
"preview": "using System;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing Genome;\r\nusing Intervals;\r\n\r\nnamespace CacheUtils.DataDump"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Mutable/MutableTranscript.cs",
"chars": 5446,
"preview": "using System;\r\nusing Genome;\r\nusing Intervals;\r\nusing VariantAnnotation.Caches.DataStructures;\r\nusing VariantAnnotation"
},
{
"path": "CacheUtils/DataDumperImport/DataStructures/Mutable/MutableTranscriptRegion.cs",
"chars": 941,
"preview": "using IO;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespace CacheUtils.DataDumperImport.DataStructure"
},
{
"path": "CacheUtils/DataDumperImport/FauxRegex/RegexDecisionTree.cs",
"chars": 4561,
"preview": "using System;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.IO;\r\n\r\nnamespace CacheUtils.DataDumperImport.FauxR"
},
{
"path": "CacheUtils/DataDumperImport/IO/DataDumperReader.cs",
"chars": 4870,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Text;\r\nusing CacheUtils.DataDumperImpo"
},
{
"path": "CacheUtils/DataDumperImport/IO/EntryType.cs",
"chars": 456,
"preview": "namespace CacheUtils.DataDumperImport.IO\r\n{\r\n internal enum EntryType\r\n {\r\n DigitKeyValue,\r\n DigitK"
},
{
"path": "CacheUtils/DataDumperImport/Import/Attribute.cs",
"chars": 5073,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Text.RegularExpressions;\r\nusing CacheUtils.DataDumper"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportExon.cs",
"chars": 3357,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\nusing Ca"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportGene.cs",
"chars": 2320,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\nusing Ca"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportIntron.cs",
"chars": 3072,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\nusing In"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportKeys.cs",
"chars": 8193,
"preview": "namespace CacheUtils.DataDumperImport.Import\r\n{\r\n internal static class ImportKeys\r\n {\r\n internal const st"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportMapper.cs",
"chars": 2590,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportMapperPair.cs",
"chars": 4193,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\nusing Ca"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportMapperUnit.cs",
"chars": 1968,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportPairGenomic.cs",
"chars": 1901,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportPrediction.cs",
"chars": 1901,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\n\nnamespace "
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportProteinFunctionPredictions.cs",
"chars": 1931,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportRegulatoryFeature.cs",
"chars": 3745,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\nusing Ca"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportSeqEdits.cs",
"chars": 2478,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\n\r\nnamesp"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportTranscript.cs",
"chars": 12258,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructur"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportTranscriptMapper.cs",
"chars": 2253,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportTranslation.cs",
"chars": 3633,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/DataDumperImport/Import/ImportVariantEffectFeatureCache.cs",
"chars": 4734,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Import;\r\nusing Ca"
},
{
"path": "CacheUtils/DataDumperImport/Utilities/ImportUtilities.cs",
"chars": 1971,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Im"
},
{
"path": "CacheUtils/DataDumperImport/Utilities/MutableTranscriptComparer.cs",
"chars": 6190,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\nusing Inte"
},
{
"path": "CacheUtils/DataDumperImport/Utilities/TranscriptUtilities.cs",
"chars": 2610,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.DataDumperImport.DataStructures.Import;\nusing Cache"
},
{
"path": "CacheUtils/GFF/GeneralAttributes.cs",
"chars": 897,
"preview": "namespace CacheUtils.GFF\r\n{\r\n public sealed class GeneralAttributes : IGeneralAttributes\r\n {\r\n public stri"
},
{
"path": "CacheUtils/GFF/GffCreator.cs",
"chars": 5712,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing Intervals;\r\nusing VariantAnnotation.AnnotatedPositions.Transcri"
},
{
"path": "CacheUtils/GFF/GffGene.cs",
"chars": 688,
"preview": "namespace CacheUtils.GFF\r\n{\r\n public sealed class GffGene : IGffGene\r\n {\r\n public int Start { get; }\r\n "
},
{
"path": "CacheUtils/GFF/GffUtilities.cs",
"chars": 2782,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.Utilities;\r\nusing Interval"
},
{
"path": "CacheUtils/GFF/GffWriter.cs",
"chars": 2913,
"preview": "using System;\r\nusing System.IO;\r\nusing Intervals;\r\n\r\nnamespace CacheUtils.GFF\r\n{\r\n public sealed class GffWriter : I"
},
{
"path": "CacheUtils/GFF/IGeneralAttributes.cs",
"chars": 334,
"preview": "namespace CacheUtils.GFF\r\n{\r\n public interface IGeneralAttributes\r\n {\r\n string GeneId { get; }\r\n st"
},
{
"path": "CacheUtils/GFF/IGffGene.cs",
"chars": 247,
"preview": "using Intervals;\r\n\r\nnamespace CacheUtils.GFF\r\n{\r\n public interface IGffGene : IInterval\r\n {\r\n string Id { "
},
{
"path": "CacheUtils/GFF/IRequiredFields.cs",
"chars": 190,
"preview": "namespace CacheUtils.GFF\r\n{\r\n public interface IRequiredFields\r\n {\r\n string UcscName { get; }\r\n str"
},
{
"path": "CacheUtils/GFF/RequiredFields.cs",
"chars": 468,
"preview": "namespace CacheUtils.GFF\r\n{\r\n public sealed class RequiredFields : IRequiredFields\r\n {\r\n public string Ucs"
},
{
"path": "CacheUtils/Genbank/GenbankEntry.cs",
"chars": 1050,
"preview": "using Intervals;\r\n\r\nnamespace CacheUtils.Genbank\r\n{\r\n public sealed class GenbankEntry\r\n {\r\n public readon"
},
{
"path": "CacheUtils/Genbank/GenbankReader.cs",
"chars": 7456,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing Intervals;\r\nusing OptimizedCore;\r\nusing Varia"
},
{
"path": "CacheUtils/Genbank/GenbankState.cs",
"chars": 152,
"preview": "namespace CacheUtils.Genbank\r\n{\r\n internal enum FeaturesState : byte\r\n {\r\n Unknown,\r\n Cds,\r\n "
},
{
"path": "CacheUtils/Genes/Combiners/CombinerUtils.cs",
"chars": 1441,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.DataStructures;\r\n\r\nnamespace CacheUtils.Gen"
},
{
"path": "CacheUtils/Genes/Combiners/HgncIdCombiner.cs",
"chars": 2618,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing CacheUtils.Genes.Utilities;\r\n\r\nnamespa"
},
{
"path": "CacheUtils/Genes/Combiners/ICombiner.cs",
"chars": 290,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Genes.DataStructures;\r\n\r\nnamespace CacheUtils.Genes.Combiners\r\n{\r\n "
},
{
"path": "CacheUtils/Genes/Combiners/PartitionCombiner.cs",
"chars": 3857,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing CacheUtils.Genes.Utilities;\r\n\r\nnamespa"
},
{
"path": "CacheUtils/Genes/DataStores/AssemblyDataStore.cs",
"chars": 3333,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Commands.Download;\r\nusing CacheUtils.Commands.UniversalGeneArchive;"
},
{
"path": "CacheUtils/Genes/DataStores/EnsemblGtf.cs",
"chars": 1558,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing CacheUtils.Genes.IO;"
},
{
"path": "CacheUtils/Genes/DataStores/GeneInfoData.cs",
"chars": 1134,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing CacheUtils.Genes.IO;\r\nusing CacheUtils"
},
{
"path": "CacheUtils/Genes/DataStores/GlobalCache.cs",
"chars": 3246,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructur"
},
{
"path": "CacheUtils/Genes/DataStores/Hgnc.cs",
"chars": 5921,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.DataStru"
},
{
"path": "CacheUtils/Genes/DataStores/IUpdateHgncData.cs",
"chars": 341,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\n\r\nnamespace CacheUtils.Ge"
},
{
"path": "CacheUtils/Genes/DataStores/RefSeqGff.cs",
"chars": 2351,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing "
},
{
"path": "CacheUtils/Genes/DataStores/UpdateHgncData.cs",
"chars": 659,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\n\r\nnamespace CacheUtils.Ge"
},
{
"path": "CacheUtils/Genes/DataStructures/EnsemblGene.cs",
"chars": 754,
"preview": "using System;\r\nusing Genome;\r\n\r\nnamespace CacheUtils.Genes.DataStructures\r\n{\r\n public sealed class EnsemblGene : IFl"
},
{
"path": "CacheUtils/Genes/DataStructures/GeneInfo.cs",
"chars": 331,
"preview": "namespace CacheUtils.Genes.DataStructures\n{\n public sealed class GeneInfo\n {\n public string Symbol { get; "
},
{
"path": "CacheUtils/Genes/DataStructures/HgncGene.cs",
"chars": 982,
"preview": "\r\nusing Genome;\r\n\r\nnamespace CacheUtils.Genes.DataStructures\r\n{\r\n public sealed class HgncGene : IChromosomeInterval"
},
{
"path": "CacheUtils/Genes/DataStructures/IFlatGene.cs",
"chars": 241,
"preview": "\r\nusing Genome;\r\n\r\nnamespace CacheUtils.Genes.DataStructures\r\n{\r\n public interface IFlatGene<out T>\r\n {\r\n "
},
{
"path": "CacheUtils/Genes/DataStructures/RefSeqGene.cs",
"chars": 1011,
"preview": "\r\nusing Genome;\r\n\r\nnamespace CacheUtils.Genes.DataStructures\r\n{\r\n public sealed class RefSeqGene : IFlatGene<RefSeqG"
},
{
"path": "CacheUtils/Genes/DataStructures/UgaGene.cs",
"chars": 2018,
"preview": "using Genome;\r\nusing Intervals;\r\nusing VariantAnnotation.AnnotatedPositions.Transcript;\r\nusing VariantAnnotation.Caches"
},
{
"path": "CacheUtils/Genes/GeneFlattener.cs",
"chars": 1437,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.DataStructures;\r\n\r\nnamespa"
},
{
"path": "CacheUtils/Genes/GeneMerger.cs",
"chars": 4996,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mu"
},
{
"path": "CacheUtils/Genes/GeneSymbolUpdater.cs",
"chars": 3457,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.DataStru"
},
{
"path": "CacheUtils/Genes/HgncIdConsolidator.cs",
"chars": 1367,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructures."
},
{
"path": "CacheUtils/Genes/HgncIdUpdater.cs",
"chars": 1207,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\nusing Cach"
},
{
"path": "CacheUtils/Genes/IO/EnsemblGtfReader.cs",
"chars": 3740,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing Error"
},
{
"path": "CacheUtils/Genes/IO/GeneInfoReader.cs",
"chars": 3464,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing Optim"
},
{
"path": "CacheUtils/Genes/IO/HgncReader.cs",
"chars": 3164,
"preview": "using System;\nusing System.Collections.Generic;\nusing System.IO;\nusing CacheUtils.Genes.DataStructures;\nusing Genome;\nu"
},
{
"path": "CacheUtils/Genes/IO/RefSeqGffReader.cs",
"chars": 4777,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing Genom"
},
{
"path": "CacheUtils/Genes/IO/UgaGeneReader.cs",
"chars": 2362,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing Genom"
},
{
"path": "CacheUtils/Genes/IO/UgaGeneWriter.cs",
"chars": 669,
"preview": "using System;\r\nusing System.IO;\r\nusing System.Text;\r\nusing CacheUtils.Genes.DataStructures;\r\n\r\nnamespace CacheUtils.Gen"
},
{
"path": "CacheUtils/Genes/UgaAssemblyCombiner.cs",
"chars": 3296,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.Combiner"
},
{
"path": "CacheUtils/Genes/Utilities/DictionaryUtilities.cs",
"chars": 2427,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\n\r\nnamespace CacheUtils.Genes.Utilities\r\n{\r\n publ"
},
{
"path": "CacheUtils/Helpers/BioTypeHelper.cs",
"chars": 6054,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespace Ca"
},
{
"path": "CacheUtils/Helpers/GeneSymbolSourceHelper.cs",
"chars": 1542,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing CacheUtils.DataDumperImport.DataStructures;\r\n\r\nnamespace CacheU"
},
{
"path": "CacheUtils/Helpers/RegulatoryRegionTypeHelper.cs",
"chars": 1511,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing VariantAnnotation.Interface.Caches;\r\n\r\nnamespace CacheUtils.Hel"
},
{
"path": "CacheUtils/Helpers/TranscriptCacheHelper.cs",
"chars": 724,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing Genome;\r\nusing IO;\r\nusing VariantAnnotation.Caches;\r\nusing V"
},
{
"path": "CacheUtils/IntermediateIO/CcdsReader.cs",
"chars": 1583,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing IO;\nusing OptimizedCore;\nusing VariantAnnotation.Utilities;\n\nn"
},
{
"path": "CacheUtils/IntermediateIO/GenbankReader.cs",
"chars": 3415,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genbank;\r\nusing Intervals;\r\nusing "
},
{
"path": "CacheUtils/IntermediateIO/GenbankWriter.cs",
"chars": 1326,
"preview": "using System;\r\nusing System.IO;\r\nusing CacheUtils.Genbank;\r\n\r\nnamespace CacheUtils.IntermediateIO\r\n{\r\n internal seal"
},
{
"path": "CacheUtils/IntermediateIO/IntermediateIoCommon.cs",
"chars": 826,
"preview": "using System.IO;\n\nnamespace CacheUtils.IntermediateIO\n{\n public static class IntermediateIoCommon\n {\n publ"
},
{
"path": "CacheUtils/IntermediateIO/IntermediateIoHeader.cs",
"chars": 2219,
"preview": "using System.IO;\r\nusing Genome;\r\nusing OptimizedCore;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespa"
},
{
"path": "CacheUtils/IntermediateIO/LrgReader.cs",
"chars": 2291,
"preview": "using System.Collections.Generic;\nusing System.IO;\nusing IO;\nusing OptimizedCore;\nusing VariantAnnotation.Utilities;\n\nn"
},
{
"path": "CacheUtils/IntermediateIO/MutableTranscriptReader.cs",
"chars": 10893,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures;\r\n"
},
{
"path": "CacheUtils/IntermediateIO/MutableTranscriptWriter.cs",
"chars": 4729,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mu"
},
{
"path": "CacheUtils/IntermediateIO/PredictionReader.cs",
"chars": 3597,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing Genome;\r\nusing IO;\r\nusing"
},
{
"path": "CacheUtils/IntermediateIO/PredictionWriter.cs",
"chars": 1156,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing Genome;\r\n\r\nnamespace CacheUtils.IntermediateI"
},
{
"path": "CacheUtils/IntermediateIO/RegulatoryRegionReader.cs",
"chars": 2161,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing Genome;\r\nusing IO;\r\nusing OptimizedCore;\r\nusi"
},
{
"path": "CacheUtils/IntermediateIO/RegulatoryRegionWriter.cs",
"chars": 809,
"preview": "using System;\r\nusing System.IO;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespace CacheUtils.Intermed"
},
{
"path": "CacheUtils/MiniCache/DataBundle.cs",
"chars": 3133,
"preview": "using Genome;\nusing IO;\nusing ReferenceSequence.IO;\nusing VariantAnnotation.Caches.DataStructures;\nusing VariantAnnotat"
},
{
"path": "CacheUtils/MiniCache/IStaging.cs",
"chars": 140,
"preview": "using System.IO;\r\n\r\nnamespace CacheUtils.MiniCache\r\n{\r\n public interface IStaging\r\n {\r\n void Write(Stream "
},
{
"path": "CacheUtils/PredictionCache/PredictionCacheBuilder.cs",
"chars": 7747,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructur"
},
{
"path": "CacheUtils/PredictionCache/PredictionCacheStaging.cs",
"chars": 1007,
"preview": "using System.IO;\nusing System.IO.Compression;\nusing CacheUtils.MiniCache;\nusing Compression.Algorithms;\nusing Compressi"
},
{
"path": "CacheUtils/PredictionCache/PredictionCacheWriter.cs",
"chars": 2214,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing Compression.FileHandling;\r\nusing VariantAnnot"
},
{
"path": "CacheUtils/PredictionCache/PredictionExtensions.cs",
"chars": 1676,
"preview": "using System;\r\nusing System.IO;\r\n\r\nnamespace CacheUtils.PredictionCache\r\n{\r\n public static class PredictionExtension"
},
{
"path": "CacheUtils/PredictionCache/PredictionUtilities.cs",
"chars": 2339,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.Genes.Utilities;\r\nusing CacheUtils.TranscriptCach"
},
{
"path": "CacheUtils/PredictionCache/RoundedEntry.cs",
"chars": 753,
"preview": "using System;\r\n\r\nnamespace CacheUtils.PredictionCache\r\n{\r\n public struct RoundedEntry : IEquatable<RoundedEntry>\r\n "
},
{
"path": "CacheUtils/PredictionCache/RoundedEntryPrediction.cs",
"chars": 746,
"preview": "using System.Collections.Generic;\r\nusing VariantAnnotation.Caches.DataStructures;\r\n\r\nnamespace CacheUtils.PredictionCac"
},
{
"path": "CacheUtils/TranscriptCache/CanonicalTranscriptMarker.cs",
"chars": 7084,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImpo"
},
{
"path": "CacheUtils/TranscriptCache/Comparers/GeneComparer.cs",
"chars": 1797,
"preview": "using System.Collections.Generic;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespace CacheUtils.Transc"
},
{
"path": "CacheUtils/TranscriptCache/Comparers/IntervalComparer.cs",
"chars": 488,
"preview": "using System.Collections.Generic;\r\nusing Intervals;\r\n\r\nnamespace CacheUtils.TranscriptCache.Comparers\r\n{\r\n internal "
},
{
"path": "CacheUtils/TranscriptCache/Comparers/RegulatoryRegionComparer.cs",
"chars": 1170,
"preview": "using System.Collections.Generic;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespace CacheUtils.Transc"
},
{
"path": "CacheUtils/TranscriptCache/Comparers/TranscriptRegionComparer.cs",
"chars": 1102,
"preview": "using System.Collections.Generic;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\n\r\nnamespace CacheUtils.Transc"
},
{
"path": "CacheUtils/TranscriptCache/Comparers/UgaGeneComparer.cs",
"chars": 2193,
"preview": "using System.Collections.Generic;\r\nusing CacheUtils.Genes.DataStructures;\r\nusing Intervals;\r\n\r\nnamespace CacheUtils.Tra"
},
{
"path": "CacheUtils/TranscriptCache/NSequence.cs",
"chars": 303,
"preview": "\r\nusing Genome;\r\n\r\nnamespace CacheUtils.TranscriptCache\r\n{\r\n public sealed class NSequence : ISequence\r\n {\r\n "
},
{
"path": "CacheUtils/TranscriptCache/SortExtensions.cs",
"chars": 581,
"preview": "using System.Collections.Generic;\r\nusing System.Linq;\r\nusing Genome;\r\nusing Intervals;\r\n\r\nnamespace CacheUtils.Transcri"
},
{
"path": "CacheUtils/TranscriptCache/TranscriptCacheBuilder.cs",
"chars": 3530,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\nusing C"
},
{
"path": "CacheUtils/TranscriptCache/TranscriptCacheStaging.cs",
"chars": 4587,
"preview": "using System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.MiniCache;\r\nusing CacheUtils."
},
{
"path": "CacheUtils/TranscriptCache/TranscriptCacheUtilities.cs",
"chars": 1943,
"preview": "using System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.Genes.Utilities;\r\nusing CacheUtils.MiniCache;\r\n"
},
{
"path": "CacheUtils/TranscriptCache/TranscriptCacheWriter.cs",
"chars": 4370,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.IO.Compression;\r\nusing System.Text;\r\nu"
},
{
"path": "CacheUtils/TranscriptCache/TranscriptConversionExtensions.cs",
"chars": 2015,
"preview": "using System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructures.Mutable;\r\nusing"
},
{
"path": "CacheUtils/TranscriptCache/TranscriptRegionMerger.cs",
"chars": 7558,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImport.DataStructures."
},
{
"path": "CacheUtils/TranscriptCache/TranscriptRegionValidater.cs",
"chars": 4190,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Linq;\r\nusing CacheUtils.DataDumperImpo"
},
{
"path": "CacheUtils/Utilities/AccessionUtilities.cs",
"chars": 1234,
"preview": "using System;\r\nusing System.IO;\r\nusing VariantAnnotation.Utilities;\r\n\r\nnamespace CacheUtils.Utilities\r\n{\r\n internal "
},
{
"path": "CacheUtils/Utilities/HeaderUtilities.cs",
"chars": 485,
"preview": "using System;\r\nusing Genome;\r\nusing IO;\r\nusing VariantAnnotation.Interface.AnnotatedPositions;\r\nusing VariantAnnotation"
},
{
"path": "CacheUtils/Utilities/RemoteFile.cs",
"chars": 1972,
"preview": "using System;\r\nusing System.IO;\r\nusing System.Net;\r\nusing IO;\r\nusing VariantAnnotation.Utilities;\r\n\r\nnamespace CacheUti"
},
{
"path": "CacheUtils/Utilities/TaskExtensions.cs",
"chars": 1056,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Threading;\r\nusing System.Threading.Tasks;\r\nusing Command"
},
{
"path": "Cloud/AmazonS3ClientWrapper.cs",
"chars": 577,
"preview": "using System.Threading.Tasks;\r\nusing Amazon.S3;\r\nusing Amazon.S3.Model;\r\nusing IO;\r\n\r\nnamespace Cloud\r\n{\r\n public se"
},
{
"path": "Cloud/AssemblyInfo.cs",
"chars": 86,
"preview": "using System.Runtime.CompilerServices;\r\n\r\n[assembly: InternalsVisibleTo(\"UnitTests\")]"
},
{
"path": "Cloud/Cloud.appsettings.json",
"chars": 335,
"preview": "{\n \"DataSource\": {\n \"BaseUrl\": \"http://nirvana-annotations.s3.us-west-2.amazonaws.com/\",\n \"CacheDirecto"
},
{
"path": "Cloud/Cloud.csproj",
"chars": 1215,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\r\n <PropertyGroup>\r\n <TargetFramework>net6.0</TargetFramework>\r\n <OutputPath>.."
},
{
"path": "Cloud/Configuration.cs",
"chars": 895,
"preview": "using Cloud.Utilities;\n\nnamespace Cloud;\nusing Microsoft.Extensions.Configuration;\n\npublic sealed class Configuration\n{\n"
},
{
"path": "Cloud/LambdaUrlHelper.cs",
"chars": 2006,
"preview": "using System;\nusing Cloud.Utilities;\nusing Genome;\nusing IO;\nusing ReferenceSequence;\n\nnamespace Cloud\n{\n public sta"
},
{
"path": "Cloud/Messages/Annotation/AnnotationConfig.cs",
"chars": 844,
"preview": "using System.Collections.Generic;\r\n\r\nnamespace Cloud.Messages.Annotation\r\n{\r\n public sealed class AnnotationConfig\r\n"
},
{
"path": "Cloud/Messages/Annotation/AnnotationPosition.cs",
"chars": 341,
"preview": "namespace Cloud.Messages.Annotation\r\n{\r\n public struct AnnotationPosition\r\n {\r\n public readonly string Chr"
},
{
"path": "Cloud/Messages/Annotation/AnnotationRange.cs",
"chars": 1001,
"preview": "using System.Collections.Generic;\r\nusing Genome;\r\n\r\nnamespace Cloud.Messages.Annotation\r\n\r\n{\r\n public sealed class A"
},
{
"path": "Cloud/Messages/Annotation/AnnotationResult.cs",
"chars": 560,
"preview": "using ErrorHandling;\r\n\r\nnamespace Cloud.Messages.Annotation\r\n{\r\n // ReSharper disable once ClassNeverInstantiated.Gl"
},
{
"path": "Cloud/Messages/Custom/CustomConfig.cs",
"chars": 367,
"preview": "// ReSharper disable InconsistentNaming\r\n\r\nnamespace Cloud.Messages.Custom\r\n{\r\n public sealed class CustomConfig\r\n "
},
{
"path": "Cloud/Messages/Custom/CustomResult.cs",
"chars": 524,
"preview": "namespace Cloud.Messages.Custom\n{\n // ReSharper disable NotAccessedField.Global\n // ReSharper disable Inconsisten"
},
{
"path": "Cloud/Messages/FileList.cs",
"chars": 370,
"preview": "namespace Cloud.Messages\r\n{\r\n // ReSharper disable InconsistentNaming\r\n // ReSharper disable NotAccessedField.Glo"
},
{
"path": "Cloud/Messages/Gene/GeneConfig.cs",
"chars": 755,
"preview": "using ErrorHandling.Exceptions;\nusing IO;\n\nnamespace Cloud.Messages.Gene\n{\n public sealed class GeneConfig\n {\n "
},
{
"path": "Cloud/Messages/JwtFields.cs",
"chars": 266,
"preview": "namespace Cloud.Messages\n{\n public class JwtFields\n {\n // ReSharper disable InconsistentNaming\n publ"
},
{
"path": "Cloud/Messages/Nirvana/NirvanaConfig.cs",
"chars": 2609,
"preview": "using System.Collections.Generic;\r\nusing ErrorHandling.Exceptions;\r\nusing IO;\r\n\r\nnamespace Cloud.Messages.Nirvana\r\n{\r\n "
},
{
"path": "Cloud/Messages/Nirvana/NirvanaResult.cs",
"chars": 478,
"preview": "namespace Cloud.Messages.Nirvana\r\n{\r\n public sealed class NirvanaResult\r\n {\r\n // ReSharper disable Inconsi"
},
{
"path": "Cloud/Messages/S3Path.cs",
"chars": 3597,
"preview": "// ReSharper disable InconsistentNaming\r\n\r\nusing System;\r\nusing Amazon;\r\nusing Amazon.S3;\r\nusing Amazon.S3.Model;\r\nusin"
},
{
"path": "Cloud/Messages/SaUrls.cs",
"chars": 2743,
"preview": "// ReSharper disable InconsistentNaming\r\n\r\nusing System.IO;\r\nusing System.Linq;\r\nusing ErrorHandling.Exceptions;\r\nusing"
},
{
"path": "Cloud/Messages/Single/SingleConfig.cs",
"chars": 470,
"preview": "using System.Collections.Generic;\r\n\r\nnamespace Cloud.Messages.Single\r\n{\r\n public sealed class SingleConfig\r\n {\r\n "
},
{
"path": "Cloud/Messages/Single/SingleVariant.cs",
"chars": 3171,
"preview": "using System.Collections.Generic;\r\nusing ErrorHandling.Exceptions;\r\n\r\nnamespace Cloud.Messages.Single\r\n{\r\n public se"
},
{
"path": "Cloud/Messages/StrValidation/ValidationConfig.cs",
"chars": 379,
"preview": "using IO;\n\nnamespace Cloud.Messages.StrValidation\n{\n public sealed class ValidationConfig\n {\n // ReSharper"
},
{
"path": "Cloud/Messages/StrValidation/ValidationResult.cs",
"chars": 351,
"preview": "namespace Cloud.Messages.StrValidation\n{\n public class ValidationResult\n {\n // ReSharper disable Inconsist"
},
{
"path": "Cloud/Notifications/SNS.cs",
"chars": 807,
"preview": "using System;\r\nusing IO;\r\n\r\nnamespace Cloud.Notifications\r\n{\r\n public static class SNS\r\n {\r\n public static"
},
{
"path": "Cloud/RedactionUtilities.cs",
"chars": 1731,
"preview": "using System.Text.RegularExpressions;\r\n\r\nnamespace Cloud\r\n{\r\n public static class RedactionUtilities\r\n {\r\n "
},
{
"path": "Cloud/Utilities/AwsExceptionUtilities.cs",
"chars": 1653,
"preview": "using System;\r\nusing Amazon.S3;\r\nusing Cloud.Messages;\r\nusing ErrorHandling.Exceptions;\r\n\r\nnamespace Cloud.Utilities\r\n{"
},
{
"path": "Cloud/Utilities/JsonUtilities.cs",
"chars": 746,
"preview": "using System.IO;\r\nusing System.Text;\r\nusing Amazon.Lambda.Serialization.Json;\r\n\r\nnamespace Cloud.Utilities\r\n{\r\n publ"
},
{
"path": "Cloud/Utilities/LambdaUtilities.cs",
"chars": 2031,
"preview": "using System;\r\nusing System.IO;\r\nusing Genome;\r\nusing IO;\r\n\r\nnamespace Cloud.Utilities\r\n{\r\n public static class Lamb"
},
{
"path": "Cloud/Utilities/LogUtilities.cs",
"chars": 1644,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Text;\r\nusing Amazon.Lambda.Core;\r\nusing IO;\r\nusing Newto"
},
{
"path": "Cloud/Utilities/UploadUtilities.cs",
"chars": 2073,
"preview": "using System;\r\nusing System.Security.Cryptography;\r\nusing System.Threading;\r\nusing Amazon.S3.Model;\r\nusing ErrorHandlin"
},
{
"path": "CommandLine/AssemblyInfo.cs",
"chars": 84,
"preview": "using System.Runtime.CompilerServices;\n\n[assembly: InternalsVisibleTo(\"UnitTests\")]"
},
{
"path": "CommandLine/Builders/ConsoleAppBuilder.cs",
"chars": 7183,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing CommandLine.NDesk.Options;\r\nusing CommandLine.Utilities;\r\nusing"
},
{
"path": "CommandLine/Builders/IConsoleAppBuilder.cs",
"chars": 1711,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing CommandLine.NDesk.Options;\r\nusing ErrorHandling;\r\nusing Variant"
},
{
"path": "CommandLine/Builders/ITopLevelAppBuilder.cs",
"chars": 1239,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing ErrorHandling;\r\n\r\nnamespace CommandLine.Builders\r\n{\r\n public"
},
{
"path": "CommandLine/Builders/TopLevelAppBuilder.cs",
"chars": 6465,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing CommandLine.Utilities;\r\nusing ErrorHandling"
},
{
"path": "CommandLine/Builders/TopLevelOption.cs",
"chars": 461,
"preview": "using System;\r\nusing ErrorHandling;\r\n\r\nnamespace CommandLine.Builders\r\n{\r\n public sealed class TopLevelOption\r\n {"
},
{
"path": "CommandLine/Builders/ValidationExtensions.cs",
"chars": 4626,
"preview": "using System;\r\nusing System.Collections.Generic;\r\nusing System.IO;\r\nusing System.Net;\r\nusing ErrorHandling;\r\n\r\nnamespac"
},
{
"path": "CommandLine/CommandLine.csproj",
"chars": 422,
"preview": "<Project Sdk=\"Microsoft.NET.Sdk\">\r\n <PropertyGroup>\r\n <TargetFramework>net6.0</TargetFramework>\r\n <OutputPath>.."
},
{
"path": "CommandLine/NDesk.Options/Options.cs",
"chars": 27340,
"preview": "//\r\n// Options.cs\r\n//\r\n// Authors:\r\n// Jonathan Pryor <jpryor@novell.com>\r\n//\r\n// Copyright (C) 2008 Novell (http://www"
},
{
"path": "CommandLine/Utilities/Benchmark.cs",
"chars": 853,
"preview": "using System;\n\nnamespace CommandLine.Utilities\n{\n public sealed class Benchmark\n {\n private DateTime _star"
},
{
"path": "CommandLine/Utilities/CommandLineUtilities.cs",
"chars": 3698,
"preview": "using System;\r\nusing System.IO;\r\nusing System.Reflection;\r\n\r\nnamespace CommandLine.Utilities\r\n{\r\n public static clas"
},
{
"path": "CommandLine/Utilities/Help.cs",
"chars": 571,
"preview": "using System;\nusing CommandLine.NDesk.Options;\n\nnamespace CommandLine.Utilities\n{\n public static class Help\n {\n "
},
{
"path": "CommandLine/Utilities/MemoryUtilities.cs",
"chars": 1444,
"preview": "using System.Diagnostics;\n\nnamespace CommandLine.Utilities\n{\n public static class MemoryUtilities\n {\n // R"
},
{
"path": "CommandLine/Utilities/OutputHelper.cs",
"chars": 464,
"preview": "using System;\nusing System.IO;\n\nnamespace CommandLine.Utilities\n{\n public static class OutputHelper\n {\n pu"
},
{
"path": "CommandLine/VersionProviders/DefaultVersionProvider.cs",
"chars": 227,
"preview": "using VariantAnnotation.Interface.Providers;\n\nnamespace CommandLine.VersionProviders\n{\n public sealed class DefaultV"
}
]
// ... and 1066 more files (download for full content)
About this extraction
This page contains the full source code of the Illumina/Nirvana GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1266 files (5.3 MB), approximately 1.5M tokens, and a symbol index with 5812 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.