Datasets:

---

monsterapi

/

code_search_net

like 0

Follow

MonsterAPI 14

[ "def", "ape", "(", "self", ",", "ape_path", "=", "None", ")", ":", "# TODO: simplify - make ApE look in PATH only", "cmd", "=", "'ApE'", "if", "ape_path", "is", "None", ":", "# Check for ApE in PATH", "ape_executables", "=", "[", "]", "for", "path", "in", "os", ".", "environ", "[", "'PATH'", "]", ".", "split", "(", "os", ".", "pathsep", ")", ":", "exepath", "=", "os", ".", "path", ".", "join", "(", "path", ",", "cmd", ")", "ape_executables", ".", "append", "(", "os", ".", "access", "(", "exepath", ",", "os", ".", "X_OK", ")", ")", "if", "not", "any", "(", "ape_executables", ")", ":", "raise", "Exception", "(", "'Ape not in PATH. Use ape_path kwarg.'", ")", "else", ":", "cmd", "=", "ape_path", "# Check whether ApE exists in PATH", "tmp", "=", "tempfile", ".", "mkdtemp", "(", ")", "if", "self", ".", "name", "is", "not", "None", "and", "self", ".", "name", ":", "filename", "=", "os", ".", "path", ".", "join", "(", "tmp", ",", "'{}.ape'", ".", "format", "(", "self", ".", "name", ")", ")", "else", ":", "filename", "=", "os", ".", "path", ".", "join", "(", "tmp", ",", "'tmp.ape'", ")", "coral", ".", "seqio", ".", "write_dna", "(", "self", ",", "filename", ")", "process", "=", "subprocess", ".", "Popen", "(", "[", "cmd", ",", "filename", "]", ")", "# Block until window is closed", "try", ":", "process", ".", "wait", "(", ")", "shutil", ".", "rmtree", "(", "tmp", ")", "except", "KeyboardInterrupt", ":", "shutil", ".", "rmtree", "(", "tmp", ")" ]

[ "Open", "in", "ApE", "if", "ApE", "is", "in", "your", "command", "line", "path", "." ]

[ "def", "copy", "(", "self", ")", ":", "# Significant performance improvements by skipping alphabet check", "features_copy", "=", "[", "feature", ".", "copy", "(", ")", "for", "feature", "in", "self", ".", "features", "]", "copy", "=", "type", "(", "self", ")", "(", "self", ".", "top", ".", "seq", ",", "circular", "=", "self", ".", "circular", ",", "features", "=", "features_copy", ",", "name", "=", "self", ".", "name", ",", "bottom", "=", "self", ".", "bottom", ".", "seq", ",", "run_checks", "=", "False", ")", "return", "copy" ]

[ "Create", "a", "copy", "of", "the", "current", "instance", "." ]

[ "def", "circularize", "(", "self", ")", ":", "if", "self", ".", "top", "[", "-", "1", "]", ".", "seq", "==", "'-'", "and", "self", ".", "bottom", "[", "0", "]", ".", "seq", "==", "'-'", ":", "raise", "ValueError", "(", "'Cannot circularize - termini disconnected.'", ")", "if", "self", ".", "bottom", "[", "-", "1", "]", ".", "seq", "==", "'-'", "and", "self", ".", "top", "[", "0", "]", ".", "seq", "==", "'-'", ":", "raise", "ValueError", "(", "'Cannot circularize - termini disconnected.'", ")", "copy", "=", "self", ".", "copy", "(", ")", "copy", ".", "circular", "=", "True", "copy", ".", "top", ".", "circular", "=", "True", "copy", ".", "bottom", ".", "circular", "=", "True", "return", "copy" ]

[ "Circularize", "linear", "DNA", "." ]

[ "def", "display", "(", "self", ")", ":", "try", ":", "from", "IPython", ".", "display", "import", "HTML", "import", "uuid", "except", "ImportError", ":", "raise", "IPythonDisplayImportError", "sequence_json", "=", "self", ".", "json", "(", ")", "d3cdn", "=", "'//d3js.org/d3.v3.min.js'", "div_id", "=", "'sequence_{}'", ".", "format", "(", "uuid", ".", "uuid1", "(", ")", ")", "cur_dir", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ")", "d3_plasmid_path", "=", "os", ".", "path", ".", "join", "(", "cur_dir", ",", "'d3-plasmid.js'", ")", "with", "open", "(", "d3_plasmid_path", ")", "as", "f", ":", "d3_plasmid_js", "=", "f", ".", "read", "(", ")", "html", "=", "'<div id={div_id}></div>'", ".", "format", "(", "div_id", "=", "div_id", ")", "js_databind", "=", "'''\n <script>\n require([\\'{d3_cdn}\\'], function(lib) {{\n window.data = {data};'''", ".", "format", "(", "div_id", "=", "div_id", ",", "d3_cdn", "=", "d3cdn", ",", "data", "=", "sequence_json", ")", "js_viz", "=", "'''\n d3sequence(window.data, \\'{div_id}\\')\n }});\n </script>\n '''", ".", "format", "(", "div_id", "=", "div_id", ")", "return", "HTML", "(", "html", "+", "js_databind", "+", "d3_plasmid_js", "+", "js_viz", ")" ]

[ "Display", "a", "visualization", "of", "the", "sequence", "in", "an", "IPython", "notebook", "." ]

[ "def", "excise", "(", "self", ",", "feature", ")", ":", "rotated", "=", "self", ".", "rotate_to_feature", "(", "feature", ")", "excised", "=", "rotated", "[", "feature", ".", "stop", "-", "feature", ".", "start", ":", "]", "return", "excised" ]

[ "Removes", "feature", "from", "circular", "plasmid", "and", "linearizes", ".", "Automatically", "reorients", "at", "the", "base", "just", "after", "the", "feature", ".", "This", "operation", "is", "complementary", "to", "the", ".", "extract", "()", "method", "." ]

[ "def", "extract", "(", "self", ",", "feature", ",", "remove_subfeatures", "=", "False", ")", ":", "extracted", "=", "self", "[", "feature", ".", "start", ":", "feature", ".", "stop", "]", "# Turn gaps into Ns or Xs", "for", "gap", "in", "feature", ".", "gaps", ":", "for", "i", "in", "range", "(", "*", "gap", ")", ":", "extracted", "[", "i", "]", "=", "self", ".", "_any_char", "if", "remove_subfeatures", ":", "# Keep only the feature specified", "extracted", ".", "features", "=", "[", "feature", "]", "# Update feature locations", "# copy them", "for", "feature", "in", "extracted", ".", "features", ":", "feature", ".", "move", "(", "-", "feature", ".", "start", ")", "return", "extracted" ]

[ "Extract", "a", "feature", "from", "the", "sequence", ".", "This", "operation", "is", "complementary", "to", "the", ".", "excise", "()", "method", "." ]

[ "def", "flip", "(", "self", ")", ":", "copy", "=", "self", ".", "copy", "(", ")", "copy", ".", "top", ",", "copy", ".", "bottom", "=", "copy", ".", "bottom", ",", "copy", ".", "top", "copy", ".", "features", "=", "[", "_flip_feature", "(", "f", ",", "len", "(", "self", ")", ")", "for", "f", "in", "copy", ".", "features", "]", "return", "copy" ]

[ "Flip", "the", "DNA", "-", "swap", "the", "top", "and", "bottom", "strands", "." ]

[ "def", "linearize", "(", "self", ",", "index", "=", "0", ")", ":", "if", "not", "self", ".", "circular", ":", "raise", "ValueError", "(", "'Cannot relinearize linear DNA.'", ")", "copy", "=", "self", ".", "copy", "(", ")", "# Snip at the index", "if", "index", ":", "return", "copy", "[", "index", ":", "]", "+", "copy", "[", ":", "index", "]", "copy", ".", "circular", "=", "False", "copy", ".", "top", ".", "circular", "=", "False", "copy", ".", "bottom", ".", "circular", "=", "False", "return", "copy" ]

[ "Linearize", "circular", "DNA", "at", "an", "index", "." ]

[ "def", "locate", "(", "self", ",", "pattern", ")", ":", "top_matches", "=", "self", ".", "top", ".", "locate", "(", "pattern", ")", "bottom_matches", "=", "self", ".", "bottom", ".", "locate", "(", "pattern", ")", "return", "[", "top_matches", ",", "bottom_matches", "]" ]

[ "Find", "sequences", "matching", "a", "pattern", ".", "For", "a", "circular", "sequence", "the", "search", "extends", "over", "the", "origin", "." ]

[ "def", "rotate", "(", "self", ",", "n", ")", ":", "if", "not", "self", ".", "circular", "and", "n", "!=", "0", ":", "raise", "ValueError", "(", "'Cannot rotate linear DNA'", ")", "else", ":", "copy", "=", "self", ".", "copy", "(", ")", "copy", ".", "top", "=", "self", ".", "top", ".", "rotate", "(", "n", ")", "copy", ".", "bottom", "=", "self", ".", "bottom", ".", "rotate", "(", "-", "n", ")", "copy", ".", "features", "=", "[", "]", "for", "feature", "in", "self", ".", "features", ":", "feature_copy", "=", "feature", ".", "copy", "(", ")", "feature_copy", ".", "move", "(", "n", ")", "# Adjust the start/stop if we move over the origin", "feature_copy", ".", "start", "=", "feature_copy", ".", "start", "%", "len", "(", "self", ")", "feature_copy", ".", "stop", "=", "feature_copy", ".", "stop", "%", "len", "(", "self", ")", "copy", ".", "features", ".", "append", "(", "feature_copy", ")", "return", "copy", ".", "circularize", "(", ")" ]

[ "Rotate", "Sequence", "by", "n", "bases", "." ]

[ "def", "reverse_complement", "(", "self", ")", ":", "copy", "=", "self", ".", "copy", "(", ")", "# Note: if sequence is double-stranded, swapping strand is basically", "# (but not entirely) the same thing - gaps affect accuracy.", "copy", ".", "top", "=", "self", ".", "top", ".", "reverse_complement", "(", ")", "copy", ".", "bottom", "=", "self", ".", "bottom", ".", "reverse_complement", "(", ")", "# Remove all features - the reverse complement isn't flip!", "copy", ".", "features", "=", "[", "]", "return", "copy" ]

[ "Reverse", "complement", "the", "DNA", "." ]

[ "def", "select_features", "(", "self", ",", "term", ",", "by", "=", "'name'", ",", "fuzzy", "=", "False", ")", ":", "features", "=", "[", "]", "if", "fuzzy", ":", "fuzzy_term", "=", "term", ".", "lower", "(", ")", "for", "feature", "in", "self", ".", "features", ":", "if", "fuzzy_term", "in", "feature", ".", "__getattribute__", "(", "by", ")", ".", "lower", "(", ")", ":", "features", ".", "append", "(", "feature", ")", "else", ":", "for", "feature", "in", "self", ".", "features", ":", "if", "feature", ".", "__getattribute__", "(", "by", ")", "==", "term", ":", "features", ".", "append", "(", "feature", ")", "return", "features" ]

[ "Select", "features", "from", "the", "features", "list", "based", "on", "feature", "name", "gene", "or", "locus", "tag", ".", ":", "param", "term", ":", "Search", "term", ".", ":", "type", "term", ":", "str", ":", "param", "by", ":", "Feature", "attribute", "to", "search", "by", ".", "Options", "are", "name", "gene", "and", "locus_tag", ".", ":", "type", "by", ":", "str", ":", "param", "fuzzy", ":", "If", "True", "search", "becomes", "case", "-", "insensitive", "and", "will", "also", "find", "substrings", "-", "e", ".", "g", ".", "if", "fuzzy", "search", "is", "enabled", "a", "search", "for", "gfp", "would", "return", "a", "hit", "for", "a", "feature", "named", "GFP_seq", ".", ":", "type", "fuzzy", ":", "bool", ":", "returns", ":", "A", "list", "of", "features", "matched", "by", "the", "search", ".", ":", "rtype", ":", "list" ]

[ "def", "to_feature", "(", "self", ",", "name", "=", "None", ",", "feature_type", "=", "'misc_feature'", ")", ":", "if", "name", "is", "None", ":", "if", "not", "self", ".", "name", ":", "raise", "ValueError", "(", "'name attribute missing from DNA instance'", "' and arguments'", ")", "name", "=", "self", ".", "name", "return", "Feature", "(", "name", ",", "start", "=", "0", ",", "stop", "=", "len", "(", "self", ")", ",", "feature_type", "=", "feature_type", ")" ]

[ "Create", "a", "feature", "from", "the", "current", "object", "." ]

[ "def", "cuts_outside", "(", "self", ")", ":", "for", "index", "in", "self", ".", "cut_site", ":", "if", "index", "<", "0", "or", "index", ">", "len", "(", "self", ".", "recognition_site", ")", "+", "1", ":", "return", "True", "return", "False" ]

[ "Report", "whether", "the", "enzyme", "cuts", "outside", "its", "recognition", "site", ".", "Cutting", "at", "the", "very", "end", "of", "the", "site", "returns", "True", "." ]

[ "def", "copy", "(", "self", ")", ":", "return", "type", "(", "self", ")", "(", "self", ".", "anneal", ",", "self", ".", "tm", ",", "overhang", "=", "self", ".", "overhang", ",", "name", "=", "self", ".", "name", ",", "note", "=", "self", ".", "note", ")" ]

[ "Generate", "a", "Primer", "copy", "." ]

