varvamp 1.1.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

varvamp/scripts/scheme.py

@@ -21,12 +21,10 @@ def construct_graph(nodes, init_graph):
         graph[node] = {}
 
     graph.update(init_graph)
-
     for node, neighbors in graph.items():
         for neighbor in neighbors.keys():
             if graph[neighbor].get(node, False) is False:
-                graph[neighbor][node] = float("infinity")
-
+                graph[neighbor][node] = (float("infinity"), 0)
     return graph
 
 
@@ -61,13 +59,12 @@ class Graph(object):
         """
         return self.graph[node1][node2]
 
-
 def find_amplicons(all_primers, opt_len, max_len):
     """
     finds all possible amplicons, creates a dictionary
     """
     amplicon_number = 0
-    amplicon_dict = {}
+    amplicons = []
 
     for left_name in all_primers["+"]:
         left_primer = all_primers["+"][left_name]
@@ -82,17 +79,17 @@ def find_amplicons(all_primers, opt_len, max_len):
             # penalty multiplied by the e^(fold length of the optimal length).
             amplicon_costs = (right_primer[3] + left_primer[3])*math.exp(amplicon_length/opt_len)
             amplicon_name = "AMPLICON_"+str(amplicon_number)
-            amplicon_dict[amplicon_name] = [
-                left_primer[1],  # start
-                right_primer[2],  # stop
-                left_name,  # name left primer
-                right_name,  # name right primer
-                amplicon_length,  # amplicon length
-                amplicon_costs  # costs
-            ]
+            amplicons.append(
+                {
+                    "id": amplicon_name,
+                    "penalty": amplicon_costs,
+                    "length": amplicon_length,
+                    "LEFT": left_primer + [left_name],
+                    "RIGHT": right_primer + [right_name],
+                }
+            )
             amplicon_number += 1
-
-    return amplicon_dict
+    return amplicons
 
 
 def create_amplicon_graph(amplicons, min_overlap):
@@ -107,24 +104,30 @@ def create_amplicon_graph(amplicons, min_overlap):
     # before the min overlap
     min_overlap = min_overlap + config.PRIMER_SIZES[2]
 
-    for current in amplicons:
+    for current_amplicon in amplicons:
         # remember all vertices
-        nodes.append(current)
-        current_amplicon = amplicons[current]
-        start = current_amplicon[0] + current_amplicon[4]/2
-        stop = current_amplicon[1] - min_overlap
-        for next_amp in amplicons:
-            next_amplicon = amplicons[next_amp]
+        amplicon_id = current_amplicon["id"]
+        nodes.append(amplicon_id)
+        start = current_amplicon["LEFT"][1] + current_amplicon["length"]/2
+        stop = current_amplicon["RIGHT"][2] - min_overlap
+        for next_amplicon in amplicons:
             # check if the next amplicon lies within the start/stop range of
             # the current amplicon and if its non-overlapping part is large
             # enough to ensure space for a primer and the min overlap of the
             # following amplicon.
-            if not all([start <= next_amplicon[0] <= stop, next_amplicon[1] > current_amplicon[1] + next_amplicon[4]/2]):
-                continue
-            if current not in amplicon_graph:
-                amplicon_graph[current] = {next_amp: next_amplicon[5]}
-            else:
-                amplicon_graph[current][next_amp] = next_amplicon[5]
+            if start <= next_amplicon["LEFT"][1] <= stop and next_amplicon["RIGHT"][2] > current_amplicon["RIGHT"][2] + next_amplicon["length"]/2:
+                if amplicon_id not in amplicon_graph:
+                    amplicon_graph[amplicon_id] = {
+                        next_amplicon["id"]: (
+                            next_amplicon.get("off_targets", False),
+                            next_amplicon["penalty"]
+                        )
+                    }
+                else:
+                    amplicon_graph[amplicon_id][next_amplicon["id"]] = (
+                        next_amplicon.get("off_targets", False),
+                        next_amplicon["penalty"]
+                    )
 
     # return a graph object
     return Graph(nodes, amplicon_graph)
@@ -136,17 +139,21 @@ def dijkstra_algorithm(graph, start_node):
     """
 
     previous_nodes = {}
-    shortest_path = {node: float('infinity') for node in graph.get_nodes()}
-    shortest_path[start_node] = 0
+    shortest_path = {node: (float('infinity'), 0) for node in graph.get_nodes()}
+    shortest_path[start_node] = (0, 0)
 
