Skip to content

Alignment Module

Sequence alignment handling and analysis.

Overview

The alignment module provides the Alignment class for working with multiple sequence alignments.

Classes

pypopart.core.alignment

Multiple sequence alignment representation and analysis for PyPopART.

AlignmentStats dataclass

Statistics about a multiple sequence alignment.

Source code in src/pypopart/core/alignment.py 
12
13
14
15
16
17
18
19
20
21
22
23
@dataclass
class AlignmentStats:
    """Statistics about a multiple sequence alignment."""

    length: int
    num_sequences: int
    total_gaps: int
    gap_percentage: float
    conserved_sites: int
    variable_sites: int
    parsimony_informative_sites: int
    gc_content: float

Alignment

Represents a multiple sequence alignment.

Provides methods for alignment analysis, validation, and manipulation.

Source code in src/pypopart/core/alignment.py 
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
class Alignment:
    """
    Represents a multiple sequence alignment.

    Provides methods for alignment analysis, validation, and manipulation.
    """

    def __init__(self, sequences: Optional[List[Sequence]] = None):
        """
        Initialize alignment with optional sequences.

        Parameters
        ----------
        sequences :
            List of Sequence objects.
        """
        self._sequences: List[Sequence] = []
        self._sequence_index: Dict[str, int] = {}

        if sequences:
            for seq in sequences:
                self.add_sequence(seq)

    def add_sequence(self, sequence: Sequence) -> None:
        """
        Add a sequence to the alignment.

        Parameters
        ----------
        sequence :
            Sequence object to add.

        Raises :
        ValueError :
            If sequence ID already exists or length doesn't match.
        """
        if sequence.id in self._sequence_index:
            raise ValueError(f"Sequence ID '{sequence.id}' already exists in alignment")

        # Check length consistency (if not first sequence)
        if self._sequences and len(sequence) != self.length:
            raise ValueError(
                f"Sequence length {len(sequence)} doesn't match alignment length {self.length}"
            )

        self._sequence_index[sequence.id] = len(self._sequences)
        self._sequences.append(sequence)

    def remove_sequence(self, sequence_id: str) -> None:
        """
        Remove a sequence from the alignment.

        Parameters
        ----------
        sequence_id :
            ID of sequence to remove.

        Raises :
        KeyError :
            If sequence ID not found.
        """
        if sequence_id not in self._sequence_index:
            raise KeyError(f"Sequence ID '{sequence_id}' not found in alignment")

        index = self._sequence_index[sequence_id]
        del self._sequences[index]

        # Rebuild index
        self._sequence_index = {seq.id: i for i, seq in enumerate(self._sequences)}

    def get_sequence(self, sequence_id: str) -> Sequence:
        """
            Get sequence by ID.

        Parameters
        ----------
            sequence_id :
                ID of sequence to retrieve.

        Returns
        -------
            Sequence object.

            Raises :
            KeyError :
                If sequence ID not found.
        """
        if sequence_id not in self._sequence_index:
            raise KeyError(f"Sequence ID '{sequence_id}' not found in alignment")

        index = self._sequence_index[sequence_id]
        return self._sequences[index]

    def __len__(self) -> int:
        """Return number of sequences in alignment."""
        return len(self._sequences)

    def __iter__(self) -> Iterator[Sequence]:
        """Iterate over sequences in alignment."""
        return iter(self._sequences)

    def __getitem__(self, key: Union[int, str, slice]) -> Union[Sequence, 'Alignment']:
        """
            Get sequence(s) by index, ID, or slice.

        Parameters
        ----------
            key :
                Index, sequence ID, or slice.

        Returns
        -------
            Sequence object or new Alignment object for slices.
        """
        if isinstance(key, str):
            return self.get_sequence(key)
        elif isinstance(key, int):
            return self._sequences[key]
        elif isinstance(key, slice):
            return Alignment(self._sequences[key])
        else:
            raise TypeError(f'Invalid key type: {type(key)}')

    @property
    def length(self) -> int:
        """Get alignment length (sequence length)."""
        if not self._sequences:
            return 0
        return len(self._sequences[0])

    @property
    def sequence_ids(self) -> List[str]:
        """Get list of sequence IDs."""
        return [seq.id for seq in self._sequences]

    def is_valid(self) -> bool:
        """
        Check if alignment is valid (all sequences same length).

        Returns
        -------
            True if all sequences have the same length.
        """
        if not self._sequences:
            return True

        first_length = len(self._sequences[0])
        return all(len(seq) == first_length for seq in self._sequences)

    def validate(self) -> None:
        """
        Validate alignment and raise exception if invalid.

        Raises
        ------
            ValueError: If alignment is invalid
        """
        if not self.is_valid():
            lengths = [len(seq) for seq in self._sequences]
            raise ValueError(
                f'Alignment invalid: sequences have different lengths {set(lengths)}'
            )

    def get_column(self, position: int) -> List[str]:
        """
            Get all characters at a specific position.

        Parameters
        ----------
            position :
                0-based position in alignment.

        Returns
        -------
            List of characters at that position.
        """
        if position < 0 or position >= self.length:
            raise IndexError(f'Position {position} out of range [0, {self.length})')

        return [seq.data[position] for seq in self._sequences]

    def slice_alignment(self, start: int, end: Optional[int] = None) -> 'Alignment':
        """
            Extract a slice of the alignment (specific columns).

        Parameters
        ----------
            start :
                Start position (0-based, inclusive).
            end :
                End position (0-based, exclusive, None for end).

        Returns
        -------
            New Alignment object with sliced sequences.
        """
        sliced_sequences = []
        for seq in self._sequences:
            sliced_seq = seq.slice(start, end)
            sliced_sequences.append(sliced_seq)

        return Alignment(sliced_sequences)

    def remove_gaps_columns(self, gap_threshold: float = 1.0) -> 'Alignment':
        """
            Remove columns with gaps above threshold.

        Parameters
        ----------
            gap_threshold :
                Fraction of gaps required to remove column (0.0-1.0).

        Returns
        -------
            New Alignment object with gap columns removed.
        """
        columns_to_keep = []

        for pos in range(self.length):
            column = self.get_column(pos)
            gap_fraction = column.count('-') / len(column)

            if gap_fraction < gap_threshold:
                columns_to_keep.append(pos)

        # Build new sequences with kept columns
        new_sequences = []
        for seq in self._sequences:
            new_data = ''.join(seq.data[pos] for pos in columns_to_keep)
            new_seq = Sequence(
                id=seq.id,
                data=new_data,
                metadata=seq.metadata.copy(),
                description=seq.description,
            )
            new_sequences.append(new_seq)

        return Alignment(new_sequences)

    def calculate_stats(self) -> AlignmentStats:
        """
        Calculate comprehensive alignment statistics.

        Returns
        -------
            AlignmentStats object with alignment metrics.
        """
        if not self._sequences:
            return AlignmentStats(0, 0, 0, 0.0, 0, 0, 0, 0.0)

        length = self.length
        num_sequences = len(self._sequences)

        # Count gaps
        total_gaps = sum(seq.count_gaps() for seq in self._sequences)
        gap_percentage = (total_gaps / (length * num_sequences)) * 100

        # Analyze sites
        conserved_sites = 0
        variable_sites = 0
        parsimony_informative_sites = 0

        for pos in range(length):
            column = self.get_column(pos)
            # Remove gaps for site analysis
            column_no_gaps = [char for char in column if char != '-']

            if not column_no_gaps:
                continue

            char_counts = Counter(column_no_gaps)
            unique_chars = len(char_counts)

            if unique_chars == 1:
                conserved_sites += 1
            else:
                variable_sites += 1

                # Parsimony informative: at least 2 different chars, each appearing ≥2 times
                if sum(1 for count in char_counts.values() if count >= 2) >= 2:
                    parsimony_informative_sites += 1

        # Calculate overall GC content
        all_bases = ''.join(seq.data.replace('-', '') for seq in self._sequences)
        gc_count = all_bases.count('G') + all_bases.count('C') + all_bases.count('S')
        total_bases = len(all_bases.replace('N', '').replace('?', ''))
        gc_content = (gc_count / total_bases) * 100 if total_bases > 0 else 0.0

        return AlignmentStats(
            length=length,
            num_sequences=num_sequences,
            total_gaps=total_gaps,
            gap_percentage=gap_percentage,
            conserved_sites=conserved_sites,
            variable_sites=variable_sites,
            parsimony_informative_sites=parsimony_informative_sites,
            gc_content=gc_content,
        )

    def get_distance_matrix(self, distance_func=None) -> np.ndarray:
        """
            Calculate pairwise distance matrix between sequences.

        Parameters
        ----------
            distance_func :
                Function to calculate distance between two sequences.
                              If None, uses Hamming distance.

        Returns
        -------
            Square numpy array with pairwise distances.
        """
        if distance_func is None:
            distance_func = self._hamming_distance

        n = len(self._sequences)
        matrix = np.zeros((n, n))

        for i in range(n):
            for j in range(i + 1, n):
                dist = distance_func(self._sequences[i], self._sequences[j])
                matrix[i, j] = matrix[j, i] = dist

        return matrix

    def _hamming_distance(self, seq1: Sequence, seq2: Sequence) -> int:
        """
            Calculate Hamming distance between two sequences.

        Parameters
        ----------
            seq1 :
                First sequence.
            seq2 :
                Second sequence.

        Returns
        -------
            Number of differing positions.
        """
        if len(seq1) != len(seq2):
            raise ValueError('Sequences must have same length for Hamming distance')

        return sum(
            c1 != c2 for c1, c2 in zip(seq1.data, seq2.data) if c1 != '-' and c2 != '-'
        )

    def identify_haplotypes(self) -> Dict[str, List[str]]:
        """
        Identify unique haplotypes and group sequences.

        Returns
        -------
            Dictionary mapping unique sequence data to list of sequence IDs.
        """
        haplotypes = {}

        for seq in self._sequences:
            # Use sequence without gaps as haplotype key
            haplotype_key = seq.remove_gaps().data

            if haplotype_key not in haplotypes:
                haplotypes[haplotype_key] = []

            haplotypes[haplotype_key].append(seq.id)

        return haplotypes

    def to_fasta(self) -> str:
        """
        Convert alignment to FASTA format string.

        Returns
        -------
            FASTA formatted string.
        """
        return '\n'.join(str(seq) for seq in self._sequences)

    def __str__(self) -> str:
        """Return string representation of alignment."""
        stats = self.calculate_stats()
        return (
            f'Alignment: {stats.num_sequences} sequences, '
            f'{stats.length} positions, '
            f'{stats.variable_sites} variable sites'
        )

    def __repr__(self) -> str:
        """Detailed representation of alignment."""
        return f'Alignment({len(self._sequences)} sequences, length={self.length})'
