Add support for creating ReferenceSequenceFile from a reference Bundle.

src/main/java/htsjdk/beta/codecs/hapref/fasta/FASTADecoderV1_0.java

@@ -34,8 +34,7 @@ public FASTADecoderV1_0(final Bundle inputBundle) {
  this.displayName = inputBundle.getPrimaryResource().getDisplayName();
  final BundleResource referenceResource = inputBundle.getOrThrow(BundleResourceType.CT_HAPLOID_REFERENCE);
  if (referenceResource.getIOPath().isPresent()) {
- referenceSequenceFile = ReferenceSequenceFileFactory.getReferenceSequenceFile(
- referenceResource.getIOPath().get().toPath(), true);
+ referenceSequenceFile = ReferenceSequenceFileFactory.getReferenceSequenceFileFromBundle(inputBundle, true, true);
  } else {
  final SeekableStream seekableStream = referenceResource.getSeekableStream().orElseThrow(
  () -> new IllegalArgumentException(

src/main/java/htsjdk/beta/io/bundle/BundleResourceType.java

@@ -56,6 +56,7 @@ public class BundleResourceType {
  /** Secondary content types for {@link BundleResourceType#CT_HAPLOID_REFERENCE} resources*/
  public static final String CT_REFERENCE_DICTIONARY = "REFERENCE_DICTIONARY";
  public static final String CT_REFERENCE_INDEX = "REFERENCE_INDEX";
+ public static final String CT_REFERENCE_INDEX_GZI = "REFERENCE_INDEX_GZI";
 
 
  /****************************************** Resource types for FEATURES ********************************/

src/main/java/htsjdk/beta/plugin/registry/HaploidReferenceResolver.java

@@ -9,9 +9,18 @@
 import htsjdk.beta.plugin.hapref.HaploidReferenceCodec;
 import htsjdk.beta.plugin.hapref.HaploidReferenceDecoder;
 import htsjdk.beta.plugin.hapref.HaploidReferenceDecoderOptions;
+import htsjdk.io.HtsPath;
 import htsjdk.io.IOPath;
+import htsjdk.samtools.reference.ReferenceSequenceFileFactory;
+import htsjdk.samtools.util.GZIIndex;
+import htsjdk.samtools.util.IOUtil;
 import htsjdk.utils.ValidationUtils;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.function.Function;
+
 /**
  * Class with methods for resolving inputs and outputs to haploid reference encoders and decoders.
  * <p>
@@ -66,9 +75,7 @@ public HaploidReferenceDecoder getHaploidReferenceDecoder(
  ValidationUtils.nonNull(inputPath, "Input path");
  ValidationUtils.nonNull(HaploidReferenceDecoderOptions, "Decoder options");
 
- final Bundle referenceBundle = new BundleBuilder().addPrimary(
- new IOPathResource(inputPath, BundleResourceType.CT_HAPLOID_REFERENCE)).build();
-
+ final Bundle referenceBundle = referenceBundleFromFastaPath(inputPath, HtsPath::new);
  return getHaploidReferenceDecoder(referenceBundle, HaploidReferenceDecoderOptions);
  }
 
@@ -110,4 +117,47 @@ public HaploidReferenceDecoder getHaploidReferenceDecoder(
  return (HaploidReferenceDecoder) resolveForDecoding(inputBundle).getDecoder(inputBundle, HaploidReferenceDecoderOptions);
  }
 
+ /**
+ * Create q reference bundle given only a fasta path, including an index and a dictionary
+ * file if they are present and located in the same directory as the fasta.
+ *
+ * @param fastaPath location of the fasta
+ * @param ioPathConstructor a constructor used to create IOPath-derived objects for the bundle
+ * @return a reference Bundle
+ * @param <T>
+ */
+ public static <T extends IOPath> Bundle referenceBundleFromFastaPath(final IOPath fastaPath, final Function<String, T> ioPathConstructor) {
+ final BundleBuilder referenceBundleBuilder = new BundleBuilder();
+ referenceBundleBuilder.addPrimary(new IOPathResource(fastaPath, BundleResourceType.CT_HAPLOID_REFERENCE));
+
+ final Path dictPath = ReferenceSequenceFileFactory.getDefaultDictionaryForReferenceSequence(fastaPath.toPath());
+ if (Files.exists(dictPath)) {
+ referenceBundleBuilder.addSecondary(
+ new IOPathResource(
+ ioPathConstructor.apply(dictPath.toUri().toString()),
+ BundleResourceType.CT_REFERENCE_DICTIONARY));
+ }
+
+ final Path idxPath = ReferenceSequenceFileFactory.getFastaIndexFileName(fastaPath.toPath());
+ if (Files.exists(idxPath)) {
+ referenceBundleBuilder.addSecondary(
+ new IOPathResource(
+ ioPathConstructor.apply(idxPath.toUri().toString()),
+ BundleResourceType.CT_REFERENCE_INDEX));
+ }
+
+ try {
+ if (IOUtil.isBlockCompressed(fastaPath.toPath(), true)) {
+ final Path gziPath = GZIIndex.resolveIndexNameForBgzipFile(fastaPath.toPath());
+ referenceBundleBuilder.addSecondary(
+ new IOPathResource(
+ ioPathConstructor.apply(gziPath.toUri().toString()),
+ BundleResourceType.CT_REFERENCE_INDEX_GZI));
+ }
+ } catch (IOException e) {
+ throw new HtsjdkException("Error while checking for block compression", e);
+ }
+ return referenceBundleBuilder.build();
+ }
+
 }

src/main/java/htsjdk/beta/plugin/variants/VariantsBundle.java

@@ -18,7 +18,7 @@
 /**
  * A {@link Bundle} for variants and variants-related resources that are backed by on disk files. A {@link
  * htsjdk.beta.plugin.variants.VariantsBundle} has a primary resource with content type {@link
- * BundleResourceType#PRIMARY_CT_VARIANT_CONTEXTS}; and an optional index resource. A VariantsBundle can also
+ * BundleResourceType#CT_VARIANT_CONTEXTS}; and an optional index resource. A VariantsBundle can also
  * contain additional resources.
  *
  * Note that this class is merely a convenience class for the case where the variants are backed by files on disk.
@@ -31,6 +31,7 @@ public class VariantsBundle extends Bundle implements Serializable {
  @Serial
  private static final long serialVersionUID = 1L;
  private static final Log LOG = Log.getInstance(VariantsBundle.class);
+
  /**
  * Create a {@link htsjdk.beta.plugin.variants.VariantsBundle} containing only a variants resource.
  *

src/main/java/htsjdk/samtools/reference/AbstractFastaSequenceFile.java

@@ -24,16 +24,16 @@
 
 package htsjdk.samtools.reference;
 
+import htsjdk.io.HtsPath;
+import htsjdk.io.IOPath;
 import htsjdk.samtools.SAMException;
-import htsjdk.samtools.SAMFileHeader;
 import htsjdk.samtools.SAMSequenceDictionary;
-import htsjdk.samtools.SAMTextHeaderCodec;
-import htsjdk.samtools.util.BufferedLineReader;
 import htsjdk.samtools.util.FileExtensions;
 import htsjdk.samtools.util.IOUtil;
 import htsjdk.samtools.util.Lazy;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.Serializable;
 import java.nio.file.Files;
@@ -84,13 +84,25 @@ abstract class AbstractFastaSequenceFile implements ReferenceSequenceFile {
  /** Attempts to find and load the sequence dictionary if present. */
  protected SAMSequenceDictionary findAndLoadSequenceDictionary(final Path fasta) {
  final Path dictPath = findSequenceDictionary(path);
- if (dictPath == null) return null;
+ if (dictPath == null) {
+ return null;
+ }
+ return loadSequenceDictionary(new HtsPath(dictPath.toUri().toString()));
+ }
 
- IOUtil.assertFileIsReadable(dictPath);
- try (InputStream dictionaryIn = IOUtil.openFileForReading(dictPath)) {
- return ReferenceSequenceFileFactory.loadDictionary(dictionaryIn);
+ /**
+ * Attempt to load a sequence dictionary given a file path. Path may be null.
+ * @param dictPath the dictionary file to open
+ * @return the SAMSequenceDictionary, or null
+ */
+ protected static SAMSequenceDictionary loadSequenceDictionary(final IOPath dictPath) {
+ if (dictPath == null) {
+ return null;
  }
- catch (Exception e) {
+ IOUtil.assertFileIsReadable(dictPath.toPath());
+ try (final InputStream dictionaryStream = IOUtil.openFileForReading(dictPath.toPath())) {
+ return ReferenceSequenceFileFactory.loadDictionary(dictionaryStream);
+ } catch (final IOException e) {
  throw new SAMException("Could not open sequence dictionary file: " + dictPath, e);
  }
  }

src/main/java/htsjdk/samtools/reference/AbstractIndexedFastaSequenceFile.java

@@ -24,6 +24,7 @@
 
 package htsjdk.samtools.reference;
 
+import htsjdk.io.IOPath;
 import htsjdk.samtools.Defaults;
 import htsjdk.samtools.SAMException;
 import htsjdk.samtools.SAMSequenceDictionary;
@@ -69,6 +70,27 @@ protected AbstractIndexedFastaSequenceFile(final Path path, final FastaSequenceI
  }
  }
 
+ /**
+ * Create a AbstractIndexedFastaSequenceFile from explicitly provided files. No assumptions are made
+ * about the relative location of the files (i.e., that they are siblings).
+ *
+ * @param fastaPath the path to the fasta file. may not be null.
+ * @param dictPath the path to the sequence dictionary. may be null.
+ * @param index the associated index object; may not be null.
+ */
+ protected AbstractIndexedFastaSequenceFile(final IOPath fastaPath, final IOPath dictPath, final FastaSequenceIndex index) {
+ super(fastaPath.toPath(), fastaPath.getURIString(), loadSequenceDictionary(dictPath));
+ if (index == null) {
+ throw new IllegalArgumentException("Null index for fasta " + index);
+ }
+ this.index = index;
+ IOUtil.assertFileIsReadable(fastaPath.toPath());
+ reset();
+ if (getSequenceDictionary() != null) {
+ sanityCheckDictionaryAgainstIndex(fastaPath.getRawInputString(), getSequenceDictionary(), index);
+ }
+ }
+
  /**
  * Initialise the given indexed fasta sequence file stream.
  * @param source The named source of the reference file (used in error messages).

src/main/java/htsjdk/samtools/reference/BlockCompressedIndexedFastaSequenceFile.java

@@ -24,6 +24,7 @@
 
 package htsjdk.samtools.reference;
 
+import htsjdk.io.IOPath;
 import htsjdk.samtools.SAMException;
 import htsjdk.samtools.SAMSequenceDictionary;
 import htsjdk.samtools.seekablestream.SeekablePathStream;
@@ -54,6 +55,32 @@ public BlockCompressedIndexedFastaSequenceFile(final Path path)
  this(path, new FastaSequenceIndex((findRequiredFastaIndexFile(path))));
  }
 
+ /**
+ * Create a BlockCompressedIndexedFastaSequenceFile from explicitly provided files. No assumptions are made
+ * about the relative location of the files (i.e., no assumption is made that they are siblings).
+ * @param fastaPath the fasta file
+ * @param dictPath the associated dictionary file
+ * @param index the associated index
+ * @param gziIndex the associated gziIndex
+ */
+ public BlockCompressedIndexedFastaSequenceFile(
+ final IOPath fastaPath,
+ final IOPath dictPath,
+ final FastaSequenceIndex index,
+ final GZIIndex gziIndex) {
+ super(fastaPath, dictPath, index);
+ if (gziIndex == null) {
+ throw new IllegalArgumentException("null gzi index");
+ }
+ assertIsBlockCompressed(fastaPath.toPath());
+ try {
+ stream = new BlockCompressedInputStream(new SeekablePathStream(fastaPath.toPath()));
+ gzindex = gziIndex;
+ } catch (IOException e) {
+ throw new SAMException("Fasta file should be readable but is not: " + fastaPath, e);
+ }
+ }
+
  public BlockCompressedIndexedFastaSequenceFile(final Path path, final FastaSequenceIndex index) {
  this(path, index, loadFastaGziIndex(path));
  }

src/main/java/htsjdk/samtools/reference/FastaSequenceFile.java

@@ -24,6 +24,7 @@
 
 package htsjdk.samtools.reference;
 
+import htsjdk.io.IOPath;
 import htsjdk.samtools.Defaults;
 import htsjdk.samtools.SAMException;
 import htsjdk.samtools.SAMSequenceDictionary;
@@ -64,6 +65,21 @@ public FastaSequenceFile(final Path path, final boolean truncateNamesAtWhitespac
  this.in = new FastLineReader(IOUtil.openFileForReading(path));
  }
 
+ /**
+ * Constructs a FastaSequenceFile that reads from the specified fasta and dictionary file. Makes no
+ * assumptions that the fata and dict file are in the same directory.
+ *
+ * @param fastaPath may not be null
+ * @param dictPath may be null
+ * @param truncateNamesAtWhitespace
+ */
+ public FastaSequenceFile(final IOPath fastaPath, final IOPath dictPath, final boolean truncateNamesAtWhitespace) {
+ super(fastaPath.toPath(), fastaPath.toString(), dictPath == null ? null : loadSequenceDictionary(dictPath));
+ this.truncateNamesAtWhitespace = truncateNamesAtWhitespace;
+ this.seekableStream = null;
+ this.in = new FastLineReader(IOUtil.openFileForReading(fastaPath.toPath()));
+ }
+
  /**
  * Constructs a FastaSequenceFile that reads from the specified stream (which must not be compressed, i.e.
  * the caller is responsible for decompressing the stream).

src/main/java/htsjdk/samtools/reference/IndexedFastaSequenceFile.java

@@ -24,18 +24,16 @@
 
 package htsjdk.samtools.reference;
 
+import htsjdk.io.IOPath;
 import htsjdk.samtools.SAMException;
 import htsjdk.samtools.SAMSequenceDictionary;
 import htsjdk.samtools.seekablestream.ReadableSeekableStreamByteChannel;
 import htsjdk.samtools.seekablestream.SeekableStream;
-import htsjdk.samtools.util.BlockCompressedInputStream;
 import htsjdk.samtools.util.IOUtil;
 
-import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.channels.SeekableByteChannel;
@@ -89,6 +87,28 @@ public IndexedFastaSequenceFile(final Path path, final FastaSequenceIndex index)
  }
  }
 
+ /**
+ */
+ /**
+ * Open the given indexed fasta sequence file. Throw an exception if the file cannot be opened.
+ *
+ * @param path The file to open.
+ * @param dictPath the dictionar path (may be null)
+ * @param index Pre-built FastaSequenceIndex, for the case in which one does not exist on disk. may not be null.
+ */
+ public IndexedFastaSequenceFile(final IOPath path, final IOPath dictPath, final FastaSequenceIndex index) {
+ super(path, dictPath, index);
+ try {
+ // reject block-compressed files (use BlockCompressedIndexedFastaSequenceFile)
+ if (IOUtil.isBlockCompressed(path.toPath(), true)) {
+ throw new SAMException("Indexed block-compressed FASTA file cannot be handled: " + path);
+ }
+ this.channel = Files.newByteChannel(path.toPath());
+ } catch (IOException e) {
+ throw new SAMException("FASTA file should be readable but is not: " + path, e);
+ }
+ }
+
  /**
  * Open the given indexed fasta sequence file. Throw an exception if the file cannot be opened.
  * @param path The file to open.