ataserinyelMSA 0.1.0__tar.gz

ataserinyelmsa-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ata Serinyel
+
+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.

ataserinyelmsa-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.2
+Name: ataserinyelMSA
+Version: 0.1.0
+Summary: A simple MAFFT-based Multiple Sequence Alignment (MSA) library
+Author-email: ataserinyel <clasher.mp2@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ataserinyel/ataserinyelMSA
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+
+# ataserinyelMSA
+
+A simple MAFFT-inspired Multiple Sequence Alignment (MSA) tool written in Python.
+
+## Installation
+
+```bash
+pip install ataserinyelMSA
+```
+
+## Usage
+
+```bash
+python main.py input.fasta output.fasta
+```
+
+## Example
+
+Input (`input.fasta`):
+```
+>seq1
+GATTACA
+>seq2
+GCATGCU
+>seq3
+AGCTAGC
+```
+Output (`output.fasta`):
+```
+>seq1
+-GAT-TACA
+>seq2
+-GC-ATGCU
+>seq3
+AGCTA-GC-
+```
+## Algorithm
+
+This tool implements a simplified version of the MAFFT FFT-NS-1 algorithm:
+
+1. **FASTA Parsing** - Read and write FASTA format files
+2. **Pairwise Alignment** - Needleman-Wunsch global alignment algorithm
+3. **Distance Matrix** - Compute pairwise distances between sequences
+4. **Guide Tree** - UPGMA clustering algorithm
+5. **Progressive Alignment** - Align sequences following the guide tree order
+
+## Differences from original MAFFT
+
+- Uses Needleman-Wunsch instead of FFT for similarity calculation
+- Simple +1/-1 scoring matrix instead of advanced substitution matrices
+- Suitable for small datasets
+
+## Author
+
+Ata Serinyel

ataserinyelmsa-0.1.0/README.md

@@ -0,0 +1,55 @@
+# ataserinyelMSA
+
+A simple MAFFT-inspired Multiple Sequence Alignment (MSA) tool written in Python.
+
+## Installation
+
+```bash
+pip install ataserinyelMSA
+```
+
+## Usage
+
+```bash
+python main.py input.fasta output.fasta
+```
+
+## Example
+
+Input (`input.fasta`):
+```
+>seq1
+GATTACA
+>seq2
+GCATGCU
+>seq3
+AGCTAGC
+```
+Output (`output.fasta`):
+```
+>seq1
+-GAT-TACA
+>seq2
+-GC-ATGCU
+>seq3
+AGCTA-GC-
+```
+## Algorithm
+
+This tool implements a simplified version of the MAFFT FFT-NS-1 algorithm:
+
+1. **FASTA Parsing** - Read and write FASTA format files
+2. **Pairwise Alignment** - Needleman-Wunsch global alignment algorithm
+3. **Distance Matrix** - Compute pairwise distances between sequences
+4. **Guide Tree** - UPGMA clustering algorithm
+5. **Progressive Alignment** - Align sequences following the guide tree order
+
+## Differences from original MAFFT
+
+- Uses Needleman-Wunsch instead of FFT for similarity calculation
+- Simple +1/-1 scoring matrix instead of advanced substitution matrices
+- Suitable for small datasets
+
+## Author
+
+Ata Serinyel

