dna-parser 0.3.0__cp313-cp313-win_amd64.whl

dna_parser/__init__.py

@@ -0,0 +1,7 @@
+from .dna_parser import *
+from .call_functions import *
+from .tfidf_class import *
+
+__doc__ = dna_parser.__doc__
+if hasattr(dna_parser, "__all__"):
+    __all__ = dna_parser.__all__

dna_parser/call_functions.py

@@ -0,0 +1,73 @@
+from .dna_parser import *
+
+
+def onehot_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return onehot_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def real_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return real_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def cross_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+    
+    return cross_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def random_seq(length, nb_of_seq, seq_type= "dna", n_jobs= 1):
+
+    return random_seq_rust(length, nb_of_seq, seq_type, n_jobs)
+
+def zcurve_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return zcurve_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def chaos_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return chaos_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def eiip_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return eiip_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def dna_walk(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return dna_walk_rust(sequences, pad_type, pad_length, n_jobs)
+
+def fickett_score(sequences, n_jobs= 1):
+    
+    return fickett_score_rust(sequences, n_jobs)
+
+def atomic_encoding(sequences, pad_type= "after", pad_length= -2, n_jobs= 1):
+
+    return atomic_encoding_rust(sequences, pad_type, pad_length, n_jobs)
+
+def load_fasta(path):
+
+    if type(path) is str:
+        return load_fasta_rust(path)
+    
+    elif type(path) is list:
+        
+        sequences= [ seq for current_file in path for seq in load_fasta_rust(current_file)]
+        return sequences
+
+def load_metadata(path):
+
+    if type(path) is str:
+        return metadata_from_fasta_rust(path)
+    
+    elif type(path) is list:
+        
+        sequences= [ seq for current_file in path for seq in metadata_from_fasta_rust(current_file)]
+        return sequences
+
+        
+def load_sequences(path):
+
+    if type(path) is str:
+        return seq_from_fasta_rust(path)
+    
+    elif type(path) is list:
+        
+        sequences= [ seq for current_file in path for seq in seq_from_fasta_rust(current_file)]
+        return sequences

dna_parser/tfidf_class.py

@@ -0,0 +1,114 @@
+from .dna_parser import *
+from scipy.sparse import csr_matrix
+import numpy as np
+from sklearn.utils.sparsefuncs_fast import inplace_csr_row_normalize_l2
+
+
+class NotFittedError(Exception):
+    pass
+
+class Tfidf:
+
+    def __init__(self, corpus , kmer, vocabulary= None, n_jobs=1):
+        
+        #check if corpus a string (path to fasta) or a list of string 
+        #check if vocabulary is string (path to file) or a list of string 
+
+        self.vocabulary= vocabulary
+        self.corpus= corpus
+        self.kmer_size= kmer
+        self.idf= None
+        self.is_idf_uptodate= False
+        self.n_jobs= n_jobs
+    
+    def set_vocabulary(self, vocabulary):
+
+        self.vocabulary= vocabulary
+        self.is_idf_uptodate= False
+    
+    def set_threads(self, n_jobs):
+
+        self.n_jobs= n_jobs
+    
+    
+    def add_to_corpus(self, new_corpus):
+        self.corpus.extend(new_corpus)
+        self.is_idf_uptodate= False
+
+    def compute_idf(self, matrix):
+
+        term_freq= (matrix > 0).sum(0)
+        self.idf= np.squeeze(np.asarray(np.log(matrix.shape[0]/term_freq)))
+        self.is_idf_uptodate= True
+
+    def fit(self):
+
+        #check if vocabulary was set by user if not compile vocabulary !
+        if not self.vocabulary:
+            self.vocabulary= fit_rust(self.corpus, self.kmer_size, self.n_jobs)
+
+        (val, row, col)= transform_rust(self.corpus, self.vocabulary, self.kmer_size, self.n_jobs)
+        matrix_count= csr_matrix(arg1= (val,(row,col)),
+                                        shape= (len(self.corpus),len(self.vocabulary)),
+                                        dtype= np.float64)
+
+        self.compute_idf(matrix_count)
+
+        
+
+    def transform(self, sequences= None, normalization= "L2"):
+        
+        #check sequences 
+        
+        if  not self.is_idf_uptodate:
+            raise NotFittedError("This Tidf instance is not fitted. Please use fit()")
+        
+        if not sequences:
+            val, row, col= transform_rust(self.corpus, self.vocabulary, self.kmer_size, self.n_jobs)
+            matrix_count= csr_matrix(arg1= (val,(row,col)),
+                                        shape= (len(self.corpus),len(self.vocabulary)),
+                                        dtype= np.float64)
+
+        else: 
+            val, row, col= transform_rust(sequences, self.vocabulary, self.kmer_size, self.n_jobs)
+            matrix_count= csr_matrix(arg1= (val,(row,col)),
+                                        shape= (len(self.corpus),len(self.vocabulary)),
+                                        dtype= np.float64)
+        
+        matrix_count.data *= np.take(a=self.idf, indices=matrix_count.indices)
+        
+        if normalization== "L2":
+            inplace_csr_row_normalize_l2(matrix_count)
+        
+        return matrix_count
+         
+    
+    def fit_transform(self, normalization= "L2"):
+        
+        if not self.vocabulary:
+            
+            self.vocabulary, val, row, col= fit_transform_rust(self.corpus, self.kmer_size, self.n_jobs)
+        
+        else:
+            val, row, col= transform_rust(self.corpus, self.vocabulary, self.kmer_size, self.n_jobs)
+        
+        matrix_count= csr_matrix(arg1= (val,(row,col)),
+                                        shape= (len(self.corpus),len(self.vocabulary)),
+                                        dtype= np.float64)
+        self.compute_idf(matrix_count)
+    
+
+
+        matrix_count.data *= np.take(a=self.idf, indices=matrix_count.indices)
+
+        if normalization== "L2":
+            inplace_csr_row_normalize_l2(matrix_count)
+
+        return matrix_count
+
+        
+
+        
+
+    
+    

dna_parser-0.3.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: dna_parser
+Version: 0.3.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: numpy >=1.16.0
+Requires-Dist: scipy >=1.3.0
+Requires-Dist: scikit-learn >=1.5.0
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: mkdocs ; extra == 'dev'
+Provides-Extra: dev
+License-File: LICENSE
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# dna-parser
+![Build Status](https://github.com/Mvila035/dna_parser/workflows/CI/badge.svg)
+
+dna-parser is a Python library written in Rust to encode (or perform feature extraction on) DNA/RNA sequences for machine learning.
+
+the source code is available on [GitHub](https://github.com/Mvila035/dna_parser)
+
+## Installation
+
+To install dna-parser simply run:
+```sh
+pip install dna-parser
+```
+
+If there is no Python wheel available for your OS you can install Rust and re-install dna-parser which should now compile on your machine.
+Run the following command on Unix-like OS to install Rust:
+```sh
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+or see more options at [https://www.rust-lang.org/tools/install](https://www.rust-lang.org/tools/install).
+
+## Quick Start
+
+```python
+import dna_parser as dps
+
+sequences= ["agt","acc"]
+encodings= dps.onehot_encoding(sequences)
+print(encodings)
+
+# Output:
+#[[[0 0 1 0]
+#  [0 1 0 0]
+#  [0 0 0 1]]
+
+# [[0 0 1 0]
+#  [1 0 0 0]
+#  [1 0 0 0]]]
+```
+All encodings with examples are available in the [Documentation](https://mvila035.github.io/dna_parser/documentation/) section.
+

dna_parser-0.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+dna_parser-0.3.0.dist-info/METADATA,sha256=hVbKcyAmx1qqfeHcR1cg5n--VVL7N_K5QGqTtueAmGE,1717
+dna_parser-0.3.0.dist-info/WHEEL,sha256=yPzXoqupHg8BR9P7lkXvHgNDRzRuD8h77-w0fWKSUok,96
+dna_parser-0.3.0.dist-info/licenses/LICENSE,sha256=Vvbjeik3sJC1JpZH-bFF82bGY6aDfFMThI3CeCl0VZI,1086
+dna_parser/call_functions.py,sha256=6qqXK9Hk-4kcGomfuMlYbOQBG0oDuhy3tV_fczhpn_s,2308
+dna_parser/tfidf_class.py,sha256=1UZIDo_Ivtg7pk_5vzwbXHAsAJmhDJZYYC-2tptB5b4,3742
+dna_parser/__init__.py,sha256=zDXZxxl17i-cGhOIxLt2mnfbQPdKWq_5T8AOWa3ZTqg,186
+dna_parser/dna_parser.cp313-win_amd64.pyd,sha256=3oY91QXU4Vpc_ctJuBrVFH4apBlxKwHU0hGpgdYtpKo,686080
+dna_parser-0.3.0.dist-info/RECORD,,

dna_parser-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.8.1)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64

dna_parser-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Mvila035
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.