msasim 2024.5.22__tar.gz → 2024.5.2719__tar.gz

msasim-2024.5.2719/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: msasim
+Version: 2024.5.2719
+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"
+
+# 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-2024.5.2719/README.md

@@ -0,0 +1,41 @@
+# 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-2024.5.22/Sailfish/simulator.py → msasim-2024.5.2719/msasim/sailfish.py

@@ -368,8 +368,8 @@ 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 __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)
@@ -504,7 +504,15 @@ class Simulator:
     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()
@@ -515,10 +523,14 @@ class Simulator:
         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())
+                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())
+                msa = Msa(blocktree._get_Sailfish_blocks(),
+                          self._simProtocol._get_root(),
+                          self.get_sequences_to_save())
 
             # sim.init_substitution_sim(mFac)
             substitutions = self.gen_substitutions(msa.get_length())

msasim-2024.5.2719/msasim.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: msasim
+Version: 2024.5.2719
+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"
+
+# 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-2024.5.22 → msasim-2024.5.2719}/msasim.egg-info/SOURCES.txt

@@ -2,8 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 setup.py
-Sailfish/__init__.py
-Sailfish/simulator.py
+msasim/__init__.py
+msasim/sailfish.py
 msasim.egg-info/PKG-INFO
 msasim.egg-info/SOURCES.txt
 msasim.egg-info/dependency_links.txt

{msasim-2024.5.22 → msasim-2024.5.2719}/msasim.egg-info/top_level.txt

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

{msasim-2024.5.22 → msasim-2024.5.2719}/setup.py

@@ -6,9 +6,9 @@ from setuptools import setup, find_packages
 
 from datetime import datetime
 
-today = datetime.today()
+now = datetime.now()
 
-__version__ = f"{today.year}.{today.month}.{today.day}"
+__version__ = f"{now.year}.{now.month}.{now.day}{now.hour}"
 
 # The main interface is through Pybind11Extension.
 # * You can add cxx_std=11/14/17, and then build_ext can be removed.
