msasim 25.5.3__cp313-cp313-macosx_11_0_arm64.whl

_Sailfish/__init__.pyi

@@ -0,0 +1,434 @@
+"""
+
+        Sailfish simulator
+        -----------------------
+
+        .. currentmodule:: _Sailfish
+
+        .. autosummary::
+           :toctree: _generate
+
+            DiscreteDistribution
+            SimProtocol
+            alphabetCode
+            modelCode
+            modelFactory
+            Simulator
+            Msa
+            Tree
+    
+"""
+from __future__ import annotations
+import pybind11_stubgen.typing_ext
+import typing
+__all__ = ['AAJC', 'AMINOACID', 'Block', 'BlockTree', 'CPREV45', 'CUSTOM', 'DAYHOFF', 'Deletion', 'DiscreteDistribution', 'EHO_EXTENDED', 'EHO_HELIX', 'EHO_OTHER', 'EMPIRICODON', 'EX_BURIED', 'EX_EHO_BUR_EXT', 'EX_EHO_BUR_HEL', 'EX_EHO_BUR_OTH', 'EX_EHO_EXP_EXT', 'EX_EHO_EXP_HEL', 'EX_EHO_EXP_OTH', 'EX_EXPOSED', 'GTR', 'HIVB', 'HIVW', 'HKY', 'Insertion', 'JONES', 'LG', 'MTREV24', 'Msa', 'NUCJC', 'NUCLEOTIDE', 'NULLCODE', 'SimProtocol', 'Simulator', 'TAMURA92', 'Tree', 'WAG', 'alphabetCode', 'event', 'modelCode', 'modelFactory', 'node', 'sequenceContainer']
+class Block:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: int, arg1: int) -> None:
+        ...
+class BlockTree:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: int) -> None:
+        ...
+    def block_list(self) -> list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]]:
+        ...
+    def print_tree(self) -> str:
+        ...
+class DiscreteDistribution:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @staticmethod
+    def set_seed(arg0: int) -> None:
+        """
+        Set seed for the random number generator
+        """
+    def __init__(self, arg0: list[float]) -> None:
+        ...
+    def draw_sample(self) -> int:
+        """
+        Draw a random sample according to the given distribution
+        """
+    def get_table(self) -> list[tuple[float, int]]:
+        """
+        Get Vose's alias table (useful for debugging)
+        """
+class Msa:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    @typing.overload
+    def __init__(self, arg0: int, arg1: int, arg2: list[bool]) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: dict[int, tuple[list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]], int]], arg1: node, arg2: list[bool]) -> None:
+        ...
+    def fill_substitutions(self, arg0: sequenceContainer) -> None:
+        ...
+    def generate_msas(self: list[dict[int, tuple[list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]], int]]], arg0: node, arg1: list[bool]) -> list[Msa]:
+        ...
+    def get_msa(self) -> dict[int, list[int]]:
+        ...
+    def get_msa_string(self) -> str:
+        ...
+    def length(self) -> int:
+        ...
+    def num_sequences(self) -> int:
+        ...
+    def print_indels(self) -> None:
+        ...
+    def print_msa(self) -> None:
+        ...
+    def set_substitutions_folder(self, arg0: str) -> None:
+        ...
+    def write_msa(self, arg0: str) -> None:
+        ...
+    def write_msa_from_dir(self, arg0: str) -> None:
+        ...
+class SimProtocol:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: Tree) -> None:
+        ...
+    def get_deletion_length_distribution(self, arg0: int) -> DiscreteDistribution:
+        ...
+    def get_deletion_rate(self, arg0: int) -> float:
+        ...
+    def get_insertion_length_distribution(self, arg0: int) -> DiscreteDistribution:
+        ...
+    def get_insertion_rate(self, arg0: int) -> float:
+        ...
+    def get_minimum_sequence_size(self) -> int:
+        ...
+    def get_seed(self) -> int:
+        ...
+    def get_sequence_size(self) -> int:
+        ...
+    def set_deletion_length_distributions(self, arg0: list[DiscreteDistribution]) -> None:
+        ...
+    def set_deletion_rates(self, arg0: list[float]) -> None:
+        ...
+    def set_insertion_length_distributions(self, arg0: list[DiscreteDistribution]) -> None:
+        ...
+    def set_insertion_rates(self, arg0: list[float]) -> None:
+        ...
+    def set_minimum_sequence_size(self, arg0: int) -> None:
+        ...
+    def set_seed(self, arg0: int) -> None:
+        ...
+    def set_sequence_size(self, arg0: int) -> None:
+        ...
+class Simulator:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: SimProtocol) -> None:
+        ...
+    def gen_indels(self) -> dict[int, tuple[list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]], int]]:
+        ...
+    def gen_substitutions(self, arg0: int) -> sequenceContainer:
+        ...
+    def gen_substitutions_to_dir(self, arg0: int, arg1: str) -> None:
+        ...
+    def get_saved_nodes_mask(self) -> list[bool]:
+        ...
+    def get_site_rates(self) -> list[float]:
+        ...
+    def init_substitution_sim(self, arg0: modelFactory) -> None:
+        ...
+    def reset_sim(self, arg0: SimProtocol) -> None:
+        ...
+    def run_sim(self, arg0: int) -> list[dict[int, tuple[list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(3)]], int]]]:
+        ...
+    def save_all_nodes_sequences(self) -> None:
+        ...
+    def save_root_sequence(self) -> None:
+        ...
+    def save_site_rates(self, arg0: bool) -> None:
+        ...
+class Tree:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: str, arg1: bool) -> None:
+        """
+        Create Phylogenetic tree object from newick formatted file
+        """
+    @property
+    def num_nodes(self) -> int:
+        ...
+    @property
+    def root(self) -> ...:
+        ...
+class alphabetCode:
+    """
+    Members:
+    
+      NULLCODE
+    
+      NUCLEOTIDE
+    
+      AMINOACID
+    """
+    AMINOACID: typing.ClassVar[alphabetCode]  # value = <alphabetCode.AMINOACID: 2>
+    NUCLEOTIDE: typing.ClassVar[alphabetCode]  # value = <alphabetCode.NUCLEOTIDE: 1>
+    NULLCODE: typing.ClassVar[alphabetCode]  # value = <alphabetCode.NULLCODE: 0>
+    __members__: typing.ClassVar[dict[str, alphabetCode]]  # value = {'NULLCODE': <alphabetCode.NULLCODE: 0>, 'NUCLEOTIDE': <alphabetCode.NUCLEOTIDE: 1>, 'AMINOACID': <alphabetCode.AMINOACID: 2>}
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: int) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: int) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class event:
+    """
+    Members:
+    
+      Insertion
+    
+      Deletion
+    """
+    Deletion: typing.ClassVar[event]  # value = <event.Deletion: 1>
+    Insertion: typing.ClassVar[event]  # value = <event.Insertion: 0>
+    __members__: typing.ClassVar[dict[str, event]]  # value = {'Insertion': <event.Insertion: 0>, 'Deletion': <event.Deletion: 1>}
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: int) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: int) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class modelCode:
+    """
+    Members:
+    
+      NUCJC
+    
+      AAJC
+    
+      GTR
+    
+      HKY
+    
+      TAMURA92
+    
+      CPREV45
+    
+      DAYHOFF
+    
+      JONES
+    
+      MTREV24
+    
+      WAG
+    
+      HIVB
+    
+      HIVW
+    
+      LG
+    
+      EMPIRICODON
+    
+      EX_BURIED
+    
+      EX_EXPOSED
+    
+      EHO_EXTENDED
+    
+      EHO_HELIX
+    
+      EHO_OTHER
+    
+      EX_EHO_BUR_EXT
+    
+      EX_EHO_BUR_HEL
+    
+      EX_EHO_BUR_OTH
+    
+      EX_EHO_EXP_EXT
+    
+      EX_EHO_EXP_HEL
+    
+      EX_EHO_EXP_OTH
+    
+      CUSTOM
+    """
+    AAJC: typing.ClassVar[modelCode]  # value = <modelCode.AAJC: 1>
+    CPREV45: typing.ClassVar[modelCode]  # value = <modelCode.CPREV45: 6>
+    CUSTOM: typing.ClassVar[modelCode]  # value = <modelCode.CUSTOM: 26>
+    DAYHOFF: typing.ClassVar[modelCode]  # value = <modelCode.DAYHOFF: 7>
+    EHO_EXTENDED: typing.ClassVar[modelCode]  # value = <modelCode.EHO_EXTENDED: 17>
+    EHO_HELIX: typing.ClassVar[modelCode]  # value = <modelCode.EHO_HELIX: 18>
+    EHO_OTHER: typing.ClassVar[modelCode]  # value = <modelCode.EHO_OTHER: 19>
+    EMPIRICODON: typing.ClassVar[modelCode]  # value = <modelCode.EMPIRICODON: 14>
+    EX_BURIED: typing.ClassVar[modelCode]  # value = <modelCode.EX_BURIED: 15>
+    EX_EHO_BUR_EXT: typing.ClassVar[modelCode]  # value = <modelCode.EX_EHO_BUR_EXT: 20>
+    EX_EHO_BUR_HEL: typing.ClassVar[modelCode]  # value = <modelCode.EX_EHO_BUR_HEL: 21>
+    EX_EHO_BUR_OTH: typing.ClassVar[modelCode]  # value = <modelCode.EX_EHO_BUR_OTH: 22>
+    EX_EHO_EXP_EXT: typing.ClassVar[modelCode]  # value = <modelCode.EX_EHO_EXP_EXT: 23>
+    EX_EHO_EXP_HEL: typing.ClassVar[modelCode]  # value = <modelCode.EX_EHO_EXP_HEL: 24>
+    EX_EHO_EXP_OTH: typing.ClassVar[modelCode]  # value = <modelCode.EX_EHO_EXP_OTH: 25>
+    EX_EXPOSED: typing.ClassVar[modelCode]  # value = <modelCode.EX_EXPOSED: 16>
+    GTR: typing.ClassVar[modelCode]  # value = <modelCode.GTR: 2>
+    HIVB: typing.ClassVar[modelCode]  # value = <modelCode.HIVB: 11>
+    HIVW: typing.ClassVar[modelCode]  # value = <modelCode.HIVW: 12>
+    HKY: typing.ClassVar[modelCode]  # value = <modelCode.HKY: 3>
+    JONES: typing.ClassVar[modelCode]  # value = <modelCode.JONES: 8>
+    LG: typing.ClassVar[modelCode]  # value = <modelCode.LG: 13>
+    MTREV24: typing.ClassVar[modelCode]  # value = <modelCode.MTREV24: 9>
+    NUCJC: typing.ClassVar[modelCode]  # value = <modelCode.NUCJC: 0>
+    TAMURA92: typing.ClassVar[modelCode]  # value = <modelCode.TAMURA92: 4>
+    WAG: typing.ClassVar[modelCode]  # value = <modelCode.WAG: 10>
+    __members__: typing.ClassVar[dict[str, modelCode]]  # value = {'NUCJC': <modelCode.NUCJC: 0>, 'AAJC': <modelCode.AAJC: 1>, 'GTR': <modelCode.GTR: 2>, 'HKY': <modelCode.HKY: 3>, 'TAMURA92': <modelCode.TAMURA92: 4>, 'CPREV45': <modelCode.CPREV45: 6>, 'DAYHOFF': <modelCode.DAYHOFF: 7>, 'JONES': <modelCode.JONES: 8>, 'MTREV24': <modelCode.MTREV24: 9>, 'WAG': <modelCode.WAG: 10>, 'HIVB': <modelCode.HIVB: 11>, 'HIVW': <modelCode.HIVW: 12>, 'LG': <modelCode.LG: 13>, 'EMPIRICODON': <modelCode.EMPIRICODON: 14>, 'EX_BURIED': <modelCode.EX_BURIED: 15>, 'EX_EXPOSED': <modelCode.EX_EXPOSED: 16>, 'EHO_EXTENDED': <modelCode.EHO_EXTENDED: 17>, 'EHO_HELIX': <modelCode.EHO_HELIX: 18>, 'EHO_OTHER': <modelCode.EHO_OTHER: 19>, 'EX_EHO_BUR_EXT': <modelCode.EX_EHO_BUR_EXT: 20>, 'EX_EHO_BUR_HEL': <modelCode.EX_EHO_BUR_HEL: 21>, 'EX_EHO_BUR_OTH': <modelCode.EX_EHO_BUR_OTH: 22>, 'EX_EHO_EXP_EXT': <modelCode.EX_EHO_EXP_EXT: 23>, 'EX_EHO_EXP_HEL': <modelCode.EX_EHO_EXP_HEL: 24>, 'EX_EHO_EXP_OTH': <modelCode.EX_EHO_EXP_OTH: 25>, 'CUSTOM': <modelCode.CUSTOM: 26>}
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: int) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: int) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class modelFactory:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self, arg0: Tree) -> None:
+        ...
+    def reset(self) -> None:
+        ...
+    def set_alphabet(self, arg0: alphabetCode) -> None:
+        ...
+    def set_amino_replacement_model_file(self, arg0: str) -> None:
+        ...
+    def set_gamma_parameters(self, arg0: float, arg1: int) -> None:
+        ...
+    def set_invariant_sites_proportion(self, arg0: float) -> None:
+        ...
+    def set_model_parameters(self, arg0: list[float]) -> None:
+        ...
+    def set_replacement_model(self, arg0: modelCode) -> None:
+        ...
+class node:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def distance_to_father(self) -> float:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def num_leaves(self) -> int:
+        ...
+    @property
+    def sons(self) -> list[node]:
+        ...
+class sequenceContainer:
+    @staticmethod
+    def _pybind11_conduit_v1_(*args, **kwargs):
+        ...
+    def __init__(self) -> None:
+        ...
+AAJC: modelCode  # value = <modelCode.AAJC: 1>
+AMINOACID: alphabetCode  # value = <alphabetCode.AMINOACID: 2>
+CPREV45: modelCode  # value = <modelCode.CPREV45: 6>
+CUSTOM: modelCode  # value = <modelCode.CUSTOM: 26>
+DAYHOFF: modelCode  # value = <modelCode.DAYHOFF: 7>
+Deletion: event  # value = <event.Deletion: 1>
+EHO_EXTENDED: modelCode  # value = <modelCode.EHO_EXTENDED: 17>
+EHO_HELIX: modelCode  # value = <modelCode.EHO_HELIX: 18>
+EHO_OTHER: modelCode  # value = <modelCode.EHO_OTHER: 19>
+EMPIRICODON: modelCode  # value = <modelCode.EMPIRICODON: 14>
+EX_BURIED: modelCode  # value = <modelCode.EX_BURIED: 15>
+EX_EHO_BUR_EXT: modelCode  # value = <modelCode.EX_EHO_BUR_EXT: 20>
+EX_EHO_BUR_HEL: modelCode  # value = <modelCode.EX_EHO_BUR_HEL: 21>
+EX_EHO_BUR_OTH: modelCode  # value = <modelCode.EX_EHO_BUR_OTH: 22>
+EX_EHO_EXP_EXT: modelCode  # value = <modelCode.EX_EHO_EXP_EXT: 23>
+EX_EHO_EXP_HEL: modelCode  # value = <modelCode.EX_EHO_EXP_HEL: 24>
+EX_EHO_EXP_OTH: modelCode  # value = <modelCode.EX_EHO_EXP_OTH: 25>
+EX_EXPOSED: modelCode  # value = <modelCode.EX_EXPOSED: 16>
+GTR: modelCode  # value = <modelCode.GTR: 2>
+HIVB: modelCode  # value = <modelCode.HIVB: 11>
+HIVW: modelCode  # value = <modelCode.HIVW: 12>
+HKY: modelCode  # value = <modelCode.HKY: 3>
+Insertion: event  # value = <event.Insertion: 0>
+JONES: modelCode  # value = <modelCode.JONES: 8>
+LG: modelCode  # value = <modelCode.LG: 13>
+MTREV24: modelCode  # value = <modelCode.MTREV24: 9>
+NUCJC: modelCode  # value = <modelCode.NUCJC: 0>
+NUCLEOTIDE: alphabetCode  # value = <alphabetCode.NUCLEOTIDE: 1>
+NULLCODE: alphabetCode  # value = <alphabetCode.NULLCODE: 0>
+TAMURA92: modelCode  # value = <modelCode.TAMURA92: 4>
+WAG: modelCode  # value = <modelCode.WAG: 10>