[ "def", "tm", "(", "seq", ",", "dna_conc", "=", "50", ",", "salt_conc", "=", "50", ",", "parameters", "=", "'cloning'", ")", ":", "if", "parameters", "==", "'breslauer'", ":", "params", "=", "tm_params", ".", "BRESLAUER", "elif", "parameters", "==", "'sugimoto'", ":", "params", "=", "tm_params", ".", "SUGIMOTO", "elif", "parameters", "==", "'santalucia96'", ":", "params", "=", "tm_params", ".", "SANTALUCIA96", "elif", "parameters", "==", "'santalucia98'", "or", "parameters", "==", "'cloning_sl98'", ":", "params", "=", "tm_params", ".", "SANTALUCIA98", "elif", "parameters", "==", "'cloning'", ":", "params", "=", "tm_params", ".", "CLONING", "else", ":", "raise", "ValueError", "(", "'Unsupported parameter set.'", ")", "# Thermodynamic parameters", "pars", "=", "{", "'delta_h'", ":", "params", "[", "'delta_h'", "]", ",", "'delta_s'", ":", "params", "[", "'delta_s'", "]", "}", "pars_error", "=", "{", "'delta_h'", ":", "params", "[", "'delta_h_err'", "]", ",", "'delta_s'", ":", "params", "[", "'delta_s_err'", "]", "}", "# Error corrections - done first for use of reverse_complement parameters", "if", "parameters", "==", "'breslauer'", ":", "deltas", "=", "breslauer_corrections", "(", "seq", ",", "pars_error", ")", "elif", "parameters", "==", "'sugimoto'", ":", "deltas", "=", "breslauer_corrections", "(", "seq", ",", "pars_error", ")", "elif", "parameters", "==", "'santalucia96'", ":", "deltas", "=", "breslauer_corrections", "(", "seq", ",", "pars_error", ")", "elif", "parameters", "==", "'santalucia98'", "or", "parameters", "==", "'cloning_sl98'", ":", "deltas", "=", "santalucia98_corrections", "(", "seq", ",", "pars_error", ")", "elif", "parameters", "==", "'cloning'", ":", "deltas", "=", "breslauer_corrections", "(", "seq", ",", "pars_error", ")", "deltas", "[", "0", "]", "+=", "3.4", "deltas", "[", "1", "]", "+=", "12.4", "# Sum up the nearest-neighbor enthalpy and entropy", "seq", "=", "str", "(", "seq", ")", ".", "upper", "(", ")", "# TODO: catch more cases when alphabets expand", "if", "'N'", "in", "seq", ":", "raise", "ValueError", "(", "'Can\\'t calculate Tm of an N base.'", ")", "new_delt", "=", "_pair_deltas", "(", "seq", ",", "pars", ")", "deltas", "[", "0", "]", "+=", "new_delt", "[", "0", "]", "deltas", "[", "1", "]", "+=", "new_delt", "[", "1", "]", "# Unit corrections", "salt_conc", "/=", "1e3", "dna_conc", "/=", "1e9", "deltas", "[", "0", "]", "*=", "1e3", "# Universal gas constant (R)", "R", "=", "1.9872", "# Supposedly this is what dnamate does, but the output doesn't match theirs", "# melt = (-deltas[0] / (-deltas[1] + R * log(dna_conc / 4.0))) +", "# 16.6 * log(salt_conc) - 273.15", "# return melt", "# Overall equation is supposedly:", "# sum{dH}/(sum{dS} + R ln(dna_conc/b)) - 273.15", "# with salt corrections for the whole term (or for santalucia98,", "# salt corrections added to the dS term.", "# So far, implementing this as described does not give results that match", "# any calculator but Biopython's", "if", "parameters", "==", "'breslauer'", "or", "parameters", "==", "'cloning'", ":", "numerator", "=", "-", "deltas", "[", "0", "]", "# Modified dna_conc denominator", "denominator", "=", "(", "-", "deltas", "[", "1", "]", ")", "+", "R", "*", "log", "(", "dna_conc", "/", "16.0", ")", "# Modified Schildkraut-Lifson equation adjustment", "salt_adjustment", "=", "16.6", "*", "log", "(", "salt_conc", ")", "/", "log", "(", "10.0", ")", "melt", "=", "numerator", "/", "denominator", "+", "salt_adjustment", "-", "273.15", "elif", "parameters", "==", "'santalucia98'", "or", "'cloning_sl98'", ":", "# TODO: dna_conc should be divided by 2.0 when dna_conc >> template", "# (like PCR)", "numerator", "=", "-", "deltas", "[", "0", "]", "# SantaLucia 98 salt correction", "salt_adjustment", "=", "0.368", "*", "(", "len", "(", "seq", ")", "-", "1", ")", "*", "log", "(", "salt_conc", ")", "denominator", "=", "-", "deltas", "[", "1", "]", "+", "salt_adjustment", "+", "R", "*", "log", "(", "dna_conc", "/", "4.0", ")", "melt", "=", "-", "deltas", "[", "0", "]", "/", "denominator", "-", "273.15", "elif", "parameters", "==", "'santalucia96'", ":", "# TODO: find a way to test whether the code below matches another", "# algorithm. It appears to be correct, but need to test it.", "numerator", "=", "-", "deltas", "[", "0", "]", "denominator", "=", "-", "deltas", "[", "1", "]", "+", "R", "*", "log", "(", "dna_conc", "/", "4.0", ")", "# SantaLucia 96 salt correction", "salt_adjustment", "=", "12.5", "*", "log10", "(", "salt_conc", ")", "melt", "=", "numerator", "/", "denominator", "+", "salt_adjustment", "-", "273.15", "elif", "parameters", "==", "'sugimoto'", ":", "# TODO: the stuff below is untested and probably wrong", "numerator", "=", "-", "deltas", "[", "0", "]", "denominator", "=", "-", "deltas", "[", "1", "]", "+", "R", "*", "log", "(", "dna_conc", "/", "4.0", ")", "# Sugimoto parameters were fit holding salt concentration constant", "# Salt correction can be chosen / ignored? Remove sugimoto set since", "# it's so similar to santalucia98?", "salt_correction", "=", "16.6", "*", "log10", "(", "salt_conc", ")", "melt", "=", "numerator", "/", "denominator", "+", "salt_correction", "-", "273.15", "if", "parameters", "==", "'cloning_sl98'", ":", "# Corrections to make santalucia98 method approximate cloning method.", "# May be even better for cloning with Phusion than 'cloning' method", "melt", "*=", "1.27329212575", "melt", "+=", "-", "2.55585450119", "return", "melt" ]

[ "Calculate", "nearest", "-", "neighbor", "melting", "temperature", "(", "Tm", ")", "." ]

[ "def", "_pair_deltas", "(", "seq", ",", "pars", ")", ":", "delta0", "=", "0", "delta1", "=", "0", "for", "i", "in", "range", "(", "len", "(", "seq", ")", "-", "1", ")", ":", "curchar", "=", "seq", "[", "i", ":", "i", "+", "2", "]", "delta0", "+=", "pars", "[", "'delta_h'", "]", "[", "curchar", "]", "delta1", "+=", "pars", "[", "'delta_s'", "]", "[", "curchar", "]", "return", "delta0", ",", "delta1" ]

[ "Add", "up", "nearest", "-", "neighbor", "parameters", "for", "a", "given", "sequence", "." ]

[ "def", "breslauer_corrections", "(", "seq", ",", "pars_error", ")", ":", "deltas_corr", "=", "[", "0", ",", "0", "]", "contains_gc", "=", "'G'", "in", "str", "(", "seq", ")", "or", "'C'", "in", "str", "(", "seq", ")", "only_at", "=", "str", "(", "seq", ")", ".", "count", "(", "'A'", ")", "+", "str", "(", "seq", ")", ".", "count", "(", "'T'", ")", "==", "len", "(", "seq", ")", "symmetric", "=", "seq", "==", "seq", ".", "reverse_complement", "(", ")", "terminal_t", "=", "str", "(", "seq", ")", "[", "0", "]", "==", "'T'", "+", "str", "(", "seq", ")", "[", "-", "1", "]", "==", "'T'", "for", "i", ",", "delta", "in", "enumerate", "(", "[", "'delta_h'", ",", "'delta_s'", "]", ")", ":", "if", "contains_gc", ":", "deltas_corr", "[", "i", "]", "+=", "pars_error", "[", "delta", "]", "[", "'anyGC'", "]", "if", "only_at", ":", "deltas_corr", "[", "i", "]", "+=", "pars_error", "[", "delta", "]", "[", "'onlyAT'", "]", "if", "symmetric", ":", "deltas_corr", "[", "i", "]", "+=", "pars_error", "[", "delta", "]", "[", "'symmetry'", "]", "if", "terminal_t", "and", "delta", "==", "'delta_h'", ":", "deltas_corr", "[", "i", "]", "+=", "pars_error", "[", "delta", "]", "[", "'terminalT'", "]", "*", "terminal_t", "return", "deltas_corr" ]

[ "Sum", "corrections", "for", "Breslauer", "84", "method", "." ]

[ "def", "santalucia98_corrections", "(", "seq", ",", "pars_error", ")", ":", "deltas_corr", "=", "[", "0", ",", "0", "]", "first", "=", "str", "(", "seq", ")", "[", "0", "]", "last", "=", "str", "(", "seq", ")", "[", "-", "1", "]", "start_gc", "=", "first", "==", "'G'", "or", "first", "==", "'C'", "start_at", "=", "first", "==", "'A'", "or", "first", "==", "'T'", "end_gc", "=", "last", "==", "'G'", "or", "last", "==", "'C'", "end_at", "=", "last", "==", "'A'", "or", "last", "==", "'T'", "init_gc", "=", "start_gc", "+", "end_gc", "init_at", "=", "start_at", "+", "end_at", "symmetric", "=", "seq", "==", "seq", ".", "reverse_complement", "(", ")", "for", "i", ",", "delta", "in", "enumerate", "(", "[", "'delta_h'", ",", "'delta_s'", "]", ")", ":", "deltas_corr", "[", "i", "]", "+=", "init_gc", "*", "pars_error", "[", "delta", "]", "[", "'initGC'", "]", "deltas_corr", "[", "i", "]", "+=", "init_at", "*", "pars_error", "[", "delta", "]", "[", "'initAT'", "]", "if", "symmetric", ":", "deltas_corr", "[", "i", "]", "+=", "pars_error", "[", "delta", "]", "[", "'symmetry'", "]", "return", "deltas_corr" ]

[ "Sum", "corrections", "for", "SantaLucia", "98", "method", "(", "unified", "parameters", ")", "." ]

[ "def", "MAFFT", "(", "sequences", ",", "gap_open", "=", "1.53", ",", "gap_extension", "=", "0.0", ",", "retree", "=", "2", ")", ":", "arguments", "=", "[", "'mafft'", "]", "arguments", "+=", "[", "'--op'", ",", "str", "(", "gap_open", ")", "]", "arguments", "+=", "[", "'--ep'", ",", "str", "(", "gap_extension", ")", "]", "arguments", "+=", "[", "'--retree'", ",", "str", "(", "retree", ")", "]", "arguments", ".", "append", "(", "'input.fasta'", ")", "tempdir", "=", "tempfile", ".", "mkdtemp", "(", ")", "try", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "tempdir", ",", "'input.fasta'", ")", ",", "'w'", ")", "as", "f", ":", "for", "i", ",", "sequence", "in", "enumerate", "(", "sequences", ")", ":", "if", "hasattr", "(", "sequence", ",", "'name'", ")", ":", "name", "=", "sequence", ".", "name", "else", ":", "name", "=", "'sequence{}'", ".", "format", "(", "i", ")", "f", ".", "write", "(", "'>{}\\n'", ".", "format", "(", "name", ")", ")", "f", ".", "write", "(", "str", "(", "sequence", ")", "+", "'\\n'", ")", "process", "=", "subprocess", ".", "Popen", "(", "arguments", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "open", "(", "os", ".", "devnull", ",", "'w'", ")", ",", "cwd", "=", "tempdir", ")", "stdout", "=", "process", ".", "communicate", "(", ")", "[", "0", "]", "finally", ":", "shutil", ".", "rmtree", "(", "tempdir", ")", "# Process stdout into something downstream process can use", "records", "=", "stdout", ".", "split", "(", "'>'", ")", "# First line is now blank", "records", ".", "pop", "(", "0", ")", "aligned_list", "=", "[", "]", "for", "record", "in", "records", ":", "lines", "=", "record", ".", "split", "(", "'\\n'", ")", "name", "=", "lines", ".", "pop", "(", "0", ")", "aligned_list", ".", "append", "(", "coral", ".", "DNA", "(", "''", ".", "join", "(", "lines", ")", ")", ")", "return", "aligned_list" ]

[ "A", "Coral", "wrapper", "for", "the", "MAFFT", "command", "line", "multiple", "sequence", "aligner", "." ]

[ "def", "repeats", "(", "seq", ",", "size", ")", ":", "seq", "=", "str", "(", "seq", ")", "n_mers", "=", "[", "seq", "[", "i", ":", "i", "+", "size", "]", "for", "i", "in", "range", "(", "len", "(", "seq", ")", "-", "size", "+", "1", ")", "]", "counted", "=", "Counter", "(", "n_mers", ")", "# No one cares about patterns that appear once, so exclude them", "found_repeats", "=", "[", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "counted", ".", "iteritems", "(", ")", "if", "value", ">", "1", "]", "return", "found_repeats" ]

[ "Count", "times", "that", "a", "sequence", "of", "a", "certain", "size", "is", "repeated", "." ]

[ "def", "gibson", "(", "seq_list", ",", "linear", "=", "False", ",", "homology", "=", "10", ",", "tm", "=", "63.0", ")", ":", "# FIXME: Preserve features in overlap", "# TODO: set a max length?", "# TODO: add 'expected' keyword argument somewhere to automate", "# validation", "# Remove any redundant (identical) sequences", "seq_list", "=", "list", "(", "set", "(", "seq_list", ")", ")", "for", "seq", "in", "seq_list", ":", "if", "seq", ".", "circular", ":", "raise", "ValueError", "(", "'Input sequences must be linear.'", ")", "# Copy input list", "working_list", "=", "[", "s", ".", "copy", "(", ")", "for", "s", "in", "seq_list", "]", "# Attempt to fuse fragments together until only one is left", "while", "len", "(", "working_list", ")", ">", "1", ":", "working_list", "=", "_find_fuse_next", "(", "working_list", ",", "homology", ",", "tm", ")", "if", "not", "linear", ":", "# Fuse the final fragment to itself", "working_list", "=", "_fuse_last", "(", "working_list", ",", "homology", ",", "tm", ")", "# Clear features", "working_list", "[", "0", "]", ".", "features", "=", "[", "]", "return", "_annotate_features", "(", "working_list", "[", "0", "]", ",", "seq_list", ")" ]

[ "Simulate", "a", "Gibson", "reaction", "." ]

[ "def", "_find_fuse_next", "(", "working_list", ",", "homology", ",", "tm", ")", ":", "# 1. Take the first sequence and find all matches", "# Get graphs:", "# a) pattern watson : targets watson", "# b) pattern watson : targets crick", "# c) pattern crick: targets watson", "# d) pattern crick: targets crick", "pattern", "=", "working_list", "[", "0", "]", "targets", "=", "working_list", "[", "1", ":", "]", "# Output graph nodes of terminal binders:", "# (destination, size, strand1, strand2)", "def", "graph_strands", "(", "strand1", ",", "strand2", ")", ":", "graph", "=", "[", "]", "for", "i", ",", "target", "in", "enumerate", "(", "targets", ")", ":", "matchlen", "=", "homology_report", "(", "pattern", ",", "target", ",", "strand1", ",", "strand2", ",", "cutoff", "=", "homology", ",", "min_tm", "=", "tm", ")", "if", "matchlen", ":", "graph", ".", "append", "(", "(", "i", ",", "matchlen", ",", "strand1", ",", "strand2", ")", ")", "return", "graph", "graph_ww", "=", "graph_strands", "(", "'w'", ",", "'w'", ")", "graph_wc", "=", "graph_strands", "(", "'w'", ",", "'c'", ")", "graph_cw", "=", "graph_strands", "(", "'c'", ",", "'w'", ")", "graph_cc", "=", "graph_strands", "(", "'c'", ",", "'c'", ")", "graphs_w", "=", "graph_ww", "+", "graph_wc", "graphs_c", "=", "graph_cw", "+", "graph_cc", "graphs", "=", "graphs_w", "+", "graphs_c", "# 2. See if there's more than one result on a strand.", "# If so, throw an exception.", "if", "len", "(", "graphs_w", ")", ">", "1", "or", "len", "(", "graphs_c", ")", ">", "1", ":", "raise", "AmbiguousGibsonError", "(", "'multiple compatible ends.'", ")", "if", "len", "(", "graphs_w", ")", "==", "len", "(", "graphs_c", ")", "==", "0", ":", "raise", "GibsonOverlapError", "(", "'Failed to find compatible Gibson ends.'", ")", "# 3. There must be one result. Where is it?", "# If there's one result on each strand, go with the one that matches the", "# pattern watson strand (will occur first - index 0)", "match", "=", "graphs", "[", "0", "]", "# 4. Combine pieces together", "# 4a. Orient pattern sequence", "if", "match", "[", "2", "]", "==", "'c'", ":", "left_side", "=", "pattern", ".", "reverse_complement", "(", ")", "else", ":", "left_side", "=", "pattern", "# 4b. Orient target sequence", "if", "match", "[", "3", "]", "==", "'w'", ":", "right_side", "=", "working_list", ".", "pop", "(", "match", "[", "0", "]", "+", "1", ")", ".", "reverse_complement", "(", ")", "else", ":", "right_side", "=", "working_list", ".", "pop", "(", "match", "[", "0", "]", "+", "1", ")", "working_list", "[", "0", "]", "=", "left_side", "+", "right_side", "[", "match", "[", "1", "]", ":", "]", "return", "working_list" ]