@@ -28,7 +28,7 @@ def print_sources(sources):
 ext_modules = [
     Pybind11Extension("_Sailfish",
         sources = sorted(print_sources(glob("src/*.cpp"))),
-        cxx_std = "14",
+        cxx_std = "17",
         extra_objects=[str(x) for x in Path(".").resolve().glob("libs/*") if x.is_file()],
         # extra_compile_args=["-g"],
         # Example: passing in the version to the compiled code
@@ -44,11 +44,13 @@ setup(
     author_email="elya.wygoda@gmail.com",
     url="https://github.com/elyawy/Sailfish-backend",
     description="A fast MSA simulator",
-    long_description="Sailfish is a performant multiple sequence alignment simulator, written in C++, allowing fast generation of large simualted datasets.",
+    # long_description="Sailfish is a performant multiple sequence alignment simulator, written in C++, allowing fast generation of large simualted datasets.",
+    long_description=open("README.md", 'r').read(),
+    long_description_content_type='text/markdown',
     ext_modules=ext_modules,
     extras_require={"test": "pytest"},
     cmdclass={"build_ext": build_ext},
     zip_safe=False,
     python_requires=">=3.6",
-    packages=find_packages(include=['Sailfish','tests'])
+    packages=find_packages(include=['msasim','tests'])
 )

{msasim-2024.5.22 → msasim-2024.5.2719}/src/main.cpp

@@ -133,12 +133,15 @@ PYBIND11_MODULE(_Sailfish, m) {
         .def("init_substitution_sim", &Simulator::initSubstitionSim)
         .def("gen_substitutions", &Simulator::simulateSubstitutions)
         .def("save_site_rates", &Simulator::setSaveRates)
-        .def("get_site_rates", &Simulator::getSiteRates);
+        .def("get_site_rates", &Simulator::getSiteRates)
+        .def("save_all_nodes_sequences", &Simulator::setSaveAllNodes)
+        .def("save_root_sequence", &Simulator::setSaveRoot)
+        .def("get_saved_nodes_mask", &Simulator::getNodesSaveList);
 
 
     py::class_<MSA>(m, "Msa")
-        .def(py::init<size_t, size_t>())
-        .def(py::init<BlockMap, tree::TreeNode*>())
+        .def(py::init<size_t, size_t, const std::vector<bool>&>())
+        .def(py::init<BlockMap, tree::TreeNode*, const std::vector<bool>&>())
         .def("generate_msas", &MSA::generateMSAs)
         .def("length", &MSA::getMSAlength)
         .def("num_sequences", &MSA::getNumberOfSequences)

{msasim-2024.5.22 → msasim-2024.5.2719}/src/rateMatrixSim.cpp

@@ -115,12 +115,11 @@ void rateMatrixSim::generate_substitution_log(int seqLength) {
 		sumOfRatesAcrossSites += ratesVec[h];
 	}
 	if (_saveRates) _siteRates.insert(_siteRates.end(), ratesVec.begin(), ratesVec.end());
-	MDOUBLE sumOfRatesNoramlizingFactor = 1.0 / sumOfRatesAcrossSites;
-
-	_siteSampler = std::make_unique<DiscreteDistribution>(ratesVec, sumOfRatesNoramlizingFactor);
+	// MDOUBLE sumOfRatesNoramlizingFactor = 1.0 / sumOfRatesAcrossSites;
 
+	// _siteSampler = std::make_unique<DiscreteDistribution>(ratesVec, sumOfRatesNoramlizingFactor);
 	_rootSequence.resize(seqLength);
-	generateRootSeq(seqLength);
+	generateRootSeq(seqLength, ratesVec);
 	if (_nodesToSave[_et->getRoot()->id()]) saveSequence(_et->getRoot()->id(), _et->getRoot()->name());
 
 	mutateSeqRecuresively(_et->getRoot(), seqLength);
@@ -128,13 +127,13 @@ void rateMatrixSim::generate_substitution_log(int seqLength) {
 }
 
 void rateMatrixSim::mutateSeqRecuresively(tree::nodeP currentNode, int seqLength) {
+	if (currentNode->isLeaf()) return;
 
 	for (auto &node: currentNode->getSons()) {
 		mutateSeqAlongBranch(node, seqLength);
-		mutateSeqRecuresively(node, seqLength);
 		if (_nodesToSave[node->id()]) saveSequence(node->id(), node->name());
+		mutateSeqRecuresively(node, seqLength);
 
-		// std::cout << "Node: " << currentNode->id() << "\n";
 		if (!_subManager.isEmpty(currentNode->id())) {
 			_subManager.undoSubs(currentNode->id(), _rootSequence, _rateCategories, _sp.get());
 		}
@@ -186,7 +185,7 @@ void rateMatrixSim::mutateSeqGillespie(tree::nodeP currentNode, int seqLength, M
 			errorMsg::reportError("waiting time is negative :(");
 		}
 
-		int mutatedSite = _siteSampler->drawSample() - 1;
+		int mutatedSite = _subManager.sampleSite(*_mt_rand);
 		ALPHACHAR parentChar = _rootSequence[mutatedSite];
 		ALPHACHAR nextChar = _gillespieSampler[parentChar]->drawSample() - 1;
 		// std::cout << (int)parentChar << "->" << (int)nextChar << "\n";
@@ -203,16 +202,17 @@ void rateMatrixSim::mutateSeqGillespie(tree::nodeP currentNode, int seqLength, M
 
 
 
-void rateMatrixSim::generateRootSeq(int seqLength) {
+void rateMatrixSim::generateRootSeq(int seqLength, std::vector<MDOUBLE>& ratesVec) {
 	size_t rootID = _et->getRoot()->id();
 	for (int i = 0; i < seqLength; i++) {
 		ALPHACHAR newChar = _frequencySampler->drawSample() - 1;
+		// ratesVec[i] = ratesVec[i]*(-_sp->Qij(newChar, newChar));
 		_rootSequence[i] =  newChar;
      }
 	// std::cout << ">Root-sequence\n" << _rootSequence  <<  "\n";
-	_subManager.handleRootSequence(seqLength, _rateCategories, _sp.get(), _rootSequence);
-
-
+	// std::cout << ">Rates\n" << ratesVec;
+	_subManager.handleRootSequence(seqLength, ratesVec, _sp.get(), _rootSequence);
+	
 	_rootSequence.setAlphabet(_alph);
 	_rootSequence.setName(_et->getRoot()->name());
 	_rootSequence.setID(_et->getRoot()->id());
@@ -223,6 +223,7 @@ void rateMatrixSim::saveSequence(const int &nodeId,const std::string &name) {
 	sequence temp(_rootSequence);
 	temp.setName(name);
 	temp.setID(nodeId);
+	// std::cout << temp << "\n";
 	_simulatedSequences->add(temp);
 }
 
@@ -252,13 +253,36 @@ std::unique_ptr<sequenceContainer> rateMatrixSim::getSequenceContainer() {
 	return std::move(outputSequences);
 }
 
-void rateMatrixSim::setNodesToSaves(std::vector<size_t> nodeIDs) {
+void rateMatrixSim::setNodesToSave(std::vector<size_t> nodeIDs) {
 	std::fill(_nodesToSave.begin(), _nodesToSave.end(), false);
 	for(auto &nodeID: nodeIDs) {
 		_nodesToSave[nodeID] = true;
 	}
 }
 
+void rateMatrixSim::setSaveAllNodes() {
+	for (size_t i = 0; i < _nodesToSave.size(); i++) {
+		_nodesToSave[i] = true;
+	}
+}
+
+void rateMatrixSim::setSaveRoot() {
+	_nodesToSave[0] = true;
+}
+
+
+void rateMatrixSim::changeNodeSaveState(size_t nodeID) {
+	_nodesToSave[nodeID] = !_nodesToSave[nodeID];
+}
+
+bool rateMatrixSim::getNodeSaveState(size_t nodeID) {
+	return _nodesToSave[nodeID];
+}
+
+const std::vector<bool>& rateMatrixSim::getNodesSaveList() {
+	return _nodesToSave;
+}
+
 bool rateMatrixSim::testSumOfRates() {
 	MDOUBLE sumOfRates = 0.0;
 	for (size_t i = 0; i < _rootSequence.seqLen(); i++) {

msasim-2024.5.22/PKG-INFO

@@ -1,13 +0,0 @@
-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
-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/README.md

@@ -1,2 +0,0 @@
-# Sailfish-backend
-Backend C++ code for the Sailfish MSA simulation library using the Pybind11 framework

msasim-2024.5.22/msasim.egg-info/PKG-INFO

@@ -1,13 +0,0 @@
-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
-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.