length property 
length: int

Get alignment length (sequence length).

sequence_ids property 
sequence_ids: List[str]

Get list of sequence IDs.

__init__ 
__init__(sequences: Optional[List[Sequence]] = None)

Initialize alignment with optional sequences.

Parameters:

Name Type Description Default
sequences Optional[List[Sequence]]

List of Sequence objects.

 None
Source code in src/pypopart/core/alignment.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
def __init__(self, sequences: Optional[List[Sequence]] = None):
    """
    Initialize alignment with optional sequences.

    Parameters
    ----------
    sequences :
        List of Sequence objects.
    """
    self._sequences: List[Sequence] = []
    self._sequence_index: Dict[str, int] = {}

    if sequences:
        for seq in sequences:
            self.add_sequence(seq)
add_sequence 
add_sequence(sequence: Sequence) -> None

Add a sequence to the alignment.

Parameters:

Name Type Description Default
sequence Sequence

Sequence object to add.

 required
Raises
required
ValueError

If sequence ID already exists or length doesn't match.

 required
Source code in src/pypopart/core/alignment.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
def add_sequence(self, sequence: Sequence) -> None:
    """
    Add a sequence to the alignment.

    Parameters
    ----------
    sequence :
        Sequence object to add.

    Raises :
    ValueError :
        If sequence ID already exists or length doesn't match.
    """
    if sequence.id in self._sequence_index:
        raise ValueError(f"Sequence ID '{sequence.id}' already exists in alignment")

    # Check length consistency (if not first sequence)
    if self._sequences and len(sequence) != self.length:
        raise ValueError(
            f"Sequence length {len(sequence)} doesn't match alignment length {self.length}"
        )

    self._sequence_index[sequence.id] = len(self._sequences)
    self._sequences.append(sequence)