[ "Find", "the", "next", "sequence", "to", "fuse", "and", "fuse", "it", "(", "or", "raise", "exception", ")", "." ]

[ "def", "_fuse_last", "(", "working_list", ",", "homology", ",", "tm", ")", ":", "# 1. Construct graph on self-self", "# (destination, size, strand1, strand2)", "pattern", "=", "working_list", "[", "0", "]", "def", "graph_strands", "(", "strand1", ",", "strand2", ")", ":", "matchlen", "=", "homology_report", "(", "pattern", ",", "pattern", ",", "strand1", ",", "strand2", ",", "cutoff", "=", "homology", ",", "min_tm", "=", "tm", ",", "top_two", "=", "True", ")", "if", "matchlen", ":", "# Ignore full-sequence matches", "# HACK: modified homology_report to accept top_two. It should", "# really just ignore full-length matches", "for", "length", "in", "matchlen", ":", "if", "length", "!=", "len", "(", "pattern", ")", ":", "return", "(", "0", ",", "length", ",", "strand1", ",", "strand2", ")", "else", ":", "return", "[", "]", "# cw is redundant with wc", "graph_ww", "=", "graph_strands", "(", "'w'", ",", "'w'", ")", "graph_wc", "=", "graph_strands", "(", "'w'", ",", "'c'", ")", "graph_cc", "=", "graph_strands", "(", "'c'", ",", "'c'", ")", "if", "graph_ww", "+", "graph_cc", ":", "raise", "AmbiguousGibsonError", "(", "'Self-self binding during circularization.'", ")", "if", "not", "graph_wc", ":", "raise", "ValueError", "(", "'Failed to find compatible ends for circularization.'", ")", "working_list", "[", "0", "]", "=", "working_list", "[", "0", "]", "[", ":", "-", "graph_wc", "[", "1", "]", "]", ".", "circularize", "(", ")", "return", "working_list" ]

[ "With", "one", "sequence", "left", "attempt", "to", "fuse", "it", "to", "itself", "." ]

[ "def", "homology_report", "(", "seq1", ",", "seq2", ",", "strand1", ",", "strand2", ",", "cutoff", "=", "0", ",", "min_tm", "=", "63.0", ",", "top_two", "=", "False", ",", "max_size", "=", "500", ")", ":", "# Ensure that strand 1 is Watson and strand 2 is Crick", "if", "strand1", "==", "'c'", ":", "seq1", "=", "seq1", ".", "reverse_complement", "(", ")", "if", "strand2", "==", "'w'", ":", "seq2", "=", "seq2", ".", "reverse_complement", "(", ")", "# Generate all same-length 5' ends of seq1 and 3' ends of seq2 within", "# maximum homology length", "# TODO: If strings aren't used here, gen_chunks takes forever. Suggests a", "# need to optimize coral.DNA subsetting", "seq1_str", "=", "str", "(", "seq1", ")", "seq2_str", "=", "str", "(", "seq2", ")", "def", "gen_chunks", "(", "s1", ",", "s2", ")", ":", "chunks1", "=", "[", "seq1_str", "[", "-", "(", "i", "+", "1", ")", ":", "]", "for", "i", "in", "range", "(", "min", "(", "len", "(", "seq1_str", ")", ",", "max_size", ")", ")", "]", "chunks2", "=", "[", "seq2_str", "[", ":", "(", "i", "+", "1", ")", "]", "for", "i", "in", "range", "(", "min", "(", "len", "(", "seq2_str", ")", ",", "max_size", ")", ")", "]", "return", "chunks1", ",", "chunks2", "seq1_chunks", ",", "seq2_chunks", "=", "gen_chunks", "(", "seq1_str", ",", "seq2_str", ")", "# Check for exact matches from terminal end to terminal end", "target_matches", "=", "[", "]", "for", "i", ",", "(", "s1", ",", "s2", ")", "in", "enumerate", "(", "zip", "(", "seq1_chunks", ",", "seq2_chunks", ")", ")", ":", "s1len", "=", "len", "(", "s1", ")", "# Inefficient! (reverse complementing a bunch of times)", "# Don't calculate tm once base tm has been reached.", "# TODO: Go through logic here again and make sure the order of checking", "# makes sense", "if", "s1", "==", "s2", ":", "logger", ".", "debug", "(", "'Found Match: {}'", ".", "format", "(", "str", "(", "s1", ")", ")", ")", "if", "s1len", ">=", "cutoff", ":", "tm", "=", "coral", ".", "analysis", ".", "tm", "(", "seq1", "[", "-", "(", "i", "+", "1", ")", ":", "]", ")", "logger", ".", "debug", "(", "'Match tm: {} C'", ".", "format", "(", "tm", ")", ")", "if", "tm", ">=", "min_tm", ":", "target_matches", ".", "append", "(", "s1len", ")", "elif", "tm", ">=", "min_tm", "-", "4", ":", "msg", "=", "'One overlap had a Tm of {} C.'", ".", "format", "(", "tm", ")", "warnings", ".", "warn", "(", "msg", ")", "target_matches", ".", "append", "(", "s1len", ")", "target_matches", ".", "sort", "(", ")", "if", "not", "top_two", ":", "return", "0", "if", "not", "target_matches", "else", "target_matches", "[", "0", "]", "else", ":", "return", "0", "if", "not", "target_matches", "else", "target_matches", "[", "0", ":", "2", "]" ]

[ "Given", "two", "sequences", "(", "seq1", "and", "seq2", ")", "report", "the", "size", "of", "all", "perfect", "matches", "between", "the", "3", "end", "of", "the", "top", "strand", "of", "seq1", "and", "the", "3", "end", "of", "either", "strand", "of", "seq2", ".", "In", "short", "in", "a", "Gibson", "reaction", "what", "would", "bind", "the", "desired", "part", "of", "seq1", "given", "a", "seq2?" ]

[ "def", "fetch_yeast_locus_sequence", "(", "locus_name", ",", "flanking_size", "=", "0", ")", ":", "from", "intermine", ".", "webservice", "import", "Service", "service", "=", "Service", "(", "'http://yeastmine.yeastgenome.org/yeastmine/service'", ")", "# Get a new query on the class (table) you will be querying:", "query", "=", "service", ".", "new_query", "(", "'Gene'", ")", "if", "flanking_size", ">", "0", ":", "# The view specifies the output columns", "# secondaryIdentifier: the systematic name (e.g. YFL039C)", "# symbol: short name (e.g. ACT1)", "# length: sequence length", "# flankingRegions.direction: Upstream or downstream (or both) of locus", "# flankingRegions.sequence.length: length of the flanking regions", "# flankingRegions.sequence.residues: sequence of the flanking regions", "query", ".", "add_view", "(", "'secondaryIdentifier'", ",", "'symbol'", ",", "'length'", ",", "'flankingRegions.direction'", ",", "'flankingRegions.sequence.length'", ",", "'flankingRegions.sequence.residues'", ")", "# You can edit the constraint values below", "query", ".", "add_constraint", "(", "'flankingRegions.direction'", ",", "'='", ",", "'both'", ",", "code", "=", "'A'", ")", "query", ".", "add_constraint", "(", "'Gene'", ",", "'LOOKUP'", ",", "locus_name", ",", "'S. cerevisiae'", ",", "code", "=", "'B'", ")", "query", ".", "add_constraint", "(", "'flankingRegions.distance'", ",", "'='", ",", "'{:.1f}kb'", ".", "format", "(", "flanking_size", "/", "1000.", ")", ",", "code", "=", "'C'", ")", "# Uncomment and edit the code below to specify your own custom logic:", "query", ".", "set_logic", "(", "'A and B and C'", ")", "# TODO: What to do when there's more than one result?", "first_result", "=", "query", ".", "rows", "(", ")", ".", "next", "(", ")", "# FIXME: Use logger module instead", "# print first_result['secondaryIdentifier']", "# print first_result['symbol'], row['length']", "# print first_result['flankingRegions.direction']", "# print first_result['flankingRegions.sequence.length']", "# print first_result['flankingRegions.sequence.residues']", "seq", "=", "coral", ".", "DNA", "(", "first_result", "[", "'flankingRegions.sequence.residues'", "]", ")", "# TODO: add more metadata", "elif", "flanking_size", "==", "0", ":", "# The view specifies the output columns", "query", ".", "add_view", "(", "'primaryIdentifier'", ",", "'secondaryIdentifier'", ",", "'symbol'", ",", "'name'", ",", "'sgdAlias'", ",", "'organism.shortName'", ",", "'sequence.length'", ",", "'sequence.residues'", ",", "'description'", ",", "'qualifier'", ")", "query", ".", "add_constraint", "(", "'status'", ",", "'IS NULL'", ",", "code", "=", "'D'", ")", "query", ".", "add_constraint", "(", "'status'", ",", "'='", ",", "'Active'", ",", "code", "=", "'C'", ")", "query", ".", "add_constraint", "(", "'qualifier'", ",", "'IS NULL'", ",", "code", "=", "'B'", ")", "query", ".", "add_constraint", "(", "'qualifier'", ",", "'!='", ",", "'Dubious'", ",", "code", "=", "'A'", ")", "query", ".", "add_constraint", "(", "'Gene'", ",", "'LOOKUP'", ",", "locus_name", ",", "'S. cerevisiae'", ",", "code", "=", "'E'", ")", "# Your custom constraint logic is specified with the code below:", "query", ".", "set_logic", "(", "'(A or B) and (C or D) and E'", ")", "first_result", "=", "query", ".", "rows", "(", ")", ".", "next", "(", ")", "seq", "=", "coral", ".", "DNA", "(", "first_result", "[", "'sequence.residues'", "]", ")", "else", ":", "print", "'Problem with the flanking region size....'", "seq", "=", "coral", ".", "DNA", "(", "''", ")", "return", "seq" ]

[ "Acquire", "a", "sequence", "from", "SGD", "http", ":", "//", "www", ".", "yeastgenome", ".", "org", "." ]

[ "def", "get_yeast_sequence", "(", "chromosome", ",", "start", ",", "end", ",", "reverse_complement", "=", "False", ")", ":", "import", "requests", "if", "start", "!=", "end", ":", "if", "reverse_complement", ":", "rev_option", "=", "'-REV'", "else", ":", "rev_option", "=", "''", "param_url", "=", "'&chr='", "+", "str", "(", "chromosome", ")", "+", "'&beg='", "+", "str", "(", "start", ")", "+", "'&end='", "+", "str", "(", "end", ")", "+", "'&rev='", "+", "rev_option", "url", "=", "'http://www.yeastgenome.org/cgi-bin/getSeq?map=a2map'", "+", "param_url", "res", "=", "requests", ".", "get", "(", "url", ")", "# ok... sadely, I contacted SGD and they haven;t implemented this so", "# I have to parse their yeastgenome page, but", "# it is easy between the raw sequence is between <pre> tags!", "# warning that's for the first < so we need +5!", "begin_index", "=", "res", ".", "text", ".", "index", "(", "'<pre>'", ")", "end_index", "=", "res", ".", "text", ".", "index", "(", "'</pre>'", ")", "sequence", "=", "res", ".", "text", "[", "begin_index", "+", "5", ":", "end_index", "]", "sequence", "=", "sequence", ".", "replace", "(", "'\\n'", ",", "''", ")", ".", "replace", "(", "'\\r'", ",", "''", ")", "else", ":", "sequence", "=", "''", "return", "coral", ".", "DNA", "(", "sequence", ")" ]

[ "Acquire", "a", "sequence", "from", "SGD", "http", ":", "//", "www", ".", "yeastgenome", ".", "org", ":", "param", "chromosome", ":", "Yeast", "chromosome", ".", ":", "type", "chromosome", ":", "int", ":", "param", "start", ":", "A", "biostart", ".", ":", "type", "start", ":", "int", ":", "param", "end", ":", "A", "bioend", ".", ":", "type", "end", ":", "int", ":", "param", "reverse_complement", ":", "Get", "the", "reverse", "complement", ".", ":", "type", "revervse_complement", ":", "bool", ":", "returns", ":", "A", "DNA", "sequence", ".", ":", "rtype", ":", "coral", ".", "DNA" ]

[ "def", "get_yeast_gene_location", "(", "gene_name", ")", ":", "from", "intermine", ".", "webservice", "import", "Service", "service", "=", "Service", "(", "'http://yeastmine.yeastgenome.org/yeastmine/service'", ")", "# Get a new query on the class (table) you will be querying:", "query", "=", "service", ".", "new_query", "(", "'Gene'", ")", "# The view specifies the output columns", "query", ".", "add_view", "(", "'primaryIdentifier'", ",", "'secondaryIdentifier'", ",", "'symbol'", ",", "'name'", ",", "'organism.shortName'", ",", "'chromosome.primaryIdentifier'", ",", "'chromosomeLocation.start'", ",", "'chromosomeLocation.end'", ",", "'chromosomeLocation.strand'", ")", "# Uncomment and edit the line below (the default) to select a custom sort", "# order:", "# query.add_sort_order('Gene.primaryIdentifier', 'ASC')", "# You can edit the constraint values below", "query", ".", "add_constraint", "(", "'organism.shortName'", ",", "'='", ",", "'S. cerevisiae'", ",", "code", "=", "'B'", ")", "query", ".", "add_constraint", "(", "'Gene'", ",", "'LOOKUP'", ",", "gene_name", ",", "code", "=", "'A'", ")", "# Uncomment and edit the code below to specify your own custom logic:", "# query.set_logic('A and B')", "chromosomes", "=", "{", "'chrI'", ":", "1", ",", "'chrII'", ":", "2", ",", "'chrIII'", ":", "3", ",", "'chrIV'", ":", "4", ",", "'chrV'", ":", "5", ",", "'chrVI'", ":", "6", ",", "'chrVII'", ":", "7", ",", "'chrVIII'", ":", "8", ",", "'chrIX'", ":", "9", ",", "'chrX'", ":", "10", ",", "'chrXI'", ":", "11", ",", "'chrXII'", ":", "12", ",", "'chrXIII'", ":", "13", ",", "'chrXIV'", ":", "14", ",", "'chrXV'", ":", "15", ",", "'chrXVI'", ":", "16", "}", "first_result", "=", "query", ".", "rows", "(", ")", ".", "next", "(", ")", "return", "[", "chromosomes", "[", "first_result", "[", "'chromosome.primaryIdentifier'", "]", "]", ",", "first_result", "[", "'chromosomeLocation.start'", "]", ",", "first_result", "[", "'chromosomeLocation.end'", "]", ",", "int", "(", "first_result", "[", "'chromosomeLocation.strand'", "]", ")", "]" ]

[ "Acquire", "the", "location", "of", "a", "gene", "from", "SGD", "http", ":", "//", "www", ".", "yeastgenome", ".", "org", ":", "param", "gene_name", ":", "Name", "of", "the", "gene", ".", ":", "type", "gene_name", ":", "string", ":", "returns", "location", ":", "[", "int", ":", "chromosome", "int", ":", "biostart", "int", ":", "bioend", "int", ":", "strand", "]", ":", "rtype", "location", ":", "list" ]

