primer3plus-core 0.1.0__py3-none-any.whl

primer3plus_core/__init__.py

@@ -0,0 +1,3 @@
+"""primer3plus_core — headless Primer3Plus logic, no Flask dependency."""
+
+__version__ = "0.1.0"

primer3plus_core/boulder.py

@@ -0,0 +1,281 @@
+"""Boulder-IO text processing: normalisation, tag injection, parsing, counting."""
+
+import re as _re
+
+from .config import (
+    RE_THERMO_PATH,
+    RE_LIB_PRIMER, RE_LIB_INTERNAL,
+    P3LIBFIX, P3LIBIFIX,
+    RE_LEFT_COUNT, RE_INTERNAL_COUNT, RE_RIGHT_COUNT,
+)
+
+
+def _clean_numeric(val: str, label: str) -> str:
+    """Strip non-numeric characters from *val*, rejecting negative signs.
+
+    Returns the cleaned string.  Raises ``ValueError`` if *val* contains
+    a ``-`` (these fields are concentrations/temperatures that must be ≥ 0).
+    """
+    if "-" in val:
+        raise ValueError(label + " must not be negative.")
+    return _re.sub(r"[^0-9\.]", "", val)
+
+
+# ---------------------------------------------------------------------------
+# Input normalisation (step 2 of migration)
+# ---------------------------------------------------------------------------
+
+def normalize_newlines(text: str) -> str:
+    """Collapse \\r\\n and bare \\r to \\n."""
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def strip_thermo_path(text: str) -> str:
+    """Remove the PRIMER_THERMODYNAMIC_PARAMETERS_PATH line."""
+    return RE_THERMO_PATH.sub("", text)
+
+
+def inject_mispriming_libs(text: str) -> str:
+    """Replace PRIMER_MISPRIMING_LIBRARY / PRIMER_INTERNAL_MISHYB_LIBRARY
+    paths with the server-local mispriming_lib directory."""
+    text = RE_LIB_PRIMER.sub(P3LIBFIX, text)
+    text = RE_LIB_INTERNAL.sub(P3LIBIFIX, text)
+    return text
+
+
+def prepare_input(indata: str) -> str:
+    """Full input-preparation pipeline: normalise → strip → inject."""
+    text = normalize_newlines(indata)
+    text = strip_thermo_path(text)
+    text = inject_mispriming_libs(text)
+    return text
+
+
+# ---------------------------------------------------------------------------
+# Output post-processing
+# ---------------------------------------------------------------------------
+
+def append_run_metadata(output: str, uuidstr: str, error: str = "") -> str:
+    """Append P3P_UUID and (optionally) P3P_ERROR to Boulder-IO output."""
+    output += "\nP3P_UUID=" + uuidstr + "\n"
+    if error:
+        output += "P3P_ERROR=" + error + "\n"
+    return output
+
+
+def count_primers(output: str) -> int:
+    """Count total primers returned (left + internal + right)."""
+    total = 0
+    for regex in (RE_LEFT_COUNT, RE_INTERNAL_COUNT, RE_RIGHT_COUNT):
+        m = regex.search(output)
+        if m:
+            total += int(m.group(1))
+    return total
+
+
+# ---------------------------------------------------------------------------
+# Prefold input parsing (UNAFold)
+# ---------------------------------------------------------------------------
+
+def parse_prefold_input(indata: str):
+    """Extract parameters from Boulder-IO input for UNAFold prefolding.
+
+    Returns a dict with keys: temp, mv, dv, start, seq_id, seq, use_seq,
+    incl_start, incl_len, incl_found, data (accumulated output string).
+    Raises ValueError on validation failures.
+    """
+    import re as _re
+
+    dat = {
+        "temp": 0.0, "mv": 0.0, "dv": 0.0, "start": 0,
+        "seq_id": "", "seq": "", "use_seq": "",
+        "incl_start": 0, "incl_len": 0, "incl_found": False,
+        "data": "",
+    }
+    for line in indata.split("\n"):
+        curr = line.split("=")
+        if len(curr) != 2:
+            continue
+        key, val = curr
+        if key == "PRIMER_ANNEALING_TEMP":
+            dat["temp"] = _clean_numeric(val, "Annealing temperature")
+            dat["data"] += "PRIMER_ANNEALING_TEMP=" + dat["temp"] + "\n"
+        elif key == "PRIMER_SALT_DIVALENT":
+            dat["dv"] = _clean_numeric(val, "Divalent salt concentration")
+            dat["data"] += "PRIMER_SALT_DIVALENT=" + dat["dv"] + "\n"
+        elif key == "PRIMER_SALT_MONOVALENT":
+            dat["mv"] = _clean_numeric(val, "Monovalent salt concentration")
+            dat["data"] += "PRIMER_SALT_MONOVALENT=" + dat["mv"] + "\n"
+        elif key == "PRIMER_FIRST_BASE_INDEX":
+            dat["start"] = int(_re.sub(r"[^0-9]", "", val))
+            dat["data"] += "PRIMER_FIRST_BASE_INDEX=" + str(dat["start"]) + "\n"
+        elif key == "SEQUENCE_ID":
+            dat["seq_id"] = _re.sub(r"[^0-9A-Za-z _,\.]", "", val)
+            dat["data"] += "SEQUENCE_ID=" + dat["seq_id"] + "\n"
+        elif key == "SEQUENCE_INCLUDED_REGION":
+            dat_incl = _re.sub(r"[^0-9,]", "", val)
+            incl_spl = dat_incl.split(",")
+            if len(incl_spl) == 2:
+                dat["incl_start"] = int(incl_spl[0])
+                dat["incl_len"] = int(incl_spl[1])
+                dat["incl_found"] = True
+        elif key == "SEQUENCE_TEMPLATE":
+            dat["seq"] = _re.sub(r"[^ACGTNacgtn]", "", val)
+            dat["use_seq"] = dat["seq"]
+            dat["data"] += "SEQUENCE_TEMPLATE=" + dat["seq"] + "\n"
+
+    # Derive use_seq from included region
+    if dat["incl_found"]:
+        adj_start = dat["incl_start"] - dat["start"]
+        if adj_start >= 0 and dat["incl_len"] >= 20 and len(dat["seq"]) > adj_start:
+            dat["use_seq"] = dat["seq"][adj_start: adj_start + dat["incl_len"]]
+
+    # Validation
+    if len(dat["use_seq"]) > 2000:
+        raise ValueError("Sequence to long. Limit with SEQUENCE_INCLUDED_REGION to < 2000 bp.")
+    if len(dat["use_seq"]) < 20:
+        raise ValueError("Sequence to short < 20 bp.")
+    mv_f = float(dat["mv"])
+    if mv_f < 1.0 or mv_f > 1000.0:
+        raise ValueError("Monovalent ions must be 1.0 - 1000.0.")
+    dv_f = float(dat["dv"])
+    if dv_f < 0.0 or dv_f > 1000.0:
+        raise ValueError("Divalent ions must be 0.0 - 1000.0.")
+    temp_f = float(dat["temp"])
+    if temp_f < 1.0 or temp_f > 99.0:
+        raise ValueError("Annealing Temp.  must be 1.0 - 99.0.")
+
+    return dat
+
+
+def parse_prefold_output(ct_text: str, dat: dict) -> dict:
+    """Parse UNAFold .ct output and produce SEQUENCE_EXCLUDED_REGION.
+
+    Returns dict with delta_g, excluded_region, state.
+    """
+    result = {"delta_g": None, "excluded_region": "", "state": "no_sec_struct"}
+
+    line_data = ct_text.split("\n")
+    deltG = line_data[0].split("\t")
+    if len(deltG) > 1:
+        result["delta_g"] = deltG[1].replace("dG = ", "")
+
+    excl_reg = ""
+    in_reg = False
+    dat_incl_start = dat["incl_start"]
+    dat_start = dat["start"]
+    dat_incl_len = dat["incl_len"]
+    dat_seq = dat["seq"]
+    inc_start = 0
+    inc_end = 0
+    inc_last = 0
+
+    if len(line_data) > 20:
+        for line in line_data:
+            cells = line.split("\t")
+            if len(cells) > 6:
+                if int(cells[4]) == 0 and in_reg:
+                    inc_end = int(cells[0]) - 1
+                    excl_reg += str(dat_incl_start + dat_start + inc_start)
+                    excl_reg += "," + str(inc_end - inc_start) + " "
+                    in_reg = False
+                if int(cells[4]) != 0 and not in_reg:
+                    inc_start = int(cells[0]) - 1
+                    in_reg = True
+                if int(cells[4]) != 0:
+                    inc_last = int(cells[0]) - 1
+        if in_reg:
+            excl_reg += str(dat_incl_start + dat_start + inc_start)
+            excl_reg += "," + str(inc_last - inc_start) + " "
+        result["state"] = "found_sec_struct"
+    else:
+        result["state"] = "no_sec_struct"
+
+    if 20 < dat_incl_start + dat_incl_len < len(dat_seq):
+        excl_reg += str(dat_incl_start + dat_incl_len + dat_start) + ","
+        excl_reg += str(len(dat_seq) - (dat_incl_start + dat_incl_len)) + " "
+
+    result["excluded_region"] = _re_sub_trailing_spaces(excl_reg)
+    return result
+
+
+def _re_sub_trailing_spaces(s: str) -> str:
+    import re as _re
+    return _re.sub(r" +$", "", s)
+
+
+# ---------------------------------------------------------------------------
+# Amplicon3 input parsing
+# ---------------------------------------------------------------------------
+
+def parse_amplicon3_input(indata: str):
+    """Extract parameters from Boulder-IO input for amplicon3.
+
+    Returns a dict with all numeric/string params and the original data.
+    Raises ValueError on validation failures.
+    """
+    import re as _re
+
+    dat = {
+        "seq": "", "mv": 0.0, "dv": 0.0, "dntp": 0.0,
+        "dmso": 0.0, "fact": 0.0, "form": 0.0,
+        "tp": 1, "sal": 1, "mf": 1, "temp": -10.0,
+    }
+    for line in indata.split("\n"):
+        curr = line.split("=")
+        if len(curr) != 2:
+            continue
+        key, val = curr
+        if key == "SEQUENCE_TEMPLATE":
+            dat["seq"] = _re.sub(r"[^ACGTNacgtn]", "", val)
+        elif key == "PRIMER_SALT_MONOVALENT":
+            dat["mv"] = _clean_numeric(val, "Monovalent salt concentration")
+        elif key == "PRIMER_SALT_DIVALENT":
+            dat["dv"] = _clean_numeric(val, "Divalent salt concentration")
+        elif key == "PRIMER_DNTP_CONC":
+            dat["dntp"] = _clean_numeric(val, "DNTP concentration")
+        elif key == "PRIMER_DMSO_CONC":
+            dat["dmso"] = _clean_numeric(val, "DMSO concentration")
+        elif key == "PRIMER_DMSO_FACTOR":
+            dat["fact"] = _clean_numeric(val, "DMSO factor")
+        elif key == "PRIMER_FORMAMIDE_CONC":
+            dat["form"] = _clean_numeric(val, "Formamide concentration")
+        elif key == "PRIMER_TM_FORMULA":
+            dat["tp"] = _re.sub(r"[^0-9]", "", val)
+        elif key == "PRIMER_SALT_CORRECTIONS":
+            dat["sal"] = _re.sub(r"[^0-9]", "", val)
+        elif key == "PRIMER_AMPLICON_FORMULA":
+            dat["mf"] = _re.sub(r"[^0-9]", "", val)
+        elif key == "SEQUENCE_MELTINGTEMP":
+            dat["temp"] = _clean_numeric(val, "Melting temperature")
+
+    # Validation
+    if len(dat["seq"]) < 36:
+        raise ValueError("Sequence to short < 36 bp.")
+    if float(dat["mv"]) < 1.0 or float(dat["mv"]) > 1000.0:
+        raise ValueError("Monovalent ions conc. must be 1.0 - 1000.0.")
+    if float(dat["dv"]) < 0.0 or float(dat["dv"]) > 1000.0:
+        raise ValueError("Divalent ions conc. must be 0.0 - 1000.0.")
+    if float(dat["dntp"]) < 0.0 or float(dat["dntp"]) > 1000.0:
+        raise ValueError("DNTPs conc. must be 0.0 - 1000.0.")
+    if float(dat["dmso"]) < 0.0 or float(dat["dmso"]) > 100.0:
+        raise ValueError("DMSO conc. must be 0.0 - 100.0.")
+    if float(dat["fact"]) < 0.0 or float(dat["fact"]) > 10.0:
+        raise ValueError("DMSO factor must be 0.0 - 10.0.")
+    if float(dat["form"]) < 0.0 or float(dat["form"]) > 1000.0:
+        raise ValueError("Formamide conc. must be 0.0 - 1000.0.")
+    tp_int = int(dat["tp"])
+    if tp_int < 0 or tp_int > 1:
+        raise ValueError("Table of thermodyn. parameters must be 0 or 1")
+    sal_int = int(dat["sal"])
+    if sal_int < 0 or sal_int > 2:
+        raise ValueError("Salt correction formula must be 0, 1 or 2")
+    mf_int = int(dat["mf"])
+    if mf_int < 0 or mf_int > 1:
+        raise ValueError("Tm calculation algorithm must be 0 or 1")
+    temp_f = float(dat["temp"])
+    if temp_f != -10.0:
+        if temp_f < 1.0 or temp_f > 99.0:
+            raise ValueError("Measured melting Temp. must be 1.0 - 99.0.")
+
+    return dat