remove_sequence 
remove_sequence(sequence_id: str) -> None

Remove a sequence from the alignment.

Parameters:

Name Type Description Default
sequence_id str

ID of sequence to remove.

 required
Raises
required
KeyError

If sequence ID not found.

 required
Source code in src/pypopart/core/alignment.py 
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
def remove_sequence(self, sequence_id: str) -> None:
    """
    Remove a sequence from the alignment.

    Parameters
    ----------
    sequence_id :
        ID of sequence to remove.

    Raises :
    KeyError :
        If sequence ID not found.
    """
    if sequence_id not in self._sequence_index:
        raise KeyError(f"Sequence ID '{sequence_id}' not found in alignment")

    index = self._sequence_index[sequence_id]
    del self._sequences[index]

    # Rebuild index
    self._sequence_index = {seq.id: i for i, seq in enumerate(self._sequences)}
get_sequence 
get_sequence(sequence_id: str) -> Sequence

Get sequence by ID.

Returns:

Type Description
Sequence object.

Raises : KeyError : If sequence ID not found.
Source code in src/pypopart/core/alignment.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def get_sequence(self, sequence_id: str) -> Sequence:
    """
        Get sequence by ID.

    Parameters
    ----------
        sequence_id :
            ID of sequence to retrieve.

    Returns
    -------
        Sequence object.

        Raises :
        KeyError :
            If sequence ID not found.
    """
    if sequence_id not in self._sequence_index:
        raise KeyError(f"Sequence ID '{sequence_id}' not found in alignment")

    index = self._sequence_index[sequence_id]
    return self._sequences[index]