[ "def", "get_gene_id", "(", "gene_name", ")", ":", "from", "intermine", ".", "webservice", "import", "Service", "service", "=", "Service", "(", "'http://yeastmine.yeastgenome.org/yeastmine/service'", ")", "# Get a new query on the class (table) you will be querying:", "query", "=", "service", ".", "new_query", "(", "'Gene'", ")", "# The view specifies the output columns", "query", ".", "add_view", "(", "'primaryIdentifier'", ",", "'secondaryIdentifier'", ",", "'symbol'", ",", "'name'", ",", "'sgdAlias'", ",", "'crossReferences.identifier'", ",", "'crossReferences.source.name'", ")", "# Uncomment and edit the line below (the default) to select a custom sort", "# order:", "# query.add_sort_order('Gene.primaryIdentifier', 'ASC')", "# You can edit the constraint values below", "query", ".", "add_constraint", "(", "'organism.shortName'", ",", "'='", ",", "'S. cerevisiae'", ",", "code", "=", "'B'", ")", "query", ".", "add_constraint", "(", "'Gene'", ",", "'LOOKUP'", ",", "gene_name", ",", "code", "=", "'A'", ")", "# Uncomment and edit the code below to specify your own custom logic:", "# query.set_logic('A and B')", "for", "row", "in", "query", ".", "rows", "(", ")", ":", "gid", "=", "row", "[", "'secondaryIdentifier'", "]", "return", "gid" ]

[ "Retrieve", "systematic", "yeast", "gene", "name", "from", "the", "common", "name", "." ]

[ "def", "get_yeast_promoter_ypa", "(", "gene_name", ")", ":", "import", "requests", "loc", "=", "get_yeast_gene_location", "(", "gene_name", ")", "gid", "=", "get_gene_id", "(", "gene_name", ")", "ypa_baseurl", "=", "'http://ypa.csbb.ntu.edu.tw/do'", "params", "=", "{", "'act'", ":", "'download'", ",", "'nucle'", ":", "'InVitro'", ",", "'right'", ":", "str", "(", "loc", "[", "2", "]", ")", ",", "'left'", ":", "str", "(", "loc", "[", "1", "]", ")", ",", "'gene'", ":", "str", "(", "gid", ")", ",", "'chr'", ":", "str", "(", "loc", "[", "0", "]", ")", "}", "response", "=", "requests", ".", "get", "(", "ypa_baseurl", ",", "params", "=", "params", ")", "text", "=", "response", ".", "text", "# FASTA records are just name-sequence pairs split up by > e.g.", "# >my_dna_name", "# GACGATA", "# TODO: most of this is redundant, as we just want the 2nd record", "record_split", "=", "text", ".", "split", "(", "'>'", ")", "record_split", ".", "pop", "(", "0", ")", "parsed", "=", "[", "]", "for", "record", "in", "record_split", ":", "parts", "=", "record", ".", "split", "(", "'\\n'", ")", "sequence", "=", "coral", ".", "DNA", "(", "''", ".", "join", "(", "parts", "[", "1", ":", "]", ")", ")", "sequence", ".", "name", "=", "parts", "[", "0", "]", "parsed", ".", "append", "(", "sequence", ")", "return", "parsed", "[", "1", "]" ]

[ "Retrieve", "promoter", "from", "Yeast", "Promoter", "Atlas", "(", "http", ":", "//", "ypa", ".", "csbb", ".", "ntu", ".", "edu", ".", "tw", ")", "." ]

[ "def", "_grow_overlaps", "(", "dna", ",", "melting_temp", ",", "require_even", ",", "length_max", ",", "overlap_min", ",", "min_exception", ")", ":", "# TODO: prevent growing overlaps from bumping into each other -", "# should halt when it happens, give warning, let user decide if they still", "# want the current construct", "# Another option would be to start over, moving the starting positions", "# near the problem region a little farther from each other - this would", "# put the AT-rich region in the middle of the spanning oligo", "# Try bare minimum number of oligos", "oligo_n", "=", "len", "(", "dna", ")", "//", "length_max", "+", "1", "# Adjust number of oligos if even number required", "if", "require_even", ":", "oligo_increment", "=", "2", "if", "oligo_n", "%", "2", "==", "1", ":", "oligo_n", "+=", "1", "else", ":", "oligo_increment", "=", "1", "# Increase oligo number until the minimum oligo_len is less than length_max", "while", "float", "(", "len", "(", "dna", ")", ")", "/", "oligo_n", ">", "length_max", ":", "oligo_n", "+=", "oligo_increment", "# Loop until all overlaps meet minimum Tm and length", "tm_met", "=", "False", "len_met", "=", "False", "while", "(", "not", "tm_met", "or", "not", "len_met", ")", ":", "# Calculate initial number of overlaps", "overlap_n", "=", "oligo_n", "-", "1", "# Place overlaps approximately equidistant over sequence length", "overlap_interval", "=", "float", "(", "len", "(", "dna", ")", ")", "/", "oligo_n", "starts", "=", "[", "int", "(", "overlap_interval", "*", "(", "i", "+", "1", ")", ")", "for", "i", "in", "range", "(", "overlap_n", ")", "]", "ends", "=", "[", "index", "+", "1", "for", "index", "in", "starts", "]", "# Fencepost for while loop", "# Initial overlaps (1 base) and their tms", "overlaps", "=", "[", "dna", "[", "start", ":", "end", "]", "for", "start", ",", "end", "in", "zip", "(", "starts", ",", "ends", ")", "]", "overlap_tms", "=", "[", "coral", ".", "analysis", ".", "tm", "(", "overlap", ")", "for", "overlap", "in", "overlaps", "]", "index", "=", "overlap_tms", ".", "index", "(", "min", "(", "overlap_tms", ")", ")", "# Initial oligos - includes the 1 base overlaps.", "# All the oligos are in the same direction - reverse", "# complementation of every other one happens later", "oligo_starts", "=", "[", "0", "]", "+", "starts", "oligo_ends", "=", "ends", "+", "[", "len", "(", "dna", ")", "]", "oligo_indices", "=", "[", "oligo_starts", ",", "oligo_ends", "]", "oligos", "=", "[", "dna", "[", "start", ":", "end", "]", "for", "start", ",", "end", "in", "zip", "(", "*", "oligo_indices", ")", "]", "# Oligo won't be maxed in first pass. tm_met and len_met will be false", "maxed", "=", "False", "while", "not", "(", "tm_met", "and", "len_met", ")", "and", "not", "maxed", ":", "# Recalculate overlaps and their Tms", "overlaps", "=", "_recalculate_overlaps", "(", "dna", ",", "overlaps", ",", "oligo_indices", ")", "# Tm calculation is bottleneck - only recalculate changed overlap", "overlap_tms", "[", "index", "]", "=", "coral", ".", "analysis", ".", "tm", "(", "overlaps", "[", "index", "]", ")", "# Find lowest-Tm overlap and its index.", "index", "=", "overlap_tms", ".", "index", "(", "min", "(", "overlap_tms", ")", ")", "# Move overlap at that index", "oligos", "=", "_expand_overlap", "(", "dna", ",", "oligo_indices", ",", "index", ",", "oligos", ",", "length_max", ")", "# Regenerate conditions", "maxed", "=", "any", "(", "[", "len", "(", "x", ")", "==", "length_max", "for", "x", "in", "oligos", "]", ")", "tm_met", "=", "all", "(", "[", "x", ">=", "melting_temp", "for", "x", "in", "overlap_tms", "]", ")", "if", "min_exception", ":", "len_met", "=", "True", "else", ":", "len_met", "=", "all", "(", "[", "len", "(", "x", ")", ">=", "overlap_min", "for", "x", "in", "overlaps", "]", ")", "# TODO: add test for min_exception case (use rob's sequence from", "# 20130624 with 65C Tm)", "if", "min_exception", ":", "len_met", "=", "all", "(", "[", "len", "(", "x", ")", ">=", "overlap_min", "for", "x", "in", "overlaps", "]", ")", "# See if len_met is true - if so do nothing", "if", "len_met", ":", "break", "else", ":", "while", "not", "len_met", "and", "not", "maxed", ":", "# Recalculate overlaps and their Tms", "overlaps", "=", "_recalculate_overlaps", "(", "dna", ",", "overlaps", ",", "oligo_indices", ")", "# Overlap to increase is the shortest one", "overlap_lens", "=", "[", "len", "(", "overlap", ")", "for", "overlap", "in", "overlaps", "]", "index", "=", "overlap_lens", ".", "index", "(", "min", "(", "overlap_lens", ")", ")", "# Increase left or right oligo", "oligos", "=", "_expand_overlap", "(", "dna", ",", "oligo_indices", ",", "index", ",", "oligos", ",", "length_max", ")", "# Recalculate conditions", "maxed", "=", "any", "(", "[", "len", "(", "x", ")", "==", "length_max", "for", "x", "in", "oligos", "]", ")", "len_met", "=", "all", "(", "[", "len", "(", "x", ")", ">=", "overlap_min", "for", "x", "in", "overlaps", "]", ")", "# Recalculate tms to reflect any changes (some are redundant)", "overlap_tms", "[", "index", "]", "=", "coral", ".", "analysis", ".", "tm", "(", "overlaps", "[", "index", "]", ")", "# Outcome could be that len_met happened *or* maxed out", "# length of one of the oligos. If len_met happened, should be", "# done so long as tm_met has been satisfied. If maxed happened,", "# len_met will not have been met, even if tm_met is satisfied,", "# and script will reattempt with more oligos", "oligo_n", "+=", "oligo_increment", "# Calculate location of overlaps", "overlap_indices", "=", "[", "(", "oligo_indices", "[", "0", "]", "[", "x", "+", "1", "]", ",", "oligo_indices", "[", "1", "]", "[", "x", "]", ")", "for", "x", "in", "range", "(", "overlap_n", ")", "]", "return", "oligos", ",", "overlaps", ",", "overlap_tms", ",", "overlap_indices" ]

[ "Grows", "equidistant", "overlaps", "until", "they", "meet", "specified", "constraints", "." ]

[ "def", "_recalculate_overlaps", "(", "dna", ",", "overlaps", ",", "oligo_indices", ")", ":", "for", "i", ",", "overlap", "in", "enumerate", "(", "overlaps", ")", ":", "first_index", "=", "oligo_indices", "[", "0", "]", "[", "i", "+", "1", "]", "second_index", "=", "oligo_indices", "[", "1", "]", "[", "i", "]", "overlap", "=", "dna", "[", "first_index", ":", "second_index", "]", "overlaps", "[", "i", "]", "=", "overlap", "return", "overlaps" ]

[ "Recalculate", "overlap", "sequences", "based", "on", "the", "current", "overlap", "indices", "." ]

[ "def", "_expand_overlap", "(", "dna", ",", "oligo_indices", ",", "index", ",", "oligos", ",", "length_max", ")", ":", "left_len", "=", "len", "(", "oligos", "[", "index", "]", ")", "right_len", "=", "len", "(", "oligos", "[", "index", "+", "1", "]", ")", "# If one of the oligos is max size, increase the other one", "if", "right_len", "==", "length_max", ":", "oligo_indices", "[", "1", "]", "=", "_adjust_overlap", "(", "oligo_indices", "[", "1", "]", ",", "index", ",", "'right'", ")", "elif", "left_len", "==", "length_max", ":", "oligo_indices", "[", "0", "]", "=", "_adjust_overlap", "(", "oligo_indices", "[", "0", "]", ",", "index", ",", "'left'", ")", "else", ":", "if", "left_len", ">", "right_len", ":", "oligo_indices", "[", "0", "]", "=", "_adjust_overlap", "(", "oligo_indices", "[", "0", "]", ",", "index", ",", "'left'", ")", "else", ":", "oligo_indices", "[", "1", "]", "=", "_adjust_overlap", "(", "oligo_indices", "[", "1", "]", ",", "index", ",", "'right'", ")", "# Recalculate oligos from start and end indices", "oligos", "=", "[", "dna", "[", "start", ":", "end", "]", "for", "start", ",", "end", "in", "zip", "(", "*", "oligo_indices", ")", "]", "return", "oligos" ]

[ "Given", "an", "overlap", "to", "increase", "increases", "smaller", "oligo", "." ]

[ "def", "_adjust_overlap", "(", "positions_list", ",", "index", ",", "direction", ")", ":", "if", "direction", "==", "'left'", ":", "positions_list", "[", "index", "+", "1", "]", "-=", "1", "elif", "direction", "==", "'right'", ":", "positions_list", "[", "index", "]", "+=", "1", "else", ":", "raise", "ValueError", "(", "'direction must be \\'left\\' or \\'right\\'.'", ")", "return", "positions_list" ]

[ "Increase", "overlap", "to", "the", "right", "or", "left", "of", "an", "index", "." ]

[ "def", "design_assembly", "(", "self", ")", ":", "# Input parameters needed to design the oligos", "length_range", "=", "self", ".", "kwargs", "[", "'length_range'", "]", "oligo_number", "=", "self", ".", "kwargs", "[", "'oligo_number'", "]", "require_even", "=", "self", ".", "kwargs", "[", "'require_even'", "]", "melting_temp", "=", "self", ".", "kwargs", "[", "'tm'", "]", "overlap_min", "=", "self", ".", "kwargs", "[", "'overlap_min'", "]", "min_exception", "=", "self", ".", "kwargs", "[", "'min_exception'", "]", "start_5", "=", "self", ".", "kwargs", "[", "'start_5'", "]", "if", "len", "(", "self", ".", "template", ")", "<", "length_range", "[", "0", "]", ":", "# If sequence can be built with just two oligos, do that", "oligos", "=", "[", "self", ".", "template", ",", "self", ".", "template", ".", "reverse_complement", "(", ")", "]", "overlaps", "=", "[", "self", ".", "template", "]", "overlap_tms", "=", "[", "coral", ".", "analysis", ".", "tm", "(", "self", ".", "template", ")", "]", "assembly_dict", "=", "{", "'oligos'", ":", "oligos", ",", "'overlaps'", ":", "overlaps", ",", "'overlap_tms'", ":", "overlap_tms", "}", "self", ".", "oligos", "=", "assembly_dict", "[", "'oligos'", "]", "self", ".", "overlaps", "=", "assembly_dict", "[", "'overlaps'", "]", "self", ".", "overlap_tms", "=", "assembly_dict", "[", "'overlap_tms'", "]", "return", "assembly_dict", "if", "oligo_number", ":", "# Make first attempt using length_range[1] and see what happens", "step", "=", "3", "# Decrease max range by this amount each iteration", "length_max", "=", "length_range", "[", "1", "]", "current_oligo_n", "=", "oligo_number", "+", "1", "oligo_n_met", "=", "False", "above_min_len", "=", "length_max", ">", "length_range", "[", "0", "]", "if", "oligo_n_met", "or", "not", "above_min_len", ":", "raise", "Exception", "(", "'Failed to design assembly.'", ")", "while", "not", "oligo_n_met", "and", "above_min_len", ":", "# Starting with low range and going up doesnt work for longer", "# sequence (overlaps become longer than 80)", "assembly", "=", "_grow_overlaps", "(", "self", ".", "template", ",", "melting_temp", ",", "require_even", ",", "length_max", ",", "overlap_min", ",", "min_exception", ")", "current_oligo_n", "=", "len", "(", "assembly", "[", "0", "]", ")", "if", "current_oligo_n", ">", "oligo_number", ":", "break", "length_max", "-=", "step", "oligo_n_met", "=", "current_oligo_n", "==", "oligo_number", "else", ":", "assembly", "=", "_grow_overlaps", "(", "self", ".", "template", ",", "melting_temp", ",", "require_even", ",", "length_range", "[", "1", "]", ",", "overlap_min", ",", "min_exception", ")", "oligos", ",", "overlaps", ",", "overlap_tms", ",", "overlap_indices", "=", "assembly", "if", "start_5", ":", "for", "i", "in", "[", "x", "for", "x", "in", "range", "(", "len", "(", "oligos", ")", ")", "if", "x", "%", "2", "==", "1", "]", ":", "oligos", "[", "i", "]", "=", "oligos", "[", "i", "]", ".", "reverse_complement", "(", ")", "else", ":", "for", "i", "in", "[", "x", "for", "x", "in", "range", "(", "len", "(", "oligos", ")", ")", "if", "x", "%", "2", "==", "0", "]", ":", "oligos", "[", "i", "]", "=", "oligos", "[", "i", "]", ".", "reverse_complement", "(", ")", "# Make single-stranded", "oligos", "=", "[", "oligo", ".", "top", "for", "oligo", "in", "oligos", "]", "assembly_dict", "=", "{", "'oligos'", ":", "oligos", ",", "'overlaps'", ":", "overlaps", ",", "'overlap_tms'", ":", "overlap_tms", ",", "'overlap_indices'", ":", "overlap_indices", "}", "self", ".", "oligos", "=", "assembly_dict", "[", "'oligos'", "]", "self", ".", "overlaps", "=", "assembly_dict", "[", "'overlaps'", "]", "self", ".", "overlap_tms", "=", "assembly_dict", "[", "'overlap_tms'", "]", "self", ".", "overlap_indices", "=", "assembly_dict", "[", "'overlap_indices'", "]", "for", "i", "in", "range", "(", "len", "(", "self", ".", "overlap_indices", ")", "-", "1", ")", ":", "# TODO: either raise an exception or prevent this from happening", "# at all", "current_start", "=", "self", ".", "overlap_indices", "[", "i", "+", "1", "]", "[", "0", "]", "current_end", "=", "self", ".", "overlap_indices", "[", "i", "]", "[", "1", "]", "if", "current_start", "<=", "current_end", ":", "self", ".", "warning", "=", "'warning: overlapping overlaps!'", "print", "self", ".", "warning", "self", ".", "_has_run", "=", "True", "return", "assembly_dict" ]