-    nodes_to_test = [(0, start_node)]
+    nodes_to_test = [((0, 0), start_node)]
 
     while nodes_to_test:
         current_distance, current_node = heapq.heappop(nodes_to_test)
         if current_distance > shortest_path[current_node]:
             continue
         for neighbor in graph.get_neighbors(current_node):
-            distance = current_distance + graph.value(current_node, neighbor)
+            off_targets, base_penalty = graph.value(current_node, neighbor)
+            distance = (
+                current_distance[0] + off_targets,
+                current_distance[1] + base_penalty
+            )
             # Only consider this new path if it's a better path
             if not distance < shortest_path[neighbor]:
                 continue
@@ -167,11 +174,12 @@ def get_end_node(previous_nodes, shortest_path, amplicons):
     for node in previous_nodes.keys():
         # check if a node has a larger stop -> empty dict and set new
         # best stop nucleotide
-        if amplicons[node][1] > stop_nucleotide:
+        amplicon_stop = amplicons[node]["RIGHT"][2]
+        if amplicon_stop > stop_nucleotide:
             possible_end_nodes = {node: shortest_path[node]}
-            stop_nucleotide = amplicons[node][1]
+            stop_nucleotide = amplicon_stop
         # if nodes have the same stop nucleotide, add to dictionary
-        elif amplicons[node][1] == stop_nucleotide:
+        elif amplicon_stop == stop_nucleotide:
             possible_end_nodes[node] = shortest_path[node]
 
     # return the end node with the lowest penalty costs
@@ -196,49 +204,44 @@ def get_min_path(previous_nodes, start_node, target_node):
     return path[::-1]
 
 
-def create_scheme_dic(amplicon_scheme, amplicons, all_primers):
+def create_scheme(amplicon_path, amplicons_by_id):
     """
-    creates the final scheme dictionary
+    creates the final tiled-amplicon scheme
     """
-
-    scheme_dictionary = {
-        0: {},
-        1: {}
-    }
+    amplicon_scheme = []
 
     for pool in (0, 1):
-        for amp in amplicon_scheme[pool::2]:
-            scheme_dictionary[pool][amp] = {}
-            primer_pair = [amplicons[amp][2], amplicons[amp][3]]
-            scheme_dictionary[pool][amp][primer_pair[0]] = all_primers["+"][primer_pair[0]]
-            scheme_dictionary[pool][amp][primer_pair[1]] = all_primers["-"][primer_pair[1]]
+        for amp_id in amplicon_path[pool::2]:
+            amplicons_by_id[amp_id]["pool"] = pool
+            amplicon_scheme.append(amplicons_by_id[amp_id])
 
-    return scheme_dictionary
+    return amplicon_scheme
 
 
-def find_best_covering_scheme(amplicons, amplicon_graph, all_primers):
+def find_best_covering_scheme(amplicons, amplicon_graph):
     """
     this brute forces the amplicon scheme search until the largest
     coverage with the minimal costs is achieved.
     """
     # ini
     best_coverage = 0
-    max_stop = max(amplicons.items(), key=lambda x: x[1])[1][1]
-    lowest_costs = float('infinity')
-
-    for start_node in amplicons:
+    max_stop = max(amplicons, key=lambda x: x["RIGHT"][2])["RIGHT"][2]
+    lowest_costs = (float('infinity'),)
+    # a dict for fast access to amplicons by their ID
+    amps_by_id = {amp["id"]: amp for amp in amplicons}
+    for amplicon in amplicons:
         # if the currently best coverage + start nucleotide of the currently tested amplicon
         # is smaller than the maximal stop nucleotide there might be a better amplicon
         # scheme that covers more of the genome
-        if amplicons[start_node][0] + best_coverage <= max_stop:
-            previous_nodes, shortest_path = dijkstra_algorithm(amplicon_graph, start_node)
+        if amplicon["LEFT"][1] + best_coverage <= max_stop:
+            previous_nodes, shortest_path = dijkstra_algorithm(amplicon_graph, amplicon["id"])
             # only continue if there are previous_nodes
             if previous_nodes:
-                target_node, costs = get_end_node(previous_nodes, shortest_path, amplicons)
-                coverage = amplicons[target_node][1] - amplicons[start_node][0]
+                target_node, costs = get_end_node(previous_nodes, shortest_path, amps_by_id)
+                coverage = amps_by_id[target_node]["RIGHT"][2] - amplicon["LEFT"][1]
                 # if the new coverage is larger, go for the larger coverage
                 if coverage > best_coverage:
-                    best_start_node = start_node
+                    best_start_node = amplicon["id"]
                     best_target_node = target_node
                     best_previous_nodes = previous_nodes
                     lowest_costs = costs
@@ -246,18 +249,19 @@ def find_best_covering_scheme(amplicons, amplicon_graph, all_primers):
                 # if the coverages are identical, go for the lowest costs
                 elif coverage == best_coverage:
                     if costs < lowest_costs:
-                        best_start_node = start_node
+                        best_start_node = amplicon["id"]
                         best_target_node = target_node
                         best_previous_nodes = previous_nodes
                         lowest_costs = costs
                         best_coverage = coverage
             else:
                 # check if the single amplicon has the largest coverage so far
-                coverage = amplicons[start_node][1] - amplicons[start_node][0]
+                coverage = amplicon["length"]
                 if coverage > best_coverage:
-                    best_start_node = start_node
+                    best_start_node = amplicon["id"]
                     best_previous_nodes = previous_nodes
-                    lowest_costs = amplicons[start_node][5]
+                    lowest_costs = (
+                        amplicon.get("off_targets", False), amplicon["penalty"])
                     best_coverage = coverage
         # no need to check more, the best covering amplicon scheme was found and
         # has the minimal costs compared to the schemes with the same coverage
@@ -265,13 +269,12 @@ def find_best_covering_scheme(amplicons, amplicon_graph, all_primers):
             break
 
     if best_previous_nodes:
-        amplicon_scheme = get_min_path(best_previous_nodes, best_start_node, best_target_node)
+        amplicon_path = get_min_path(best_previous_nodes, best_start_node, best_target_node)
     else:
         # if no previous nodes are found but the single amplicon results in the largest
         # coverage - return as the best scheme
-        amplicon_scheme = [best_start_node]
-
-    return best_coverage, create_scheme_dic(amplicon_scheme, amplicons, all_primers)
+        amplicon_path = [best_start_node]
+    return best_coverage, create_scheme(amplicon_path, amps_by_id)
 
 
 def test_scheme_for_dimers(amplicon_scheme):
