Skip to content

Base Algorithm Module

Base classes and interfaces for network algorithms.

Overview

The base module defines the abstract base class for all network construction algorithms.

Classes

pypopart.algorithms.base

Base classes for network construction algorithms in PyPopART.

NetworkAlgorithm

Bases: ABC

Abstract base class for haplotype network construction algorithms.

All network construction algorithms should inherit from this class and implement the construct_network method.

Source code in src/pypopart/algorithms/base.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 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
class NetworkAlgorithm(ABC):
    """
    Abstract base class for haplotype network construction algorithms.

    All network construction algorithms should inherit from this class
    and implement the construct_network method.
    """

    def __init__(self, distance_method: str = 'hamming', **kwargs):
        """
        Initialize network algorithm.

        Parameters
        ----------
        distance_method :
            Method for calculating distances (hamming, p, jc, k2p, tn).
        **kwargs :
            Additional algorithm-specific parameters.
        """
        self.distance_method = distance_method
        self.params = kwargs
        self._distance_matrix: Optional[DistanceMatrix] = None

    @abstractmethod
    def construct_network(
        self, alignment: Alignment, distance_matrix: Optional[DistanceMatrix] = None
    ) -> HaplotypeNetwork:
        """
            Construct haplotype network from sequence alignment.

        Parameters
        ----------
            alignment :
                Multiple sequence alignment.
            distance_matrix :
                Optional pre-computed distance matrix.

        Returns
        -------
            Constructed haplotype network.
        """
        pass

    def calculate_distances(self, alignment: Alignment) -> DistanceMatrix:
        """
            Calculate pairwise distances between sequences.

        Parameters
        ----------
            alignment :
                Multiple sequence alignment.

        Returns
        -------
            Distance matrix.
        """
        return calculate_pairwise_distances(
            alignment,
            method=self.distance_method,
            ignore_gaps=self.params.get('ignore_gaps', True),
        )

    def build_network(
        self, alignment: Alignment, distance_matrix: Optional[DistanceMatrix] = None
    ) -> HaplotypeNetwork:
        """
        Build haplotype network from sequence alignment.

        This is an alias for construct_network() to maintain backward compatibility
        with CLI and GUI code.

        Parameters
        ----------
            alignment :
                Multiple sequence alignment.
            distance_matrix :
                Optional pre-computed distance matrix.

        Returns
        -------
            Constructed haplotype network.
        """
        return self.construct_network(alignment, distance_matrix)

    def get_parameters(self) -> Dict[str, Any]:
        """
        Get algorithm parameters.

        Returns
        -------
            Dictionary of parameters.
        """
        return {'distance_method': self.distance_method, **self.params}

    def __str__(self) -> str:
        """Return string representation."""
        return f'{self.__class__.__name__}(distance={self.distance_method})'

    def __repr__(self) -> str:
        """Detailed representation."""
        params_str = ', '.join(f'{k}={v}' for k, v in self.get_parameters().items())
        return f'{self.__class__.__name__}({params_str})'
__init__ 
__init__(distance_method: str = 'hamming', **kwargs)

Initialize network algorithm.

Parameters:

Name Type Description Default
distance_method str

Method for calculating distances (hamming, p, jc, k2p, tn).

 'hamming'
**kwargs

Additional algorithm-specific parameters.

 {}
Source code in src/pypopart/algorithms/base.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def __init__(self, distance_method: str = 'hamming', **kwargs):
    """
    Initialize network algorithm.

    Parameters
    ----------
    distance_method :
        Method for calculating distances (hamming, p, jc, k2p, tn).
    **kwargs :
        Additional algorithm-specific parameters.
    """
    self.distance_method = distance_method
    self.params = kwargs
    self._distance_matrix: Optional[DistanceMatrix] = None
construct_network abstractmethod 
construct_network(
    alignment: Alignment,
    distance_matrix: Optional[DistanceMatrix] = None,
) -> HaplotypeNetwork

Construct haplotype network from sequence alignment.

Returns:

Type Description
Constructed haplotype network.
Source code in src/pypopart/algorithms/base.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@abstractmethod
def construct_network(
    self, alignment: Alignment, distance_matrix: Optional[DistanceMatrix] = None
) -> HaplotypeNetwork:
    """
        Construct haplotype network from sequence alignment.

    Parameters
    ----------
        alignment :
            Multiple sequence alignment.
        distance_matrix :
            Optional pre-computed distance matrix.

    Returns
    -------
        Constructed haplotype network.
    """
    pass
calculate_distances 
calculate_distances(alignment: Alignment) -> DistanceMatrix

Calculate pairwise distances between sequences.

Returns:

Type Description
Distance matrix.
Source code in src/pypopart/algorithms/base.py 
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
def calculate_distances(self, alignment: Alignment) -> DistanceMatrix:
    """
        Calculate pairwise distances between sequences.

    Parameters
    ----------
        alignment :
            Multiple sequence alignment.

    Returns
    -------
        Distance matrix.
    """
    return calculate_pairwise_distances(
        alignment,
        method=self.distance_method,
        ignore_gaps=self.params.get('ignore_gaps', True),
    )
build_network 
build_network(
    alignment: Alignment,
    distance_matrix: Optional[DistanceMatrix] = None,
) -> HaplotypeNetwork

Build haplotype network from sequence alignment.

This is an alias for construct_network() to maintain backward compatibility with CLI and GUI code.

Returns:

Type Description
Constructed haplotype network.
Source code in src/pypopart/algorithms/base.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
def build_network(
    self, alignment: Alignment, distance_matrix: Optional[DistanceMatrix] = None
) -> HaplotypeNetwork:
    """
    Build haplotype network from sequence alignment.

    This is an alias for construct_network() to maintain backward compatibility
    with CLI and GUI code.

    Parameters
    ----------
        alignment :
            Multiple sequence alignment.
        distance_matrix :
            Optional pre-computed distance matrix.

    Returns
    -------
        Constructed haplotype network.
    """
    return self.construct_network(alignment, distance_matrix)
get_parameters 
get_parameters() -> Dict[str, Any]

Get algorithm parameters.

Returns:

Type Description
Dictionary of parameters.
Source code in src/pypopart/algorithms/base.py 
 95
 96
 97
 98
 99
100
101
102
103
def get_parameters(self) -> Dict[str, Any]:
    """
    Get algorithm parameters.

    Returns
    -------
        Dictionary of parameters.
    """
    return {'distance_method': self.distance_method, **self.params}
__str__ 
__str__() -> str

Return string representation.

Source code in src/pypopart/algorithms/base.py 
105
106
107
def __str__(self) -> str:
    """Return string representation."""
    return f'{self.__class__.__name__}(distance={self.distance_method})'
__repr__ 
__repr__() -> str

Detailed representation.

Source code in src/pypopart/algorithms/base.py 
109
110
111
112
def __repr__(self) -> str:
    """Detailed representation."""
    params_str = ', '.join(f'{k}={v}' for k, v in self.get_parameters().items())
    return f'{self.__class__.__name__}({params_str})'