[ "Design", "the", "overlapping", "oligos", "." ]

[ "def", "primers", "(", "self", ",", "tm", "=", "60", ")", ":", "self", ".", "primers", "=", "coral", ".", "design", ".", "primers", "(", "self", ".", "template", ",", "tm", "=", "tm", ")", "return", "self", ".", "primers" ]

[ "Design", "primers", "for", "amplifying", "the", "assembled", "sequence", "." ]

[ "def", "write", "(", "self", ",", "path", ")", ":", "with", "open", "(", "path", ",", "'wb'", ")", "as", "oligo_file", ":", "oligo_writer", "=", "csv", ".", "writer", "(", "oligo_file", ",", "delimiter", "=", "','", ",", "quoting", "=", "csv", ".", "QUOTE_MINIMAL", ")", "oligo_writer", ".", "writerow", "(", "[", "'name'", ",", "'oligo'", ",", "'notes'", "]", ")", "for", "i", ",", "oligo", "in", "enumerate", "(", "self", ".", "oligos", ")", ":", "name", "=", "'oligo {}'", ".", "format", "(", "i", "+", "1", ")", "oligo_len", "=", "len", "(", "oligo", ")", "if", "i", "!=", "len", "(", "self", ".", "oligos", ")", "-", "1", ":", "oligo_tm", "=", "self", ".", "overlap_tms", "[", "i", "]", "notes", "=", "'oligo length: {}, '", ".", "format", "(", "oligo_len", ")", "+", "'overlap Tm: {:.2f}'", ".", "format", "(", "oligo_tm", ")", "else", ":", "notes", "=", "'oligo length: {}'", ".", "format", "(", "oligo_len", ")", "oligo_writer", ".", "writerow", "(", "[", "name", ",", "oligo", ",", "notes", "]", ")", "if", "self", ".", "primers", ":", "for", "i", ",", "(", "primer", ",", "melt", ")", "in", "enumerate", "(", "self", ".", "primers", ")", ":", "oligo_writer", ".", "writerow", "(", "[", "'primer {}'", ".", "format", "(", "i", "+", "1", ")", ",", "primer", ",", "'Tm: {:.2f}'", ".", "format", "(", "melt", ")", "]", ")" ]

[ "Write", "assembly", "oligos", "and", "(", "if", "applicable", ")", "primers", "to", "csv", "." ]

[ "def", "write_map", "(", "self", ",", "path", ")", ":", "starts", "=", "[", "index", "[", "0", "]", "for", "index", "in", "self", ".", "overlap_indices", "]", "features", "=", "[", "]", "for", "i", ",", "start", "in", "enumerate", "(", "starts", ")", ":", "stop", "=", "start", "+", "len", "(", "self", ".", "overlaps", "[", "i", "]", ")", "name", "=", "'overlap {}'", ".", "format", "(", "i", "+", "1", ")", "feature_type", "=", "'misc'", "strand", "=", "0", "features", ".", "append", "(", "coral", ".", "Feature", "(", "name", ",", "start", ",", "stop", ",", "feature_type", ",", "strand", "=", "strand", ")", ")", "seq_map", "=", "coral", ".", "DNA", "(", "self", ".", "template", ",", "features", "=", "features", ")", "coral", ".", "seqio", ".", "write_dna", "(", "seq_map", ",", "path", ")" ]

[ "Write", "genbank", "map", "that", "highlights", "overlaps", "." ]

[ "def", "coding_sequence", "(", "rna", ")", ":", "if", "isinstance", "(", "rna", ",", "coral", ".", "DNA", ")", ":", "rna", "=", "transcribe", "(", "rna", ")", "codons_left", "=", "len", "(", "rna", ")", "//", "3", "start_codon", "=", "coral", ".", "RNA", "(", "'aug'", ")", "stop_codons", "=", "[", "coral", ".", "RNA", "(", "'uag'", ")", ",", "coral", ".", "RNA", "(", "'uga'", ")", ",", "coral", ".", "RNA", "(", "'uaa'", ")", "]", "start", "=", "None", "stop", "=", "None", "valid", "=", "[", "None", ",", "None", "]", "index", "=", "0", "while", "codons_left", ":", "codon", "=", "rna", "[", "index", ":", "index", "+", "3", "]", "if", "valid", "[", "0", "]", "is", "None", ":", "if", "codon", "in", "start_codon", ":", "start", "=", "index", "valid", "[", "0", "]", "=", "True", "else", ":", "if", "codon", "in", "stop_codons", ":", "stop", "=", "index", "+", "3", "valid", "[", "1", "]", "=", "True", "break", "index", "+=", "3", "codons_left", "-=", "1", "if", "valid", "[", "0", "]", "is", "None", ":", "raise", "ValueError", "(", "'Sequence has no start codon.'", ")", "elif", "stop", "is", "None", ":", "raise", "ValueError", "(", "'Sequence has no stop codon.'", ")", "coding_rna", "=", "rna", "[", "start", ":", "stop", "]", "return", "coding_rna" ]

[ "Extract", "coding", "sequence", "from", "an", "RNA", "template", "." ]

[ "def", "update", "(", "self", ")", ":", "# Download http://rebase.neb.com/rebase/link_withref to tmp", "self", ".", "_tmpdir", "=", "tempfile", ".", "mkdtemp", "(", ")", "try", ":", "self", ".", "_rebase_file", "=", "self", ".", "_tmpdir", "+", "'/rebase_file'", "print", "'Downloading latest enzyme definitions'", "url", "=", "'http://rebase.neb.com/rebase/link_withref'", "header", "=", "{", "'User-Agent'", ":", "'Mozilla/5.0'", "}", "req", "=", "urllib2", ".", "Request", "(", "url", ",", "headers", "=", "header", ")", "con", "=", "urllib2", ".", "urlopen", "(", "req", ")", "with", "open", "(", "self", ".", "_rebase_file", ",", "'wb'", ")", "as", "rebase_file", ":", "rebase_file", ".", "write", "(", "con", ".", "read", "(", ")", ")", "# Process into self._enzyme_dict", "self", ".", "_process_file", "(", ")", "except", "urllib2", ".", "HTTPError", ",", "e", ":", "print", "'HTTP Error: {} {}'", ".", "format", "(", "e", ".", "code", ",", "url", ")", "print", "'Falling back on default enzyme list'", "self", ".", "_enzyme_dict", "=", "coral", ".", "constants", ".", "fallback_enzymes", "except", "urllib2", ".", "URLError", ",", "e", ":", "print", "'URL Error: {} {}'", ".", "format", "(", "e", ".", "reason", ",", "url", ")", "print", "'Falling back on default enzyme list'", "self", ".", "_enzyme_dict", "=", "coral", ".", "constants", ".", "fallback_enzymes", "# Process into RestrictionSite objects? (depends on speed)", "print", "'Processing into RestrictionSite instances.'", "self", ".", "restriction_sites", "=", "{", "}", "# TODO: make sure all names are unique", "for", "key", ",", "(", "site", ",", "cuts", ")", "in", "self", ".", "_enzyme_dict", ".", "iteritems", "(", ")", ":", "# Make a site", "try", ":", "r", "=", "coral", ".", "RestrictionSite", "(", "coral", ".", "DNA", "(", "site", ")", ",", "cuts", ",", "name", "=", "key", ")", "# Add it to dict with name as key", "self", ".", "restriction_sites", "[", "key", "]", "=", "r", "except", "ValueError", ":", "# Encountered ambiguous sequence, have to ignore it until", "# coral.DNA can handle ambiguous DNA", "pass" ]

[ "Update", "definitions", "." ]

[ "def", "_process_file", "(", "self", ")", ":", "print", "'Processing file'", "with", "open", "(", "self", ".", "_rebase_file", ",", "'r'", ")", "as", "f", ":", "raw", "=", "f", ".", "readlines", "(", ")", "names", "=", "[", "line", ".", "strip", "(", ")", "[", "3", ":", "]", "for", "line", "in", "raw", "if", "line", ".", "startswith", "(", "'<1>'", ")", "]", "seqs", "=", "[", "line", ".", "strip", "(", ")", "[", "3", ":", "]", "for", "line", "in", "raw", "if", "line", ".", "startswith", "(", "'<5>'", ")", "]", "if", "len", "(", "names", ")", "!=", "len", "(", "seqs", ")", ":", "raise", "Exception", "(", "'Found different number of enzyme names and '", "'sequences.'", ")", "self", ".", "_enzyme_dict", "=", "{", "}", "for", "name", ",", "seq", "in", "zip", "(", "names", ",", "seqs", ")", ":", "if", "'?'", "in", "seq", ":", "# Is unknown sequence, don't keep it", "pass", "elif", "seq", ".", "startswith", "(", "'('", ")", "and", "seq", ".", "endswith", "(", "')'", ")", ":", "# Has four+ cut sites, don't keep it", "pass", "elif", "'^'", "in", "seq", ":", "# Has reasonable internal cut sites, keep it", "top_cut", "=", "seq", ".", "index", "(", "'^'", ")", "bottom_cut", "=", "len", "(", "seq", ")", "-", "top_cut", "-", "1", "site", "=", "seq", ".", "replace", "(", "'^'", ",", "''", ")", "self", ".", "_enzyme_dict", "[", "name", "]", "=", "(", "site", ",", "(", "top_cut", ",", "bottom_cut", ")", ")", "elif", "seq", ".", "endswith", "(", "')'", ")", ":", "# Has reasonable external cut sites, keep it", "# (4-cutter also starts with '(')", "# separate site and cut locations", "site", ",", "cuts", "=", "seq", ".", "split", "(", "'('", ")", "cuts", "=", "cuts", ".", "replace", "(", "')'", ",", "''", ")", "top_cut", ",", "bottom_cut", "=", "[", "int", "(", "x", ")", "+", "len", "(", "site", ")", "for", "x", "in", "cuts", ".", "split", "(", "'/'", ")", "]", "self", ".", "_enzyme_dict", "[", "name", "]", "=", "(", "site", ",", "(", "top_cut", ",", "bottom_cut", ")", ")", "shutil", ".", "rmtree", "(", "self", ".", "_tmpdir", ")" ]

[ "Process", "rebase", "file", "into", "dict", "with", "name", "and", "cut", "site", "information", "." ]

[ "def", "copy", "(", "self", ")", ":", "return", "type", "(", "self", ")", "(", "str", "(", "self", ".", "_sequence", ")", ",", "features", "=", "self", ".", "features", ",", "run_checks", "=", "False", ")" ]

[ "Create", "a", "copy", "of", "the", "current", "instance", "." ]

[ "def", "tempdir", "(", "fun", ")", ":", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "self", "=", "args", "[", "0", "]", "if", "os", ".", "path", ".", "isdir", "(", "self", ".", "_tempdir", ")", ":", "shutil", ".", "rmtree", "(", "self", ".", "_tempdir", ")", "self", ".", "_tempdir", "=", "tempfile", ".", "mkdtemp", "(", ")", "# If the method raises an exception, delete the temporary dir", "try", ":", "retval", "=", "fun", "(", "*", "args", ",", "*", "*", "kwargs", ")", "finally", ":", "shutil", ".", "rmtree", "(", "self", ".", "_tempdir", ")", "if", "os", ".", "path", ".", "isdir", "(", "self", ".", "_tempdir", ")", ":", "shutil", ".", "rmtree", "(", "self", ".", "_tempdir", ")", "return", "retval", "return", "wrapper" ]

[ "For", "use", "as", "a", "decorator", "of", "instance", "methods", "-", "creates", "a", "temporary", "dir", "named", "self", ".", "_tempdir", "and", "then", "deletes", "it", "after", "the", "method", "runs", "." ]

[ "def", "convert_sequence", "(", "seq", ",", "to_material", ")", ":", "if", "isinstance", "(", "seq", ",", "coral", ".", "DNA", ")", "and", "to_material", "==", "'rna'", ":", "# Transcribe", "# Can't transcribe a gap", "if", "'-'", "in", "seq", ":", "raise", "ValueError", "(", "'Cannot transcribe gapped DNA'", ")", "# Convert DNA chars to RNA chars", "origin", "=", "ALPHABETS", "[", "'dna'", "]", "[", ":", "-", "1", "]", "destination", "=", "ALPHABETS", "[", "'rna'", "]", "code", "=", "dict", "(", "zip", "(", "origin", ",", "destination", ")", ")", "converted", "=", "''", ".", "join", "(", "[", "code", ".", "get", "(", "str", "(", "k", ")", ",", "str", "(", "k", ")", ")", "for", "k", "in", "seq", "]", ")", "# Instantiate RNA object", "converted", "=", "coral", ".", "RNA", "(", "converted", ")", "elif", "isinstance", "(", "seq", ",", "coral", ".", "RNA", ")", ":", "if", "to_material", "==", "'dna'", ":", "# Reverse transcribe", "origin", "=", "ALPHABETS", "[", "'rna'", "]", "destination", "=", "ALPHABETS", "[", "'dna'", "]", "[", ":", "-", "1", "]", "code", "=", "dict", "(", "zip", "(", "origin", ",", "destination", ")", ")", "converted", "=", "''", ".", "join", "(", "[", "code", ".", "get", "(", "str", "(", "k", ")", ",", "str", "(", "k", ")", ")", "for", "k", "in", "seq", "]", ")", "# Instantiate DNA object", "converted", "=", "coral", ".", "DNA", "(", "converted", ")", "elif", "to_material", "==", "'peptide'", ":", "# Translate", "seq_list", "=", "list", "(", "str", "(", "seq", ")", ")", "# Convert to peptide until stop codon is found.", "converted", "=", "[", "]", "while", "True", ":", "if", "len", "(", "seq_list", ")", ">=", "3", ":", "base_1", "=", "seq_list", ".", "pop", "(", "0", ")", "base_2", "=", "seq_list", ".", "pop", "(", "0", ")", "base_3", "=", "seq_list", ".", "pop", "(", "0", ")", "codon", "=", "''", ".", "join", "(", "base_1", "+", "base_2", "+", "base_3", ")", ".", "upper", "(", ")", "amino_acid", "=", "CODONS", "[", "codon", "]", "# Stop when stop codon is found", "if", "amino_acid", "==", "'*'", ":", "break", "converted", ".", "append", "(", "amino_acid", ")", "else", ":", "break", "converted", "=", "''", ".", "join", "(", "converted", ")", "converted", "=", "coral", ".", "Peptide", "(", "converted", ")", "else", ":", "msg1", "=", "'Conversion from '", "msg2", "=", "'{0} to {1} is not supported.'", ".", "format", "(", "seq", ".", "__class__", ".", "__name__", ",", "to_material", ")", "raise", "ValueError", "(", "msg1", "+", "msg2", ")", "return", "converted" ]

