msasim 2024.5.22__cp36-cp36m-musllinux_1_1_x86_64.whl

Sailfish/simulator.py

@@ -0,0 +1,537 @@
+import _Sailfish
+import os, warnings, math, operator, time, profile
+from functools import reduce
+from typing import List, Optional, Dict
+from re import split
+from enum import Enum
+
+# print(_Sailfish.Tree)
+# print(_Sailfish.Simulator)
+# print(_Sailfish.SimProtocol)
+# print(_Sailfish.Msa)
+# print(_Sailfish.DiscreteDistribution)
+# print(_Sailfish.modelFactory)
+# print(_Sailfish.alphabetCode)
+# print(_Sailfish.modelCode)
+
+
+MODEL_CODES = _Sailfish.modelCode
+
+class SIMULATION_TYPE(Enum):
+    DNA = 1
+    PROTEIN = 2
+
+class Distribution:
+    def set_dist(self, dist):
+        # sum should be "around" 1
+        epsilon = 10e-6
+        if abs(sum(dist)-1) > epsilon:
+            raise ValueError(f"Sum of the distribution should be 1 for a valid probability distribution. Input received is: {dist}, sum is {sum(dist)}")
+        for x in dist:
+            if x < 0 or x > 1:
+                raise ValueError(f"Each value of the probabilities should be between 0 to 1. Received a value of {x}")
+        self._dist = _Sailfish.DiscreteDistribution(dist)
+    
+    def draw_sample(self) -> int:
+        return self._dist.draw_sample()
+    
+    def set_seed(self, seed: int) -> None:
+        return self._dist.set_seed(seed)
+    
+    def get_table(self) -> List:
+        return self._dist.get_table()
+    
+    def _get_Sailfish_dist(self) -> _Sailfish.DiscreteDistribution:
+        return self._dist
+
+class CustomDistribution(Distribution):
+    '''
+    Provide a custom discrete distribution to the model.
+    '''
+    def __init__(self, dist: List[float]):
+        self.set_dist(dist)
+
+class GeometricDistribution(Distribution):
+    def __init__(self, p: float, truncation: int = 150):
+        """
+        Calculation of geoemtric moment
+        inputs:
+        p - p parameter of the geoemtric distribution
+        truncation - (optional, by default 150) maximal value of the distribution
+        """
+        self.p = p
+        self.truncation = truncation
+        PMF = lambda x: p*(1-p)**(x-1)
+        CDF = lambda x: 1-(1-p)**x
+        norm_factor = CDF(truncation) - CDF(0)
+
+        probabilities = [PMF(i)/norm_factor for i in range(1, truncation+1)]
+        # probabilities = probabilities / norm_factor
+
+        self.set_dist(probabilities)
+
+    def __repr__(self) -> str:
+        return f"Geometric distribution: (p={self.p}, truncation{self.truncation})"
+
+class PoissonDistribution(Distribution):
+    def __init__(self, p: float, truncation: int = 150):
+        """
+        Calculation of geoemtric moment
+        inputs:
+        p - p parameter of the geoemtric distribution
+        truncation - (optional, by default 150) maximal value of the distribution
+        """
+        self.p = p
+        self.truncation = truncation
+
+        factorial = lambda z: reduce(operator.mul, [1, 1] if z == 0 else range(1,z+1))
+
+        PMF = lambda x: ((p**x)*(math.e**-p))*(1.0/factorial(x))
+        CDF = lambda x: (math.e**-p)*sum([(p**i)*(1.0/factorial(i)) for i in range(0,x+1)])
+
+        norm_factor = CDF(truncation) - CDF(0)
+
+        probabilities = [PMF(i)/norm_factor for i in range(1, truncation+1)]
+
+        self.set_dist(probabilities)
+
+    def __repr__(self) -> str:
+        return f"Poisson distribution: (p={self.p}, truncation{self.truncation})"
+
+class ZipfDistribution(Distribution):
+    def __init__(self, p: float, truncation: int = 150):
+        """
+        Calculation of geoemtric moment
+        inputs:
+        p - p parameter of the geoemtric distribution
+        truncation - (optional, by default 150) maximal value of the distribution
+        """
+        self.p = p
+        self.truncation = truncation
+        HARMONIC = lambda n,s: sum([(i**-s) for i in range(1,n+1)])
+        PMF = lambda x: (x**-p)*(1.0/HARMONIC(truncation, p))
+        CDF = lambda x: HARMONIC(x, p) / HARMONIC(truncation, p)
+        norm_factor = CDF(truncation) - CDF(0)
+
+        probabilities = [PMF(i)/norm_factor for i in range(1, truncation+1)]
+
+        self.set_dist(probabilities)
+    
+    def __repr__(self) -> str:
+        return f"Zipf distribution: (p={self.p}, truncation{self.truncation})" 
+
+def is_newick(tree: str):
+    # from: https://github.com/ila/Newick-validator/blob/master/Newick_Validator.py
+    # dividing the string into tokens, to check them singularly
+    tokens = split(r'([A-Za-z]+[^A-Za-z,)]+[A-Za-z]+|[0-9.]*[A-Za-z]+[0-9.]+|[0-9.]+\s+[0-9.]+|[0-9.]+|[A-za-z]+|\(|\)|;|:|,)', tree)
+
+    # removing spaces and empty strings (spaces within labels are still present)
+    parsed_tokens = list(filter(lambda x: not (x.isspace() or not x), tokens))
+
+    # checking whether the tree ends with ;
+    if parsed_tokens[-1] != ';':
+        raise ValueError(f"Tree without ; at the end. Tree received: {tree}")
+        return False
+    return True
+
+# TODO, I think should be deleted
+class Block:
+    '''
+    A single block of event. 
+    Used to add insertions or deletions.
+    '''
+    def __init__(self, num1: int, num2: int):
+        self.block = _Sailfish.Block(num1, num2)
+
+class BlockTree:
+    '''
+    Used to contain the events on a multiple branches (entire tree).
+    '''
+    def __init__(self, root_length: int):
+        self.blockTree = _Sailfish.BlockTree(root_length)
+    
+    def print_tree(self) -> str:
+        return self.blockTree.print_tree()
+    
+    def block_list(self)  -> List:
+        return self.blockTree.block_list()
+
+# TODO delete one of this (I think the above if not used)
+class BlockTreePython:
+    '''
+    Used to contain the events on a multiple branches (entire tree).
+    '''
+    def __init__(self, branch_block_dict: Dict[str, _Sailfish.Block]):
+        self._branch_block_dict = branch_block_dict
+        # dictionary of {str: List of blocks}
+        self._branch_block_dict_python = {i: x for i, x in branch_block_dict.items()}
+    
+    def _get_Sailfish_blocks(self) -> Dict[str, _Sailfish.Block]:
+        return self._branch_block_dict
+    
+    def get_branches_str(self) -> str:
+        return {i: self._branch_block_dict[i].print_tree() for i in list(self._branch_block_dict.keys())}
+    
+    def get_specific_branch(self, branch: str) -> str:
+        if not branch in self._branch_block_dict_python:
+            raise ValueError(f"branch not in the _branch_block, aviable branches are: {list(self._branch_block_dict_python.keys())}")
+        return self._branch_block_dict[branch].print_tree()
+    
+    def print_branches(self) -> str:
+        for i in list(self._branch_block_dict.keys()):
+            print(f"branch = {i}")
+            print(self._branch_block_dict[i].print_tree())
+    
+    def block_list(self)  -> List:
+        if not branch in self._branch_block_dict_python:
+            raise ValueError(f"branch not in the _branch_block, aviable branches are: {list(self._branch_block_dict_python.keys())}")
+        return self._branch_block_dict_python[branch]
+
+class Tree:
+    '''
+    The tree class for the simulator
+    '''
+    def __init__(self, input_str: str):
+        is_from_file = False
+        if os.path.isfile(input_str):
+            is_from_file = True
+            tree_str = open(input_str, 'r').read()
+        else:
+            tree_str = input_str
+        if not is_newick(tree_str):
+            if is_from_file:
+                raise ValueError(f"Failed to read tree from file. File path: {input_str}, content: {tree_str}")
+            else:
+                raise ValueError(f"Failed construct tree from string. String received: {tree_str}")
+        self._tree = _Sailfish.Tree(input_str, is_from_file)
+        self._tree_str = tree_str
+    
+    def get_num_nodes(self) -> int:
+        return self._tree.num_nodes
+
+    def get_num_leaves(self) -> int:
+        return self._tree.root.num_leaves
+
+    def _get_Sailfish_tree(self) -> _Sailfish.Tree:
+        return self._tree
+    
+    def __repr__(self) -> str:
+        return f"{self._tree_str}"
+
+class SimProtocol:
+    '''
+    The simulator protocol, sets the different distribution, tree and root length.
+    '''
+    def __init__(self, tree = None,
+                 root_seq_size: int = 100,
+                 deletion_rate: float = 0.0, 
+                 insertion_rate: float = 0.0,
+                 deletion_dist: Distribution = ZipfDistribution(1.7, 50),
+                 insertion_dist: Distribution = ZipfDistribution(1.7, 50),
+                 seed: int = 0,
+        ):
+        if isinstance(tree, Tree):
+            self._tree = tree
+        elif isinstance(tree, str):
+            self._tree = Tree(tree) 
+        else:
+            raise ValueError(f"please provide one of the following: (1) a newick format of a tree; (2) a path to a file containing a tree; (3) or a tree created by the Tree class")
+        
+        self._num_branches = self._tree.get_num_nodes() - 1
+        self._sim = _Sailfish.SimProtocol(self._tree._get_Sailfish_tree())
+        self.set_seed(seed)
+        self.set_sequence_size(root_seq_size)
+        self._is_deletion_rate_zero = not deletion_rate
+        self._is_insertion_rate_zero = not insertion_rate
+        self.set_deletion_rates(deletion_rate=deletion_rate)
+        self.set_insertion_rates(insertion_rate=insertion_rate)
+        self.set_deletion_length_distributions(deletion_dist=deletion_dist)
+        self.set_insertion_length_distributions(insertion_dist=insertion_dist)
+    
+    def get_tree(self) -> Tree:
+        return self._tree
+    
+    def _get_Sailfish_tree(self) -> _Sailfish.Tree:
+        return self._tree._get_Sailfish_tree()
+    
+    def _get_root(self):
+        return self._tree._get_Sailfish_tree().root
+    
+    def get_num_branches(self) -> int:
+        return self._num_branches
+    
+    def set_seed(self, seed: int) -> None:
+        self._seed = seed
+        self._sim.set_seed(seed)
+    
+    def get_seed(self) -> int:
+        return self._seed
+    
+    def set_sequence_size(self, sequence_size: int) -> None:
+        self._sim.set_sequence_size(sequence_size)
+        self._root_seq_size = sequence_size
+    
+    def get_sequence_size(self) -> int:
+        return self._root_seq_size
+    
+    def set_insertion_rates(self, insertion_rate: Optional[float] = None, insertion_rates: Optional[List[float]] = None) -> None:
+        if insertion_rate is not None:
+            self.insertion_rates = [insertion_rate] * self._num_branches
+            if insertion_rate:
+                self._is_insertion_rate_zero = False
+        elif insertion_rates:
+            if not len(insertion_rates) == self._num_branches:
+                raise ValueError(f"The length of the insertaion rates should be equal to the number of branches in the tree. The insertion_rates length is {len(insertion_rates)} and the number of branches is {self._num_branches}. You can pass a single value as insertion_rate which will be used for all branches.")
+            self.insertion_rates = insertion_rates
+            for insertion_rate in insertion_rates:
+                if insertion_rate:
+                    self._is_insertion_rate_zero = False
+        else:
+            raise ValueError(f"please provide one of the following: insertion_rate (a single value used for all branches), or a insertion_rates (a list of values, each corresponding to a different branch)")
+        
+        self._sim.set_insertion_rates(self.insertion_rates)
+    
+    def get_insertion_rate(self, branch_num: int) -> float:
+        if branch_num >= self._num_branches:
+            raise ValueError(f"The branch number should be between 0 to {self._num_branches} (not included). Received value of {branch_num}")
+        return self._sim.get_insertion_rate(branch_num)
+    
+    def get_all_insertion_rates(self) -> Dict:
+        return {i: self.get_insertion_rate(i) for i in range(self._num_branches)}
+    
+    def set_deletion_rates(self, deletion_rate: Optional[float] = None, deletion_rates: Optional[List[float]] = None) -> None:
+        if deletion_rate is not None:
+            self.deletion_rates = [deletion_rate] * self._num_branches
+            if deletion_rate:
+                self._is_deletion_rate_zero = False
+        elif deletion_rates:
+            if not len(deletion_rates) == self._num_branches:
+                raise ValueError(f"The length of the deletion rates should be equal to the number of branches in the tree. The deletion_rates length is {len(deletion_rates)} and the number of branches is {self._num_branches}. You can pass a single value as deletion_rate which will be used for all branches.")
+            self.deletion_rates = deletion_rates
+            for deletion_rate in deletion_rates:
+                if deletion_rate:
+                    self._is_deletion_rate_zero = False
+        else:
+            raise ValueError(f"please provide one of the following: deletion_rate (a single value used for all branches), or a deletion_rates (a list of values, each corresponding to a different branch)")
+        
+        self._sim.set_deletion_rates(self.deletion_rates)
+    
+    def get_deletion_rate(self, branch_num: int) -> float:
+        if branch_num >= self._num_branches:
+            raise ValueError(f"The branch number should be between 0 to {self._num_branches} (not included). Received value of {branch_num}")
+        return self._sim.get_deletion_rate(branch_num)
+    
+    def get_all_deletion_rates(self) -> Dict:
+        return {i: self.get_deletion_rate(i) for i in range(self._num_branches)}
+    
+    def set_insertion_length_distributions(self, insertion_dist: Optional[Distribution] = None, insertion_dists: Optional[List[Distribution]] = None) -> None:
+        if insertion_dist:
+            self.insertion_dists = [insertion_dist] * self._num_branches
+        elif insertion_dists:
+            if not len(insertion_dists) == self._num_branches:
+                raise ValueError(f"The length of the insertion dists should be equal to the number of branches in the tree. The insertion_dists length is {len(insertion_dists)} and the number of branches is {self._num_branches}. You can pass a single value as insertion_dist which will be used for all branches.")
+            self.insertion_dists = insertion_dists
+        else:
+            raise ValueError(f"please provide one of the following: deletion_rate (a single value used for all branches), or a deletion_rates (a list of values, each corresponding to a different branch)")
+        
+        self._sim.set_insertion_length_distributions([dist._get_Sailfish_dist() for dist in self.insertion_dists])
+    
+    def get_insertion_length_distribution(self, branch_num: int) -> Distribution:
+        if branch_num >= self._num_branches:
+            raise ValueError(f"The branch number should be between 0 to {self._num_branches} (not included). Received value of {branch_num}")
+        return self.insertion_dists[branch_num]
+    
+    def get_all_insertion_length_distribution(self) -> Dict:
+        return {i: self.get_insertion_length_distribution(i) for i in range(self._num_branches)}
+    
+    def set_deletion_length_distributions(self, deletion_dist: Optional[Distribution] = None, deletion_dists: Optional[List[Distribution]] = None) -> None:
+        if deletion_dist:
+            self.deletion_dists = [deletion_dist] * self._num_branches
+        elif deletion_dists:
+            if not len(deletion_dists) == self._num_branches:
+                raise ValueError(f"The length of the deletion dists should be equal to the number of branches in the tree. The deletion_dists length is {len(deletion_dists)} and the number of branches is {self._num_branches}. You can pass a single value as deletion_dist which will be used for all branches.")
+            self.deletion_dists = deletion_dists
+        else:
+            raise ValueError(f"please provide one of the following: deletion_rate (a single value used for all branches), or a deletion_rates (a list of values, each corresponding to a different branch)")
+        
+        self._sim.set_deletion_length_distributions([dist._get_Sailfish_dist() for dist in self.deletion_dists])
+    
+    def get_deletion_length_distribution(self, branch_num: int) -> Distribution:
+        if branch_num >= self._num_branches:
+            raise ValueError(f"The branch number should be between 0 to {self._num_branches} (not included). Received value of {branch_num}")
+        return self.deletion_dists[branch_num]
+    
+    def get_all_deletion_length_distribution(self) -> Dict:
+        return {i: self.get_deletion_length_distribution(i) for i in range(self._num_branches)}
+
+class Msa:
+    '''
+    The MSA class from the simulator
+    '''
+    def __init__(self, species_dict: Dict[str, BlockTree], root_node):
+        self._msa = _Sailfish.Msa(species_dict, root_node)
+    
+    def generate_msas(self, node):
+        self._msa.generate_msas(node)
+    
+    def get_length(self) -> int:
+        return self._msa.length()
+    
+    def get_num_sequences(self) -> int:
+        return self._msa.num_sequences()
+    
+    def fill_substitutions(self, sequenceContainer) -> None:
+        self._msa.fill_substitutions(sequenceContainer)
+    
+    def print_msa(self) -> str:
+        return self._msa.print_msa()
+    
+    def print_indels(self) -> str:
+        return self._msa.print_indels()
+    
+    def get_msa(self) -> str:
+        return self._msa.get_msa()
+    
+    def write_msa(self, file_path) -> None:
+        self._msa.write_msa(file_path)
+    
+    #def __repr__(self) -> str:
+    #    return f"{self.get_msa()}"
+
+class Simulator:
+    '''
+    Simulate MSAs based on SimProtocol
+    '''
+    def __init__(self, simProtocol: Optional[SimProtocol] = None, simulation_type: Optional[SIMULATION_TYPE] = None):
+        if not simProtocol:
+            warnings.warn(f"initalized a simulator without simProtocol -> using a default protocol with Tree = '(A:0.01,B:0.5,C:0.03);' and root length of 100")
+            # default simulation values
+            possion = PoissonDistribution(10, 100)
+            simProtocol = SimProtocol(tree="(A:0.01,B:0.5,C:0.03);")
+            simProtocol.set_insertion_length_distributions(possion)
+            simProtocol.set_deletion_length_distributions(possion)
+            simProtocol.set_insertion_rates(0.05)
+            simProtocol.set_deletion_rates(0.05)
+            simProtocol.set_sequence_size(100)
+        # verify sim_protocol
+        if self._verify_sim_protocol(simProtocol):
+            self._simProtocol = simProtocol
+            self._simulator = _Sailfish.Simulator(self._simProtocol._sim)
+        else:
+            raise ValueError(f"failed to verify simProtocol")
+        
+        if not simulation_type:
+            warnings.warn(f"simulation type not provided -> running protein simulation")
+            simulation_type = SIMULATION_TYPE.PROTEIN
+        
+        if simulation_type == SIMULATION_TYPE.PROTEIN:
+            self._alphabet = _Sailfish.alphabetCode.AMINOACID
+        elif simulation_type == SIMULATION_TYPE.DNA:
+            self._alphabet = _Sailfish.alphabetCode.NUCLEOTIDE
+        else:
+            raise ValueError(f"unknown simulation type, please provde one of the following: {[e.name for e in SIMULATION_TYPE]}")
+        
+        self._simulation_type = simulation_type
+        self._is_sub_model_init = False
+    
+    def _verify_sim_protocol(self, simProtocol) -> bool:
+        if not simProtocol.get_tree():
+            raise ValueError(f"protocol miss tree, please provide when initalizing the simProtocol")
+        if not simProtocol.get_sequence_size() or simProtocol.get_sequence_size() == 0:
+            raise ValueError(f"protocol miss root length, please provide -> simProtocol.set_sequence_size(int)")
+        if not simProtocol.get_insertion_length_distribution(0):
+            raise ValueError(f"protocol miss insertion length distribution, please provide -> simProtocol.set_insertion_length_distributions(float)")
+        if not simProtocol.get_deletion_length_distribution(0):
+            raise ValueError(f"protocol miss deletion length distribution, please provide -> simProtocol.set_deletion_length_distributions(float)")
+        if simProtocol.get_insertion_rate(0) < 0:
+            raise ValueError(f"please provide a non zero value for insertion rate, provided value of: {simProtocol.get_insertion_rate(0)} -> simProtocol.set_insertion_rate(float)")
+        if simProtocol.get_deletion_rate(0) < 0:
+            raise ValueError(f"please provide a non zero value for deletion rate, provided value of: {simProtocol.get_deletion_rate(0)} -> simProtocol.set_deletion_rate(float)")
+        return True
+    
+    def reset_sim(self):
+        # TODO, complete
+        pass
+    
+    def _init_sub_model(self) -> None:
+        self._model_factory = _Sailfish.modelFactory(self._simProtocol._get_Sailfish_tree())
+        self._model_factory.set_alphabet(self._alphabet)
+        if self._simulation_type == SIMULATION_TYPE.PROTEIN:
+            warnings.warn(f"replacement matrix not provided -> running with default parameters: WAG model")
+            self._model_factory.set_replacement_model(_Sailfish.modelCode.WAG)
+        else:
+            warnings.warn(f"replacement matrix not provided -> running with default parameters: JC model")
+            self._model_factory.set_replacement_model(_Sailfish.modelCode.NUCJC)
+        self._model_factory.set_gamma_parameters(1.0, 1)
+
+        self._simulator.init_substitution_sim(self._model_factory)
+        self._is_sub_model_init = True
+    
+    def set_replacement_model(
+            self,
+            model: _Sailfish.modelCode,
+            model_parameters: List = None,
+            gamma_parameters_alpha : float = 1.0,
+            gamma_parameters_catergories: int = 1
+        ) -> None:
+        if not model:
+            raise ValueError(f"please provide a substitution model from the the following list: {_Sailfish.modelCode}")
+        if int(gamma_parameters_catergories) != gamma_parameters_catergories:
+            raise ValueError(f"gamma_parameters_catergories has to be a positive int value: received value of {gamma_parameters_catergories}")
+        self._model_factory = _Sailfish.modelFactory(self._simProtocol._get_Sailfish_tree())
+
+        self._model_factory.set_alphabet(self._alphabet)
+        if self._simulation_type == SIMULATION_TYPE.PROTEIN:
+            if model_parameters:
+                raise ValueError(f"no model parameters are used in protein, recevied value of: {model_parameters}")
+            self._model_factory.set_replacement_model(model)
+        else:
+            if model == MODEL_CODES.NUCJC and model_parameters:
+                raise ValueError(f"no model parameters in JC model, recevied value of: {model_parameters}")
+            self._model_factory.set_replacement_model(model)
+            if model == MODEL_CODES.NUCJC and not model_parameters:
+                pass
+            elif not model_parameters:
+                raise ValueError(f"please provide a model parameters")
+            else:
+                self._model_factory.set_model_parameters(model_parameters)
+        
+        self._model_factory.set_gamma_parameters(gamma_parameters_alpha, gamma_parameters_catergories)
+        self._simulator.init_substitution_sim(self._model_factory)
+
+        self._is_sub_model_init = True
+    
+    def gen_indels(self) -> BlockTreePython:
+        return BlockTreePython(self._simulator.gen_indels())
+    
+    
+    def gen_substitutions(self, length: int):
+        if not self._is_sub_model_init:
+            self._init_sub_model()
+        return self._simulator.gen_substitutions(length)
+    
+    # @profile
+    def simulate(self, times: int = 1) -> List[Msa]:
+        Msas = []
+        for _ in range(times):
+            if self._simProtocol._is_insertion_rate_zero and self._simProtocol._is_deletion_rate_zero:
+                msa = Msa(self._simProtocol.get_tree().get_num_leaves(), self._simProtocol.get_sequence_size())
+            else:
+                blocktree = self.gen_indels()
+                msa = Msa(blocktree._get_Sailfish_blocks(), self._simProtocol._get_root())
+
+            # sim.init_substitution_sim(mFac)
+            substitutions = self.gen_substitutions(msa.get_length())
+            msa.fill_substitutions(substitutions)
+
+            Msas.append(msa)
+        return Msas
+    
+    def __call__(self) -> Msa:
+        return self.simulate(1)[0]
+    
+    def save_rates(self, is_save: bool) -> None:
+        self._simulator.save_site_rates(is_save)
+    
+    def get_rates(self) -> List[float]:
+        return self._simulator.get_site_rates()

