libz 0.7__tar.gz → 0.9__tar.gz

{libz-0.7 → libz-0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libz
-Version: 0.7
+Version: 0.9
 Summary: A lightweight Python utility toolkit.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown

libz-0.9/libz/BIO/__init__.py

@@ -0,0 +1,14 @@
+from libz._core import register
+
+TITLES = {
+    1: "Retrieval from GenBank, BLASTN / BLASTP search, sequence manipulation",
+    2: "Pairwise sequence alignment - Smith Waterman / Needleman Wunsch",
+    3: "Dynamic programming algorithm for pairwise sequence alignment",
+    4: "Sequence alignment and phylogenetic reconstruction",
+    5: "BLASTP search - unmatched amino acids, % matching, amino acid count",
+    6: "Protein structure analysis - homology modelling",
+    7: "Regular expression of protein sequences from different organisms",
+    8: "GenBank record FJ966082 - comments, translation, FASTA format",
+}
+
+register(__name__, globals(), TITLES)

libz-0.9/libz/BIO/prac1.py

@@ -0,0 +1,186 @@
+# uv add biopython
+
+from Bio.Seq import Seq
+
+dna = Seq(
+    "AATTCTAGGCCGTCCTGGCGATAAAGGTGAGCCAGGTAAACATGTGCCCGGAGTTGCACCACCAGGACCA"
+    "CCAGGTCGACCGGGTGATATGGGACCACCTGGACCACCTGGGCCACCAGGCGAGAAAGGAAAACCTGGAA"
+    "CAAAAGGCCCAATAGGACCACCGGGAGACCAAGGAAATCCAGGTATTTATATTCGTAGTTAATGCTTGAT"
+    "TCGAGAATT"
+)
+
+print("Complement:", dna.complement())
+
+print("Reverse complement:", dna.reverse_complement())
+
+rna = dna.transcribe()
+print("RNA:", rna)
+
+print("DNA to protein:", dna.translate())
+print("RNA to protein:", rna.translate())
+
+import random
+
+random.choices("HT", weights=[0.5, 0.5], k=5)
+
+import random
+import numpy as np
+
+def generate_random_sequence(sequence_length, probability_distribution):
+    sequence = ""
+    for i in range(0, sequence_length):
+        sequence = (
+            sequence
+            + random.choices(
+                ["A", "C", "G", "T"], weights=probability_distribution, k=1
+            )[0]
+        )
+    return sequence
+
+our_random_seq = generate_random_sequence(100, [0.25, 0.25, 0.25, 0.25])
+print(our_random_seq)
+
+from Bio.Seq import Seq
+
+my_dna = Seq("ATCGATGATAGGATA")
+type(my_dna)
+
+my_protein = Seq("KGLYQRGD")
+
+a_sub_sequence = my_dna[3:7]
+the_sequence_length = len(my_dna)
+
+print(the_sequence_length, a_sub_sequence)
+
+the_rev_comp = my_dna.reverse_complement()
+
+print(the_rev_comp)
+
+print(my_dna.transcribe())
+print(my_dna.translate())
+
+def verify(sequence):
+    # This code verifies if a sequence is a DNA or RNA
+    seq = set(sequence)
+
+    if seq == {"A", "T", "C", "G"}.union(seq):
+        return "DNA"
+    elif seq == {"A", "U", "C", "G"}.union(seq):
+        return "RNA"
+    else:
+        return "Invalid"
+
+seq1 = "ATGCAGCTGTGTTACGCGAT"
+seq2 = "UGGCGGAUAAGCGCA"
+seq3 = "TYHGGHHHHH"
+
+print(seq1 + " is " + verify(seq1))
+print(seq2 + " is " + verify(seq2))
+print(seq3 + " is " + verify(seq3))
+
+def verify(sequence):
+    # This code verifies if a sequence is a DNA or RNA
+    seq = set(sequence)
+
+    if seq == {"A", "T", "C", "G"}.union(seq):
+        return "DNA"
+    elif seq == {"A", "U", "C", "G"}.union(seq):
+        return "RNA"
+    else:
+        return "Invalid"
+
+def rev_comp_st(seq):
+    # This function returns a reverse complement of a DNA or RNA strand
+    verified = verify(seq)
+    if verified == "DNA":
+
+        # complement strand
+        seq = (
+            seq.replace("A", "t").replace("C", "g").replace("T", "a").replace("G", "c")
+        )
+        seq = seq.upper()
+
+        # reverse strand
+        seq = seq[::-1]
+        return seq
+
+    elif verified == "RNA":
+
+        # complement strand
+        seq = (
+            seq.replace("A", "u").replace("C", "g").replace("U", "a").replace("G", "c")
+        )
+        seq = seq.upper()
+
+        # reverse strand
+        seq = seq[::-1]
+        return seq
+    else:
+        return "Invalid"
+
+# test variables
+seq1 = "ATGCAGCTGTGTTACGCGAT"
+seq2 = "UGGCGGAUAAGCGCA"
+seq3 = "TYHGGHHHHH"
+
+print("The reverse complementary strand of " + seq1 + " is " + rev_comp_st(seq1))
+print("The reverse complementary strand of " + seq2 + " is " + rev_comp_st(seq2))
+print("The reverse complementary strand of " + seq3 + " is " + rev_comp_st(seq3))
+
+def verify(sequence):
+    # This code verifies if a sequence is a DNA or RNA
+    seq = set(sequence)
+
+    if seq == {"A", "T", "C", "G"}.union(seq):
+        return "DNA"
+    elif seq == {"A", "U", "C", "G"}.union(seq):
+        return "RNA"
+    else:
+        return "Invalid"
+
+def rev_comp_if(seq):
+    comp = []
+    if verify(seq) == "DNA":
+        for base in seq:
+            if base == "A":
+                comp.append("T")
+            elif base == "G":
+                comp.append("C")
+            elif base == "T":
+                comp.append("A")
+            elif base == "C":
+                comp.append("G")
+    elif verify(seq) == "RNA":
+        for base in seq:
+            if base == "U":
+                comp.append("A")
+            elif base == "G":
+                comp.append("C")
+            elif base == "A":
+                comp.append("U")
+            elif base == "C":
+                comp.append("G")
+    else:
+        return "Invalid"
+
+    # reverse the sequence
+    comp_rev = comp[::-1]
+
+    # convert list to string
+    comp_rev = "".join(comp_rev)
+    return comp_rev
+
+seq1 = "ATGCAGCTGTGTTACGCGAT"
+seq2 = "UGGCGGAUAAGCGCA"
+seq3 = "TYHGGHHHHH"
+
+print("The reverse complementary strand of " + seq1 + " is " + rev_comp_if(seq1))
+print("The reverse complementary strand of " + seq2 + " is " + rev_comp_if(seq2))
+print("The reverse complementary strand of " + seq3 + " is " + rev_comp_if(seq3))
+
+from Bio.Seq import Seq
+
+messenger_rna = Seq("AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG")
+print(messenger_rna)
+
+print(messenger_rna.translate())

libz-0.9/libz/BIO/prac2.py

@@ -0,0 +1,215 @@
+# uv add biopython
+
+from Bio import pairwise2
+from Bio import Align
+
+aligner = Align.PairwiseAligner()
+
+aligner.match_score = 1.0
+
+target = "GAACT"
+query = "GAT"
+
+score = aligner.score(target, query)
+print(score)
+
+alignments = aligner.align(target, query)
+
+alignment = alignments[0]
+print(alignment)
+
+for alignment in alignments:
+    print(alignment)
+
+print(alignment.score)
+print(alignment.target)
+print(alignment.query)
+
+alignment = alignments[0]
+
+print(alignment.coordinates)
+
+print(len(alignment))
+print(alignment.length)
+
+alignment = alignments[1]
+print(alignment)
+
+print(alignment.aligned)
+
+aligner.mode = "global"
+aligner.mismatch_score = -10
+
+alignments = aligner.align("AAACAAA", "AAAGAAA")
+
+print(len(alignments))
+
+print(alignments[0])
+
+print(alignments[0].aligned)
+
+print(alignments[1])
+
+print(alignments[1].aligned)
+
+aligner.mode = "local"
+aligner.open_gap_score = -1
+aligner.extend_gap_score = 0
+
+chromosome = "AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA"
+transcript = "CCCCCCCGGGGGG"
+
+alignments1 = aligner.align(chromosome, transcript)
+
+print(len(alignments1))
+
+alignment1 = alignments1[0]
+print(alignment1)
+
+sequence = "CCCCGGGG"
+
+alignments2 = aligner.align(transcript, sequence)
+
+print(len(alignments2))
+
+alignment2 = alignments2[0]
+print(alignment2)
+
+mapped_alignment = alignment1.map(alignment2)
+
+print(mapped_alignment)
+
+format(mapped_alignment, "psl")
+
+from Bio.Seq import Seq
+
+alignment1.target = Seq(None, len(alignment1.target))
+alignment1.query = Seq(None, len(alignment1.query))
+
+alignment2.target = Seq(None, len(alignment2.target))
+alignment2.query = Seq(None, len(alignment2.query))
+
+mapped_alignment = alignment1.map(alignment2)
+
+format(mapped_alignment, "psl")
+
+aligner.mode = "local"
+
+target = "AGAACTC"
+query = "GAACT"
+
+score = aligner.score(target, query)
+
+print(score)
+
+alignments = aligner.align(target, query)
+
+for alignment in alignments:
+    print(alignment)
+
+from Bio import Align
+
+aligner = Align.PairwiseAligner(
+    match_score=1.0,
+    mode="local"
+)
+
+print(aligner.algorithm)
+print(aligner)
+
+aligner = Align.PairwiseAligner()
+
+print(aligner.match_score)
+
+score = aligner.score("ACGT", "ACAT")
+print(score)
+
+aligner.match_score = 1.0
+aligner.mismatch_score = -2.0
+aligner.gap_score = -2.5
+
+score = aligner.score("ACGT", "ACAT")
+
+print(score)
+
+import numpy as np
+
+def nw(x, y, match=1, mismatch=1, gap=1):
+    nx = len(x)
+    ny = len(y)
+
+    F = np.zeros((nx + 1, ny + 1))
+    F[:,0] = np.linspace(0, -nx * gap, nx + 1)
+    F[0,:] = np.linspace(0, -ny * gap, ny + 1)
+
+    P = np.zeros((nx + 1, ny + 1))
+    P[:,0] = 3
+    P[0,:] = 4
+
+    t = np.zeros(3)
+
+    for i in range(nx):
+        for j in range(ny):
+
+            if x[i] == y[j]:
+                t[0] = F[i,j] + match
+            else:
+                t[0] = F[i,j] - mismatch
+
+            t[1] = F[i,j+1] - gap
+            t[2] = F[i+1,j] - gap
+
+            tmax = np.max(t)
+            F[i+1,j+1] = tmax
+
+            if t[0] == tmax:
+                P[i+1,j+1] += 2
+            if t[1] == tmax:
+                P[i+1,j+1] += 3
+            if t[2] == tmax:
+                P[i+1,j+1] += 4
+
+    i = nx
+    j = ny
+
+    rx = []
+    ry = []
+
+    while i > 0 or j > 0:
+
+        if P[i,j] in [2,5,6,9]:
+            rx.append(x[i-1])
+            ry.append(y[j-1])
+            i -= 1
+            j -= 1
+
+        elif P[i,j] in [3,5,7,9]:
+            rx.append(x[i-1])
+            ry.append('-')
+            i -= 1
+
+        elif P[i,j] in [4,6,7,9]:
+            rx.append('-')
+            ry.append(y[j-1])
+            j -= 1
+
+    rx = ''.join(rx)[::-1]
+    ry = ''.join(ry)[::-1]
+
+    return '\n'.join([rx, ry])
+
+x = "GATTACA"
+y = "GCATGCU"
+
+print(nw(x, y))
+
+np.random.seed(42)
+
+x = np.random.choice(['A','T','G','C'],50)
+y = np.random.choice(['A','T','G','C'],50)
+
+print(nw(x, y, gap=0))
+
+print(nw(x, y, gap=1))
+
+print(nw(x, y, gap=2))

libz-0.9/libz/BIO/prac3.py

@@ -0,0 +1,77 @@
+def needleman_wunsch_score(seq1, seq2, match=2, mismatch=-1, gap=-2):
+    m, n = len(seq1), len(seq2)
+
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+    # Initialize first row and column
+    for i in range(1, m + 1):
+        dp[i][0] = i * gap
+
+    for j in range(1, n + 1):
+        dp[0][j] = j * gap
+
+    # Fill DP table
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            score = match if seq1[i - 1] == seq2[j - 1] else mismatch
+
+            dp[i][j] = max(
+                dp[i - 1][j - 1] + score,
+                dp[i - 1][j] + gap,
+                dp[i][j - 1] + gap
+            )
+
+    return dp[m][n], dp
+
+
+def print_table(dp):
+    for row in dp:
+        print(row)
+
+seq1 = "GAATTC"
+seq2 = "GATAC"
+
+score, table = needleman_wunsch_score(seq1, seq2)
+
+print("Needleman-Wunsch DP Table:")
+print_table(table)
+
+print("\nGlobal Alignment Score:", score)
+
+def smith_waterman_score(seq1, seq2, match=2, mismatch=-1, gap=-2):
+    m, n = len(seq1), len(seq2)
+
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+    max_score = 0
+
+    # Fill DP table
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+
+            score = match if seq1[i - 1] == seq2[j - 1] else mismatch
+
+            dp[i][j] = max(
+                0,
+                dp[i - 1][j - 1] + score,
+                dp[i - 1][j] + gap,
+                dp[i][j - 1] + gap
+            )
+
+            max_score = max(max_score, dp[i][j])
+
+    return max_score, dp
+
+def print_table(dp):
+    for row in dp:
+        print(row)
+
+seq1 = "GAATTC"
+seq2 = "GATAC"
+
+score, table = smith_waterman_score(seq1, seq2)
+
+print("Smith-Waterman DP Table:")
+print_table(table)
+
+print("\nLocal Alignment Score:", score)

libz-0.9/libz/BIO/prac4.py

@@ -0,0 +1,97 @@
+import pandas as pd
+import numpy as np
+
+import matplotlib.pyplot as plt
+from scipy.cluster.hierarchy import linkage, dendrogram
+from scipy.spatial.distance import squareform
+
+data = {
+    "Human": "ATCGGCTA",
+    "Chimp": "ATCGGCTA",
+    "Monkey": "ATCGACTA",
+    "Mouse": "TTAGACTG"
+}
+
+species_names = list(data.keys())
+sequences = list(data.values())
+n = len(species_names)
+
+def calculate_metrics(seq1, seq2):
+    matches = sum(1 for a, b in zip(seq1, seq2) if a == b)
+    total_positions = len(seq1)
+    similarity = matches / total_positions
+    distance = 1 - similarity
+    return similarity * 100, distance
+
+similarity_matrix = np.zeros((n, n))
+distance_matrix = np.zeros((n, n))
+
+for i in range(n):
+    for j in range(n):
+        sim, dist = calculate_metrics(sequences[i], sequences[j])
+        similarity_matrix[i][j] = sim
+        distance_matrix[i][j] = dist
+
+df_similarity = pd.DataFrame(similarity_matrix, index=species_names, columns=species_names)
+df_distance = pd.DataFrame(distance_matrix, index=species_names, columns=species_names)
+
+print("--- Similarity Matrix (%) ---")
+print(df_similarity)
+print("\n--- Distance Matrix ---")
+print(df_distance)
+
+flattened_distances = df_distance.where(np.triu(np.ones(df_distance.shape), k=1).astype(bool)).stack()
+closest_pair = flattened_distances.idxmin()
+min_dist = flattened_distances.min()
+
+print(f"Interpretation: The closest pair is {closest_pair} with a distance of {min_dist}.")
+print("Following the workflow, these would be the first to cluster in a phylogenetic tree.")
+
+import pandas as pd
+import numpy as np
+
+import matplotlib.pyplot as plt
+from scipy.cluster.hierarchy import linkage, dendrogram
+from scipy.spatial.distance import squareform
+
+data = {
+    "Human": "ATCGGCTA",
+    "Chimp": "ATCGGCTA",
+    "Monkey": "ATCGACTA",
+    "Mouse": "TTAGACTG"
+}
+
+species_names = list(data.keys())
+sequences = list(data.values())
+n = len(species_names)
+
+def calculate_distance(seq1, seq2):
+    matches = sum(1 for a, b in zip(seq1, seq2) if a == b)
+    similarity = matches / len(seq1)
+    return 1 - similarity
+
+dist_matrix = np.zeros((n, n))
+for i in range(n):
+    for j in range(n):
+        dist_matrix[i][j] = calculate_distance(sequences[i], sequences[j])
+
+condensed_dist = squareform(dist_matrix)
+
+linked = linkage(condensed_dist, method='average')
+
+plt.figure(figsize=(8, 5))
+dendrogram(linked,
+           labels=species_names,
+           orientation='left',
+           distance_sort='descending')
+
+plt.title("Phylogenetic Tree (Based on Source Data)")
+plt.xlabel("Evolutionary Distance")
+plt.ylabel("Species")
+plt.grid(axis='x', linestyle='--', alpha=0.7)
+plt.show()
+
+print("Tree Iteration Logic:")
+print("1. Cluster 1: Human and Chimp (Distance = 0.0)")
+print("2. Cluster 2: Add Monkey (Distance to Human/Chimp = 0.125)")
+print("3. Cluster 3: Add Mouse (Greatest distance)")