msasim/sailfish.py

@@ -0,0 +1,576 @@
+import _Sailfish
+import os, warnings, math, operator, time, profile, tempfile, pathlib
+from functools import reduce
+from typing import List, Optional, Dict
+from re import split
+from enum import Enum
+
+
+
+MODEL_CODES = _Sailfish.modelCode
+
+class SIMULATION_TYPE(Enum):
+    NOSUBS = 0
+    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
+
+        norm_factor = sum([(i**-p) for i in range(1,truncation+1)])
+        probabilities = [(i**-p)/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),
+                 minimum_seq_size: int = 100,
+                 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)
+        self.set_min_sequence_size(min_sequence_size=minimum_seq_size)
+
+    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_min_sequence_size(self, min_sequence_size: int) -> None:
+        self._sim.set_minimum_sequence_size(min_sequence_size)
+        self._min_seq_size = min_sequence_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, save_list: List[bool]):
+        self._msa = _Sailfish.Msa(species_dict, root_node, save_list)
+    
+    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_string()
+    
+    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)
+            simProtocol.set_min_sequence_size(1)
+
+        # 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 indel only simulation")
+            simulation_type = SIMULATION_TYPE.NOSUBS
+        
+        if simulation_type == SIMULATION_TYPE.PROTEIN:
+            self._alphabet = _Sailfish.alphabetCode.AMINOACID
+        elif simulation_type == SIMULATION_TYPE.DNA:
+            self._alphabet = _Sailfish.alphabetCode.NUCLEOTIDE
+        elif simulation_type == SIMULATION_TYPE.NOSUBS:
+            self._alphabet = _Sailfish.alphabetCode.NULLCODE
+        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,
+            amino_model_file: pathlib.Path = None,
+            model_parameters: List = None,
+            gamma_parameters_alpha : float = 1.0,
+            gamma_parameters_categories: int = 1,
+            invariant_sites_proportion: float = 0.0
+        ) -> None:
+        if not model:
+            raise ValueError(f"please provide a substitution model from the the following list: {_Sailfish.modelCode}")
+        if int(gamma_parameters_categories) != gamma_parameters_categories:
+            raise ValueError(f"gamma_parameters_catergories has to be a positive int value: received value of {gamma_parameters_categories}")
+        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)
+            if model == MODEL_CODES.CUSTOM and amino_model_file:
+                self._model_factory.set_amino_replacement_model_file(str(amino_model_file))
+        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_categories)
+        self._model_factory.set_invariant_sites_proportion(invariant_sites_proportion)
+        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 get_sequences_to_save(self) -> List[bool]:
+        return self._simulator.get_saved_nodes_mask()
+    
+    def save_root_sequence(self):
+        self._simulator.save_root_sequence()
+    
+    def save_all_nodes_sequences(self):
+        self._simulator.save_all_nodes_sequences()
+
+    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(sum(self.get_sequences_to_save()),
+                          self._simProtocol.get_sequence_size(),
+                          self.get_sequences_to_save())
+            else:
+                blocktree = self.gen_indels()
+                msa = Msa(blocktree._get_Sailfish_blocks(),
+                          self._simProtocol._get_root(),
+                          self.get_sequences_to_save())
+
+            # sim.init_substitution_sim(mFac)
+            if self._simulation_type != SIMULATION_TYPE.NOSUBS:
+                substitutions = self.gen_substitutions(msa.get_length())
+                msa.fill_substitutions(substitutions)
+
+            Msas.append(msa)
+        return Msas
+    
+    def simulate_low_memory(self, output_file_path: pathlib.Path) -> Msa:
+        if self._simProtocol._is_insertion_rate_zero and self._simProtocol._is_deletion_rate_zero:
+            msa = Msa(sum(self.get_sequences_to_save()),
+                        self._simProtocol.get_sequence_size(),
+                        self.get_sequences_to_save())
+        else:
+            blocktree = self.gen_indels()
+            msa = Msa(blocktree._get_Sailfish_blocks(),
+                        self._simProtocol._get_root(),
+                        self.get_sequences_to_save())
+
+        # sim.init_substitution_sim(mFac)
+        if self._simulation_type != SIMULATION_TYPE.NOSUBS:
+            with tempfile.TemporaryDirectory() as tmpdirname:
+                self._simulator.gen_substitutions_to_dir(msa.get_length(), tmpdirname)
+                msa._msa.set_substitutions_folder(tmpdirname)
+                msa._msa.write_msa_from_dir(str(output_file_path))
+
+
+    
+    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-25.5.3.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: msasim
+Version: 25.5.3
+Summary: A fast MSA simulator
+Home-page: https://github.com/elyawy/Sailfish-backend
+Author: Elya Wygoda
+Author-email: elya.wygoda@gmail.com
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# Sailfish
+
+Sailfish is a performant multiple sequence alignment(MSA) simulator, written in C++ and Python, allowing for quick and easy generation of large simulated datasets. 
+
+## Project goals
+
+- Ease of use
+- Speed
+- Modularity
+
+## Installation
+
+```bash
+pip install msasim
+```
+
+## Example
+
+```python
+from msasim import sailfish as sim
+from msasim.sailfish import MODEL_CODES, ZipfDistribution
+
+ROOT_SEQUENCE_LENGTH = 100
+
+sim_protocol = sim.SimProtocol("(A:0.5,B:0.5);",
+                               deletion_rate=0.01,
+                               insertion_rate=0.01,
+                               deletion_dist=ZipfDistribution(1.08, 50),
+                               insertion_dist=ZipfDistribution(1.08, 50),
+                               seed=50)
+sim_protocol.set_sequence_size(ROOT_SEQUENCE_LENGTH)
+
+simulation = sim.Simulator(sim_protocol, simulation_type=sim.SIMULATION_TYPE.PROTEIN)
+
+simulation.set_replacement_model(model=MODEL_CODES.WAG, 
+                                 gamma_parameters_alpha=1.0, 
+                                 gamma_parameters_catergories=4)
+msa = simulation()
+msa.print_msa()
+
+```