msasim-2024.5.22.dist-info/LICENSE

@@ -0,0 +1,172 @@
+Academic Free License ("AFL") v. 3.0
+
+This Academic Free License (the "License") applies to any original work of
+authorship (the "Original Work") whose owner (the "Licensor") has placed the
+following licensing notice adjacent to the copyright notice for the Original
+Work:
+
+  Licensed under the Academic Free License version 3.0
+
+1) Grant of Copyright License. Licensor grants You a worldwide, royalty-free,
+non-exclusive, sublicensable license, for the duration of the copyright, to do
+the following:
+
+  a) to reproduce the Original Work in copies, either alone or as part of a
+  collective work;
+
+  b) to translate, adapt, alter, transform, modify, or arrange the Original
+  Work, thereby creating derivative works ("Derivative Works") based upon the
+  Original Work;
+
+  c) to distribute or communicate copies of the Original Work and Derivative
+  Works to the public, under any license of your choice that does not
+  contradict the terms and conditions, including Licensor's reserved rights
+  and remedies, in this Academic Free License;
+
+  d) to perform the Original Work publicly; and
+
+  e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor grants You a worldwide, royalty-free,
+non-exclusive, sublicensable license, under patent claims owned or controlled
+by the Licensor that are embodied in the Original Work as furnished by the
+Licensor, for the duration of the patents, to make, use, sell, offer for sale,
+have made, and import the Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the preferred
+form of the Original Work for making modifications to it and all available
+documentation describing how to modify the Original Work. Licensor agrees to
+provide a machine-readable copy of the Source Code of the Original Work along
+with each copy of the Original Work that Licensor distributes. Licensor
+reserves the right to satisfy this obligation by placing a machine-readable
+copy of the Source Code in an information repository reasonably calculated to
+permit inexpensive and convenient access by You for as long as Licensor
+continues to distribute the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the names
+of any contributors to the Original Work, nor any of their trademarks or
+service marks, may be used to endorse or promote products derived from this
+Original Work without express prior permission of the Licensor. Except as
+expressly stated herein, nothing in this License grants any license to
+Licensor's trademarks, copyrights, patents, trade secrets or any other
+intellectual property. No patent license is granted to make, use, sell, offer
+for sale, have made, or import embodiments of any patent claims other than the
+licensed claims defined in Section 2. No license is granted to the trademarks
+of Licensor even if such marks are included in the Original Work. Nothing in
+this License shall be interpreted to prohibit Licensor from licensing under
+terms different from this License any Original Work that Licensor otherwise
+would have a right to license.
+
+5) External Deployment. The term "External Deployment" means the use,
+distribution, or communication of the Original Work or Derivative Works in any
+way such that the Original Work or Derivative Works may be used by anyone
+other than You, whether those works are distributed or communicated to those
+persons or made available as an application intended for use over a network.
+As an express condition for the grants of license hereunder, You must treat
+any External Deployment by You of the Original Work or a Derivative Work as a
+distribution under section 1(c).
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative
+Works that You create, all copyright, patent, or trademark notices from the
+Source Code of the Original Work, as well as any notices of licensing and any
+descriptive text identified therein as an "Attribution Notice." You must cause
+the Source Code for any Derivative Works that You create to carry a prominent
+Attribution Notice reasonably calculated to inform recipients that You have
+modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that
+the copyright in and to the Original Work and the patent rights granted herein
+by Licensor are owned by the Licensor or are sublicensed to You under the
+terms of this License with the permission of the contributor(s) of those
+copyrights and patent rights. Except as expressly stated in the immediately
+preceding sentence, the Original Work is provided under this License on an "AS
+IS" BASIS and WITHOUT WARRANTY, either express or implied, including, without
+limitation, the warranties of non-infringement, merchantability or fitness for
+a particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK
+IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this
+License. No license to the Original Work is granted by this License except
+under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory,
+whether in tort (including negligence), contract, or otherwise, shall the
+Licensor be liable to anyone for any indirect, special, incidental, or
+consequential damages of any character arising as a result of this License or
+the use of the Original Work including, without limitation, damages for loss
+of goodwill, work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses. This limitation of liability shall not
+apply to the extent applicable law prohibits such limitation.
+
+9) Acceptance and Termination. If, at any time, You expressly assented to this
+License, that assent indicates your clear and irrevocable acceptance of this
+License and all of its terms and conditions. If You distribute or communicate
+copies of the Original Work or a Derivative Work, You must make a reasonable
+effort under the circumstances to obtain the express assent of recipients to
+the terms of this License. This License conditions your rights to undertake
+the activities listed in Section 1, including your right to create Derivative
+Works based upon the Original Work, and doing so without honoring these terms
+and conditions is prohibited by copyright law and international treaty.
+Nothing in this License is intended to affect copyright exceptions and
+limitations (including "fair use" or "fair dealing"). This License shall
+terminate immediately and You may no longer exercise any of the rights granted
+to You by this License upon your failure to honor the conditions in Section
+1(c).
+
+10) Termination for Patent Action. This License shall terminate automatically
+and You may no longer exercise any of the rights granted to You by this
+License as of the date You commence an action, including a cross-claim or
+counterclaim, against Licensor or any licensee alleging that the Original Work
+infringes a patent. This termination provision shall not apply for an action
+alleging patent infringement by combinations of the Original Work with other
+software or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
+License may be brought only in the courts of a jurisdiction wherein the
+Licensor resides or in which Licensor conducts its primary business, and under
+the laws of that jurisdiction excluding its conflict-of-law provisions. The
+application of the United Nations Convention on Contracts for the
+International Sale of Goods is expressly excluded. Any use of the Original
+Work outside the scope of this License or after its termination shall be
+subject to the requirements and penalties of copyright or patent law in the
+appropriate jurisdiction. This section shall survive the termination of this
+License.
+
+12) Attorneys' Fees. In any action to enforce the terms of this License or
+seeking damages relating thereto, the prevailing party shall be entitled to
+recover its costs and expenses, including, without limitation, reasonable
+attorneys' fees and costs incurred in connection with such action, including
+any appeal of such action. This section shall survive the termination of this
+License.
+
+13) Miscellaneous. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent necessary
+to make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License,
+whether in upper or lower case, means an individual or a legal entity
+exercising rights under, and complying with all of the terms of, this License.
+For legal entities, "You" includes any entity that controls, is controlled by,
+or is under common control with you. For purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the direction or
+management of such entity, whether by contract or otherwise, or (ii) ownership
+of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial
+ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise
+restricted or conditioned by this License or by law, and Licensor promises not
+to interfere with or be responsible for such uses by You.
+
+16) Modification of This License. This License is Copyright © 2005 Lawrence
+Rosen. Permission is granted to copy, distribute, or communicate this License
+without modification. Nothing in this License permits You to modify this
+License as applied to the Original Work or to Derivative Works. However, You
+may modify the text of this License and copy, distribute or communicate your
+modified version (the "Modified License") and apply it to other original works
+of authorship subject to the following conditions: (i) You may not indicate in
+any way that your Modified License is the "Academic Free License" or "AFL" and
+you may not use those names in the name of your Modified License; (ii) You
+must replace the notice specified in the first paragraph above with the notice
+"Licensed under <insert your license name here>" or with a notice of your own
+that is not confusingly similar to the notice in this License; and (iii) You
+may not claim that your original works are open source software unless your
+Modified License has been approved by Open Source Initiative (OSI) and You
+comply with its license review and certification process.