[ "Translate", "a", "DNA", "sequence", "into", "peptide", "sequence", "." ]

[ "def", "gc", "(", "self", ")", ":", "gc", "=", "len", "(", "[", "base", "for", "base", "in", "self", ".", "seq", "if", "base", "==", "'C'", "or", "base", "==", "'G'", "]", ")", "return", "float", "(", "gc", ")", "/", "len", "(", "self", ")" ]

[ "Find", "the", "frequency", "of", "G", "and", "C", "in", "the", "current", "sequence", "." ]

[ "def", "is_rotation", "(", "self", ",", "other", ")", ":", "if", "len", "(", "self", ")", "!=", "len", "(", "other", ")", ":", "return", "False", "for", "i", "in", "range", "(", "len", "(", "self", ")", ")", ":", "if", "self", ".", "rotate", "(", "i", ")", "==", "other", ":", "return", "True", "return", "False" ]

[ "Determine", "whether", "two", "sequences", "are", "the", "same", "just", "at", "different", "rotations", "." ]

[ "def", "linearize", "(", "self", ",", "index", "=", "0", ")", ":", "if", "not", "self", ".", "circular", "and", "index", "!=", "0", ":", "raise", "ValueError", "(", "'Cannot relinearize a linear sequence.'", ")", "copy", "=", "self", ".", "copy", "(", ")", "# Snip at the index", "if", "index", ":", "return", "copy", "[", "index", ":", "]", "+", "copy", "[", ":", "index", "]", "copy", ".", "circular", "=", "False", "return", "copy" ]

[ "Linearize", "the", "Sequence", "at", "an", "index", "." ]

[ "def", "locate", "(", "self", ",", "pattern", ")", ":", "if", "self", ".", "circular", ":", "if", "len", "(", "pattern", ")", ">=", "2", "*", "len", "(", "self", ")", ":", "raise", "ValueError", "(", "'Search pattern longer than searchable '", "+", "'sequence.'", ")", "seq", "=", "self", "+", "self", "[", ":", "len", "(", "pattern", ")", "-", "1", "]", "return", "super", "(", "NucleicAcid", ",", "seq", ")", ".", "locate", "(", "pattern", ")", "else", ":", "return", "super", "(", "NucleicAcid", ",", "self", ")", ".", "locate", "(", "pattern", ")" ]

[ "Find", "sequences", "matching", "a", "pattern", "." ]

[ "def", "mw", "(", "self", ")", ":", "counter", "=", "collections", ".", "Counter", "(", "self", ".", "seq", ".", "lower", "(", ")", ")", "mw_a", "=", "counter", "[", "'a'", "]", "*", "313.2", "mw_t", "=", "counter", "[", "'t'", "]", "*", "304.2", "mw_g", "=", "counter", "[", "'g'", "]", "*", "289.2", "mw_c", "=", "counter", "[", "'c'", "]", "*", "329.2", "mw_u", "=", "counter", "[", "'u'", "]", "*", "306.2", "if", "self", ".", "material", "==", "'dna'", ":", "return", "mw_a", "+", "mw_t", "+", "mw_g", "+", "mw_c", "+", "79.0", "else", ":", "return", "mw_a", "+", "mw_u", "+", "mw_g", "+", "mw_c", "+", "159.0" ]

[ "Calculate", "the", "molecular", "weight", "." ]

[ "def", "rotate", "(", "self", ",", "n", ")", ":", "if", "not", "self", ".", "circular", "and", "n", "!=", "0", ":", "raise", "ValueError", "(", "'Cannot rotate a linear sequence'", ")", "else", ":", "rotated", "=", "self", "[", "-", "n", ":", "]", "+", "self", "[", ":", "-", "n", "]", "return", "rotated", ".", "circularize", "(", ")" ]

[ "Rotate", "Sequence", "by", "n", "bases", "." ]

[ "def", "five_resect", "(", "dna", ",", "n_bases", ")", ":", "new_instance", "=", "dna", ".", "copy", "(", ")", "if", "n_bases", ">=", "len", "(", "dna", ")", ":", "new_instance", ".", "top", ".", "seq", "=", "''", ".", "join", "(", "[", "'-'", "for", "i", "in", "range", "(", "len", "(", "dna", ")", ")", "]", ")", "else", ":", "new_instance", ".", "top", ".", "seq", "=", "'-'", "*", "n_bases", "+", "str", "(", "dna", ")", "[", "n_bases", ":", "]", "new_instance", "=", "_remove_end_gaps", "(", "new_instance", ")", "return", "new_instance" ]

[ "Remove", "bases", "from", "5", "end", "of", "top", "strand", "." ]

[ "def", "_remove_end_gaps", "(", "sequence", ")", ":", "# Count terminal blank sequences", "def", "count_end_gaps", "(", "seq", ")", ":", "gap", "=", "coral", ".", "DNA", "(", "'-'", ")", "count", "=", "0", "for", "base", "in", "seq", ":", "if", "base", "==", "gap", ":", "count", "+=", "1", "else", ":", "break", "return", "count", "top_left", "=", "count_end_gaps", "(", "sequence", ".", "top", ")", "top_right", "=", "count_end_gaps", "(", "reversed", "(", "sequence", ".", "top", ")", ")", "bottom_left", "=", "count_end_gaps", "(", "reversed", "(", "sequence", ".", "bottom", ")", ")", "bottom_right", "=", "count_end_gaps", "(", "sequence", ".", "bottom", ")", "# Trim sequence", "left_index", "=", "min", "(", "top_left", ",", "bottom_left", ")", "right_index", "=", "len", "(", "sequence", ")", "-", "min", "(", "top_right", ",", "bottom_right", ")", "return", "sequence", "[", "left_index", ":", "right_index", "]" ]

[ "Removes", "double", "-", "stranded", "gaps", "from", "ends", "of", "the", "sequence", "." ]

[ "def", "needle", "(", "reference", ",", "query", ",", "gap_open", "=", "-", "15", ",", "gap_extend", "=", "0", ",", "matrix", "=", "submat", ".", "DNA_SIMPLE", ")", ":", "# Align using cython Needleman-Wunsch", "aligned_ref", ",", "aligned_res", "=", "aligner", "(", "str", "(", "reference", ")", ",", "str", "(", "query", ")", ",", "gap_open", "=", "gap_open", ",", "gap_extend", "=", "gap_extend", ",", "method", "=", "'global_cfe'", ",", "matrix", "=", "matrix", ".", "matrix", ",", "alphabet", "=", "matrix", ".", "alphabet", ")", "# Score the alignment", "score", "=", "score_alignment", "(", "aligned_ref", ",", "aligned_res", ",", "gap_open", ",", "gap_extend", ",", "matrix", ".", "matrix", ",", "matrix", ".", "alphabet", ")", "return", "cr", ".", "DNA", "(", "aligned_ref", ")", ",", "cr", ".", "DNA", "(", "aligned_res", ")", ",", "score" ]

[ "Do", "a", "Needleman", "-", "Wunsch", "alignment", "." ]

[ "def", "needle_msa", "(", "reference", ",", "results", ",", "gap_open", "=", "-", "15", ",", "gap_extend", "=", "0", ",", "matrix", "=", "submat", ".", "DNA_SIMPLE", ")", ":", "gap", "=", "'-'", "# Convert alignments to list of strings", "alignments", "=", "[", "]", "for", "result", "in", "results", ":", "ref_dna", ",", "res_dna", ",", "score", "=", "needle", "(", "reference", ",", "result", ",", "gap_open", "=", "gap_open", ",", "gap_extend", "=", "gap_extend", ",", "matrix", "=", "matrix", ")", "alignments", ".", "append", "(", "[", "str", "(", "ref_dna", ")", ",", "str", "(", "res_dna", ")", ",", "score", "]", ")", "def", "insert_gap", "(", "sequence", ",", "position", ")", ":", "return", "sequence", "[", ":", "position", "]", "+", "gap", "+", "sequence", "[", "position", ":", "]", "i", "=", "0", "while", "True", ":", "# Iterate over 'columns' in every reference", "refs", "=", "[", "alignment", "[", "0", "]", "[", "i", "]", "for", "alignment", "in", "alignments", "]", "# If there's a non-unanimous gap, insert gap into alignments", "gaps", "=", "[", "ref", "==", "gap", "for", "ref", "in", "refs", "]", "if", "any", "(", "gaps", ")", "and", "not", "all", "(", "gaps", ")", ":", "for", "alignment", "in", "alignments", ":", "if", "alignment", "[", "0", "]", "[", "i", "]", "!=", "gap", ":", "alignment", "[", "0", "]", "=", "insert_gap", "(", "alignment", "[", "0", "]", ",", "i", ")", "alignment", "[", "1", "]", "=", "insert_gap", "(", "alignment", "[", "1", "]", ",", "i", ")", "# If all references match, we're all done", "alignment_set", "=", "set", "(", "alignment", "[", "0", "]", "for", "alignment", "in", "alignments", ")", "if", "len", "(", "alignment_set", ")", "==", "1", ":", "break", "# If we've reach the end of some, but not all sequences, add end gap", "lens", "=", "[", "len", "(", "alignment", "[", "0", "]", ")", "for", "alignment", "in", "alignments", "]", "if", "i", "+", "1", "in", "lens", ":", "for", "alignment", "in", "alignments", ":", "if", "len", "(", "alignment", "[", "0", "]", ")", "==", "i", "+", "1", ":", "alignment", "[", "0", "]", "=", "alignment", "[", "0", "]", "+", "gap", "alignment", "[", "1", "]", "=", "alignment", "[", "1", "]", "+", "gap", "i", "+=", "1", "if", "i", ">", "20", ":", "break", "# Convert into MSA format", "output_alignment", "=", "[", "cr", ".", "DNA", "(", "alignments", "[", "0", "]", "[", "0", "]", ")", "]", "for", "alignment", "in", "alignments", ":", "output_alignment", ".", "append", "(", "cr", ".", "DNA", "(", "alignment", "[", "1", "]", ")", ")", "return", "output_alignment" ]

[ "Create", "a", "multiple", "sequence", "alignment", "based", "on", "aligning", "every", "result", "sequence", "against", "the", "reference", "then", "inserting", "gaps", "until", "every", "aligned", "reference", "is", "identical" ]

[ "def", "needle_multi", "(", "references", ",", "queries", ",", "gap_open", "=", "-", "15", ",", "gap_extend", "=", "0", ",", "matrix", "=", "submat", ".", "DNA_SIMPLE", ")", ":", "pool", "=", "multiprocessing", ".", "Pool", "(", ")", "try", ":", "args_list", "=", "[", "[", "ref", ",", "que", ",", "gap_open", ",", "gap_extend", ",", "matrix", "]", "for", "ref", ",", "que", "in", "zip", "(", "references", ",", "queries", ")", "]", "aligned", "=", "pool", ".", "map", "(", "run_needle", ",", "args_list", ")", "except", "KeyboardInterrupt", ":", "print", "(", "'Caught KeyboardInterrupt, terminating workers'", ")", "pool", ".", "terminate", "(", ")", "pool", ".", "join", "(", ")", "raise", "KeyboardInterrupt", "return", "aligned" ]

[ "Batch", "process", "of", "sequencing", "split", "over", "several", "cores", ".", "Acts", "just", "like", "needle", "but", "sequence", "inputs", "are", "lists", "." ]

[ "def", "import_global", "(", "name", ",", "modules", "=", "None", ",", "exceptions", "=", "DummyException", ",", "locals_", "=", "None", ",", "globals_", "=", "None", ",", "level", "=", "-", "1", ")", ":", "frame", "=", "None", "try", ":", "# If locals_ or globals_ are not given, autodetect them by inspecting", "# the current stack", "if", "locals_", "is", "None", "or", "globals_", "is", "None", ":", "import", "inspect", "frame", "=", "inspect", ".", "stack", "(", ")", "[", "1", "]", "[", "0", "]", "if", "locals_", "is", "None", ":", "locals_", "=", "frame", ".", "f_locals", "if", "globals_", "is", "None", ":", "globals_", "=", "frame", ".", "f_globals", "try", ":", "name", "=", "name", ".", "split", "(", "'.'", ")", "# Relative imports are supported (from .spam import eggs)", "if", "not", "name", "[", "0", "]", ":", "name", "=", "name", "[", "1", ":", "]", "level", "=", "1", "# raise IOError((name, level))", "module", "=", "__import__", "(", "name", "=", "name", "[", "0", "]", "or", "'.'", ",", "globals", "=", "globals_", ",", "locals", "=", "locals_", ",", "fromlist", "=", "name", "[", "1", ":", "]", ",", "level", "=", "max", "(", "level", ",", "0", ")", ",", ")", "# Make sure we get the right part of a dotted import (i.e.", "# spam.eggs should return eggs, not spam)", "try", ":", "for", "attr", "in", "name", "[", "1", ":", "]", ":", "module", "=", "getattr", "(", "module", ",", "attr", ")", "except", "AttributeError", ":", "raise", "ImportError", "(", "'No module named '", "+", "'.'", ".", "join", "(", "name", ")", ")", "# If no list of modules is given, autodetect from either __all__", "# or a dir() of the module", "if", "not", "modules", ":", "modules", "=", "getattr", "(", "module", ",", "'__all__'", ",", "dir", "(", "module", ")", ")", "else", ":", "modules", "=", "set", "(", "modules", ")", ".", "intersection", "(", "dir", "(", "module", ")", ")", "# Add all items in modules to the global scope", "for", "k", "in", "set", "(", "dir", "(", "module", ")", ")", ".", "intersection", "(", "modules", ")", ":", "if", "k", "and", "k", "[", "0", "]", "!=", "'_'", ":", "globals_", "[", "k", "]", "=", "getattr", "(", "module", ",", "k", ")", "except", "exceptions", "as", "e", ":", "return", "e", "finally", ":", "# Clean up, just to be sure", "del", "name", ",", "modules", ",", "exceptions", ",", "locals_", ",", "globals_", ",", "frame" ]

[ "Import", "the", "requested", "items", "into", "the", "global", "scope" ]