primer3plus_core/config.py

@@ -0,0 +1,44 @@
+"""Shared constants, paths, and compiled regexes."""
+
+import os
+import re
+
+# ---------------------------------------------------------------------------
+# Paths — resolved relative to this file so the package works when
+# installed via pip (data files ship inside primer3plus_core/).
+# ---------------------------------------------------------------------------
+CORE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+MISPRIMING_LIB_DIR = os.path.join(CORE_DIR, "mispriming_lib")
+SETTINGS_FILES_DIR = os.path.join(CORE_DIR, "settings_files")
+
+# ---------------------------------------------------------------------------
+# Tunables
+# ---------------------------------------------------------------------------
+KILLTIME = 60          # seconds before primer3 / UNAFold / amplicon3 are killed
+LOGP3RUNS = True       # log primer3 runs to disk
+LOGIPANONYM = True     # anonymise IP addresses in log files
+
+# ---------------------------------------------------------------------------
+# Allowed upload extensions
+# ---------------------------------------------------------------------------
+ALLOWED_EXTENSIONS = {"json", "fa", "bed"}
+
+# ---------------------------------------------------------------------------
+# Regexes — Boulder-IO tag manipulation
+# ---------------------------------------------------------------------------
+
+# Strip PRIMER_THERMODYNAMIC_PARAMETERS_PATH line
+RE_THERMO_PATH = re.compile(r"PRIMER_THERMODYNAMIC_PARAMETERS_PATH=[^\n]*\n")
+
+# Mispriming library replacement
+P3LIBFIX = "PRIMER_MISPRIMING_LIBRARY=" + os.path.join(MISPRIMING_LIB_DIR, "")
+RE_LIB_PRIMER = re.compile(r"PRIMER_MISPRIMING_LIBRARY=")
+
+P3LIBIFIX = "PRIMER_INTERNAL_MISHYB_LIBRARY=" + os.path.join(MISPRIMING_LIB_DIR, "")
+RE_LIB_INTERNAL = re.compile(r"PRIMER_INTERNAL_MISHYB_LIBRARY=")
+
+# Primer count extraction from output
+RE_LEFT_COUNT = re.compile(r"PRIMER_LEFT_NUM_RETURNED=([^\n]*)\n")
+RE_INTERNAL_COUNT = re.compile(r"PRIMER_INTERNAL_NUM_RETURNED=([^\n]*)\n")
+RE_RIGHT_COUNT = re.compile(r"PRIMER_RIGHT_NUM_RETURNED=([^\n]*)\n")