msasim-2024.5.22.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: msasim
+Version: 2024.5.22
+Summary: A fast MSA simulator
+Home-page: https://github.com/elyawy/Sailfish-backend
+Author: Elya Wygoda
+Author-email: elya.wygoda@gmail.com
+License: UNKNOWN
+Platform: UNKNOWN
+Requires-Python: >=3.6
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest ; extra == 'test'
+
+Sailfish is a performant multiple sequence alignment simulator, written in C++, allowing fast generation of large simualted datasets.
+

msasim-2024.5.22.dist-info/RECORD

@@ -0,0 +1,10 @@
+_Sailfish.cpython-36m-x86_64-linux-gnu.so,sha256=wDu66tG2DnoqDsSenpvNOX-4aZfg17hyBs9-NRyKfOo,1199161
+Sailfish/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Sailfish/simulator.py,sha256=CTFAnavIHy918aF141FKeZjO5Y-oYASI-TR5MMGGVks,24324
+msasim.libs/libstdc++-a9383cce.so.6.0.28,sha256=Wy9UCdwS1rwI9GU5e7qE61S0AkRqqwti1q_adWSs-Rk,2447393
+msasim.libs/libgcc_s-a04fdf82.so.1,sha256=YxqJNaesQMhDswHEQpXsiLnVvMBBbYO6KYMDZFPWKSM,81257
+msasim-2024.5.22.dist-info/WHEEL,sha256=rbVfYZzJiOCEiiKDVkaog3MWj3SC9SfTJ-H92vzqnHY,112
+msasim-2024.5.22.dist-info/LICENSE,sha256=p1Aa_mM2Nu6dG3XqMVU62Jhf04lNOwtXUrhhvhcDips,10312
+msasim-2024.5.22.dist-info/top_level.txt,sha256=mVJT9Q6vqdBJyJ6acJvUdopsnVCQH7wEMQ-3iT6C-Jg,19
+msasim-2024.5.22.dist-info/RECORD,,
+msasim-2024.5.22.dist-info/METADATA,sha256=2gIzialKFhrP-FmN1o7Lf_kGyAWPBHxu6WwX44JkQI0,471

msasim-2024.5.22.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp36-cp36m-musllinux_1_1_x86_64
+

msasim-2024.5.22.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+Sailfish
+_Sailfish