lab01.py

import math

forward = "AGGACGAAGACCCAATCATCC"
reverse = "CTGTCTTCCATGTCGTCGGA"

def get_melting_temperature(strand):
    nA = strand.count("A")
    nT = strand.count("T")
    nG = strand.count("C")
    nC = strand.count("G")
    if len(strand) > 14:
        return (64.9 + 41 * (nG + nC - 16.4) / (nA + nT + nG + nC))
    else:
        return (nA + nT) * 2 + (nG + nC) * 4

def get_gc_content(strand):
    return ((strand.count("G") + strand.count("C")) / len(strand)) * 100

def is_between(num, x, y):
    return x <= num <= y

def check_length(strand):
    return is_between(len(strand), 18, 24)

def contains_gc(strand):
    return "G" in strand or "C" in strand

def get_complementary_dna(strand):
    buffer = []
    for l in strand:
        if l == "A":
            buffer += "T"
        elif l == "T":
            buffer += "A"
        elif l == "G":
            buffer += "C"
        elif l == "C":
            buffer += "G"
    return buffer


def print_result(s):
    print(f"{"-" * 100}\n{s}", end="\n")


def verify_starters(forward, reverse):
    status = {0: "FAILED", 1: "PASSED"}
    result = {"length": None, "gc_content": None, "gc_start": None, "gc_end": None, "temperature_difference": None, "complementary_starters": None}
    # Length check
    result["length"] = {"status": status[check_length(forward) and check_length(reverse)], "forward_length": len(forward), "reverse_length": len(reverse)}

    # GC content check
    gc_content_forward = round(get_gc_content(forward), 2)
    gc_content_reverse = round(get_gc_content(reverse), 2)
    result["gc_content"] = {"status": status[is_between(gc_content_forward, 10, 60) and is_between(gc_content_reverse, 10, 60)], "forward_content": gc_content_forward, "reverse_content": gc_content_reverse}
    
    # Verify GC start
    forward_start = forward[:2]
    reverse_start = reverse[:2]
    result["gc_start"] = {"status": status[contains_gc(forward_start) and contains_gc(reverse_start)], "forward_start": forward_start, "reverse_start": reverse_start}

    # Verify GC end
    forward_end = forward[-2:]
    reverse_end = reverse[-2:]
    result["gc_end"] = {"status": status[contains_gc(forward_end) and contains_gc(reverse_end)], "forward_end": forward_end, "reverse_end": reverse_end}

    # Temperature difference
    forward_melting_temp = round(get_melting_temperature(forward), 2)
    reverse_melting_temp = round(get_melting_temperature(reverse), 2)
    result["temperature_difference"] = {"status": status[math.fabs(forward_melting_temp - reverse_melting_temp) < 5], "forward_melting_temp": forward_melting_temp, "reverse_melting_temp": reverse_melting_temp}
    
    # Check if starters are complementary
    temp_forward = forward
    complementary = get_complementary_dna(reverse)
    complementary_pos = []
    nucleotides = {"A": "T", "T": "A", "C": "G", "G": "C"}

    if len(forward) > len(complementary):
        temp_forward = forward[:len(complementary)]

    i = 0
    for n in temp_forward:
        if nucleotides[n] == complementary[i]:
            complementary_pos.append([n, complementary[i], i + 1])
        i += 1

    result["complementary_starters"] = {"hits": complementary_pos, "forward": temp_forward, "reverse_complementary": "".join(complementary)}
    return result

results = verify_starters(forward, reverse)

length = results["length"]
gc_content = results["gc_content"]
gc_start = results["gc_start"]
gc_end = results["gc_end"]
temperature_difference = results["temperature_difference"]
complementarity = results["complementary_starters"]

print_result(f"Length check: {length["status"]}\tForward strand length: {length["forward_length"]}\tReverse strand length: {length["reverse_length"]}")
print_result(f"GC content (forward): {gc_content["status"]}\tForward strand content: {gc_content["forward_content"]}%\tReverse strand content: {gc_content["reverse_content"]}%")
print_result(f"Strand start contains G or C: {gc_start["status"]}\tForward strand start sequence: {gc_start["forward_start"]}\tReverse strand start sequence: {gc_start["reverse_start"]}")
print_result(f"Strand end contains G or C: {gc_end["status"]}\tForward strand start sequence: {gc_end["forward_end"]}\tReverse strand start sequence: {gc_end["reverse_end"]}")
print_result(f"Melting temperature difference: {temperature_difference["status"]}\tForward strand melting temperature: {temperature_difference["forward_melting_temp"]}°C\tReverse strand melting temperature: {temperature_difference["reverse_melting_temp"]}°C")
print_result(f"Complementarity: \nForward strand: {complementarity["forward"]}\tReverse complementary strand: {complementarity["reverse_complementary"]}")
print(f"Complementarity hits found: {len(complementarity["hits"])}")
print("\nForward strand\tReverse complementary strand\tPosition")
print(f'{"\n".join(f"{hit[0]}\t{hit[1]}\ton pos {hit[2]}" for hit in complementarity["hits"])}')