primer3plus_core/files.py

@@ -0,0 +1,74 @@
+"""UUID validation, work-directory management, and file-path helpers."""
+
+import os
+import re
+import uuid
+
+from .config import ALLOWED_EXTENSIONS
+
+# ---------------------------------------------------------------------------
+# UUID
+# ---------------------------------------------------------------------------
+_UUID_RE = re.compile(
+    r"(^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})"
+    r"-{0,1}([ap]{0,1})([cj]{0,1})$"
+)
+
+
+def is_valid_uuid(s: str) -> bool:
+    return _UUID_RE.match(s) is not None
+
+
+def new_uuid() -> str:
+    return str(uuid.uuid4())
+
+
+# ---------------------------------------------------------------------------
+# File helpers
+# ---------------------------------------------------------------------------
+
+def allowed_file(filename: str) -> bool:
+    return "." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXTENSIONS
+
+
+def work_dir(upload_folder: str, uuidstr: str) -> str:
+    """Return (and create) the per-UUID sub-folder under *upload_folder*."""
+    sf = os.path.join(upload_folder, uuidstr[0:2])
+    os.makedirs(sf, exist_ok=True)
+    return sf
+
+
+def ensure_log_dir(log_folder: str) -> None:
+    os.makedirs(log_folder, exist_ok=True)
+
+
+# ---------------------------------------------------------------------------
+# Canonical file-name builders
+# ---------------------------------------------------------------------------
+
+def input_path(sf: str, uuidstr: str, prefix: str = "p3p") -> str:
+    return os.path.join(sf, f"{prefix}_{uuidstr}_input.txt")
+
+
+def output_path(sf: str, uuidstr: str, prefix: str = "p3p") -> str:
+    return os.path.join(sf, f"{prefix}_{uuidstr}_output.txt")
+
+
+def error_path(sf: str, uuidstr: str, prefix: str = "p3p") -> str:
+    return os.path.join(sf, f"{prefix}_{uuidstr}_error.txt")
+
+
+def log_path(sf: str, uuidstr: str, prefix: str = "p3p") -> str:
+    return os.path.join(sf, f"{prefix}_{uuidstr}.log")
+
+
+def stderr_path(sf: str, uuidstr: str, prefix: str = "p3p") -> str:
+    return os.path.join(sf, f"{prefix}_{uuidstr}.err")
+
+
+def upload_path(sf: str, uuidstr: str) -> str:
+    return os.path.join(sf, f"p3p_{uuidstr}_upload.txt")
+
+
+def bed_path(sf: str, uuidstr: str) -> str:
+    return os.path.join(sf, f"p3p_{uuidstr}.bed")