__len__ 
__len__() -> int

Return number of sequences in alignment.

Source code in src/pypopart/core/alignment.py 
119
120
121
def __len__(self) -> int:
    """Return number of sequences in alignment."""
    return len(self._sequences)
__iter__ 
__iter__() -> Iterator[Sequence]

Iterate over sequences in alignment.

Source code in src/pypopart/core/alignment.py 
123
124
125
def __iter__(self) -> Iterator[Sequence]:
    """Iterate over sequences in alignment."""
    return iter(self._sequences)
__getitem__ 
__getitem__(
    key: Union[int, str, slice],
) -> Union[Sequence, Alignment]

Get sequence(s) by index, ID, or slice.

Returns:

Type Description
Sequence object or new Alignment object for slices.
Source code in src/pypopart/core/alignment.py 
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def __getitem__(self, key: Union[int, str, slice]) -> Union[Sequence, 'Alignment']:
    """
        Get sequence(s) by index, ID, or slice.

    Parameters
    ----------
        key :
            Index, sequence ID, or slice.

    Returns
    -------
        Sequence object or new Alignment object for slices.
    """
    if isinstance(key, str):
        return self.get_sequence(key)
    elif isinstance(key, int):
        return self._sequences[key]
    elif isinstance(key, slice):
        return Alignment(self._sequences[key])
    else:
        raise TypeError(f'Invalid key type: {type(key)}')
is_valid 
is_valid() -> bool

Check if alignment is valid (all sequences same length).

Returns:

Type Description
True if all sequences have the same length.
Source code in src/pypopart/core/alignment.py 
161
162
163
164
165
166
167
168
169
170
171
172
173
def is_valid(self) -> bool:
    """
    Check if alignment is valid (all sequences same length).

    Returns
    -------
        True if all sequences have the same length.
    """
    if not self._sequences:
        return True

    first_length = len(self._sequences[0])
    return all(len(seq) == first_length for seq in self._sequences)
