tsalign 2.1.1__tar.gz → 3.0.0__tar.gz

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

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

tsalign-3.0.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: tsalign
+Version: 3.0.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# Python Bindings for [`lib_tsalign`](https://crates.io/crates/lib_tsalign)
+
+[![PyPI](https://img.shields.io/pypi/v/tsalign)](https://pypi.org/project/tsalign/)
+
+Python bindings for the template switch aligner.  Aligns two DNA sequences
+while detecting template switches — short-range translocations where a query
+region is copied from (or aligns to) a different location, possibly on the
+reverse complement strand.
+
+## Installation
+
+```bash
+pip install tsalign
+```
+
+## Quick start
+
+```python
+import tsalign
+
+result = tsalign.align("ACGTACGT", "ACGACGT")
+print(result.cigar())   # compact alignment string
+print(result.stats())   # cost, duration, node counts, …
+```
+
+## Aligner options
+
+Create an `Aligner` once and reuse it for many sequences:
+
+```python
+aligner = tsalign.Aligner(
+    min_length_strategy="preprocess_lookahead",  # default: "lookahead"
+    chaining_strategy="lower_bound",             # default: "none"
+    total_length_strategy="maximise",            # default: "maximise"
+    no_ts=False,                                 # set True for plain gap-affine
+)
+
+result = aligner.align("ACGTACGT", "ACGACGT")
+```
+
+## Custom cost configuration
+
+Costs are specified in `.tsa` format.  Use `sample_tsa_config/config.tsa`
+as a starting point and consult the [main repository README](../README.md#modifying-the-cost-function) for a description
+of each parameter.
+
+```python
+aligner = tsalign.Aligner(costs_file="sample_tsa_config/config.tsa")
+result = aligner.align("ACGTACGT", "ACGACGT")
+```
+
+You can also pass the cost string directly:
+
+```python
+with open("my_costs.tsa") as f:
+    cost_str = f.read()
+aligner = tsalign.Aligner(costs=cost_str)
+```
+
+## Restricting the alignment range
+
+Use `AlignmentRange` to align only a window of the input sequences:
+
+```python
+from tsalign import Aligner, AlignmentRange
+
+aligner = Aligner()
+result = aligner.align(
+    "NNNACGTACGTNNN",
+    "ACGACGT",
+    range=AlignmentRange(reference_start=3, reference_end=11),
+)
+print(result.cigar())
+```
+
+Individual start/limit keyword arguments are also accepted when `range` is
+not provided:
+
+```python
+result = aligner.align(
+    "NNNACGTACGTNNN",
+    "ACGACGT",
+    reference_start=3,
+    reference_limit=11,
+)
+```
+
+## Working with alignment operations
+
+`alignment.alignments()` returns a typed list of `(count, op)` pairs:
+
+```python
+from tsalign import align, TemplateSwitchEntranceOp, TemplateSwitchExitOp
+
+result = align(reference, query)
+for count, op in result.alignments():
+    if isinstance(op, TemplateSwitchEntranceOp):
+        print(f"Template switch: {op.direction}, descendant={op.descendant}, offset={op.first_offset}")
+    elif isinstance(op, TemplateSwitchExitOp):
+        print(f"Exit, anti-descendant gap: {op.anti_descendant_gap}")
+    else:
+        # SimpleAlignmentOp — a basic edit in the primary or secondary track
+        print(f"{count}x {op.kind}")
+```
+
+## Visualisation
+
+```python
+result = tsalign.align(reference, query)
+result.viz_template_switches()   # prints ASCII art to stdout
+```
+
+## Limiting search resources
+
+```python
+result = aligner.align(
+    reference,
+    query,
+    cost_limit=100,       # return None if cost would exceed this
+    memory_limit=500_000, # return None if memory exceeds this number of bytes
+)
+if result is None:
+    print("No alignment found within limits")
+```
+
+## Accepted sequence types
+
+Any object whose `str()` representation is a valid DNA string (ACGTN) is
+accepted — including `Bio.Seq`:
+
+```python
+from Bio.Seq import Seq
+result = tsalign.align(Seq("ACGTACGT"), Seq("ACGACGT"))
+```
+

{tsalign-2.1.1/python_bindings → tsalign-3.0.0}/README.md

@@ -41,7 +41,7 @@ result = aligner.align("ACGTACGT", "ACGACGT")
 ## Custom cost configuration
 
 Costs are specified in `.tsa` format.  Use `sample_tsa_config/config.tsa`
-as a starting point and consult the main repository README for a description
+as a starting point and consult the [main repository README](../README.md#modifying-the-cost-function) for a description
 of each parameter.
 
 ```python
@@ -95,9 +95,9 @@ from tsalign import align, TemplateSwitchEntranceOp, TemplateSwitchExitOp
 result = align(reference, query)
 for count, op in result.alignments():
     if isinstance(op, TemplateSwitchEntranceOp):
-        print(f"Template switch: {op.direction}, primary={op.primary}, offset={op.first_offset}")
+        print(f"Template switch: {op.direction}, descendant={op.descendant}, offset={op.first_offset}")
     elif isinstance(op, TemplateSwitchExitOp):
-        print(f"Exit, anti-primary gap: {op.anti_primary_gap}")
+        print(f"Exit, anti-descendant gap: {op.anti_descendant_gap}")
     else:
         # SimpleAlignmentOp — a basic edit in the primary or secondary track
         print(f"{count}x {op.kind}")

{tsalign-2.1.1 → tsalign-3.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 = "2.1.1"
+version = "3.0.0"
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

{tsalign-2.1.1 → tsalign-3.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 = "2.1.1"
+version = "3.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 = "2.1.1", path = "../generic_a_star" }
+generic_a_star = { version = "3.0.0", path = "../generic_a_star" }
 log.workspace = true
 rustc-hash = "2.1.1"
-seed_chain = { version = "2.1.1", path = "../seed_chain" }
+seed_chain = { version = "3.0.0", path = "../seed_chain" }
 extend_map = "0.14.3"
 template-switch-error-free-inners = "0.1.1"

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

@@ -2,7 +2,7 @@ use std::{collections::VecDeque, iter};
 
 use crate::a_star_aligner::{
     alignment_result::alignment::Alignment,
-    template_switch_distance::{AlignmentType, TemplateSwitchPrimary},
+    template_switch_distance::{AlignmentType, TemplateSwitchDescendant},
 };
 
 #[derive(Debug, Clone)]
@@ -20,7 +20,7 @@ pub struct AlignmentStream {
 pub struct AlignmentStreamCoordinates {
     reference: usize,
     query: usize,
-    template_switch_primary: Option<TemplateSwitchPrimary>,
+    template_switch_descendant: Option<TemplateSwitchDescendant>,
 }
 
 impl AlignmentStream {
@@ -190,7 +190,7 @@ impl AlignmentStreamCoordinates {
         Self {
             reference: reference_offset,
             query: query_offset,
-            template_switch_primary: None,
+            template_switch_descendant: None,
         }
     }
 
@@ -210,34 +210,37 @@ impl AlignmentStreamCoordinates {
             | AlignmentType::PrimaryMatch
             | AlignmentType::PrimaryFlankSubstitution
             | AlignmentType::PrimaryFlankMatch => (1, 1),
-            AlignmentType::TemplateSwitchEntrance { primary, .. } => {
+            AlignmentType::TemplateSwitchEntrance { descendant, .. } => {
                 assert!(
-                    self.template_switch_primary.is_none(),
+                    self.template_switch_descendant.is_none(),
                     "Encountered template switch entrance within template switch"
                 );
-                self.template_switch_primary = Some(primary);
+                self.template_switch_descendant = Some(descendant);
                 (0, 0)
             }
             AlignmentType::SecondaryInsertion
             | AlignmentType::SecondarySubstitution
-            | AlignmentType::SecondaryMatch => match self.template_switch_primary.unwrap() {
-                TemplateSwitchPrimary::Reference => (1, 0),
-                TemplateSwitchPrimary::Query => (0, 1),
+            | AlignmentType::SecondaryMatch => match self.template_switch_descendant.unwrap() {
+                TemplateSwitchDescendant::Reference => (1, 0),
+                TemplateSwitchDescendant::Query => (0, 1),
             },
-            AlignmentType::TemplateSwitchExit { anti_primary_gap } => {
-                let Some(template_switch_primary) = self.template_switch_primary.take() else {
+            AlignmentType::TemplateSwitchExit {
+                anti_descendant_gap,
+            } => {
+                let Some(template_switch_descendant) = self.template_switch_descendant.take()
+                else {
                     panic!(
                         "Encountered template switch exit without first encountering a template switch entrance"
                     )
                 };
-                match template_switch_primary {
-                    TemplateSwitchPrimary::Reference => {
+                match template_switch_descendant {
+                    TemplateSwitchDescendant::Reference => {
                         self.query =
-                            usize::try_from(self.query as isize + anti_primary_gap).unwrap()
+                            usize::try_from(self.query as isize + anti_descendant_gap).unwrap()
                     }
-                    TemplateSwitchPrimary::Query => {
+                    TemplateSwitchDescendant::Query => {
                         self.reference =
-                            usize::try_from(self.reference as isize + anti_primary_gap).unwrap()
+                            usize::try_from(self.reference as isize + anti_descendant_gap).unwrap()
                     }
                 }
                 (0, 0)