msasim-25.5.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+_Sailfish.cpython-313-darwin.so,sha256=OHjaTECS2_-064t5U39QksVjp4Q2D-1PkqlqRRQQwTg,1083472
+msasim-25.5.3.dist-info/RECORD,,
+msasim-25.5.3.dist-info/WHEEL,sha256=Cxq5pla4scSj9raD9htoFbIhfTk0lSQlQLVCyAjgIi4,136
+msasim-25.5.3.dist-info/top_level.txt,sha256=NS1ILx5V94Yyh_M7yDrrqbBPu1TL_zJuxhsI90YEJVY,17
+msasim-25.5.3.dist-info/METADATA,sha256=8QKpevdyyqP12_yZKu7gh4ZsEl50fFadC2hwqifhbWs,1666
+msasim-25.5.3.dist-info/licenses/LICENSE,sha256=p1Aa_mM2Nu6dG3XqMVU62Jhf04lNOwtXUrhhvhcDips,10312
+msasim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+msasim/sailfish.py,sha256=smYUY3vr5LomFQgACskkVy8lZkedGwahz6PEBbvpeSU,26249
+_Sailfish/__init__.pyi,sha256=g1apAVKIwxit-nAJ1B9WXADEkpFqRTR8wmLvFN39ZME,15178
+_Sailfish/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

msasim-25.5.3.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-macosx_11_0_arm64
+Generator: delocate 0.13.0
+

msasim-25.5.3.dist-info/licenses/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-25.5.3.dist-info/top_level.txt

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