tsalign 3.0.0__tar.gz → 4.0.0__tar.gz

{tsalign-3.0.0 → tsalign-4.0.0}/Cargo.lock

@@ -417,7 +417,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "generic_a_star"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "binary-heap-plus",
  "compare",
@@ -548,7 +548,7 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "lib_ts_chainalign"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "binary-heap-plus",
  "bincode",
@@ -568,7 +568,7 @@ dependencies = [
 
 [[package]]
 name = "lib_tsalign"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "binary-heap-plus",
  "compact-genome",
@@ -589,7 +589,7 @@ dependencies = [
 
 [[package]]
 name = "lib_tsshow"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "ena",
  "itertools",
@@ -804,7 +804,7 @@ dependencies = [
 
 [[package]]
 name = "py_lib_tsalign"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "compact-genome",
  "lib_tsalign",
@@ -1008,7 +1008,7 @@ dependencies = [
 
 [[package]]
 name = "seed_chain"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "compact-genome",
  "generic_a_star",
@@ -1360,7 +1360,7 @@ checksum = "2b939c825d0c4295ac520f7b479927c1e5b458c9107a9d6f5ba65bc867bb93a5"
 
 [[package]]
 name = "tsalign"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "anyhow",
  "bincode",
@@ -1381,7 +1381,7 @@ dependencies = [
 
 [[package]]
 name = "tsalign-tests"
-version = "3.0.0"
+version = "4.0.0"
 dependencies = [
  "anyhow",
  "clap",

{tsalign-3.0.0 → tsalign-4.0.0}/Cargo.toml

@@ -18,5 +18,9 @@ num-traits = "0.2.19"
 rustc-hash = "2.1.1"
 binary-heap-plus = "0.5.0"
 
+[profile.dev]
+debug = 1 # or "line-tables-only" instead of full debug info
+split-debuginfo = "unpacked" # Keeps symbols out of the main object file
+
 [profile.release]
-debug = true
+debug = 1

{tsalign-3.0.0 → tsalign-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsalign
-Version: 3.0.0
+Version: 4.0.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{tsalign-3.0.0 → tsalign-4.0.0}/generic_a_star/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "generic_a_star"
 description = "A generic implementation of the A* algorithm"
-version = "3.0.0"
+version = "4.0.0"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/Cargo.toml

@@ -2,7 +2,7 @@
 name = "lib_tsalign"
 description = "A sequence-to-sequence aligner that accounts for template switches"
 authors = ["Sebastian Schmidt <sebastian.schmidt@helsinki.fi>"]
-version = "3.0.0"
+version = "4.0.0"
 license.workspace = true
 edition.workspace = true
 rust-version.workspace = true
@@ -26,9 +26,9 @@ thiserror = "2.0.3"
 num-traits.workspace = true
 serde = { workspace = true, features = ["derive"], optional = true }
 noisy_float = { version = "0.2.0" }
-generic_a_star = { version = "3.0.0", path = "../generic_a_star" }
+generic_a_star = { version = "4.0.0", path = "../generic_a_star" }
 log.workspace = true
 rustc-hash = "2.1.1"
-seed_chain = { version = "3.0.0", path = "../seed_chain" }
+seed_chain = { version = "4.0.0", path = "../seed_chain" }
 extend_map = "0.14.3"
 template-switch-error-free-inners = "0.1.1"

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/alignment_geometry.rs

@@ -17,6 +17,18 @@ pub struct AlignmentCoordinates {
 }
 
 impl AlignmentRange {
+    pub fn new(
+        reference_offset: usize,
+        query_offset: usize,
+        reference_limit: usize,
+        query_limit: usize,
+    ) -> Self {
+        Self {
+            offset: AlignmentCoordinates::new(reference_offset, query_offset),
+            limit: AlignmentCoordinates::new(reference_limit, query_limit),
+        }
+    }
+
     pub fn new_complete(reference: usize, query: usize) -> Self {
         Self {
             offset: AlignmentCoordinates::new_zero(),
@@ -102,6 +114,16 @@ impl AlignmentRange {
             ),
         ))
     }
+
+    #[must_use]
+    pub fn with_offset(&self, offset: AlignmentCoordinates) -> Self {
+        Self::new_offset_limit(offset, self.limit)
+    }
+
+    #[must_use]
+    pub fn with_limit(&self, limit: AlignmentCoordinates) -> Self {
+        Self::new_offset_limit(self.offset, limit)
+    }
 }
 
 impl AlignmentCoordinates {
@@ -112,6 +134,14 @@ impl AlignmentCoordinates {
     pub fn new_zero() -> Self {
         Self::new(0, 0)
     }
+
+    pub fn reference(&self) -> usize {
+        self.reference
+    }
+
+    pub fn query(&self) -> usize {
+        self.query
+    }
 }
 
 impl Display for AlignmentRange {

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/alignment_result/alignment/stream.rs

@@ -176,8 +176,9 @@ impl AlignmentStream {
             AlignmentType::TemplateSwitchEntrance { .. }
             | AlignmentType::TemplateSwitchExit { .. }
             | AlignmentType::Root
+            | AlignmentType::AlternativeStart { .. }
             | AlignmentType::SecondaryRoot
-            | AlignmentType::PrimaryReentry => 0,
+            | AlignmentType::PrimaryReentry { .. } => 0,
             AlignmentType::PrimaryShortcut { .. } => {
                 unreachable!("Shortcut alignments are not supported for show")
             }
@@ -245,10 +246,25 @@ impl AlignmentStreamCoordinates {
                 }
                 (0, 0)
             }
+            AlignmentType::AlternativeStart {
+                reference_index,
+                query_index,
+            } => {
+                assert_eq!(self.reference, reference_index);
+                assert_eq!(self.query, query_index);
+                (0, 0)
+            }
+            AlignmentType::PrimaryReentry {
+                reference_index,
+                query_index,
+            } => {
+                assert_eq!(self.reference, reference_index);
+                assert_eq!(self.query, query_index);
+                (0, 0)
+            }
             AlignmentType::SecondaryDeletion
             | AlignmentType::Root
-            | AlignmentType::SecondaryRoot
-            | AlignmentType::PrimaryReentry => (0, 0),
+            | AlignmentType::SecondaryRoot => (0, 0),
             AlignmentType::PrimaryShortcut { .. } => {
                 unreachable!("Shortcut alignments are not supported for show")
             }

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/alignment_result/alignment/template_switch_specifics.rs

@@ -832,9 +832,23 @@ impl Alignment<AlignmentType> {
                     };
                     cost_increment
                 }
-                AlignmentType::Root
-                | AlignmentType::SecondaryRoot
-                | AlignmentType::PrimaryReentry => {
+                AlignmentType::AlternativeStart {
+                    reference_index: reference_start,
+                    query_index: query_start,
+                } => {
+                    assert_eq!(reference_index, reference_start);
+                    assert_eq!(query_index, query_start);
+                    Cost::zero()
+                }
+                AlignmentType::PrimaryReentry {
+                    reference_index: reference_reentry_index,
+                    query_index: query_reentry_index,
+                } => {
+                    assert_eq!(reference_index, reference_reentry_index);
+                    assert_eq!(query_index, query_reentry_index);
+                    Cost::zero()
+                }
+                AlignmentType::Root | AlignmentType::SecondaryRoot => {
                     // Do nothing
                     Cost::zero()
                 }

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/alignment_result.rs

@@ -9,7 +9,10 @@ use noisy_float::types::{R64, r64};
 use num_traits::{Float, Zero};
 
 use crate::{
-    a_star_aligner::template_switch_distance::AlignmentType, config::TemplateSwitchConfig,
+    a_star_aligner::{
+        alignment_geometry::AlignmentCoordinates, template_switch_distance::AlignmentType,
+    },
+    config::TemplateSwitchConfig,
 };
 
 use super::alignment_geometry::AlignmentRange;
@@ -17,7 +20,7 @@ use super::alignment_geometry::AlignmentRange;
 pub mod a_star_sequences;
 pub mod alignment;
 
-pub trait IAlignmentType {
+pub trait IAlignmentType: Clone {
     fn is_repeatable(&self) -> bool;
 
     fn is_repeated(&self, previous: &Self) -> bool;
@@ -27,6 +30,10 @@ pub trait IAlignmentType {
     fn is_template_switch_entrance(&self) -> bool;
 
     fn is_template_switch_exit(&self) -> bool;
+
+    fn alternative_start(&self) -> Option<AlignmentCoordinates>;
+
+    fn alternative_end(&self) -> Option<AlignmentCoordinates>;
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
@@ -57,6 +64,8 @@ pub struct AlignmentStatistics<Cost> {
     pub sequences: SequencePair,
     pub reference_offset: usize,
     pub query_offset: usize,
+    pub reference_limit: usize,
+    pub query_limit: usize,
 
     pub cost: R64,
     pub cost_per_base: R64,
@@ -106,8 +115,7 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
         query: &SubsequenceType,
         reference_name: &str,
         query_name: &str,
-        reference_offset: usize,
-        query_offset: usize,
+        alignment_range: AlignmentRange,
         result: AStarResult<(), Cost>,
         duration_seconds: f64,
         opened_nodes: usize,
@@ -122,8 +130,7 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
             query,
             reference_name,
             query_name,
-            reference_offset,
-            query_offset,
+            alignment_range,
             result,
             duration_seconds,
             opened_nodes,
@@ -144,8 +151,7 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
         query: &SubsequenceType,
         reference_name: &str,
         query_name: &str,
-        reference_offset: usize,
-        query_offset: usize,
+        alignment_range: AlignmentRange,
         duration_seconds: f64,
         opened_nodes: usize,
         closed_nodes: usize,
@@ -159,8 +165,7 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
             query,
             reference_name,
             query_name,
-            reference_offset,
-            query_offset,
+            alignment_range,
             result,
             duration_seconds,
             opened_nodes,
@@ -181,8 +186,7 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
         query: &SubsequenceType,
         reference_name: &str,
         query_name: &str,
-        reference_offset: usize,
-        query_offset: usize,
+        alignment_range: AlignmentRange,
         result: AStarResult<(), Cost>,
         duration_seconds: f64,
         opened_nodes: usize,
@@ -195,8 +199,10 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
         let statistics = AlignmentStatistics {
             result,
             sequences: SequencePair::new(reference, query, reference_name, query_name),
-            reference_offset,
-            query_offset,
+            reference_offset: alignment_range.reference_offset(),
+            query_offset: alignment_range.query_offset(),
+            reference_limit: alignment_range.reference_limit(),
+            query_limit: alignment_range.query_limit(),
 
             cost: (cost.as_f64()).try_into().unwrap(),
             cost_per_base: ((cost.as_f64() * 2.0) / (reference_length + query_length) as f64)
@@ -235,6 +241,18 @@ impl<AlignmentType: IAlignmentType, Cost: AStarCost> AlignmentResult<AlignmentTy
             Self::WithoutTarget { statistics }
         }
     }
+
+    pub fn alignment_range(&self) -> AlignmentRange {
+        let (reference_offset, query_offset, reference_limit, query_limit) = match self {
+            Self::WithTarget { statistics, .. } | Self::WithoutTarget { statistics } => (
+                statistics.reference_offset,
+                statistics.query_offset,
+                statistics.reference_limit,
+                statistics.query_limit,
+            ),
+        };
+        AlignmentRange::new(reference_offset, query_offset, reference_limit, query_limit)
+    }
 }
 
 impl<Cost: AStarCost + From<u64>>
@@ -783,6 +801,8 @@ impl<Cost> Default for AlignmentStatistics<Cost> {
             sequences: Default::default(),
             reference_offset: Default::default(),
             query_offset: Default::default(),
+            reference_limit: usize::MAX,
+            query_limit: usize::MAX,
             cost: Default::default(),
             cost_per_base: Default::default(),
             duration_seconds: Default::default(),

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/configurable_a_star_align.rs

@@ -13,11 +13,14 @@ use crate::{
             context::DynamicStrategies,
             strategies::{
                 AlignmentStrategySelection,
+                allow_ts_14_out_of_range::{
+                    AdditionalExplicitTSMStartsAndEnds, Ts14OutOfRangeStrategy,
+                },
                 descendant::{
                     AnyTemplateSwitchDescendantStrategy, OnlyEqualTemplateSwitchDescendantStrategy,
                     TemplateSwitchDescendantStrategy,
                 },
-                primary_range::NoPrunePrimaryRangeStrategy,
+                primary_range::RangePrunePrimaryRangeStrategy,
                 secondary_deletion::AllowSecondaryDeletionStrategy,
                 shortcut::NoShortcutStrategy,
                 template_switch_min_length::{
@@ -112,6 +115,7 @@ struct QueryData<'a> {
     query_name: &'a str,
     query: &'a [u8],
     ranges: Option<AlignmentRange>,
+    gap_characters: &'a [u8],
     cost_limit: Option<u64>,
     memory_limit: Option<usize>,
     extend_beyond_range: bool,
@@ -127,6 +131,7 @@ pub struct Aligner<AlphabetType: Alphabet = DnaAlphabetOrN> {
     chaining_strategy: ChainingStrategySelector,
     total_length_strategy: TotalLengthStrategySelector,
     descendant_strategy: DescendantStrategySelector,
+    ts_14_out_of_range_strategy: Ts14OutOfRangeStrategy,
     no_ts: bool,
 }
 
@@ -143,10 +148,11 @@ impl<AlphabetType: Alphabet> Default for Aligner<AlphabetType> {
     fn default() -> Self {
         Self {
             costs: TemplateSwitchConfig::<AlphabetType, U64Cost>::default(),
-            min_length_strategy: MinLengthStrategySelector::default(),
-            chaining_strategy: ChainingStrategySelector::default(),
-            total_length_strategy: TotalLengthStrategySelector::default(),
-            descendant_strategy: DescendantStrategySelector::default(),
+            min_length_strategy: Default::default(),
+            chaining_strategy: Default::default(),
+            total_length_strategy: Default::default(),
+            descendant_strategy: Default::default(),
+            ts_14_out_of_range_strategy: Default::default(),
             no_ts: false,
         }
     }
@@ -204,7 +210,20 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
         self
     }
 
-    /// This performs the actual alignment and is, depending on the inputs, potentially taking quite long.
+    pub fn set_ts_14_out_of_range_strategy(
+        &mut self,
+        ts_14_out_of_range_strategy: Ts14OutOfRangeStrategy,
+    ) -> &mut Self {
+        self.ts_14_out_of_range_strategy = ts_14_out_of_range_strategy;
+        self
+    }
+
+    /// Perform the actual alignment.
+    ///
+    /// Special gap characters can be specified in order to interpret the given sequences as an alignment with gaps instead of raw sequences.
+    /// In this case, the range coordinates must refer to the ungapped sequences.
+    ///
+    /// Depending on the inputs, this takes quite long.
     /// Consider spawning tasks to not block the user application.
     #[allow(
         clippy::too_many_arguments,
@@ -218,6 +237,7 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
         query_name: &str,
         query: &[u8],
         ranges: Option<AlignmentRange>,
+        gap_characters: &[u8],
         cost_limit: Option<u64>,
         memory_limit: Option<usize>,
         extend_beyond_range: bool,
@@ -228,6 +248,7 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
             query_name,
             query,
             ranges,
+            gap_characters,
             cost_limit,
             memory_limit,
             extend_beyond_range,
@@ -336,9 +357,48 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
         count_strategy_memory: TC::Memory,
     ) -> AlignmentResult<AlignmentType, U64Cost> {
         // TODO error handling
-        let reference = VectorGenome::<AlphabetType>::from_slice_u8(data.reference).unwrap();
-        let query = VectorGenome::from_slice_u8(data.query).unwrap();
+        let reference = VectorGenome::<AlphabetType>::from_iter_u8(
+            data.reference
+                .iter()
+                .copied()
+                .filter(|c| !data.gap_characters.contains(c)),
+        )
+        .unwrap();
+        let query = VectorGenome::from_iter_u8(
+            data.query
+                .iter()
+                .copied()
+                .filter(|c| !data.gap_characters.contains(c)),
+        )
+        .unwrap();
+
+        let range = data
+            .ranges
+            .unwrap_or_else(|| AlignmentRange::new_complete(reference.len(), query.len()));
+        let additional_tsm_starts_and_ends =
+            if self.ts_14_out_of_range_strategy == Ts14OutOfRangeStrategy::Allow {
+                AdditionalExplicitTSMStartsAndEnds::new(
+                    &data
+                        .reference
+                        .iter()
+                        .map(|c| *c as char)
+                        .collect::<String>(),
+                    &data.query.iter().map(|c| *c as char).collect::<String>(),
+                    &range,
+                    &data
+                        .gap_characters
+                        .iter()
+                        .map(|c| *c as char)
+                        .collect::<Vec<_>>(),
+                    false,
+                )
+                .unwrap()
+            } else {
+                AdditionalExplicitTSMStartsAndEnds::default()
+            };
+
         let cost_limit = data.cost_limit.map(U64Cost::from);
+
         template_switch_distance_a_star_align::<
             AlignmentStrategySelection<
                 AlphabetType,
@@ -350,7 +410,7 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
                 AllowSecondaryDeletionStrategy,
                 NoShortcutStrategy<U64Cost>,
                 AllowPrimaryMatchStrategy,
-                NoPrunePrimaryRangeStrategy,
+                RangePrunePrimaryRangeStrategy,
                 TL,
                 DS,
             >,
@@ -360,10 +420,12 @@ impl<AlphabetType: Alphabet> Aligner<AlphabetType> {
             query.as_genome_subsequence(),
             data.reference_name,
             data.query_name,
-            data.ranges
-                .unwrap_or_else(|| AlignmentRange::new_complete(reference.len(), query.len())),
+            range,
+            additional_tsm_starts_and_ends,
             &self.costs,
-            DynamicStrategies {},
+            DynamicStrategies {
+                ts_14_out_of_range: self.ts_14_out_of_range_strategy,
+            },
             cost_limit,
             data.memory_limit,
             false,
@@ -395,6 +457,7 @@ mod tests {
                 AlignmentCoordinates::new(27, 200),
                 AlignmentCoordinates::new(33, 214)
             ).into(),
+            &[],
             None,
             None,
         true);

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/gap_affine_edit_distance.rs

@@ -385,6 +385,14 @@ impl IAlignmentType for AlignmentType {
     fn is_template_switch_exit(&self) -> bool {
         false
     }
+
+    fn alternative_start(&self) -> Option<super::alignment_geometry::AlignmentCoordinates> {
+        None
+    }
+
+    fn alternative_end(&self) -> Option<super::alignment_geometry::AlignmentCoordinates> {
+        None
+    }
 }
 
 impl AStarIdentifier for Identifier {}

{tsalign-3.0.0 → tsalign-4.0.0}/lib_tsalign/src/a_star_aligner/template_switch_distance/alignment_type.rs

@@ -1,6 +1,8 @@
 use equal_cost_range::EqualCostRange;
 
-use crate::a_star_aligner::alignment_result::IAlignmentType;
+use crate::a_star_aligner::{
+    alignment_geometry::AlignmentCoordinates, alignment_result::IAlignmentType,
+};
 
 use super::identifier::{
     TemplateSwitchAncestor, TemplateSwitchDescendant, TemplateSwitchDirection,
@@ -63,10 +65,18 @@ pub enum AlignmentType {
     },
     /// This node is the root node, hence it was not generated via alignment.
     Root,
+    /// The alignment starts from a different position than given by the alignment ranges.
+    AlternativeStart {
+        reference_index: usize,
+        query_index: usize,
+    },
     /// The root node of a secondary graph.
     SecondaryRoot,
     /// A reentry node into the primary graph, treated like a root.
-    PrimaryReentry,
+    PrimaryReentry {
+        reference_index: usize,
+        query_index: usize,
+    },
     /// A shortcut in the primary matrix.
     ///
     /// Used only for computing lower bounds.
@@ -92,8 +102,9 @@ impl IAlignmentType for AlignmentType {
             | Self::PrimaryFlankMatch
             | Self::SecondaryMatch
             | Self::Root
+            | Self::AlternativeStart { .. }
             | Self::SecondaryRoot
-            | Self::PrimaryReentry => true,
+            | Self::PrimaryReentry { .. } => true,
             Self::TemplateSwitchEntrance { .. }
             | Self::TemplateSwitchExit { .. }
             | Self::PrimaryShortcut { .. } => false,
@@ -143,7 +154,10 @@ impl IAlignmentType for AlignmentType {
     fn is_internal(&self) -> bool {
         matches!(
             self,
-            Self::Root | Self::SecondaryRoot | Self::PrimaryReentry
+            Self::Root
+                | Self::AlternativeStart { .. }
+                | Self::SecondaryRoot
+                | Self::PrimaryReentry { .. }
         )
     }
 
@@ -154,6 +168,30 @@ impl IAlignmentType for AlignmentType {
     fn is_template_switch_exit(&self) -> bool {
         matches!(self, Self::TemplateSwitchExit { .. })
     }
+
+    fn alternative_start(&self) -> Option<AlignmentCoordinates> {
+        if let Self::AlternativeStart {
+            reference_index,
+            query_index,
+        } = self
+        {
+            Some(AlignmentCoordinates::new(*reference_index, *query_index))
+        } else {
+            None
+        }
+    }
+
+    fn alternative_end(&self) -> Option<AlignmentCoordinates> {
+        if let Self::PrimaryReentry {
+            reference_index,
+            query_index,
+        } = self
+        {
+            Some(AlignmentCoordinates::new(*reference_index, *query_index))
+        } else {
+            None
+        }
+    }
 }
 
 impl AlignmentType {
@@ -178,6 +216,20 @@ impl AlignmentType {
                 equal_cost_range: *equal_cost_range,
                 first_offset: *first_offset,
             },
+            Self::AlternativeStart {
+                reference_index,
+                query_index,
+            } => Self::AlternativeStart {
+                reference_index: *query_index,
+                query_index: *reference_index,
+            },
+            Self::PrimaryReentry {
+                reference_index,
+                query_index,
+            } => Self::PrimaryReentry {
+                reference_index: *query_index,
+                query_index: *reference_index,
+            },
             Self::PrimaryShortcut {
                 delta_reference,
                 delta_query,
@@ -194,8 +246,7 @@ impl AlignmentType {
             | Self::SecondaryMatch
             | Self::TemplateSwitchExit { .. }
             | Self::Root
-            | Self::SecondaryRoot
-            | Self::PrimaryReentry) => *symmetric,
+            | Self::SecondaryRoot) => *symmetric,
         }
     }
 }