primer3plus_core/logging.py

@@ -0,0 +1,69 @@
+"""Run-logging helper (no Flask dependency).
+
+The Flask layer passes *client_ip* and *user_agent* so this module never
+imports ``request``.
+"""
+
+import datetime
+import os
+from ipaddress import ip_address
+from typing import Optional
+
+from .config import LOGP3RUNS, LOGIPANONYM
+
+
+def anonymise_ip(raw_ip: str) -> str:
+    """Zero-out the last octets of *raw_ip* (v4 last byte, v4 last 10 bytes)."""
+    ip_bits = ip_address(raw_ip).packed
+    mod = bytearray(ip_bits)
+    if len(ip_bits) == 4:
+        mod[3] = 0
+    if len(ip_bits) == 16:
+        for i in range(6, len(mod)):
+            mod[i] = 0
+    return str(ip_address(bytes(mod)))
+
+
+def log_data(log_folder: str,
+             prog: str, key: str, value: str, run_uuid: str,
+             client_ip: Optional[str] = None,
+             user_agent: Optional[str] = None,
+             anonymise: bool = LOGIPANONYM) -> None:
+    """Append one TSV line to the monthly log file.
+
+    Parameters
+    ----------
+    log_folder : str
+        Directory where log files are stored.
+    prog, key, value, run_uuid : str
+        The four data columns.
+    client_ip : str or None
+        Client IP as seen by the reverse proxy (X-Real-IP header).
+    user_agent : str or None
+        User-Agent header value.
+    anonymise : bool
+        Whether to zero-out trailing IP octets.
+    """
+    if not LOGP3RUNS:
+        return
+
+    now = datetime.datetime.now(datetime.UTC)
+    line = now.strftime("%Y-%m-%dT%H:%M:%S")
+    line += "\t" + prog + "\t" + key + "\t" + value + "\t" + run_uuid + "\t"
+
+    if client_ip:
+        if anonymise:
+            line += anonymise_ip(client_ip)
+        else:
+            line += client_ip
+
+    line += "\t\t"
+
+    if user_agent:
+        line += user_agent.replace("\t", " ")
+
+    line += "\n"
+
+    stat_file = os.path.join(log_folder, "p3_runs_" + now.strftime("%Y_%m") + ".log")
+    with open(stat_file, "a") as f:
+        f.write(line)