validate 
validate() -> None

Validate alignment and raise exception if invalid.

Raises:

Type Description
ValueError: If alignment is invalid
Source code in src/pypopart/core/alignment.py 
175
176
177
178
179
180
181
182
183
184
185
186
187
def validate(self) -> None:
    """
    Validate alignment and raise exception if invalid.

    Raises
    ------
        ValueError: If alignment is invalid
    """
    if not self.is_valid():
        lengths = [len(seq) for seq in self._sequences]
        raise ValueError(
            f'Alignment invalid: sequences have different lengths {set(lengths)}'
        )
get_column 
get_column(position: int) -> List[str]

Get all characters at a specific position.

Returns:

Type Description
List of characters at that position.
Source code in src/pypopart/core/alignment.py 
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
def get_column(self, position: int) -> List[str]:
    """
        Get all characters at a specific position.

    Parameters
    ----------
        position :
            0-based position in alignment.

    Returns
    -------
        List of characters at that position.
    """
    if position < 0 or position >= self.length:
        raise IndexError(f'Position {position} out of range [0, {self.length})')

    return [seq.data[position] for seq in self._sequences]
slice_alignment 
slice_alignment(
    start: int, end: Optional[int] = None
) -> Alignment

Extract a slice of the alignment (specific columns).

Returns:

Type Description
New Alignment object with sliced sequences.
Source code in src/pypopart/core/alignment.py 
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
def slice_alignment(self, start: int, end: Optional[int] = None) -> 'Alignment':
    """
        Extract a slice of the alignment (specific columns).

    Parameters
    ----------
        start :
            Start position (0-based, inclusive).
        end :
            End position (0-based, exclusive, None for end).

    Returns
    -------
        New Alignment object with sliced sequences.
    """
    sliced_sequences = []
    for seq in self._sequences:
        sliced_seq = seq.slice(start, end)
        sliced_sequences.append(sliced_seq)

    return Alignment(sliced_sequences)
remove_gaps_columns 
remove_gaps_columns(
    gap_threshold: float = 1.0,
) -> Alignment

Remove columns with gaps above threshold.

Returns:

Type Description
New Alignment object with gap columns removed.
Source code in src/pypopart/core/alignment.py 
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
def remove_gaps_columns(self, gap_threshold: float = 1.0) -> 'Alignment':
    """
        Remove columns with gaps above threshold.

    Parameters
    ----------
        gap_threshold :
            Fraction of gaps required to remove column (0.0-1.0).

    Returns
    -------
        New Alignment object with gap columns removed.
    """
    columns_to_keep = []

    for pos in range(self.length):
        column = self.get_column(pos)
        gap_fraction = column.count('-') / len(column)

        if gap_fraction < gap_threshold:
            columns_to_keep.append(pos)

    # Build new sequences with kept columns
    new_sequences = []
    for seq in self._sequences:
        new_data = ''.join(seq.data[pos] for pos in columns_to_keep)
        new_seq = Sequence(
            id=seq.id,
            data=new_data,
            metadata=seq.metadata.copy(),
            description=seq.description,
        )
        new_sequences.append(new_seq)

    return Alignment(new_sequences)
calculate_stats 
calculate_stats() -> AlignmentStats

Calculate comprehensive alignment statistics.

Returns:

Type Description
AlignmentStats object with alignment metrics.
Source code in src/pypopart/core/alignment.py 
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
def calculate_stats(self) -> AlignmentStats:
    """
    Calculate comprehensive alignment statistics.

    Returns
    -------
        AlignmentStats object with alignment metrics.
    """
    if not self._sequences:
        return AlignmentStats(0, 0, 0, 0.0, 0, 0, 0, 0.0)

    length = self.length
    num_sequences = len(self._sequences)

    # Count gaps
    total_gaps = sum(seq.count_gaps() for seq in self._sequences)
    gap_percentage = (total_gaps / (length * num_sequences)) * 100

    # Analyze sites
    conserved_sites = 0
    variable_sites = 0
    parsimony_informative_sites = 0

    for pos in range(length):
        column = self.get_column(pos)
        # Remove gaps for site analysis
        column_no_gaps = [char for char in column if char != '-']

        if not column_no_gaps:
            continue

        char_counts = Counter(column_no_gaps)
        unique_chars = len(char_counts)

        if unique_chars == 1:
            conserved_sites += 1
        else:
            variable_sites += 1

            # Parsimony informative: at least 2 different chars, each appearing ≥2 times
            if sum(1 for count in char_counts.values() if count >= 2) >= 2:
                parsimony_informative_sites += 1

    # Calculate overall GC content
    all_bases = ''.join(seq.data.replace('-', '') for seq in self._sequences)
    gc_count = all_bases.count('G') + all_bases.count('C') + all_bases.count('S')
    total_bases = len(all_bases.replace('N', '').replace('?', ''))
    gc_content = (gc_count / total_bases) * 100 if total_bases > 0 else 0.0

    return AlignmentStats(
        length=length,
        num_sequences=num_sequences,
        total_gaps=total_gaps,
        gap_percentage=gap_percentage,
        conserved_sites=conserved_sites,
        variable_sites=variable_sites,
        parsimony_informative_sites=parsimony_informative_sites,
        gc_content=gc_content,
    )
get_distance_matrix 
get_distance_matrix(distance_func=None) -> np.ndarray

Calculate pairwise distance matrix between sequences.

Returns:

Type Description
Square numpy array with pairwise distances.
Source code in src/pypopart/core/alignment.py 
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
def get_distance_matrix(self, distance_func=None) -> np.ndarray:
    """
        Calculate pairwise distance matrix between sequences.

    Parameters
    ----------
        distance_func :
            Function to calculate distance between two sequences.
                          If None, uses Hamming distance.

    Returns
    -------
        Square numpy array with pairwise distances.
    """
    if distance_func is None:
        distance_func = self._hamming_distance

    n = len(self._sequences)
    matrix = np.zeros((n, n))

    for i in range(n):
        for j in range(i + 1, n):
            dist = distance_func(self._sequences[i], self._sequences[j])
            matrix[i, j] = matrix[j, i] = dist

    return matrix
identify_haplotypes 
identify_haplotypes() -> Dict[str, List[str]]

Identify unique haplotypes and group sequences.

Returns:

Type Description
Dictionary mapping unique sequence data to list of sequence IDs.
Source code in src/pypopart/core/alignment.py 
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
def identify_haplotypes(self) -> Dict[str, List[str]]:
    """
    Identify unique haplotypes and group sequences.

    Returns
    -------
        Dictionary mapping unique sequence data to list of sequence IDs.
    """
    haplotypes = {}

    for seq in self._sequences:
        # Use sequence without gaps as haplotype key
        haplotype_key = seq.remove_gaps().data

        if haplotype_key not in haplotypes:
            haplotypes[haplotype_key] = []

        haplotypes[haplotype_key].append(seq.id)

    return haplotypes
to_fasta 
to_fasta() -> str

Convert alignment to FASTA format string.

Returns:

Type Description
FASTA formatted string.
Source code in src/pypopart/core/alignment.py 
395
396
397
398
399
400
401
402
403
def to_fasta(self) -> str:
    """
    Convert alignment to FASTA format string.

    Returns
    -------
        FASTA formatted string.
    """
    return '\n'.join(str(seq) for seq in self._sequences)
__str__ 
__str__() -> str

Return string representation of alignment.

Source code in src/pypopart/core/alignment.py 
405
406
407
408
409
410
411
412
def __str__(self) -> str:
    """Return string representation of alignment."""
    stats = self.calculate_stats()
    return (
        f'Alignment: {stats.num_sequences} sequences, '
        f'{stats.length} positions, '
        f'{stats.variable_sites} variable sites'
    )
__repr__ 
__repr__() -> str

Detailed representation of alignment.

Source code in src/pypopart/core/alignment.py 
414
415
416
def __repr__(self) -> str:
    """Detailed representation of alignment."""
    return f'Alignment({len(self._sequences)} sequences, length={self.length})'