@@ -280,17 +283,20 @@ def test_scheme_for_dimers(amplicon_scheme):
     """
 
     primer_dimers = []
-
-    for pool in amplicon_scheme:
+    pools = {amp["pool"] for amp in amplicon_scheme}
+    for pool in pools:
         # test the primer dimers only within the respective pools
         tested_primers = []
-        for amp in amplicon_scheme[pool]:
-            for primer in amplicon_scheme[pool][amp]:
+        for amp_index, amp in enumerate(amplicon_scheme):
+            if amp["pool"] != pool:
+                continue
+            for primer in ["LEFT", "RIGHT"]:
                 # remember where the currrent primer was in the scheme
-                current_primer = (pool, amp, primer, amplicon_scheme[pool][amp][primer])
-                current_seq = current_primer[3][0]
+                # store the amplicon's index in the scheme, the current primer's original name and its details
+                current_primer = (amp_index, amp[primer][-1], amp[primer][:-1])
+                current_seq = current_primer[2][0]
                 for tested in tested_primers:
-                    tested_seq = tested[3][0]
+                    tested_seq = tested[2][0]
                     if primers.calc_dimer(current_seq, tested_seq).tm <= config.PRIMER_MAX_DIMER_TMP:
                         continue
                     primer_dimers.append((current_primer, tested))
@@ -309,22 +315,22 @@ def get_overlapping_primers(dimer, left_primer_candidates, right_primer_candidat
 
     overlapping_primers = []
     # test each primer in dimer
-    for primer in dimer:
+    for amp_index, primer_name, primer in dimer:
         overlapping_primers_temp = []
-        thirds_len = int((primer[3][2] - primer[3][1]) / 3)
+        thirds_len = int((primer[2] - primer[1]) / 3)
         # get the middle third of the primer (here are the previously excluded primers)
-        overlap_set = set(range(primer[3][1] + thirds_len, primer[3][2] - thirds_len + 1))
+        overlap_set = set(range(primer[1] + thirds_len, primer[2] - thirds_len))
         # check in which list to look for them
-        if "RIGHT" in primer[2]:
+        if "RIGHT" in primer_name:
             primers_to_test = right_primer_candidates
         else:
             primers_to_test = left_primer_candidates
         # and check this list for all primers that overlap
         for potential_new in primers_to_test:
-            primer_positions = list(range(potential_new[1], potential_new[2]+1))
+            primer_positions = list(range(potential_new[1], potential_new[2]))
             if not any(x in primer_positions for x in overlap_set):
                 continue
-            overlapping_primers_temp.append((primer[0], primer[1], primer[2], potential_new))
+            overlapping_primers_temp.append((amp_index, primer_name, potential_new))
 
         overlapping_primers.append(overlapping_primers_temp)
 
@@ -339,7 +345,7 @@ def test_overlaps_for_dimers(overlapping_primers):
         for second_overlap in overlapping_primers[1]:
             # return the first match. primers are sorted by penalty.
             # first pair that makes it has the lowest penalty
-            if primers.calc_dimer(first_overlap[3][0], second_overlap[3][0]).tm <= config.PRIMER_MAX_DIMER_TMP:
+            if primers.calc_dimer(first_overlap[2][0], second_overlap[2][0]).tm <= config.PRIMER_MAX_DIMER_TMP:
                 return [first_overlap, second_overlap]
 
 
@@ -360,53 +366,55 @@ def check_and_solve_heterodimers(amplicon_scheme, left_primer_candidates, right_
         return []
 
     for dimer in primer_dimers:
-        # get overlapping primers that have not been considere
+        # get overlapping primers that have not been considered
         overlapping_primers = get_overlapping_primers(dimer, left_primer_candidates, right_primer_candidates)
         # test all possible primers against each other for dimers
         new_primers = test_overlaps_for_dimers(overlapping_primers)
         # now change these primers in the scheme
         if new_primers:
-            for new in new_primers:
+            for amp_index, primer_name, primer in new_primers:
                 # overwrite in final scheme
-                amplicon_scheme[new[0]][new[1]][new[2]] = new[3]
-                # and in all primers
-                if "LEFT" in new[2]:
+                # ATTENTION: doesn't update the amplicon penalty currently
+                # This is ok only because that value isn't used after and doesn't get reported anywhere.
+                if "LEFT" in primer_name:
                     strand = "+"
+                    amplicon_scheme[amp_index]["LEFT"] = primer + [primer_name]
                 else:
                     strand = "-"
-                all_primers[strand][new[2]] = new[3]
-
-    primer_dimers = test_scheme_for_dimers(amplicon_scheme)
+                    amplicon_scheme[amp_index]["RIGHT"] = primer + [primer_name]
+                amplicon_scheme[amp_index]["length"] = amplicon_scheme[amp_index]["RIGHT"][2] - amplicon_scheme[amp_index]["LEFT"][1]
+                # and in all primers
+                all_primers[strand][primer_name] = primer
+    # get remaining dimers in the revised scheme and add pool identifier for reporting
+    primer_dimers = [
+        (amplicon_scheme[primer1[0]]["pool"], primer1, primer2)
+        for primer1, primer2 in test_scheme_for_dimers(amplicon_scheme)
+    ]
 
     return primer_dimers
 
 
-def find_single_amplicons(amplicons, all_primers, n):
+def find_single_amplicons(amplicons, n):
     """
     find non-overlapping amplicons with low penalties
     from all found amplicons. only for the SINGLE mode.
     """
     # sort amplicons
-    sorted_amplicons = sorted(amplicons.items(), key=lambda x: x[1][5])
-    to_retain = [sorted_amplicons[0]]
-    amplicon_range = list(range(sorted_amplicons[0][1][0], sorted_amplicons[0][1][1]+1))
-    amplicon_set = set(amplicon_range)
+    sorted_amplicons = sorted(amplicons, key=lambda x: (x.get("off_targets", False), x["penalty"]))
+    to_retain = []
+    retained_ranges = []
     # find lowest non-overlapping
     for amp in sorted_amplicons:
-        amp_positions = list(range(amp[1][0], amp[1][1]+1))
-        if not any(x in amp_positions for x in amplicon_set):
-            amplicon_set.update(amp_positions)
+        overlaps_retained = False
+        amp_range = range(amp["LEFT"][1], amp["RIGHT"][2])
+        for r in retained_ranges:
+            if amp_range.start < r.stop and r.start < amp_range.stop:
+                overlaps_retained = True
+                break
+        if not overlaps_retained:
+            retained_ranges.append(amp_range)
             to_retain.append(amp)
-    # build the final dictionary
-    scheme_dictionary = {0: {}}
-    counter = 1
-    for amp in to_retain:
-        scheme_dictionary[0][amp[0]] = {}
-        scheme_dictionary[0][amp[0]][amp[1][2]] = all_primers["+"][amp[1][2]]
-        scheme_dictionary[0][amp[0]][amp[1][3]] = all_primers["-"][amp[1][3]]
-        if n != float("inf"):
-            if counter == n:
+            if len(to_retain) == n:
                 break
-            counter += 1
 
-    return scheme_dictionary
+    return to_retain

{varvamp-1.1.3.dist-info → varvamp-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: varvamp
-Version: 1.1.3
+Version: 1.2.1
 Summary: Variable VirusAMPlicons (varVAMP) is a tool to design primers for highly diverse viruses
 Home-page: https://github.com/jonas-fuchs/varVAMP
 Author: Dr. Jonas Fuchs
@@ -61,15 +61,13 @@ For a lot of virus genera it is difficult to design pan-specific primers. varVAM
 
 We, in collaboration with specialists for the respective viruses, have already designed and wet-lab evaluated primer schemes for various viral pathogens. All the input data and varVAMP outputs are freely available [here](https://github.com/jonas-fuchs/ViralPrimerSchemes). 
 
-If you design primers for a particular pathogen, we will be happy to include them in this repo and make it freely available. Just contribute via an issue or pull request!
+Moreover, varVAMP primers are now available at [primerschemes](https://labs.primalscheme.com/). varVAMP now reports primer bed files in ARTICv3 format. Feel free to contribute newly designed schemes via this [Github repository of the QuickLab](https://github.com/quick-lab/primerschemes). Use [primal-page](https://github.com/ChrisgKent/primal-page) developed by [Chris Kent](https://github.com/ChrisgKent) to generate data for compatible pull-requests.
 
-# Citing varVAMP (coming soon)
-
-Please cite with the respective DOI of the version you used:
+# Citing varVAMP
 
 **varVAMP: automated pan-specific primer design for tiled full genome sequencing and qPCR of highly diverse viral pathogens.**
 
-(paper currently under preparation)
+[biorxiv preprint](https://doi.org/10.1101/2024.05.08.593102)
 
 ---
 

varvamp-1.2.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+varvamp/__init__.py,sha256=dcU1t4AmPwg3LoG01RN2Q4VvzPKoZ00gRfg-qoofv28,107
+varvamp/__main__.py,sha256=9R3mbX2_Q5LByPx8WLoTbvZ-G2dbRSMpDlgze0Wm5Fc,98
+varvamp/command.py,sha256=Oh6WdYgbPKRChrxCoOOEFJHjINF3BIXahmSlYILDfPU,19723
+varvamp/scripts/__init__.py,sha256=DtRsgfnA60BvccKMuD-Ueo1UpxaeANUfIWxGi1xPcV0,46
+varvamp/scripts/alignment.py,sha256=w2I7BnaUt_rh1EaDQaU9Q_dmL_q019NtnaC8YMccOgM,7317
+varvamp/scripts/blast.py,sha256=yF1-FjL7-P8sxSO6x4Q15gzj_I3LbE8ZfP37w6K3Akk,8434
+varvamp/scripts/consensus.py,sha256=eU5eKU9iXyWeln2BW_LMPI8JiEq0_NXBI0jy4kMOvQg,3375
+varvamp/scripts/default_config.py,sha256=8yjZ1ugZ5pus1daWRXeQMo-lVIikJXV4_q7FPEkTS64,3766
+varvamp/scripts/get_config.py,sha256=Kvg3YhttUbDeRxjKhfxLjI5JSKpPoiLSEYqcE6rT4Xk,2940
+varvamp/scripts/logging.py,sha256=bk7SA7DtNtKtAJXRGLAQyA0stpLqBmRUydBG0dpoZQ0,20820
+varvamp/scripts/param_estimation.py,sha256=jpfmbjCFp23V07af3y1uO2dQZJiWLlyOBa11aMphkko,3694
+varvamp/scripts/primers.py,sha256=zLNs3lWiHS0dBmRIMpi8v0XxWi26JrS43YJW7xhEneM,13422
+varvamp/scripts/qpcr.py,sha256=qO6JTl36WMUZGoz6NHIjRrtMOF87yQedmj-sE85Yay8,14453
+varvamp/scripts/regions.py,sha256=VgYAlZmkC3rT946yhAdxATi-YT4oGcEwAPa0BkkfWIg,3239
+varvamp/scripts/reporting.py,sha256=_o-A-X1OPEB6ym0w-q3Tb0nehVJwuCbsoyspZjzmvs4,22921
+varvamp/scripts/scheme.py,sha256=lB-HT-rFSjN0o1KemzojyMT3jBw-LSrDGakshBXCAR4,16198
+varvamp-1.2.1.dist-info/METADATA,sha256=tqQlI16IR0-DMDNYV1e6Ka9SzbzKbtqF1zV4gwBiVRM,5382
+varvamp-1.2.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+varvamp-1.2.1.dist-info/entry_points.txt,sha256=puzW-basyBexZT4JVRUfUEqobvFmEyfqRQaqFjp7rB0,49
+varvamp-1.2.1.dist-info/top_level.txt,sha256=11oVwE3SBUB9aTmvpvEDru95Tc5GZqQikzzFjw2eVGc,8
+varvamp-1.2.1.dist-info/RECORD,,

{varvamp-1.1.3.dist-info → varvamp-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

varvamp-1.1.3.dist-info/RECORD

@@ -1,21 +0,0 @@
-varvamp/__init__.py,sha256=060aYAsVPugZY2O5wRQHxoHkmtzcWkS2hjeksYxJxbU,107
-varvamp/__main__.py,sha256=9R3mbX2_Q5LByPx8WLoTbvZ-G2dbRSMpDlgze0Wm5Fc,98
-varvamp/command.py,sha256=rCP0k7wb2vbnlSKwTRkla4_pGQBl972EGmyWRBjfKXA,18516
-varvamp/scripts/__init__.py,sha256=DtRsgfnA60BvccKMuD-Ueo1UpxaeANUfIWxGi1xPcV0,46
-varvamp/scripts/alignment.py,sha256=w2I7BnaUt_rh1EaDQaU9Q_dmL_q019NtnaC8YMccOgM,7317
-varvamp/scripts/blast.py,sha256=9gDijzLI0jcsk3b4oJ6a0r-bjIWkNcn_NAQ2HlYO86s,9699
-varvamp/scripts/consensus.py,sha256=eU5eKU9iXyWeln2BW_LMPI8JiEq0_NXBI0jy4kMOvQg,3375
-varvamp/scripts/default_config.py,sha256=FkZUiIy8McyFXRzd8UTTTVRPbWNS8Oxmye3i-WsyDWw,3876
-varvamp/scripts/get_config.py,sha256=Kvg3YhttUbDeRxjKhfxLjI5JSKpPoiLSEYqcE6rT4Xk,2940
-varvamp/scripts/logging.py,sha256=ftOrySTkh5y0dEXQSDMJHMjA7Q9myJv9EhRcb6SmERc,20624
-varvamp/scripts/param_estimation.py,sha256=jpfmbjCFp23V07af3y1uO2dQZJiWLlyOBa11aMphkko,3694
-varvamp/scripts/primers.py,sha256=IEOoccW5OKK8d2a0ZQ1L1CICZIzOqKfeZp5e8iE717I,13428
-varvamp/scripts/qpcr.py,sha256=Oh1HUJ6QF3dvghS5LceUgZqC5UHNB1arOsxQVNa-WnY,14483
-varvamp/scripts/regions.py,sha256=VgYAlZmkC3rT946yhAdxATi-YT4oGcEwAPa0BkkfWIg,3239
-varvamp/scripts/reporting.py,sha256=CT_ZD9-73Di56zBHmaQ8Kr4VkWjqf8zgb0ohk8_8Puo,21338
-varvamp/scripts/scheme.py,sha256=rHeigj-tYyLJgB4w5F5tXZA-kkXkpDZ-kKpdE1Elonk,15229
-varvamp-1.1.3.dist-info/METADATA,sha256=lmMlO4FDPWNxhbxON1i_VBUYf6y_EwxKoOKBNZjk3mo,5149
-varvamp-1.1.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-varvamp-1.1.3.dist-info/entry_points.txt,sha256=puzW-basyBexZT4JVRUfUEqobvFmEyfqRQaqFjp7rB0,49
-varvamp-1.1.3.dist-info/top_level.txt,sha256=11oVwE3SBUB9aTmvpvEDru95Tc5GZqQikzzFjw2eVGc,8
-varvamp-1.1.3.dist-info/RECORD,,