[ "def", "camel_to_underscore", "(", "name", ")", ":", "output", "=", "[", "]", "for", "i", ",", "c", "in", "enumerate", "(", "name", ")", ":", "if", "i", ">", "0", ":", "pc", "=", "name", "[", "i", "-", "1", "]", "if", "c", ".", "isupper", "(", ")", "and", "not", "pc", ".", "isupper", "(", ")", "and", "pc", "!=", "'_'", ":", "# Uppercase and the previous character isn't upper/underscore?", "# Add the underscore", "output", ".", "append", "(", "'_'", ")", "elif", "i", ">", "3", "and", "not", "c", ".", "isupper", "(", ")", ":", "# Will return the last 3 letters to check if we are changing", "# case", "previous", "=", "name", "[", "i", "-", "3", ":", "i", "]", "if", "previous", ".", "isalpha", "(", ")", "and", "previous", ".", "isupper", "(", ")", ":", "output", ".", "insert", "(", "len", "(", "output", ")", "-", "1", ",", "'_'", ")", "output", ".", "append", "(", "c", ".", "lower", "(", ")", ")", "return", "''", ".", "join", "(", "output", ")" ]

[ "Convert", "camel", "case", "style", "naming", "to", "underscore", "style", "naming" ]

[ "def", "timesince", "(", "dt", ",", "default", "=", "'just now'", ")", ":", "if", "isinstance", "(", "dt", ",", "datetime", ".", "timedelta", ")", ":", "diff", "=", "dt", "else", ":", "now", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "diff", "=", "abs", "(", "now", "-", "dt", ")", "periods", "=", "(", "(", "diff", ".", "days", "/", "365", ",", "'year'", ",", "'years'", ")", ",", "(", "diff", ".", "days", "%", "365", "/", "30", ",", "'month'", ",", "'months'", ")", ",", "(", "diff", ".", "days", "%", "30", "/", "7", ",", "'week'", ",", "'weeks'", ")", ",", "(", "diff", ".", "days", "%", "7", ",", "'day'", ",", "'days'", ")", ",", "(", "diff", ".", "seconds", "/", "3600", ",", "'hour'", ",", "'hours'", ")", ",", "(", "diff", ".", "seconds", "%", "3600", "/", "60", ",", "'minute'", ",", "'minutes'", ")", ",", "(", "diff", ".", "seconds", "%", "60", ",", "'second'", ",", "'seconds'", ")", ",", ")", "output", "=", "[", "]", "for", "period", ",", "singular", ",", "plural", "in", "periods", ":", "if", "int", "(", "period", ")", ":", "if", "int", "(", "period", ")", "==", "1", ":", "output", ".", "append", "(", "'%d %s'", "%", "(", "period", ",", "singular", ")", ")", "else", ":", "output", ".", "append", "(", "'%d %s'", "%", "(", "period", ",", "plural", ")", ")", "if", "output", ":", "return", "'%s ago'", "%", "' and '", ".", "join", "(", "output", "[", ":", "2", "]", ")", "return", "default" ]

[ "Returns", "string", "representing", "time", "since", "e", ".", "g", ".", "3", "days", "ago", "5", "hours", "ago", "etc", "." ]

[ "def", "timedelta_to_seconds", "(", "delta", ")", ":", "# Only convert to float if needed", "if", "delta", ".", "microseconds", ":", "total", "=", "delta", ".", "microseconds", "*", "1e-6", "else", ":", "total", "=", "0", "total", "+=", "delta", ".", "seconds", "total", "+=", "delta", ".", "days", "*", "60", "*", "60", "*", "24", "return", "total" ]

[ "Convert", "a", "timedelta", "to", "seconds", "with", "the", "microseconds", "as", "fraction" ]

[ "def", "format_time", "(", "timestamp", ",", "precision", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "1", ")", ")", ":", "precision_seconds", "=", "precision", ".", "total_seconds", "(", ")", "if", "isinstance", "(", "timestamp", ",", "six", ".", "string_types", "+", "six", ".", "integer_types", "+", "(", "float", ",", ")", ")", ":", "try", ":", "castfunc", "=", "six", ".", "integer_types", "[", "-", "1", "]", "timestamp", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "castfunc", "(", "timestamp", ")", ")", "except", "OverflowError", ":", "# pragma: no cover", "timestamp", "=", "None", "if", "isinstance", "(", "timestamp", ",", "datetime", ".", "timedelta", ")", ":", "seconds", "=", "timestamp", ".", "total_seconds", "(", ")", "# Truncate the number to the given precision", "seconds", "=", "seconds", "-", "(", "seconds", "%", "precision_seconds", ")", "return", "str", "(", "datetime", ".", "timedelta", "(", "seconds", "=", "seconds", ")", ")", "elif", "isinstance", "(", "timestamp", ",", "datetime", ".", "datetime", ")", ":", "# Python 2 doesn't have the timestamp method", "if", "hasattr", "(", "timestamp", ",", "'timestamp'", ")", ":", "# pragma: no cover", "seconds", "=", "timestamp", ".", "timestamp", "(", ")", "else", ":", "seconds", "=", "timedelta_to_seconds", "(", "timestamp", "-", "epoch", ")", "# Truncate the number to the given precision", "seconds", "=", "seconds", "-", "(", "seconds", "%", "precision_seconds", ")", "try", ":", "# pragma: no cover", "if", "six", ".", "PY3", ":", "dt", "=", "datetime", ".", "datetime", ".", "fromtimestamp", "(", "seconds", ")", "else", ":", "dt", "=", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "seconds", ")", "except", "ValueError", ":", "# pragma: no cover", "dt", "=", "datetime", ".", "datetime", ".", "max", "return", "str", "(", "dt", ")", "elif", "isinstance", "(", "timestamp", ",", "datetime", ".", "date", ")", ":", "return", "str", "(", "timestamp", ")", "elif", "timestamp", "is", "None", ":", "return", "'--:--:--'", "else", ":", "raise", "TypeError", "(", "'Unknown type %s: %r'", "%", "(", "type", "(", "timestamp", ")", ",", "timestamp", ")", ")" ]

[ "Formats", "timedelta", "/", "datetime", "/", "seconds" ]

[ "def", "get_terminal_size", "(", ")", ":", "# pragma: no cover", "try", ":", "# Default to 79 characters for IPython notebooks", "from", "IPython", "import", "get_ipython", "ipython", "=", "get_ipython", "(", ")", "from", "ipykernel", "import", "zmqshell", "if", "isinstance", "(", "ipython", ",", "zmqshell", ".", "ZMQInteractiveShell", ")", ":", "return", "79", ",", "24", "except", "Exception", ":", "# pragma: no cover", "pass", "try", ":", "# This works for Python 3, but not Pypy3. Probably the best method if", "# it's supported so let's always try", "import", "shutil", "w", ",", "h", "=", "shutil", ".", "get_terminal_size", "(", ")", "if", "w", "and", "h", ":", "# The off by one is needed due to progressbars in some cases, for", "# safety we'll always substract it.", "return", "w", "-", "1", ",", "h", "except", "Exception", ":", "# pragma: no cover", "pass", "try", ":", "w", "=", "int", "(", "os", ".", "environ", ".", "get", "(", "'COLUMNS'", ")", ")", "h", "=", "int", "(", "os", ".", "environ", ".", "get", "(", "'LINES'", ")", ")", "if", "w", "and", "h", ":", "return", "w", ",", "h", "except", "Exception", ":", "# pragma: no cover", "pass", "try", ":", "import", "blessings", "terminal", "=", "blessings", ".", "Terminal", "(", ")", "w", "=", "terminal", ".", "width", "h", "=", "terminal", ".", "height", "if", "w", "and", "h", ":", "return", "w", ",", "h", "except", "Exception", ":", "# pragma: no cover", "pass", "try", ":", "w", ",", "h", "=", "_get_terminal_size_linux", "(", ")", "if", "w", "and", "h", ":", "return", "w", ",", "h", "except", "Exception", ":", "# pragma: no cover", "pass", "try", ":", "# Windows detection doesn't always work, let's try anyhow", "w", ",", "h", "=", "_get_terminal_size_windows", "(", ")", "if", "w", "and", "h", ":", "return", "w", ",", "h", "except", "Exception", ":", "# pragma: no cover", "pass", "try", ":", "# needed for window's python in cygwin's xterm!", "w", ",", "h", "=", "_get_terminal_size_tput", "(", ")", "if", "w", "and", "h", ":", "return", "w", ",", "h", "except", "Exception", ":", "# pragma: no cover", "pass", "return", "79", ",", "24" ]

[ "Get", "the", "current", "size", "of", "your", "terminal" ]