ataserinyelmsa-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0,<77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ataserinyelMSA"
+version = "0.1.0"
+authors = [
+  { name="ataserinyel", email="clasher.mp2@gmail.com" }
+]
+description = "A simple MAFFT-based Multiple Sequence Alignment (MSA) library"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Bio-Informatics",
+]
+dependencies = [
+  "numpy>=1.21.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ataserinyel/ataserinyelMSA"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ataserinyelmsa-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ataserinyelmsa-0.1.0/src/ataserinyelMSA/alignment.py

@@ -0,0 +1,155 @@
+# Needleman-Wunsch Algoritması
+
+import numpy as np
+from src.ataserinyelMSA.scoring import get_score, GAP_PENALTY
+
+def needleman_wunsch(seq1, seq2):
+    '''
+    İki diziyi Needleman-Wunsch algoritması ile hizalar.
+    Hizalanmış seq1 ve seq2 döndürür.
+    '''
+
+    # MAtrisleri 0 ile doldurma
+    S = np.zeros([len(seq1)+1, len(seq2)+1])
+
+    for i in range(1, len(seq1)+1):
+        S[i, 0] = S[i-1, 0] + GAP_PENALTY
+
+    for j in range(1, len(seq2)+1):
+        S[0, j] = S[0, j-1] + GAP_PENALTY
+
+    for i in range(1, len(seq1)+1):
+        for j in range(1, len(seq2)+1):
+            a = S[i-1, j-1] + get_score(seq1[i-1], seq2[j-1])   # Çapraz kontrol
+            b = S[i-1, j] + GAP_PENALTY                         # Yukarı
+            c = S[i, j-1] + GAP_PENALTY                         # Sol
+            S[i,j] = max(a,b,c)                                 # En yükseği al
+            
+    # Traceback işlemi
+    aligned_seq1 = ''
+    aligned_seq2 = ''
+    i, j = len(seq1), len(seq2)
+
+    while i>0 or j>0:
+        # Çaprazdan gelme
+        if i>0 and j>0 and S[i,j] == S[i-1, j-1] + get_score(seq1[i-1], seq2[j-1]):
+            aligned_seq1 = seq1[i-1] + aligned_seq1
+            aligned_seq2 = seq2[j-1] + aligned_seq2
+            i = i-1
+            j = j-1
+        # Yukarıdan Gelme
+        elif i>0 and S[i,j] == S[i-1,j] + GAP_PENALTY:
+            aligned_seq1 = seq1[i-1] + aligned_seq1
+            aligned_seq2 = '-' + aligned_seq2
+            i = i-1
+        # Soldan Gelme
+        else:
+            aligned_seq1 = '-' + aligned_seq1
+            aligned_seq2 = seq2[j-1] + aligned_seq2
+            j = j-1
+    
+    return aligned_seq1, aligned_seq2
+
+def compute_distance(seq1, seq2):
+    '''
+    İki dizi arasındaki mesafeyi hesaplar.
+    Hizalama skorunu mesafeye çevirir.
+    Yüksek Skor = Düşük Mesafe
+    '''
+
+    aligned_seq1, aligned_seq2 = needleman_wunsch(seq1, seq2)
+
+    matches = 0
+    total = len(aligned_seq1)
+
+    for a, b in zip(aligned_seq1, aligned_seq2):
+        if a == b:
+            matches += 1
+
+    smilarity = matches / total     # 0 ile 1 arasında benzerlik oranı
+    distance = 1 - smilarity        # Benzerliğin tersi = mesafe
+
+    return distance
+
+def distance_matrix(sequences):
+    '''
+    Tüm dizi çiftleri için mesafe hesaplar.
+    Girdi: {'seq1': 'GATTACA', 'seq2': 'GCATGCU', ...}
+    Döndürdüğü 2 boyutlu liste (matris) ve isim listesi.
+    '''
+
+    names = list(sequences.keys())
+    seqs = list(sequences.values())
+    n = len(seqs)
+
+    matrix = np.zeros((n, n))
+
+    for i in range(n):
+        for j in range(i+1, n): # i+1'den başlıyoruz çünkü i == j anyı dizi ve mefase 0
+            dist = compute_distance(seqs[i], seqs[j])
+            matrix[i][j] = dist
+            matrix[j][i] = dist # Simetrik, seq1 -> seq2 mesafesi = seq2 -> seq1 mesafesi.
+
+    return matrix, names
+
+def get_consensus(aligned_seqs):
+    """
+    Hizalanmış diziler grubundan konsensüs dizi üretir.
+    Gap olmayan karakterlere öncelik verir.
+    """
+    consensus = ''
+    for i in range(len(aligned_seqs[0])):
+        column = [seq[i] for seq in aligned_seqs]
+        non_gaps = [c for c in column if c != '-']
+        if non_gaps:
+            consensus += max(set(non_gaps), key=non_gaps.count)  # Gap olmayanların en sığını al
+        else:
+            consensus += '-'  # Tüm pozisyon gap ise gap koy
+    return consensus
+
+def progressive_alignment(sequences, merge_order):
+    '''
+    UPGMA'nın verdiği sıraya göre dizileri hizalar.
+    Girdi:  - sequences -> {'seq1': 'GATTACA', ...}
+            - merge_oreder -> [('seq2', 'seq3'), ('seq1', '(seq2, seq3)')]
+    Döndürdüğü: hizalanmış diziler sözlüğü
+    '''
+
+    # Grupları takip eden sözlük, başta her isim kendi dizisini takip eder
+    groups = {name: [seq] for name, seq in sequences.items()}
+
+    for (name1, name2) in merge_order:
+        # İki grubunu konsensüsünü al
+        consensus1 = get_consensus(groups[name1])
+        consensus2 = get_consensus(groups[name2])
+
+        # Konsensüsler arasında hizalama yap
+        aligned1, aligned2 = needleman_wunsch(consensus1, consensus2)
+
+        # Gap pozisyonlarını tüm gruba uygula
+        def apply_gaps(seqs, aligned_consensus, original_consensus):
+            result = []
+
+            for seq in seqs:
+                new_seq = ''
+                seq_idx = 0
+                for char in aligned_consensus:
+                    if char == '-':
+                        new_seq += '-'  # Yeni gap ekle
+                    else:
+                        new_seq += seq[seq_idx]
+                        seq_idx += 1
+                result.append(new_seq)
+            return result
+        
+        new_group1 = apply_gaps(groups[name1], aligned1, consensus1)
+        new_group2 = apply_gaps(groups[name2], aligned2, consensus2)
+
+        # Yeni grubu oluşturma
+        new_name = f'({name1}, {name2})'
+        groups[new_name] = new_group1 + new_group2
+
+    final_group = groups[list(groups.keys())[-1]]
+    names = list(sequences.keys())
+
+    return {names[i]: final_group[i] for i in range(len(names))}

ataserinyelmsa-0.1.0/src/ataserinyelMSA/fasta.py

@@ -0,0 +1,35 @@
+# FASTA Dosyalarını okumak ve yazmak için yardımcı fonkyionlar.
+
+def read_fasta(filename):
+    '''
+    FASTA dosyasını okur.
+    Döndürme şu şekilde olur:
+        {'seq1': 'ATAATAGC', 'seq2': 'GATACACG'}
+    '''
+    
+    sequences = {}
+    current_name = None
+
+    with open(filename, 'r') as f:
+        for line in f:
+            line = line.strip() # Satır sonu \n karakterini temizler
+
+            if line.startswith('>'):
+                current_name = line[1:] # > karkterini atla
+                sequences[current_name] = ''
+            else:
+                sequences[current_name] += line
+                # += kullannıyoruz çünkü bazı diziler birden fazla satıra bölünmüş olabilir
+    
+    return sequences
+    
+def write_fasta(sequences, filename):
+    '''
+    Sözlükteki dizileri FASTA formatında dosyaya yazar.
+    Hizalamadan sonra dizilerde gap karakteri olabilir.
+    '''
+
+    with open(filename, 'w') as f:
+        for name, seq in sequences.items():
+            f.write(f'>{name}\n')
+            f.write(f'{seq}\n')

ataserinyelmsa-0.1.0/src/ataserinyelMSA/scoring.py

@@ -0,0 +1,24 @@
+# Dizi hizalamasında kullanılan puanlama matrisi.
+# DNA ve RNA dizileri için nükleotid puanlama matrisi.
+
+MATCH = 1
+MISMATCH = -1
+GAP_PENALTY = -1
+
+# Eşleşme: MATCH, Uyuşmazlık: MISMATCH
+
+NUCLEOTIDE_MATRIX = {
+    ('A', 'A'): MATCH,      ('A', 'T'): MISMATCH,   ('A', 'G'): MISMATCH,   ('A', 'C'): MISMATCH,   ('A', 'U'): MISMATCH,
+    ('T', 'A'): MISMATCH,   ('T', 'T'): MATCH,      ('T', 'G'): MISMATCH,   ('T', 'C'): MISMATCH,   ('T', 'U'): MISMATCH,   
+    ('G', 'A'): MISMATCH,   ('G', 'T'): MISMATCH,   ('G', 'G'): MATCH,      ('G', 'C'): MISMATCH,   ('G', 'U'): MISMATCH,
+    ('C', 'A'): MISMATCH,   ('C', 'T'): MISMATCH,   ('C', 'G'): MISMATCH,   ('C', 'C'): MATCH,      ('C', 'U'): MISMATCH,
+    ('U', 'A'): MISMATCH,   ('U', 'T'): MISMATCH,   ('U', 'G'): MISMATCH,   ('U', 'C'): MISMATCH,   ('U', 'U'): MATCH,
+}
+
+def get_score(a,b):
+    '''
+    İki karakter arasındaki skoru döndürür.
+    Matriste olmayan karakterler için 0 döndürür.
+    '''
+
+    return NUCLEOTIDE_MATRIX.get((a,b), 0)

ataserinyelmsa-0.1.0/src/ataserinyelMSA/tree.py

@@ -0,0 +1,60 @@
+# UPGMA algoritması ile guide tree oluşturur.
+# Girdi: Distance matrix ve isim listesi
+# Çıktı: Dizilerin hangi sırayla birleştirildiği listesi
+# [(i,j), (k,l), ...] gibi gibi
+
+import numpy as np
+
+def upgma(matrix, names):
+    '''
+    UPGMA algorimtası ile birleştirme sırasını döndürür.
+    Döndürdüğğü: [('seq2', 'seq3'), ('seq1', '(seq2,seq3)'), ...]
+    '''
+
+    matrix = [row[:] for row in matrix] # Orijinal matrisi bozmamak için kopyala
+    names = list(names)                 # İsim listesini kopyala
+    merge_order = []                    # Birleştirme sırası
+
+    while len(names) > 1:
+        n = len(names)
+
+        # En küçük mesafeyi bul
+        min_dist = float('inf')
+        min_i, min_j = 0, 1
+
+        for i in range(n):
+            for j in range(i+1, n):
+                if matrix[i][j] < min_dist:
+                    min_dist = matrix[i][j]
+                    min_i, min_j = i, j
+
+        # Birleştirme sırasına ekle
+        merge_order.append((names[min_i], names[min_j]))
+
+        # Yeni grubun ismini oluştur
+        new_name = f'({names[min_i]}, {names[min_j]})'
+
+        # Yeni grubun diğer dizilere mesafesini hesapla
+        new_distances = []
+        for k in range(n):
+            if k != min_i and k != min_j:
+                new_dist = (matrix[min_i][k] + matrix[min_j][k]) / 2
+                new_distances.append(new_dist)
+
+        # Eski grupları sil, yeni grubu ekle
+        names.pop(min_j)
+        names.pop(min_i)
+        names.append(new_name)
+
+        # Matrisi güncelle
+        matrix = np.delete(matrix, [min_i, min_j], axis=0)
+        matrix = np.delete(matrix, [min_i, min_j], axis=1)
+        matrix = matrix.tolist()
+
+        # Yeni satır ve sütun ekle
+        for k in range(len(matrix)):
+            matrix[k].append(new_distances[k])
+        new_distances.append(0.0)
+        matrix.append(new_distances)
+
+    return merge_order

ataserinyelmsa-0.1.0/src/ataserinyelMSA.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.2
+Name: ataserinyelMSA
+Version: 0.1.0
+Summary: A simple MAFFT-based Multiple Sequence Alignment (MSA) library
+Author-email: ataserinyel <clasher.mp2@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ataserinyel/ataserinyelMSA
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+
+# ataserinyelMSA
+
+A simple MAFFT-inspired Multiple Sequence Alignment (MSA) tool written in Python.
+
+## Installation
+
+```bash
+pip install ataserinyelMSA
+```
+
+## Usage
+
+```bash
+python main.py input.fasta output.fasta
+```
+
+## Example
+
+Input (`input.fasta`):
+```
+>seq1
+GATTACA
+>seq2
+GCATGCU
+>seq3
+AGCTAGC
+```
+Output (`output.fasta`):
+```
+>seq1
+-GAT-TACA
+>seq2
+-GC-ATGCU
+>seq3
+AGCTA-GC-
+```
+## Algorithm
+
+This tool implements a simplified version of the MAFFT FFT-NS-1 algorithm:
+
+1. **FASTA Parsing** - Read and write FASTA format files
+2. **Pairwise Alignment** - Needleman-Wunsch global alignment algorithm
+3. **Distance Matrix** - Compute pairwise distances between sequences
+4. **Guide Tree** - UPGMA clustering algorithm
+5. **Progressive Alignment** - Align sequences following the guide tree order
+
+## Differences from original MAFFT
+
+- Uses Needleman-Wunsch instead of FFT for similarity calculation
+- Simple +1/-1 scoring matrix instead of advanced substitution matrices
+- Suitable for small datasets
+
+## Author
+
+Ata Serinyel

ataserinyelmsa-0.1.0/src/ataserinyelMSA.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/ataserinyelMSA/alignment.py
+src/ataserinyelMSA/fasta.py
+src/ataserinyelMSA/scoring.py
+src/ataserinyelMSA/tree.py
+src/ataserinyelMSA.egg-info/PKG-INFO
+src/ataserinyelMSA.egg-info/SOURCES.txt
+src/ataserinyelMSA.egg-info/dependency_links.txt
+src/ataserinyelMSA.egg-info/requires.txt
+src/ataserinyelMSA.egg-info/top_level.txt
+test/test_alignment.py
+test/test_distance.py
+test/test_fasta.py
+test/test_pipline.py
+test/test_progressive_alignment.py
+test/test_scoring.py
+test/test_tree.py

ataserinyelmsa-0.1.0/src/ataserinyelMSA.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ataserinyelmsa-0.1.0/src/ataserinyelMSA.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.21.0

ataserinyelmsa-0.1.0/src/ataserinyelMSA.egg-info/top_level.txt

@@ -0,0 +1 @@
+ataserinyelMSA

ataserinyelmsa-0.1.0/test/test_alignment.py

@@ -0,0 +1,3 @@
+from src.ataserinyelMSA.alignment import needleman_wunsch
+
+print(needleman_wunsch('GATTACA', 'GCATGCU'))

ataserinyelmsa-0.1.0/test/test_distance.py

@@ -0,0 +1,8 @@
+
+from src.ataserinyelMSA.fasta import read_fasta
+from src.ataserinyelMSA.alignment import distance_matrix
+seqs = read_fasta('test/test.fasta')
+matrix, names = distance_matrix(seqs)
+print(names)
+for row in matrix:
+    print([round(float(x), 2) for x in row])

ataserinyelmsa-0.1.0/test/test_fasta.py

@@ -0,0 +1,3 @@
+from ataserinyelMSA.fasta import read_fasta
+
+print(read_fasta('test/test.fasta'))

ataserinyelmsa-0.1.0/test/test_pipline.py

@@ -0,0 +1,33 @@
+
+from src.ataserinyelMSA.fasta import read_fasta, write_fasta
+from src.ataserinyelMSA.alignment import distance_matrix, progressive_alignment
+from src.ataserinyelMSA.tree import upgma
+
+# 1. FASTA oku
+seqs = read_fasta('test/test.fasta')
+print('1. Diziler okundu:')
+for name, seq in seqs.items():
+    print(f'   {name}: {seq}')
+
+# 2. Distance matrix
+mat, names = distance_matrix(seqs)
+print('\n2. Distance Matrix:')
+print('   ', names)
+for i, row in enumerate(mat):
+    print(f'   {names[i]}: {[round(float(x), 2) for x in row]}')
+
+# 3. UPGMA
+order = upgma(mat, names)
+print('\n3. Birleştirme Sirasi:')
+for step in order:
+    print(f'   {step[0]} + {step[1]}')
+
+# 4. Progressive Alignment
+result = progressive_alignment(seqs, order)
+print('\n4. Hizalanmis Diziler:')
+for name, seq in result.items():
+    print(f'   {name}: {seq}')
+
+# 5. Sonucu dosyaya yaz
+write_fasta(result, 'test/output.fasta')
+print('\n5. Sonuc test/output.fasta dosyasina yazildi.')

ataserinyelmsa-0.1.0/test/test_progressive_alignment.py

@@ -0,0 +1,11 @@
+from src.ataserinyelMSA.fasta import read_fasta
+from src.ataserinyelMSA.alignment import distance_matrix, progressive_alignment
+from src.ataserinyelMSA.tree import upgma
+
+seqs = read_fasta('test/test.fasta')
+mat, names = distance_matrix(seqs)
+order = upgma(mat, names)
+result = progressive_alignment(seqs, order)
+
+for name, seq in result.items():
+    print(f'{name}: {seq}')

ataserinyelmsa-0.1.0/test/test_scoring.py

@@ -0,0 +1,6 @@
+from src.ataserinyelMSA.scoring import get_score
+
+print(get_score('A', 'A'))
+print(get_score('A', 'T'))
+print(get_score('A', 'X'))
+

ataserinyelmsa-0.1.0/test/test_tree.py

@@ -0,0 +1,8 @@
+from src.ataserinyelMSA.fasta import read_fasta
+from src.ataserinyelMSA.alignment import distance_matrix
+from src.ataserinyelMSA.tree import upgma
+
+seqs = read_fasta('test/test.fasta')
+mat, names = distance_matrix(seqs)
+order = upgma(mat, names)
+print(order)