[ "def", "AsyncSearchUsers", "(", "self", ",", "Target", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_AsyncSearchUsersCommands'", ")", ":", "self", ".", "_AsyncSearchUsersCommands", "=", "[", "]", "self", ".", "RegisterEventHandler", "(", "'Reply'", ",", "self", ".", "_AsyncSearchUsersReplyHandler", ")", "command", "=", "Command", "(", "'SEARCH USERS %s'", "%", "tounicode", "(", "Target", ")", ",", "'USERS'", ",", "False", ",", "self", ".", "Timeout", ")", "self", ".", "_AsyncSearchUsersCommands", ".", "append", "(", "command", ")", "self", ".", "SendCommand", "(", "command", ")", "# return pCookie - search identifier", "return", "command", ".", "Id" ]

[ "Asynchronously", "searches", "for", "Skype", "users", "." ]

[ "def", "Attach", "(", "self", ",", "Protocol", "=", "5", ",", "Wait", "=", "True", ")", ":", "try", ":", "self", ".", "_Api", ".", "protocol", "=", "Protocol", "self", ".", "_Api", ".", "attach", "(", "self", ".", "Timeout", ",", "Wait", ")", "except", "SkypeAPIError", ":", "self", ".", "ResetCache", "(", ")", "raise" ]

[ "Establishes", "a", "connection", "to", "Skype", "." ]

[ "def", "Call", "(", "self", ",", "Id", "=", "0", ")", ":", "o", "=", "Call", "(", "self", ",", "Id", ")", "o", ".", "Status", "# Test if such a call exists.", "return", "o" ]

[ "Queries", "a", "call", "object", "." ]

[ "def", "ChangeUserStatus", "(", "self", ",", "Status", ")", ":", "if", "self", ".", "CurrentUserStatus", ".", "upper", "(", ")", "==", "Status", ".", "upper", "(", ")", ":", "return", "self", ".", "_ChangeUserStatus_Event", "=", "threading", ".", "Event", "(", ")", "self", ".", "_ChangeUserStatus_Status", "=", "Status", ".", "upper", "(", ")", "self", ".", "RegisterEventHandler", "(", "'UserStatus'", ",", "self", ".", "_ChangeUserStatus_UserStatus", ")", "self", ".", "CurrentUserStatus", "=", "Status", "self", ".", "_ChangeUserStatus_Event", ".", "wait", "(", ")", "self", ".", "UnregisterEventHandler", "(", "'UserStatus'", ",", "self", ".", "_ChangeUserStatus_UserStatus", ")", "del", "self", ".", "_ChangeUserStatus_Event", ",", "self", ".", "_ChangeUserStatus_Status" ]

[ "Changes", "the", "online", "status", "for", "the", "current", "user", "." ]

[ "def", "Chat", "(", "self", ",", "Name", "=", "''", ")", ":", "o", "=", "Chat", "(", "self", ",", "Name", ")", "o", ".", "Status", "# Tests if such a chat really exists.", "return", "o" ]

[ "Queries", "a", "chat", "object", "." ]

[ "def", "ClearCallHistory", "(", "self", ",", "Username", "=", "'ALL'", ",", "Type", "=", "chsAllCalls", ")", ":", "cmd", "=", "'CLEAR CALLHISTORY %s %s'", "%", "(", "str", "(", "Type", ")", ",", "Username", ")", "self", ".", "_DoCommand", "(", "cmd", ",", "cmd", ")" ]

[ "Clears", "the", "call", "history", "." ]

[ "def", "Command", "(", "self", ",", "Command", ",", "Reply", "=", "u''", ",", "Block", "=", "False", ",", "Timeout", "=", "30000", ",", "Id", "=", "-", "1", ")", ":", "from", "api", "import", "Command", "as", "CommandClass", "return", "CommandClass", "(", "Command", ",", "Reply", ",", "Block", ",", "Timeout", ",", "Id", ")" ]

[ "Creates", "an", "API", "command", "object", "." ]

[ "def", "Conference", "(", "self", ",", "Id", "=", "0", ")", ":", "o", "=", "Conference", "(", "self", ",", "Id", ")", "if", "Id", "<=", "0", "or", "not", "o", ".", "Calls", ":", "raise", "SkypeError", "(", "0", ",", "'Unknown conference'", ")", "return", "o" ]

[ "Queries", "a", "call", "conference", "object", "." ]

[ "def", "CreateChatWith", "(", "self", ",", "*", "Usernames", ")", ":", "return", "Chat", "(", "self", ",", "chop", "(", "self", ".", "_DoCommand", "(", "'CHAT CREATE %s'", "%", "', '", ".", "join", "(", "Usernames", ")", ")", ",", "2", ")", "[", "1", "]", ")" ]

[ "Creates", "a", "chat", "with", "one", "or", "more", "users", "." ]

[ "def", "CreateGroup", "(", "self", ",", "GroupName", ")", ":", "groups", "=", "self", ".", "CustomGroups", "self", ".", "_DoCommand", "(", "'CREATE GROUP %s'", "%", "tounicode", "(", "GroupName", ")", ")", "for", "g", "in", "self", ".", "CustomGroups", ":", "if", "g", "not", "in", "groups", "and", "g", ".", "DisplayName", "==", "GroupName", ":", "return", "g", "raise", "SkypeError", "(", "0", ",", "'Group creating failed'", ")" ]

[ "Creates", "a", "custom", "contact", "group", "." ]

[ "def", "CreateSms", "(", "self", ",", "MessageType", ",", "*", "TargetNumbers", ")", ":", "return", "SmsMessage", "(", "self", ",", "chop", "(", "self", ".", "_DoCommand", "(", "'CREATE SMS %s %s'", "%", "(", "MessageType", ",", "', '", ".", "join", "(", "TargetNumbers", ")", ")", ")", ",", "2", ")", "[", "1", "]", ")" ]

[ "Creates", "an", "SMS", "message", "." ]

[ "def", "Greeting", "(", "self", ",", "Username", "=", "''", ")", ":", "for", "v", "in", "self", ".", "Voicemails", ":", "if", "Username", "and", "v", ".", "PartnerHandle", "!=", "Username", ":", "continue", "if", "v", ".", "Type", "in", "(", "vmtDefaultGreeting", ",", "vmtCustomGreeting", ")", ":", "return", "v" ]

[ "Queries", "the", "greeting", "used", "as", "voicemail", "." ]

[ "def", "Message", "(", "self", ",", "Id", "=", "0", ")", ":", "o", "=", "ChatMessage", "(", "self", ",", "Id", ")", "o", ".", "Status", "# Test if such an id is known.", "return", "o" ]

[ "Queries", "a", "chat", "message", "object", "." ]

[ "def", "PlaceCall", "(", "self", ",", "*", "Targets", ")", ":", "calls", "=", "self", ".", "ActiveCalls", "reply", "=", "self", ".", "_DoCommand", "(", "'CALL %s'", "%", "', '", ".", "join", "(", "Targets", ")", ")", "# Skype for Windows returns the call status which gives us the call Id;", "if", "reply", ".", "startswith", "(", "'CALL '", ")", ":", "return", "Call", "(", "self", ",", "chop", "(", "reply", ",", "2", ")", "[", "1", "]", ")", "# On linux we get 'OK' as reply so we search for the new call on", "# list of active calls.", "for", "c", "in", "self", ".", "ActiveCalls", ":", "if", "c", "not", "in", "calls", ":", "return", "c", "raise", "SkypeError", "(", "0", ",", "'Placing call failed'", ")" ]

[ "Places", "a", "call", "to", "a", "single", "user", "or", "creates", "a", "conference", "call", "." ]

[ "def", "Property", "(", "self", ",", "ObjectType", ",", "ObjectId", ",", "PropName", ",", "Set", "=", "None", ")", ":", "return", "self", ".", "_Property", "(", "ObjectType", ",", "ObjectId", ",", "PropName", ",", "Set", ")" ]

[ "Queries", "/", "sets", "the", "properties", "of", "an", "object", "." ]

[ "def", "SendCommand", "(", "self", ",", "Command", ")", ":", "try", ":", "self", ".", "_Api", ".", "send_command", "(", "Command", ")", "except", "SkypeAPIError", ":", "self", ".", "ResetCache", "(", ")", "raise" ]

[ "Sends", "an", "API", "command", "." ]

[ "def", "SendSms", "(", "self", ",", "*", "TargetNumbers", ",", "*", "*", "Properties", ")", ":", "sms", "=", "self", ".", "CreateSms", "(", "smsMessageTypeOutgoing", ",", "*", "TargetNumbers", ")", "for", "name", ",", "value", "in", "Properties", ".", "items", "(", ")", ":", "if", "isinstance", "(", "getattr", "(", "sms", ".", "__class__", ",", "name", ",", "None", ")", ",", "property", ")", ":", "setattr", "(", "sms", ",", "name", ",", "value", ")", "else", ":", "raise", "TypeError", "(", "'Unknown property: %s'", "%", "prop", ")", "sms", ".", "Send", "(", ")", "return", "sms" ]

[ "Creates", "and", "sends", "an", "SMS", "message", "." ]

[ "def", "SendVoicemail", "(", "self", ",", "Username", ")", ":", "if", "self", ".", "_Api", ".", "protocol", ">=", "6", ":", "self", ".", "_DoCommand", "(", "'CALLVOICEMAIL %s'", "%", "Username", ")", "else", ":", "self", ".", "_DoCommand", "(", "'VOICEMAIL %s'", "%", "Username", ")" ]

[ "Sends", "a", "voicemail", "to", "a", "specified", "user", "." ]

[ "def", "User", "(", "self", ",", "Username", "=", "''", ")", ":", "if", "not", "Username", ":", "Username", "=", "self", ".", "CurrentUserHandle", "o", "=", "User", "(", "self", ",", "Username", ")", "o", ".", "OnlineStatus", "# Test if such a user exists.", "return", "o" ]

[ "Queries", "a", "user", "object", "." ]

[ "def", "Voicemail", "(", "self", ",", "Id", ")", ":", "o", "=", "Voicemail", "(", "self", ",", "Id", ")", "o", ".", "Type", "# Test if such a voicemail exists.", "return", "o" ]

[ "Queries", "the", "voicemail", "object", "." ]

[ "def", "Connect", "(", "self", ",", "Username", ",", "WaitConnected", "=", "False", ")", ":", "if", "WaitConnected", ":", "self", ".", "_Connect_Event", "=", "threading", ".", "Event", "(", ")", "self", ".", "_Connect_Stream", "=", "[", "None", "]", "self", ".", "_Connect_Username", "=", "Username", "self", ".", "_Connect_ApplicationStreams", "(", "self", ",", "self", ".", "Streams", ")", "self", ".", "_Owner", ".", "RegisterEventHandler", "(", "'ApplicationStreams'", ",", "self", ".", "_Connect_ApplicationStreams", ")", "self", ".", "_Alter", "(", "'CONNECT'", ",", "Username", ")", "self", ".", "_Connect_Event", ".", "wait", "(", ")", "self", ".", "_Owner", ".", "UnregisterEventHandler", "(", "'ApplicationStreams'", ",", "self", ".", "_Connect_ApplicationStreams", ")", "try", ":", "return", "self", ".", "_Connect_Stream", "[", "0", "]", "finally", ":", "del", "self", ".", "_Connect_Stream", ",", "self", ".", "_Connect_Event", ",", "self", ".", "_Connect_Username", "else", ":", "self", ".", "_Alter", "(", "'CONNECT'", ",", "Username", ")" ]

[ "Connects", "application", "to", "user", "." ]

[ "def", "SendDatagram", "(", "self", ",", "Text", ",", "Streams", "=", "None", ")", ":", "if", "Streams", "is", "None", ":", "Streams", "=", "self", ".", "Streams", "for", "s", "in", "Streams", ":", "s", ".", "SendDatagram", "(", "Text", ")" ]

[ "Sends", "datagram", "to", "application", "streams", "." ]

[ "def", "SendDatagram", "(", "self", ",", "Text", ")", ":", "self", ".", "Application", ".", "_Alter", "(", "'DATAGRAM'", ",", "'%s %s'", "%", "(", "self", ".", "Handle", ",", "tounicode", "(", "Text", ")", ")", ")" ]

[ "Sends", "datagram", "to", "stream", "." ]

[ "def", "Write", "(", "self", ",", "Text", ")", ":", "self", ".", "Application", ".", "_Alter", "(", "'WRITE'", ",", "'%s %s'", "%", "(", "self", ".", "Handle", ",", "tounicode", "(", "Text", ")", ")", ")" ]

[ "Writes", "data", "to", "stream", "." ]

[ "def", "CreateEvent", "(", "self", ",", "EventId", ",", "Caption", ",", "Hint", ")", ":", "self", ".", "_Skype", ".", "_DoCommand", "(", "'CREATE EVENT %s CAPTION %s HINT %s'", "%", "(", "tounicode", "(", "EventId", ")", ",", "quote", "(", "tounicode", "(", "Caption", ")", ")", ",", "quote", "(", "tounicode", "(", "Hint", ")", ")", ")", ")", "return", "PluginEvent", "(", "self", ".", "_Skype", ",", "EventId", ")" ]

[ "Creates", "a", "custom", "event", "displayed", "in", "Skype", "client", "s", "events", "pane", "." ]

[ "def", "CreateMenuItem", "(", "self", ",", "MenuItemId", ",", "PluginContext", ",", "CaptionText", ",", "HintText", "=", "u''", ",", "IconPath", "=", "''", ",", "Enabled", "=", "True", ",", "ContactType", "=", "pluginContactTypeAll", ",", "MultipleContacts", "=", "False", ")", ":", "cmd", "=", "'CREATE MENU_ITEM %s CONTEXT %s CAPTION %s ENABLED %s'", "%", "(", "tounicode", "(", "MenuItemId", ")", ",", "PluginContext", ",", "quote", "(", "tounicode", "(", "CaptionText", ")", ")", ",", "cndexp", "(", "Enabled", ",", "'true'", ",", "'false'", ")", ")", "if", "HintText", ":", "cmd", "+=", "' HINT %s'", "%", "quote", "(", "tounicode", "(", "HintText", ")", ")", "if", "IconPath", ":", "cmd", "+=", "' ICON %s'", "%", "quote", "(", "path2unicode", "(", "IconPath", ")", ")", "if", "MultipleContacts", ":", "cmd", "+=", "' ENABLE_MULTIPLE_CONTACTS true'", "if", "PluginContext", "==", "pluginContextContact", ":", "cmd", "+=", "' CONTACT_TYPE_FILTER %s'", "%", "ContactType", "self", ".", "_Skype", ".", "_DoCommand", "(", "cmd", ")", "return", "PluginMenuItem", "(", "self", ".", "_Skype", ",", "MenuItemId", ",", "CaptionText", ",", "HintText", ",", "Enabled", ")" ]

[ "Creates", "custom", "menu", "item", "in", "Skype", "client", "s", "Do", "More", "menus", "." ]

[ "def", "Focus", "(", "self", ")", ":", "self", ".", "_Skype", ".", "_Api", ".", "allow_focus", "(", "self", ".", "_Skype", ".", "Timeout", ")", "self", ".", "_Skype", ".", "_DoCommand", "(", "'FOCUS'", ")" ]

[ "Brings", "the", "client", "window", "into", "focus", "." ]

[ "def", "OpenDialog", "(", "self", ",", "Name", ",", "*", "Params", ")", ":", "self", ".", "_Skype", ".", "_Api", ".", "allow_focus", "(", "self", ".", "_Skype", ".", "Timeout", ")", "params", "=", "filter", "(", "None", ",", "(", "str", "(", "Name", ")", ",", ")", "+", "Params", ")", "self", ".", "_Skype", ".", "_DoCommand", "(", "'OPEN %s'", "%", "tounicode", "(", "' '", ".", "join", "(", "params", ")", ")", ")" ]

[ "Open", "dialog", ".", "Use", "this", "method", "to", "open", "dialogs", "added", "in", "newer", "Skype", "versions", "if", "there", "is", "no", "dedicated", "method", "in", "Skype4Py", "." ]

[ "def", "OpenMessageDialog", "(", "self", ",", "Username", ",", "Text", "=", "u''", ")", ":", "self", ".", "OpenDialog", "(", "'IM'", ",", "Username", ",", "tounicode", "(", "Text", ")", ")" ]

[ "Opens", "Send", "an", "IM", "Message", "dialog", "." ]

[ "def", "Start", "(", "self", ",", "Minimized", "=", "False", ",", "Nosplash", "=", "False", ")", ":", "self", ".", "_Skype", ".", "_Api", ".", "startup", "(", "Minimized", ",", "Nosplash", ")" ]

[ "Starts", "Skype", "application", "." ]

[ "def", "start", "(", "self", ")", ":", "if", "not", "self", ".", "thread_started", ":", "super", "(", "SkypeAPI", ",", "self", ")", ".", "start", "(", ")", "self", ".", "thread_started", "=", "True" ]

[ "Start", "the", "thread", "associated", "with", "this", "API", "object", ".", "Ensure", "that", "the", "call", "is", "made", "no", "more", "than", "once", "to", "avoid", "raising", "a", "RuntimeError", "." ]

[ "def", "threads_init", "(", "gtk", "=", "True", ")", ":", "# enable X11 multithreading", "x11", ".", "XInitThreads", "(", ")", "if", "gtk", ":", "from", "gtk", ".", "gdk", "import", "threads_init", "threads_init", "(", ")" ]

[ "Enables", "multithreading", "support", "in", "Xlib", "and", "PyGTK", ".", "See", "the", "module", "docstring", "for", "more", "info", ".", ":", "Parameters", ":", "gtk", ":", "bool", "May", "be", "set", "to", "False", "to", "skip", "the", "PyGTK", "module", "." ]

[ "def", "get_skype", "(", "self", ")", ":", "skype_inst", "=", "x11", ".", "XInternAtom", "(", "self", ".", "disp", ",", "'_SKYPE_INSTANCE'", ",", "True", ")", "if", "not", "skype_inst", ":", "return", "type_ret", "=", "Atom", "(", ")", "format_ret", "=", "c_int", "(", ")", "nitems_ret", "=", "c_ulong", "(", ")", "bytes_after_ret", "=", "c_ulong", "(", ")", "winp", "=", "pointer", "(", "Window", "(", ")", ")", "fail", "=", "x11", ".", "XGetWindowProperty", "(", "self", ".", "disp", ",", "self", ".", "win_root", ",", "skype_inst", ",", "0", ",", "1", ",", "False", ",", "33", ",", "byref", "(", "type_ret", ")", ",", "byref", "(", "format_ret", ")", ",", "byref", "(", "nitems_ret", ")", ",", "byref", "(", "bytes_after_ret", ")", ",", "byref", "(", "winp", ")", ")", "if", "not", "fail", "and", "format_ret", ".", "value", "==", "32", "and", "nitems_ret", ".", "value", "==", "1", ":", "return", "winp", ".", "contents", ".", "value" ]

[ "Returns", "Skype", "window", "ID", "or", "None", "if", "Skype", "not", "running", "." ]

[ "def", "Join", "(", "self", ",", "Id", ")", ":", "#self._Alter('JOIN_CONFERENCE', Id)", "reply", "=", "self", ".", "_Owner", ".", "_DoCommand", "(", "'SET CALL %s JOIN_CONFERENCE %s'", "%", "(", "self", ".", "Id", ",", "Id", ")", ",", "'CALL %s CONF_ID'", "%", "self", ".", "Id", ")", "return", "Conference", "(", "self", ".", "_Owner", ",", "reply", ".", "split", "(", ")", "[", "-", "1", "]", ")" ]

[ "Joins", "with", "another", "call", "to", "form", "a", "conference", "." ]

[ "def", "Avatar", "(", "self", ",", "Id", "=", "1", ",", "Set", "=", "None", ")", ":", "from", "warnings", "import", "warn", "warn", "(", "'Settings.Avatar: Use Settings.LoadAvatarFromFile instead.'", ",", "DeprecationWarning", ",", "stacklevel", "=", "2", ")", "if", "Set", "is", "None", ":", "raise", "TypeError", "(", "'Argument \\'Set\\' is mandatory!'", ")", "self", ".", "LoadAvatarFromFile", "(", "Set", ",", "Id", ")" ]

[ "Sets", "user", "avatar", "picture", "from", "file", "." ]

[ "def", "LoadAvatarFromFile", "(", "self", ",", "Filename", ",", "AvatarId", "=", "1", ")", ":", "s", "=", "'AVATAR %s %s'", "%", "(", "AvatarId", ",", "path2unicode", "(", "Filename", ")", ")", "self", ".", "_Skype", ".", "_DoCommand", "(", "'SET %s'", "%", "s", ",", "s", ")" ]

[ "Loads", "user", "avatar", "picture", "from", "file", "." ]

[ "def", "RingTone", "(", "self", ",", "Id", "=", "1", ",", "Set", "=", "None", ")", ":", "if", "Set", "is", "None", ":", "return", "unicode2path", "(", "self", ".", "_Skype", ".", "_Property", "(", "'RINGTONE'", ",", "Id", ",", "''", ")", ")", "self", ".", "_Skype", ".", "_Property", "(", "'RINGTONE'", ",", "Id", ",", "''", ",", "path2unicode", "(", "Set", ")", ")" ]

[ "Returns", "/", "sets", "a", "ringtone", "." ]

[ "def", "RingToneStatus", "(", "self", ",", "Id", "=", "1", ",", "Set", "=", "None", ")", ":", "if", "Set", "is", "None", ":", "return", "(", "self", ".", "_Skype", ".", "_Property", "(", "'RINGTONE'", ",", "Id", ",", "'STATUS'", ")", "==", "'ON'", ")", "self", ".", "_Skype", ".", "_Property", "(", "'RINGTONE'", ",", "Id", ",", "'STATUS'", ",", "cndexp", "(", "Set", ",", "'ON'", ",", "'OFF'", ")", ")" ]

[ "Enables", "/", "disables", "a", "ringtone", "." ]

[ "def", "SaveAvatarToFile", "(", "self", ",", "Filename", ",", "AvatarId", "=", "1", ")", ":", "s", "=", "'AVATAR %s %s'", "%", "(", "AvatarId", ",", "path2unicode", "(", "Filename", ")", ")", "self", ".", "_Skype", ".", "_DoCommand", "(", "'GET %s'", "%", "s", ",", "s", ")" ]

[ "Saves", "user", "avatar", "picture", "to", "file", "." ]