Datasets:

---

monsterapi

/

code_search_net

like 0

Follow

MonsterAPI 14

[ "def", "__clientDefer", "(", "self", ",", "c", ")", ":", "def", "handle_headers", "(", "r", ")", ":", "self", ".", "gotHeaders", "(", "c", ".", "response_headers", ")", "return", "r", "return", "c", ".", "deferred", ".", "addBoth", "(", "handle_headers", ")" ]

[ "Return", "a", "deferred", "for", "a", "HTTP", "client", "after", "handling", "incoming", "headers" ]

[ "def", "__doDownloadPage", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "logger", ".", "debug", "(", "\"download page: %r, %r\"", ",", "args", ",", "kwargs", ")", "return", "self", ".", "__clientDefer", "(", "downloadPage", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Works", "like", "client", ".", "downloadPage", "()", "but", "handle", "incoming", "headers" ]

[ "def", "verify_credentials", "(", "self", ",", "delegate", "=", "None", ")", ":", "parser", "=", "txml", ".", "Users", "(", "delegate", ")", "return", "self", ".", "__downloadPage", "(", "'/account/verify_credentials.xml'", ",", "parser", ")" ]

[ "Verify", "a", "user", "s", "credentials", "." ]

[ "def", "update", "(", "self", ",", "status", ",", "source", "=", "None", ",", "params", "=", "{", "}", ")", ":", "params", "=", "params", ".", "copy", "(", ")", "params", "[", "'status'", "]", "=", "status", "if", "source", ":", "params", "[", "'source'", "]", "=", "source", "return", "self", ".", "__parsed_post", "(", "self", ".", "__post", "(", "'/statuses/update.xml'", ",", "params", ")", ",", "txml", ".", "parseUpdateResponse", ")" ]

[ "Update", "your", "status", ".", "Returns", "the", "ID", "of", "the", "new", "post", "." ]

[ "def", "retweet", "(", "self", ",", "id", ",", "delegate", ")", ":", "parser", "=", "txml", ".", "Statuses", "(", "delegate", ")", "return", "self", ".", "__postPage", "(", "'/statuses/retweet/%s.xml'", "%", "(", "id", ")", ",", "parser", ")" ]

[ "Retweet", "a", "post" ]

[ "def", "friends", "(", "self", ",", "delegate", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ")", ":", "return", "self", ".", "__get", "(", "'/statuses/friends_timeline.xml'", ",", "delegate", ",", "params", ",", "txml", ".", "Statuses", ",", "extra_args", "=", "extra_args", ")" ]

[ "Get", "updates", "from", "friends", "." ]

[ "def", "home_timeline", "(", "self", ",", "delegate", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ")", ":", "return", "self", ".", "__get", "(", "'/statuses/home_timeline.xml'", ",", "delegate", ",", "params", ",", "txml", ".", "Statuses", ",", "extra_args", "=", "extra_args", ")" ]

[ "Get", "updates", "from", "friends", "." ]

[ "def", "user_timeline", "(", "self", ",", "delegate", ",", "user", "=", "None", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ")", ":", "if", "user", ":", "params", "[", "'id'", "]", "=", "user", "return", "self", ".", "__get", "(", "'/statuses/user_timeline.xml'", ",", "delegate", ",", "params", ",", "txml", ".", "Statuses", ",", "extra_args", "=", "extra_args", ")" ]

[ "Get", "the", "most", "recent", "updates", "for", "a", "user", "." ]

[ "def", "public_timeline", "(", "self", ",", "delegate", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ")", ":", "return", "self", ".", "__get", "(", "'/statuses/public_timeline.atom'", ",", "delegate", ",", "params", ",", "extra_args", "=", "extra_args", ")" ]

[ "Get", "the", "most", "recent", "public", "timeline", "." ]

[ "def", "direct_messages", "(", "self", ",", "delegate", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ")", ":", "return", "self", ".", "__get", "(", "'/direct_messages.xml'", ",", "delegate", ",", "params", ",", "txml", ".", "Direct", ",", "extra_args", "=", "extra_args", ")" ]

[ "Get", "direct", "messages", "for", "the", "authenticating", "user", "." ]

[ "def", "send_direct_message", "(", "self", ",", "text", ",", "user", "=", "None", ",", "delegate", "=", "None", ",", "screen_name", "=", "None", ",", "user_id", "=", "None", ",", "params", "=", "{", "}", ")", ":", "params", "=", "params", ".", "copy", "(", ")", "if", "user", "is", "not", "None", ":", "params", "[", "'user'", "]", "=", "user", "if", "user_id", "is", "not", "None", ":", "params", "[", "'user_id'", "]", "=", "user_id", "if", "screen_name", "is", "not", "None", ":", "params", "[", "'screen_name'", "]", "=", "screen_name", "params", "[", "'text'", "]", "=", "text", "parser", "=", "txml", ".", "Direct", "(", "delegate", ")", "return", "self", ".", "__postPage", "(", "'/direct_messages/new.xml'", ",", "parser", ",", "params", ")" ]

[ "Send", "a", "direct", "message" ]

[ "def", "replies", "(", "self", ",", "delegate", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ")", ":", "return", "self", ".", "__get", "(", "'/statuses/replies.atom'", ",", "delegate", ",", "params", ",", "extra_args", "=", "extra_args", ")" ]

[ "Get", "the", "most", "recent", "replies", "for", "the", "authenticating", "user", "." ]

[ "def", "follow_user", "(", "self", ",", "user", ",", "delegate", ")", ":", "parser", "=", "txml", ".", "Users", "(", "delegate", ")", "return", "self", ".", "__postPage", "(", "'/friendships/create/%s.xml'", "%", "(", "user", ")", ",", "parser", ")" ]

[ "Follow", "the", "given", "user", "." ]

[ "def", "unfollow_user", "(", "self", ",", "user", ",", "delegate", ")", ":", "parser", "=", "txml", ".", "Users", "(", "delegate", ")", "return", "self", ".", "__postPage", "(", "'/friendships/destroy/%s.xml'", "%", "(", "user", ")", ",", "parser", ")" ]

[ "Unfollow", "the", "given", "user", "." ]

[ "def", "list_friends", "(", "self", ",", "delegate", ",", "user", "=", "None", ",", "params", "=", "{", "}", ",", "extra_args", "=", "None", ",", "page_delegate", "=", "None", ")", ":", "if", "user", ":", "url", "=", "'/statuses/friends/'", "+", "user", "+", "'.xml'", "else", ":", "url", "=", "'/statuses/friends.xml'", "return", "self", ".", "__get_maybe_paging", "(", "url", ",", "delegate", ",", "params", ",", "txml", ".", "PagedUserList", ",", "extra_args", ",", "page_delegate", ")" ]

[ "Get", "the", "list", "of", "friends", "for", "a", "user", "." ]

[ "def", "show_user", "(", "self", ",", "user", ")", ":", "url", "=", "'/users/show/%s.xml'", "%", "(", "user", ")", "d", "=", "defer", ".", "Deferred", "(", ")", "self", ".", "__downloadPage", "(", "url", ",", "txml", ".", "Users", "(", "lambda", "u", ":", "d", ".", "callback", "(", "u", ")", ")", ")", ".", "addErrback", "(", "lambda", "e", ":", "d", ".", "errback", "(", "e", ")", ")", "return", "d" ]

[ "Get", "the", "info", "for", "a", "specific", "user", "." ]

[ "def", "search", "(", "self", ",", "query", ",", "delegate", ",", "args", "=", "None", ",", "extra_args", "=", "None", ")", ":", "if", "args", "is", "None", ":", "args", "=", "{", "}", "args", "[", "'q'", "]", "=", "query", "return", "self", ".", "__doDownloadPage", "(", "self", ".", "search_url", "+", "'?'", "+", "self", ".", "_urlencode", "(", "args", ")", ",", "txml", ".", "Feed", "(", "delegate", ",", "extra_args", ")", ",", "agent", "=", "self", ".", "agent", ")" ]

[ "Perform", "a", "search", "query", "." ]

[ "def", "startService", "(", "self", ")", ":", "service", ".", "Service", ".", "startService", "(", "self", ")", "self", ".", "_toState", "(", "'idle'", ")", "try", ":", "self", ".", "connect", "(", ")", "except", "NoConsumerError", ":", "pass" ]

[ "Start", "the", "service", "." ]

[ "def", "connect", "(", "self", ",", "forceReconnect", "=", "False", ")", ":", "if", "self", ".", "_state", "==", "'stopped'", ":", "raise", "Error", "(", "\"This service is not running. Not connecting.\"", ")", "if", "self", ".", "_state", "==", "'connected'", ":", "if", "forceReconnect", ":", "self", ".", "_toState", "(", "'disconnecting'", ")", "return", "True", "else", ":", "raise", "ConnectError", "(", "\"Already connected.\"", ")", "elif", "self", ".", "_state", "==", "'aborting'", ":", "raise", "ConnectError", "(", "\"Aborting connection in progress.\"", ")", "elif", "self", ".", "_state", "==", "'disconnecting'", ":", "raise", "ConnectError", "(", "\"Disconnect in progress.\"", ")", "elif", "self", ".", "_state", "==", "'connecting'", ":", "if", "forceReconnect", ":", "self", ".", "_toState", "(", "'aborting'", ")", "return", "True", "else", ":", "raise", "ConnectError", "(", "\"Connect in progress.\"", ")", "if", "self", ".", "delegate", "is", "None", ":", "if", "self", ".", "_state", "!=", "'idle'", ":", "self", ".", "_toState", "(", "'idle'", ")", "raise", "NoConsumerError", "(", ")", "if", "self", ".", "_state", "==", "'waiting'", ":", "if", "self", ".", "_reconnectDelayedCall", ".", "called", ":", "self", ".", "_reconnectDelayedCall", "=", "None", "pass", "else", ":", "self", ".", "_reconnectDelayedCall", ".", "reset", "(", "0", ")", "return", "True", "self", ".", "_toState", "(", "'connecting'", ")", "return", "True" ]

[ "Check", "current", "conditions", "and", "initiate", "connection", "if", "possible", "." ]

[ "def", "makeConnection", "(", "self", ",", "protocol", ")", ":", "self", ".", "_errorState", "=", "None", "def", "cb", "(", "result", ")", ":", "self", ".", "protocol", "=", "None", "if", "self", ".", "_state", "==", "'stopped'", ":", "# Don't transition to any other state. We are stopped.", "pass", "else", ":", "if", "isinstance", "(", "result", ",", "failure", ".", "Failure", ")", ":", "reason", "=", "result", "else", ":", "reason", "=", "None", "self", ".", "_toState", "(", "'disconnected'", ",", "reason", ")", "self", ".", "protocol", "=", "protocol", "d", "=", "protocol", ".", "deferred", "d", ".", "addBoth", "(", "cb", ")" ]

[ "Called", "when", "the", "connection", "has", "been", "established", "." ]

[ "def", "_reconnect", "(", "self", ",", "errorState", ")", ":", "def", "connect", "(", ")", ":", "if", "self", ".", "noisy", ":", "log", ".", "msg", "(", "\"Reconnecting now.\"", ")", "self", ".", "connect", "(", ")", "backOff", "=", "self", ".", "backOffs", "[", "errorState", "]", "if", "self", ".", "_errorState", "!=", "errorState", "or", "self", ".", "_delay", "is", "None", ":", "self", ".", "_errorState", "=", "errorState", "self", ".", "_delay", "=", "backOff", "[", "'initial'", "]", "else", ":", "self", ".", "_delay", "=", "min", "(", "backOff", "[", "'max'", "]", ",", "self", ".", "_delay", "*", "backOff", "[", "'factor'", "]", ")", "if", "self", ".", "_delay", "==", "0", ":", "connect", "(", ")", "else", ":", "self", ".", "_reconnectDelayedCall", "=", "self", ".", "reactor", ".", "callLater", "(", "self", ".", "_delay", ",", "connect", ")", "self", ".", "_toState", "(", "'waiting'", ")" ]

[ "Attempt", "to", "reconnect", "." ]

[ "def", "_toState", "(", "self", ",", "state", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "method", "=", "getattr", "(", "self", ",", "'_state_%s'", "%", "state", ")", "except", "AttributeError", ":", "raise", "ValueError", "(", "\"No such state %r\"", "%", "state", ")", "log", ".", "msg", "(", "\"%s: to state %r\"", "%", "(", "self", ".", "__class__", ".", "__name__", ",", "state", ")", ")", "self", ".", "_state", "=", "state", "method", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Transition", "to", "the", "next", "state", "." ]

[ "def", "_state_stopped", "(", "self", ")", ":", "if", "self", ".", "_reconnectDelayedCall", ":", "self", ".", "_reconnectDelayedCall", ".", "cancel", "(", ")", "self", ".", "_reconnectDelayedCall", "=", "None", "self", ".", "loseConnection", "(", ")" ]

[ "The", "service", "is", "not", "running", "." ]

[ "def", "_state_connecting", "(", "self", ")", ":", "def", "responseReceived", "(", "protocol", ")", ":", "self", ".", "makeConnection", "(", "protocol", ")", "if", "self", ".", "_state", "==", "'aborting'", ":", "self", ".", "_toState", "(", "'disconnecting'", ")", "else", ":", "self", ".", "_toState", "(", "'connected'", ")", "def", "trapError", "(", "failure", ")", ":", "self", ".", "_toState", "(", "'error'", ",", "failure", ")", "def", "onEntry", "(", "entry", ")", ":", "if", "self", ".", "delegate", ":", "try", ":", "self", ".", "delegate", "(", "entry", ")", "except", ":", "log", ".", "err", "(", ")", "else", ":", "pass", "d", "=", "self", ".", "api", "(", "onEntry", ",", "self", ".", "args", ")", "d", ".", "addCallback", "(", "responseReceived", ")", "d", ".", "addErrback", "(", "trapError", ")" ]

[ "A", "connection", "is", "being", "started", "." ]

[ "def", "_state_error", "(", "self", ",", "reason", ")", ":", "log", ".", "err", "(", "reason", ")", "def", "matchException", "(", "failure", ")", ":", "for", "errorState", ",", "backOff", "in", "self", ".", "backOffs", ".", "iteritems", "(", ")", ":", "if", "'errorTypes'", "not", "in", "backOff", ":", "continue", "if", "failure", ".", "check", "(", "*", "backOff", "[", "'errorTypes'", "]", ")", ":", "return", "errorState", "return", "'other'", "errorState", "=", "matchException", "(", "reason", ")", "self", ".", "_reconnect", "(", "errorState", ")" ]

[ "The", "connection", "attempt", "resulted", "in", "an", "error", "." ]

[ "def", "lineReceived", "(", "self", ",", "line", ")", ":", "if", "line", "and", "line", ".", "isdigit", "(", ")", ":", "self", ".", "_expectedLength", "=", "int", "(", "line", ")", "self", ".", "_rawBuffer", "=", "[", "]", "self", ".", "_rawBufferLength", "=", "0", "self", ".", "setRawMode", "(", ")", "else", ":", "self", ".", "keepAliveReceived", "(", ")" ]

[ "Called", "when", "a", "line", "is", "received", "." ]

[ "def", "rawDataReceived", "(", "self", ",", "data", ")", ":", "self", ".", "_rawBuffer", ".", "append", "(", "data", ")", "self", ".", "_rawBufferLength", "+=", "len", "(", "data", ")", "if", "self", ".", "_rawBufferLength", ">=", "self", ".", "_expectedLength", ":", "receivedData", "=", "''", ".", "join", "(", "self", ".", "_rawBuffer", ")", "expectedData", "=", "receivedData", "[", ":", "self", ".", "_expectedLength", "]", "extraData", "=", "receivedData", "[", "self", ".", "_expectedLength", ":", "]", "self", ".", "_rawBuffer", "=", "None", "self", ".", "_rawBufferLength", "=", "None", "self", ".", "_expectedLength", "=", "None", "self", ".", "datagramReceived", "(", "expectedData", ")", "self", ".", "setLineMode", "(", "extraData", ")" ]

[ "Called", "when", "raw", "data", "is", "received", "." ]

[ "def", "fromDict", "(", "cls", ",", "data", ")", ":", "obj", "=", "cls", "(", ")", "obj", ".", "raw", "=", "data", "for", "name", ",", "value", "in", "data", ".", "iteritems", "(", ")", ":", "if", "cls", ".", "SIMPLE_PROPS", "and", "name", "in", "cls", ".", "SIMPLE_PROPS", ":", "setattr", "(", "obj", ",", "name", ",", "value", ")", "elif", "cls", ".", "COMPLEX_PROPS", "and", "name", "in", "cls", ".", "COMPLEX_PROPS", ":", "value", "=", "cls", ".", "COMPLEX_PROPS", "[", "name", "]", ".", "fromDict", "(", "value", ")", "setattr", "(", "obj", ",", "name", ",", "value", ")", "elif", "cls", ".", "LIST_PROPS", "and", "name", "in", "cls", ".", "LIST_PROPS", ":", "value", "=", "[", "cls", ".", "LIST_PROPS", "[", "name", "]", ".", "fromDict", "(", "item", ")", "for", "item", "in", "value", "]", "setattr", "(", "obj", ",", "name", ",", "value", ")", "return", "obj" ]

[ "Fill", "this", "objects", "attributes", "from", "a", "dict", "for", "known", "properties", "." ]

[ "def", "datagramReceived", "(", "self", ",", "data", ")", ":", "try", ":", "obj", "=", "json", ".", "loads", "(", "data", ")", "except", "ValueError", ",", "e", ":", "log", ".", "err", "(", "e", ",", "'Invalid JSON in stream: %r'", "%", "data", ")", "return", "if", "u'text'", "in", "obj", ":", "obj", "=", "Status", ".", "fromDict", "(", "obj", ")", "else", ":", "log", ".", "msg", "(", "'Unsupported object %r'", "%", "obj", ")", "return", "self", ".", "callback", "(", "obj", ")" ]

[ "Decode", "the", "JSON", "-", "encoded", "datagram", "and", "call", "the", "callback", "." ]

[ "def", "connectionLost", "(", "self", ",", "reason", ")", ":", "self", ".", "setTimeout", "(", "None", ")", "if", "reason", ".", "check", "(", "ResponseDone", ",", "PotentialDataLoss", ")", ":", "self", ".", "deferred", ".", "callback", "(", "None", ")", "else", ":", "self", ".", "deferred", ".", "errback", "(", "reason", ")" ]

[ "Called", "when", "the", "body", "is", "complete", "or", "the", "connection", "was", "lost", "." ]

[ "def", "simpleListFactory", "(", "list_type", ")", ":", "def", "create", "(", "delegate", ",", "extra_args", "=", "None", ")", ":", "\"\"\"Create a Parser object for the specific tag type, on the fly\"\"\"", "return", "listParser", "(", "list_type", ",", "delegate", ",", "extra_args", ")", "return", "create" ]

[ "Used", "for", "simple", "parsers", "that", "support", "only", "one", "type", "of", "object" ]

[ "def", "setSubDelegates", "(", "self", ",", "namelist", ",", "before", "=", "None", ",", "after", "=", "None", ")", ":", "if", "len", "(", "namelist", ")", ">", "1", ":", "def", "set_sub", "(", "i", ")", ":", "i", ".", "setSubDelegates", "(", "namelist", "[", "1", ":", "]", ",", "before", ",", "after", ")", "self", ".", "setBeforeDelegate", "(", "namelist", "[", "0", "]", ",", "set_sub", ")", "elif", "len", "(", "namelist", ")", "==", "1", ":", "self", ".", "setDelegate", "(", "namelist", "[", "0", "]", ",", "before", ",", "after", ")" ]

[ "Set", "a", "delegate", "for", "a", "sub", "-", "sub", "-", "item", "according", "to", "a", "list", "of", "names" ]

[ "def", "_split_path", "(", "path", ")", ":", "path", "=", "path", ".", "strip", "(", "'/'", ")", "list_path", "=", "path", ".", "split", "(", "'/'", ")", "sentinel", "=", "list_path", ".", "pop", "(", "0", ")", "return", "sentinel", ",", "list_path", ",", "path" ]

[ "split", "a", "path", "return", "by", "the", "api" ]

[ "def", "path_dispatch_rename", "(", "rename_like_method", ")", ":", "def", "_wrapper_method", "(", "self", ",", "old_path", ",", "new_path", ")", ":", "old_path", ",", "_old_path", ",", "old_sentinel", "=", "_split_path", "(", "old_path", ")", "new_path", ",", "_new_path", ",", "new_sentinel", "=", "_split_path", "(", "new_path", ")", "if", "old_sentinel", "!=", "new_sentinel", ":", "raise", "ValueError", "(", "'Does not know how to move things across contents manager mountpoints'", ")", "else", ":", "sentinel", "=", "new_sentinel", "man", "=", "self", ".", "managers", ".", "get", "(", "sentinel", ",", "None", ")", "if", "man", "is", "not", "None", ":", "rename_meth", "=", "getattr", "(", "man", ",", "rename_like_method", ".", "__name__", ")", "sub", "=", "rename_meth", "(", "'/'", ".", "join", "(", "_old_path", ")", ",", "'/'", ".", "join", "(", "_new_path", ")", ")", "return", "sub", "else", ":", "return", "rename_meth", "(", "self", ",", "old_path", ",", "new_path", ")", "return", "_wrapper_method" ]

[ "decorator", "for", "rename", "-", "like", "function", "that", "need", "dispatch", "on", "2", "arguments" ]

[ "def", "deactivate", "(", "profile", "=", "'default'", ")", ":", "with", "jconfig", "(", "profile", ")", "as", "config", ":", "deact", "=", "True", "if", "not", "getattr", "(", "config", ".", "NotebookApp", ".", "contents_manager_class", ",", "'startswith'", ",", "lambda", "x", ":", "False", ")", "(", "'jupyterdrive'", ")", ":", "deact", "=", "False", "if", "'gdrive'", "not", "in", "getattr", "(", "config", ".", "NotebookApp", ".", "tornado_settings", ",", "'get'", ",", "lambda", "_", ",", "__", ":", "''", ")", "(", "'contents_js_source'", ",", "''", ")", ":", "deact", "=", "False", "if", "deact", ":", "del", "config", "[", "'NotebookApp'", "]", "[", "'tornado_settings'", "]", "[", "'contents_js_source'", "]", "del", "config", "[", "'NotebookApp'", "]", "[", "'contents_manager_class'", "]" ]

[ "should", "be", "a", "matter", "of", "just", "unsetting", "the", "above", "keys" ]

[ "def", "sequence_type", "(", "seq", ")", ":", "if", "isinstance", "(", "seq", ",", "coral", ".", "DNA", ")", ":", "material", "=", "'dna'", "elif", "isinstance", "(", "seq", ",", "coral", ".", "RNA", ")", ":", "material", "=", "'rna'", "elif", "isinstance", "(", "seq", ",", "coral", ".", "Peptide", ")", ":", "material", "=", "'peptide'", "else", ":", "raise", "ValueError", "(", "'Input was not a recognized coral.sequence object.'", ")", "return", "material" ]

[ "Validates", "a", "coral", ".", "sequence", "data", "type", "." ]

[ "def", "pcr", "(", "template", ",", "primer1", ",", "primer2", ",", "min_tm", "=", "50.0", ",", "min_primer_len", "=", "14", ")", ":", "# Find match in top or bottom strands for each primer", "p1_matches", "=", "coral", ".", "analysis", ".", "anneal", "(", "template", ",", "primer1", ",", "min_tm", "=", "min_tm", ",", "min_len", "=", "min_primer_len", ")", "p2_matches", "=", "coral", ".", "analysis", ".", "anneal", "(", "template", ",", "primer2", ",", "min_tm", "=", "min_tm", ",", "min_len", "=", "min_primer_len", ")", "p1_binding_locations", "=", "[", "m", "[", "0", "]", "for", "strand", "in", "p1_matches", "for", "m", "in", "strand", "]", "p2_binding_locations", "=", "[", "m", "[", "0", "]", "for", "strand", "in", "p2_matches", "for", "m", "in", "strand", "]", "# Ensure unique top and bottom matches", "if", "len", "(", "p1_binding_locations", ")", ">", "1", ":", "primer_msg", "=", "'Multiple primer 1 binding locations: {}'", "raise", "PrimingError", "(", "primer_msg", ".", "format", "(", "p1_binding_locations", ")", ")", "if", "len", "(", "p2_binding_locations", ")", ">", "1", ":", "primer_msg", "=", "'Multiple primer 2 binding locations: {}'", "raise", "PrimingError", "(", "primer_msg", ".", "format", "(", "p2_binding_locations", ")", ")", "if", "not", "p1_binding_locations", "and", "not", "p2_binding_locations", ":", "raise", "PrimingError", "(", "'Neither primer binds the template'", ")", "if", "not", "p1_binding_locations", ":", "raise", "PrimingError", "(", "'Primer 1 does not bind the template'", ")", "if", "not", "p2_binding_locations", ":", "raise", "PrimingError", "(", "'Primer 2 does not bind the template'", ")", "# Check that primers bind on opposite strands of the template", "tops", "=", "p1_matches", "[", "0", "]", "+", "p2_matches", "[", "0", "]", "bottoms", "=", "p1_matches", "[", "1", "]", "+", "p2_matches", "[", "1", "]", "if", "not", "tops", ":", "raise", "PrimingError", "(", "'No primers bind the template\\'s top strand.'", ")", "if", "not", "bottoms", ":", "raise", "PrimingError", "(", "'No primers bind the template\\'s bottom strand.'", ")", "# Figure out which primer matches the top strand", "if", "p1_matches", "[", "0", "]", ":", "# primer1 is top", "fwd", "=", "primer1", "rev", "=", "primer2", "else", ":", "# primer2 matches top strand", "fwd", "=", "primer2", "rev", "=", "primer1", "# Now we can simulate the PCR. If primer locations are overlapping, we", "# throw an error. If the primers won't amplify a product (e.g. a linear", "# template with primers facing away from one another), throw a different", "# error. Otherwise, amplify the product, including any overhangs.", "# 3' locations, annealing region length", "fwd_3", ",", "fwd_len", "=", "tops", "[", "0", "]", "rev_3", ",", "rev_len", "=", "bottoms", "[", "0", "]", "# 5' locations", "fwd_5", "=", "fwd_3", "-", "fwd_len", "rev_5", "=", "rev_3", "-", "rev_len", "# location on the top strand where the 'reverse' primer ends (its 3' end)", "rev_3_top", "=", "len", "(", "template", ")", "-", "rev_3", "rev_5_top", "=", "len", "(", "template", ")", "-", "rev_5", "# TODO: Use % operator?", "if", "rev_5_top", ">", "len", "(", "template", ")", ":", "rev_5_top", "=", "rev_5_top", "-", "len", "(", "template", ")", "# overhangs", "fwd_overhang", "=", "fwd", ".", "primer", "(", ")", "[", ":", "-", "fwd_len", "]", "rev_overhang", "=", "rev", ".", "primer", "(", ")", "[", ":", "-", "rev_len", "]", "# TODO: what about searching substrings over circulate templates?", "# Cases:", "# 1) Primers point towards one another - overlapping is fine", "# -> isolate region between 5' annealing regions and tack on the", "# rest of the overhang.", "# 2) Primers point away from one another, template is linear", "# -> error", "# 3) Primers point away from one another, template is circular", "# a) Primers don't overlap", "# -> rotate to 'top' primer start, extract sequence", "# b) Primers overlap", "# -> Extract whole sequence as linear fragment, tack on rest of", "# 'bottom' primer. May disrupt features.", "if", "template", ".", "circular", ":", "# Circular template - primers always point towards one another", "if", "rev_3_top", ">", "fwd_3", ":", "# Inter-primer region doesn't go over the origin (index 0)", "# However, the 'anneal' region may extend over it.", "# FIXME: handle case where 'anneal' region extends over origin", "# FIXME: simplify - just generate 'before' and 'after', then", "# combine with preamplicon later", "if", "rev_3_top", "+", "rev_len", ">", "len", "(", "template", ")", ":", "# Reverse primer extends over the origin", "if", "fwd_5", "-", "fwd_len", "<", "0", ":", "# Forward primer extends over the origin", "preamplicon", "=", "template", ".", "linearize", "(", ")", "# Add extra anneal regions", "before", "=", "template", "[", "fwd_5", ":", "]", "after", "=", "template", "[", ":", "rev_5_top", "]", "preamplicon", "=", "before", "+", "preamplicon", "+", "after", "else", ":", "# Only the reverse primer extends over the origin", "preamplicon", "=", "template", "[", "fwd_5", ":", "]", "after", "=", "template", "[", ":", "rev_5_top", "]", "preamplicon", "=", "preamplicon", "+", "after", "elif", "fwd_5", "-", "fwd_len", "<", "0", ":", "# Only the forward primer extends over the origin", "before", "=", "template", "[", "fwd_5", ":", "]", "preamplicon", "=", "before", "+", "template", "[", ":", "rev_5_top", "]", "else", ":", "# Extract like normal", "preamplicon", "=", "template", "[", "fwd_5", ":", "len", "(", "template", ")", "-", "rev_5", "]", "else", ":", "# Inter-primer region goes over the origin (index 0)", "preamplicon_len", "=", "len", "(", "template", ")", "-", "fwd_5", "+", "rev_5_top", "preamplicon", "=", "template", ".", "rotate", "(", "-", "fwd_5", ")", "[", ":", "preamplicon_len", "]", "else", ":", "# Linear template", "if", "rev_3_top", "<", "fwd_5", "or", "fwd_3", ">", "rev_5_top", ":", "# Primers point away from one another.", "raise", "PrimingError", "(", "'Primers point away from one another.'", ")", "else", ":", "# Primers point towards each other.", "preamplicon", "=", "template", "[", "fwd_5", ":", "len", "(", "template", ")", "-", "rev_5", "]", "# Add overhangs", "amplicon", "=", "(", "fwd_overhang", ".", "to_ds", "(", ")", "+", "preamplicon", "+", "rev_overhang", ".", "to_ds", "(", ")", ".", "reverse_complement", "(", ")", ")", "return", "amplicon" ]

[ "Simulate", "a", "PCR", "." ]

[ "def", "digest", "(", "dna", ",", "restriction_enzyme", ")", ":", "pattern", "=", "restriction_enzyme", ".", "recognition_site", "located", "=", "dna", ".", "locate", "(", "pattern", ")", "if", "not", "located", "[", "0", "]", "and", "not", "located", "[", "1", "]", ":", "return", "[", "dna", "]", "# Bottom strand indices are relative to the bottom strand 5' end.", "# Convert to same type as top strand", "pattern_len", "=", "len", "(", "pattern", ")", "r_indices", "=", "[", "len", "(", "dna", ")", "-", "index", "-", "pattern_len", "for", "index", "in", "located", "[", "1", "]", "]", "# If sequence is palindrome, remove redundant results", "if", "pattern", ".", "is_palindrome", "(", ")", ":", "r_indices", "=", "[", "index", "for", "index", "in", "r_indices", "if", "index", "not", "in", "located", "[", "0", "]", "]", "# Flatten cut site indices", "cut_sites", "=", "sorted", "(", "located", "[", "0", "]", "+", "r_indices", ")", "# Go through each cut site starting at highest one", "# Cut remaining template once, generating remaining + new", "current", "=", "[", "dna", "]", "for", "cut_site", "in", "cut_sites", "[", ":", ":", "-", "1", "]", ":", "new", "=", "_cut", "(", "current", ",", "cut_site", ",", "restriction_enzyme", ")", "current", ".", "append", "(", "new", "[", "1", "]", ")", "current", ".", "append", "(", "new", "[", "0", "]", ")", "current", ".", "reverse", "(", ")", "# Combine first and last back together if digest was circular", "if", "dna", ".", "circular", ":", "current", "[", "0", "]", "=", "current", ".", "pop", "(", ")", "+", "current", "[", "0", "]", "return", "current" ]

[ "Restriction", "endonuclease", "reaction", "." ]

[ "def", "_cut", "(", "dna", ",", "index", ",", "restriction_enzyme", ")", ":", "# TODO: handle case where cut site is outside of recognition sequence,", "# for both circular and linear cases where site is at index 0", "# Find absolute indices at which to cut", "cut_site", "=", "restriction_enzyme", ".", "cut_site", "top_cut", "=", "index", "+", "cut_site", "[", "0", "]", "bottom_cut", "=", "index", "+", "cut_site", "[", "1", "]", "# Isolate left and ride sequences", "to_cut", "=", "dna", ".", "pop", "(", ")", "max_cut", "=", "max", "(", "top_cut", ",", "bottom_cut", ")", "min_cut", "=", "min", "(", "top_cut", ",", "bottom_cut", ")", "left", "=", "to_cut", "[", ":", "max_cut", "]", "right", "=", "to_cut", "[", "min_cut", ":", "]", "# If applicable, leave overhangs", "diff", "=", "top_cut", "-", "bottom_cut", "if", "not", "diff", ":", "# Blunt-end cutter, no adjustment necessary", "pass", "elif", "diff", ">", "0", ":", "# 3' overhangs", "left", "=", "coral", ".", "reaction", ".", "five_resect", "(", "left", ".", "flip", "(", ")", ",", "diff", ")", ".", "flip", "(", ")", "right", "=", "coral", ".", "reaction", ".", "five_resect", "(", "right", ",", "diff", ")", "else", ":", "# 5' overhangs", "left", "=", "coral", ".", "reaction", ".", "three_resect", "(", "left", ",", "abs", "(", "diff", ")", ")", "right", "=", "coral", ".", "reaction", ".", "three_resect", "(", "right", ".", "flip", "(", ")", ",", "abs", "(", "diff", ")", ")", ".", "flip", "(", ")", "return", "[", "left", ",", "right", "]" ]

[ "Cuts", "template", "once", "at", "the", "specified", "index", "." ]

[ "def", "ipynb_to_rst", "(", "directory", ",", "filename", ")", ":", "print", "(", "filename", ")", "os", ".", "chdir", "(", "directory", ")", "subprocess", ".", "Popen", "(", "[", "\"ipython\"", ",", "\"nbconvert\"", ",", "\"--to\"", ",", "\"rst\"", ",", "filename", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "cwd", "=", "directory", ")" ]

[ "Converts", "a", "given", "file", "in", "a", "directory", "to", "an", "rst", "in", "the", "same", "directory", "." ]

[ "def", "convert_ipynbs", "(", "directory", ")", ":", "# The ipython_examples dir has to be in the same dir as this script", "for", "root", ",", "subfolders", ",", "files", "in", "os", ".", "walk", "(", "os", ".", "path", ".", "abspath", "(", "directory", ")", ")", ":", "for", "f", "in", "files", ":", "if", "\".ipynb_checkpoints\"", "not", "in", "root", ":", "if", "f", ".", "endswith", "(", "\"ipynb\"", ")", ":", "ipynb_to_rst", "(", "root", ",", "f", ")" ]

[ "Recursively", "converts", "all", "ipynb", "files", "in", "a", "directory", "into", "rst", "files", "in", "the", "same", "directory", "." ]

[ "def", "_context_walk", "(", "dna", ",", "window_size", ",", "context_len", ",", "step", ")", ":", "# Generate window indices", "window_start_ceiling", "=", "len", "(", "dna", ")", "-", "context_len", "-", "window_size", "window_starts", "=", "range", "(", "context_len", "-", "1", ",", "window_start_ceiling", ",", "step", ")", "window_ends", "=", "[", "start", "+", "window_size", "for", "start", "in", "window_starts", "]", "# Generate left and right in-context subsequences", "l_starts", "=", "[", "step", "*", "i", "for", "i", "in", "range", "(", "len", "(", "window_starts", ")", ")", "]", "l_seqs", "=", "[", "dna", "[", "start", ":", "end", "]", "for", "start", ",", "end", "in", "zip", "(", "l_starts", ",", "window_ends", ")", "]", "r_ends", "=", "[", "x", "+", "window_size", "+", "context_len", "for", "x", "in", "window_starts", "]", "r_seqs", "=", "[", "dna", "[", "start", ":", "end", "]", ".", "reverse_complement", "(", ")", "for", "start", ",", "end", "in", "zip", "(", "window_starts", ",", "r_ends", ")", "]", "# Combine and calculate nupack pair probabilities", "seqs", "=", "l_seqs", "+", "r_seqs", "pairs_run", "=", "coral", ".", "analysis", ".", "nupack_multi", "(", "seqs", ",", "'dna'", ",", "'pairs'", ",", "{", "'index'", ":", "0", "}", ")", "# Focus on pair probabilities that matter - those in the window", "pairs", "=", "[", "run", "[", "-", "window_size", ":", "]", "for", "run", "in", "pairs_run", "]", "# Score by average pair probability", "lr_scores", "=", "[", "sum", "(", "pair", ")", "/", "len", "(", "pair", ")", "for", "pair", "in", "pairs", "]", "# Split into left-right contexts again and sum for each window", "l_scores", "=", "lr_scores", "[", "0", ":", "len", "(", "seqs", ")", "/", "2", "]", "r_scores", "=", "lr_scores", "[", "len", "(", "seqs", ")", "/", "2", ":", "]", "scores", "=", "[", "(", "l", "+", "r", ")", "/", "2", "for", "l", ",", "r", "in", "zip", "(", "l_scores", ",", "r_scores", ")", "]", "# Summarize and return window indices and score", "summary", "=", "zip", "(", "window_starts", ",", "window_ends", ",", "scores", ")", "return", "summary" ]

[ "Generate", "context", "-", "dependent", "non", "-", "boundedness", "scores", "for", "a", "DNA", "sequence", "." ]

[ "def", "windows", "(", "self", ",", "window_size", "=", "60", ",", "context_len", "=", "90", ",", "step", "=", "10", ")", ":", "self", ".", "walked", "=", "_context_walk", "(", "self", ".", "template", ",", "window_size", ",", "context_len", ",", "step", ")", "self", ".", "core_starts", ",", "self", ".", "core_ends", ",", "self", ".", "scores", "=", "zip", "(", "*", "self", ".", "walked", ")", "return", "self", ".", "walked" ]

[ "Walk", "through", "the", "sequence", "of", "interest", "in", "windows", "of", "window_size", "evaluate", "free", "(", "unbound", ")", "pair", "probabilities", "." ]

[ "def", "plot", "(", "self", ")", ":", "try", ":", "from", "matplotlib", "import", "pylab", "except", "ImportError", ":", "raise", "ImportError", "(", "'Optional dependency matplotlib not installed.'", ")", "if", "self", ".", "walked", ":", "fig", "=", "pylab", ".", "figure", "(", ")", "ax1", "=", "fig", ".", "add_subplot", "(", "111", ")", "ax1", ".", "plot", "(", "self", ".", "core_starts", ",", "self", ".", "scores", ",", "'bo-'", ")", "pylab", ".", "xlabel", "(", "'Core sequence start position (base pairs).'", ")", "pylab", ".", "ylabel", "(", "'Score - Probability of being unbound.'", ")", "pylab", ".", "show", "(", ")", "else", ":", "raise", "Exception", "(", "'Run calculate() first so there\\'s data to plot!'", ")" ]

[ "Plot", "the", "results", "of", "the", "run", "method", "." ]

[ "def", "anneal", "(", "template", ",", "primer", ",", "min_tm", "=", "50.0", ",", "min_len", "=", "10", ")", ":", "# TODO: add possibility for primer basepair mismatch", "if", "len", "(", "primer", ")", "<", "min_len", ":", "msg", "=", "'Primer length is shorter than min_len argument.'", "raise", "PrimerLengthError", "(", "msg", ")", "if", "len", "(", "template", ")", "<", "min_len", ":", "msg", "=", "'Template is shorter than the min_len argument.'", "raise", "AnnealError", "(", "msg", ")", "# Strategy: locate all min-length matches, then extend them until they", "# no longer match. This provides an advantage over the previous strategy of", "# updating a dictionary with indices from coral.DNA.locate() as keys, as", "# the latter's indices may actually move for a given primer as it passes", "# over the origin", "def", "update_match_linear", "(", "base", ",", "location_length", ",", "anneal_seq", ")", ":", "'''Increase the location and length of binding site, if applicable.'''", "# TODO: this is very inefficient - should stop updating once the first", "# mismatch occurs.", "location", ",", "length", "=", "location_length", "if", "location", "==", "0", ":", "return", "location_length", "location_next", "=", "location", "-", "1", "length_next", "=", "length", "+", "1", "seq", "=", "base", "[", "location_next", ":", "location_next", "+", "length_next", "]", "if", "seq", "==", "anneal_seq", ":", "return", "(", "location_next", ",", "length_next", ")", "else", ":", "return", "location_length", "def", "update_match_circular", "(", "base", ",", "location_length", ",", "anneal_seq", ")", ":", "'''Increase the location and length of binding site, if applicable.'''", "# TODO: this is very inefficient - should stop updating once the first", "# mismatch occurs.", "base_len", "=", "len", "(", "base", ")", "location", ",", "length", "=", "location_length", "if", "location", "==", "0", ":", "location_next", "=", "base_len", "-", "1", "else", ":", "location_next", "=", "location", "-", "1", "length_next", "=", "length", "+", "1", "if", "(", "location_next", "+", "length_next", ")", ">", "base_len", ":", "upstream", "=", "base", "[", "location_next", ":", "]", "downstream", "=", "base", "[", ":", "length_next", "-", "(", "base_len", "-", "location_next", ")", "]", "seq", "=", "upstream", "+", "downstream", "else", ":", "# No need to 'rotate' sequence", "seq", "=", "base", "[", "location_next", ":", "location_next", "+", "length_next", "]", "if", "seq", "==", "anneal_seq", ":", "return", "(", "location_next", ",", "length_next", ")", "else", ":", "return", "location_length", "if", "template", ".", "circular", ":", "update_fun", "=", "update_match_circular", "else", ":", "update_fun", "=", "update_match_linear", "# Maximum annealing length to test (can't exceed template length)", "max_len", "=", "min", "(", "len", "(", "template", ")", ",", "len", "(", "primer", ")", ")", "primer_dna", "=", "primer", ".", "to_ds", "(", ")", "anneal_len", "=", "min_len", "anneal_seq", "=", "primer_dna", "[", "-", "anneal_len", ":", "]", "binding_data", "=", "[", "]", "for", "k", ",", "strand_locs", "in", "enumerate", "(", "template", ".", "locate", "(", "anneal_seq", ")", ")", ":", "matches", "=", "zip", "(", "strand_locs", ",", "[", "min_len", "]", "*", "len", "(", "strand_locs", ")", ")", "for", "i", "in", "range", "(", "anneal_len", "+", "1", ",", "max_len", "+", "1", ")", ":", "anneal_seq", "=", "primer_dna", "[", "-", "i", ":", "]", "for", "j", ",", "match", "in", "enumerate", "(", "matches", ")", ":", "if", "k", "==", "0", ":", "matches", "[", "j", "]", "=", "update_fun", "(", "template", ".", "top", ",", "match", ",", "anneal_seq", ")", "else", ":", "matches", "[", "j", "]", "=", "update_fun", "(", "template", ".", "bottom", ",", "match", ",", "anneal_seq", ")", "binding_data", ".", "append", "(", "matches", ")", "# Now, filter out all the matches that are too short", "for", "i", "in", "reversed", "(", "range", "(", "len", "(", "primer_dna", ")", "+", "1", ")", ")", ":", "min_len", "=", "i", "+", "1", "tm", "=", "primer_dna", "[", "-", "min_len", ":", "]", ".", "tm", "(", ")", "if", "tm", "<", "min_tm", ":", "break", "for", "strand", "in", "binding_data", ":", "for", "i", "in", "reversed", "(", "range", "(", "len", "(", "strand", ")", ")", ")", ":", "if", "strand", "[", "i", "]", "[", "1", "]", "<", "min_len", ":", "strand", ".", "pop", "(", "i", ")", "# Finally, adjust the position to be the 3' end", "for", "strand", "in", "binding_data", ":", "for", "i", ",", "match", "in", "enumerate", "(", "strand", ")", ":", "length", "=", "match", "[", "1", "]", "loc_new", "=", "match", "[", "0", "]", "+", "length", "if", "loc_new", ">", "len", "(", "template", ")", ":", "# Circularly permute", "loc_new", "=", "loc_new", "-", "len", "(", "template", ")", "strand", "[", "i", "]", "=", "[", "loc_new", ",", "length", "]", "# Overwriting dictionary keys ensures uniqueness", "# fwd_matches = {}", "# rev_matches = {}", "# for i in range(len(primer) - min_len + 1)[::-1]:", "# primer_dna = primer.overhang + primer.anneal", "# annealing = primer_dna[i:]", "# anneal_temp = annealing.tm()", "# anneal_len = len(annealing)", "# if anneal_temp > min_tm:", "# p_matches = template.locate(annealing)", "# for match in p_matches[0]:", "# fwd_matches[match + anneal_len] = anneal_len", "# for match in p_matches[1]:", "# rev_matches[match + anneal_len] = anneal_len", "# # Convert dictionaries to lists", "# fwds = [[key, val] for key, val in fwd_matches.iteritems()]", "# revs = [[key, val] for key, val in rev_matches.iteritems()]", "return", "binding_data" ]

[ "Simulates", "a", "primer", "binding", "event", ".", "Will", "find", "the", "maximum", "subset", "of", "bases", "in", "the", "primer", "that", "binds", "to", "the", "template", "including", "overhang", "sequences", ".", "**", "Note", "**", ":", "Primer", "binding", "locations", "indicate", "the", "3", "end", "of", "the", "primer", "not", "the", "begining", "of", "the", "annealing", "sequence", "." ]

[ "def", "primer", "(", "dna", ",", "tm", "=", "65", ",", "min_len", "=", "10", ",", "tm_undershoot", "=", "1", ",", "tm_overshoot", "=", "3", ",", "end_gc", "=", "False", ",", "tm_parameters", "=", "'cloning'", ",", "overhang", "=", "None", ",", "structure", "=", "False", ")", ":", "# Check Tm of input sequence to see if it's already too low", "seq_tm", "=", "coral", ".", "analysis", ".", "tm", "(", "dna", ",", "parameters", "=", "tm_parameters", ")", "if", "seq_tm", "<", "(", "tm", "-", "tm_undershoot", ")", ":", "msg", "=", "'Input sequence Tm is lower than primer Tm setting'", "raise", "ValueError", "(", "msg", ")", "# Focus on first 90 bases - shouldn't need more than 90bp to anneal", "dna", "=", "dna", "[", "0", ":", "90", "]", "# Generate primers from min_len to 'tm' + tm_overshoot", "# TODO: this is a good place for optimization. Only calculate as many", "# primers as are needed. Use binary search.", "primers_tms", "=", "[", "]", "last_tm", "=", "0", "bases", "=", "min_len", "while", "last_tm", "<=", "tm", "+", "tm_overshoot", "and", "bases", "!=", "len", "(", "dna", ")", ":", "next_primer", "=", "dna", "[", "0", ":", "bases", "]", "last_tm", "=", "coral", ".", "analysis", ".", "tm", "(", "next_primer", ",", "parameters", "=", "tm_parameters", ")", "primers_tms", ".", "append", "(", "(", "next_primer", ",", "last_tm", ")", ")", "bases", "+=", "1", "# Trim primer list based on tm_undershoot and end_gc", "primers_tms", "=", "[", "(", "primer", ",", "melt", ")", "for", "primer", ",", "melt", "in", "primers_tms", "if", "melt", ">=", "tm", "-", "tm_undershoot", "]", "if", "end_gc", ":", "primers_tms", "=", "[", "pair", "for", "pair", "in", "primers_tms", "if", "pair", "[", "0", "]", "[", "-", "1", "]", "==", "coral", ".", "DNA", "(", "'C'", ")", "or", "pair", "[", "0", "]", "[", "-", "1", "]", "==", "coral", ".", "DNA", "(", "'G'", ")", "]", "if", "not", "primers_tms", ":", "raise", "ValueError", "(", "'No primers could be generated using these settings'", ")", "# Find the primer closest to the set Tm, make it single stranded", "tm_diffs", "=", "[", "abs", "(", "melt", "-", "tm", ")", "for", "primer", ",", "melt", "in", "primers_tms", "]", "best_index", "=", "tm_diffs", ".", "index", "(", "min", "(", "tm_diffs", ")", ")", "best_primer", ",", "best_tm", "=", "primers_tms", "[", "best_index", "]", "best_primer", "=", "best_primer", ".", "top", "# Apply overhang", "if", "overhang", ":", "overhang", "=", "overhang", ".", "top", "output_primer", "=", "coral", ".", "Primer", "(", "best_primer", ",", "best_tm", ",", "overhang", "=", "overhang", ")", "def", "_structure", "(", "primer", ")", ":", "'''Check annealing sequence for structure.\n\n :param primer: Primer for which to evaluate structure\n :type primer: sequence.Primer\n\n '''", "# Check whole primer for high-probability structure, focus in on", "# annealing sequence, report average", "nupack", "=", "coral", ".", "analysis", ".", "Nupack", "(", "primer", ".", "primer", "(", ")", ")", "pairs", "=", "nupack", ".", "pairs", "(", "0", ")", "anneal_len", "=", "len", "(", "primer", ".", "anneal", ")", "pairs_mean", "=", "sum", "(", "pairs", "[", "-", "anneal_len", ":", "]", ")", "/", "anneal_len", "if", "pairs_mean", "<", "0.5", ":", "warnings", ".", "warn", "(", "'High probability structure'", ",", "Warning", ")", "return", "pairs_mean", "if", "structure", ":", "_structure", "(", "output_primer", ")", "return", "output_primer" ]

[ "Design", "primer", "to", "a", "nearest", "-", "neighbor", "Tm", "setpoint", "." ]

[ "def", "primers", "(", "dna", ",", "tm", "=", "65", ",", "min_len", "=", "10", ",", "tm_undershoot", "=", "1", ",", "tm_overshoot", "=", "3", ",", "end_gc", "=", "False", ",", "tm_parameters", "=", "'cloning'", ",", "overhangs", "=", "None", ",", "structure", "=", "False", ")", ":", "if", "not", "overhangs", ":", "overhangs", "=", "[", "None", ",", "None", "]", "templates", "=", "[", "dna", ",", "dna", ".", "reverse_complement", "(", ")", "]", "primer_list", "=", "[", "]", "for", "template", ",", "overhang", "in", "zip", "(", "templates", ",", "overhangs", ")", ":", "primer_i", "=", "primer", "(", "template", ",", "tm", "=", "tm", ",", "min_len", "=", "min_len", ",", "tm_undershoot", "=", "tm_undershoot", ",", "tm_overshoot", "=", "tm_overshoot", ",", "end_gc", "=", "end_gc", ",", "tm_parameters", "=", "tm_parameters", ",", "overhang", "=", "overhang", ",", "structure", "=", "structure", ")", "primer_list", ".", "append", "(", "primer_i", ")", "return", "primer_list" ]

[ "Design", "primers", "for", "PCR", "amplifying", "any", "arbitrary", "sequence", "." ]

[ "def", "assemble_oligos", "(", "dna_list", ",", "reference", "=", "None", ")", ":", "# FIXME: this protocol currently only supports 5' ends on the assembly", "# Find all matches for every oligo. If more than 2 per side, error.", "# Self-oligo is included in case the 3' end is self-complementary.", "# 1) Find all unique 3' binders (and non-binders).", "match_3", "=", "[", "bind_unique", "(", "seq", ",", "dna_list", ",", "right", "=", "True", ")", "for", "i", ",", "seq", "in", "enumerate", "(", "dna_list", ")", "]", "# 2) Find all unique 5' binders (and non-binders).", "match_5", "=", "[", "bind_unique", "(", "seq", ",", "dna_list", ",", "right", "=", "False", ")", "for", "i", ",", "seq", "in", "enumerate", "(", "dna_list", ")", "]", "# Assemble into 2-tuple", "zipped", "=", "zip", "(", "match_5", ",", "match_3", ")", "# 3) If none found, error out with 'oligo n has no binders'", "for", "i", ",", "oligo_match", "in", "enumerate", "(", "zipped", ")", ":", "if", "not", "any", "(", "oligo_match", ")", ":", "error", "=", "'Oligo {} has no binding partners.'", ".", "format", "(", "i", "+", "1", ")", "raise", "AssemblyError", "(", "error", ")", "# 4) There should be exactly 2 oligos that bind at 3' end but", "# not 5'.", "ends", "=", "[", "]", "for", "i", ",", "(", "five", ",", "three", ")", "in", "enumerate", "(", "zipped", ")", ":", "if", "five", "is", "None", "and", "three", "is", "not", "None", ":", "ends", ".", "append", "(", "i", ")", "# 5) If more than 2, error with 'too many ends'.", "if", "len", "(", "ends", ")", ">", "2", ":", "raise", "AssemblyError", "(", "'Too many (>2) end oligos found.'", ")", "# 6) If more than 2, error with 'not enough ends'.", "if", "len", "(", "ends", ")", "<", "2", ":", "raise", "AssemblyError", "(", "'Not enough (<2) end oligos found.'", ")", "# NOTE:If 1-4 are satisfied, unique linear assembly has been found (proof?)", "# 8) Start with first end and build iteratively", "last_index", "=", "ends", "[", "0", "]", "assembly", "=", "dna_list", "[", "last_index", "]", "flip", "=", "True", "# This would be slightly less complicated if the sequences were tied to", "# their match info in a tuple", "# Append next region n - 1 times", "for", "i", "in", "range", "(", "len", "(", "dna_list", ")", "-", "1", ")", ":", "if", "flip", ":", "# Next oligo needs to be flipped before concatenation", "# Grab 3' match from last oligo's info", "current_index", ",", "matchlen", "=", "zipped", "[", "last_index", "]", "[", "1", "]", "# Get new oligo sequence, make double-stranded for concatenation", "next_oligo", "=", "dna_list", "[", "current_index", "]", ".", "to_ds", "(", ")", "# Reverse complement for concatenation", "next_oligo", "=", "next_oligo", ".", "reverse_complement", "(", ")", "# Don't reverse complement the next one", "flip", "=", "False", "else", ":", "# Grab 5' match from last oligo's info", "current_index", ",", "matchlen", "=", "zipped", "[", "last_index", "]", "[", "0", "]", "# Get new oligo sequence, make double-stranded for concatenation", "next_oligo", "=", "dna_list", "[", "current_index", "]", ".", "to_ds", "(", ")", "# Reverse complement the next one", "flip", "=", "True", "# Trim overlap from new sequence", "next_oligo", "=", "next_oligo", "[", "(", "matchlen", "-", "1", ")", ":", "]", "# Concatenate and update last oligo's information", "assembly", "+=", "next_oligo", "last_index", "=", "current_index", "if", "reference", ":", "if", "assembly", "==", "reference", "or", "assembly", "==", "reference", ".", "reverse_complement", "(", ")", ":", "return", "assembly", "else", ":", "raise", "AssemblyError", "(", "'Assembly did not match reference'", ")", "else", ":", "return", "assembly" ]

[ "Given", "a", "list", "of", "DNA", "sequences", "assemble", "into", "a", "single", "construct", ".", ":", "param", "dna_list", ":", "List", "of", "DNA", "sequences", "-", "they", "must", "be", "single", "-", "stranded", ".", ":", "type", "dna_list", ":", "coral", ".", "DNA", "list", ":", "param", "reference", ":", "Expected", "sequence", "-", "once", "assembly", "completed", "this", "will", "be", "used", "to", "reorient", "the", "DNA", "(", "assembly", "could", "potentially", "occur", "from", "either", "side", "of", "a", "linear", "DNA", "construct", "if", "oligos", "are", "in", "a", "random", "order", ")", ".", "If", "this", "fails", "an", "AssemblyError", "is", "raised", ".", ":", "type", "reference", ":", "coral", ".", "DNA", ":", "raises", ":", "AssemblyError", "if", "it", "can", "t", "assemble", "for", "any", "reason", ".", ":", "returns", ":", "A", "single", "assembled", "DNA", "sequence", ":", "rtype", ":", "coral", ".", "DNA" ]

[ "def", "bind_unique", "(", "reference", ",", "query_list", ",", "min_overlap", "=", "12", ",", "right", "=", "True", ")", ":", "size", "=", "min_overlap", "found", "=", "[", "]", "# Reverse complementing here provides massive speedup?", "rev_query", "=", "[", "seq", ".", "reverse_complement", "(", ")", "for", "seq", "in", "query_list", "]", "while", "not", "found", "and", "not", "size", ">", "len", "(", "reference", ")", ":", "for", "i", ",", "seq", "in", "enumerate", "(", "rev_query", ")", ":", "if", "right", ":", "# FIXME: these getitems are the slowest part of assembly", "# Easiest speedup?", "if", "reference", ".", "endswith", "(", "seq", "[", ":", "size", "]", ")", ":", "found", ".", "append", "(", "i", ")", "else", ":", "if", "reference", ".", "startswith", "(", "seq", "[", "-", "size", ":", "]", ")", ":", "found", ".", "append", "(", "i", ")", "size", "+=", "1", "if", "len", "(", "found", ")", ">", "1", ":", "raise", "AssemblyError", "(", "'Ambiguous oligo binding'", ")", "if", "not", "found", ":", "return", "None", "else", ":", "return", "found", "[", "0", "]", ",", "size" ]

[ "(", "5", "or", "3", "region", "on", "reference", "sequence", "that", "uniquely", "matches", "the", "reverse", "complement", "of", "the", "associated", "(", "5", "or", "3", ")", "region", "of", "one", "sequence", "in", "a", "list", "of", "query", "sequences", "." ]

[ "def", "nonmatches", "(", "self", ")", ":", "# For every result, keep a dictionary of mismatches, insertions, and", "# deletions", "report", "=", "[", "]", "for", "result", "in", "self", ".", "aligned_results", ":", "report", ".", "append", "(", "self", ".", "_analyze_single", "(", "self", ".", "aligned_reference", ",", "result", ")", ")", "return", "report" ]

[ "Report", "mismatches", "indels", "and", "coverage", "." ]

[ "def", "plot", "(", "self", ")", ":", "import", "matplotlib", ".", "pyplot", "as", "plt", "import", "matplotlib", ".", "patches", "as", "patches", "# Constants to use throughout drawing", "n", "=", "len", "(", "self", ".", "results", ")", "nbases", "=", "len", "(", "self", ".", "aligned_reference", ")", "barheight", "=", "0.4", "# Vary height of figure based on number of results", "figheight", "=", "3", "+", "3", "*", "(", "n", "-", "1", ")", "fig", "=", "plt", ".", "figure", "(", "figsize", "=", "(", "9", ",", "figheight", ")", ")", "ax1", "=", "fig", ".", "add_subplot", "(", "111", ")", "# Plot bars to represent coverage area", "# Reference sequence", "ax1", ".", "add_patch", "(", "patches", ".", "Rectangle", "(", "(", "0", ",", "0", ")", ",", "nbases", ",", "barheight", ",", "facecolor", "=", "'black'", ")", ")", "# Results", "for", "i", ",", "report", "in", "enumerate", "(", "self", ".", "nonmatches", "(", ")", ")", ":", "j", "=", "i", "+", "1", "start", ",", "stop", "=", "report", "[", "'coverage'", "]", "patch", "=", "patches", ".", "Rectangle", "(", "(", "start", ",", "j", ")", ",", "stop", "-", "start", ",", "barheight", ",", "facecolor", "=", "'darkgray'", ")", "ax1", ".", "add_patch", "(", "patch", ")", "# Draw a vertical line for each type of result", "plt", ".", "vlines", "(", "report", "[", "'mismatches'", "]", ",", "j", ",", "j", "+", "barheight", ",", "colors", "=", "'b'", ")", "plt", ".", "vlines", "(", "report", "[", "'insertions'", "]", ",", "j", ",", "j", "+", "barheight", ",", "colors", "=", "'r'", ")", "# Terminal trailing deletions shouldn't be added", "deletions", "=", "[", "]", "crange", "=", "range", "(", "*", "report", "[", "'coverage'", "]", ")", "deletions", "=", "[", "idx", "for", "idx", "in", "report", "[", "'deletions'", "]", "if", "idx", "in", "crange", "]", "plt", ".", "vlines", "(", "deletions", ",", "j", ",", "j", "+", "barheight", ",", "colors", "=", "'g'", ")", "ax1", ".", "set_xlim", "(", "(", "0", ",", "nbases", ")", ")", "ax1", ".", "set_ylim", "(", "(", "-", "0.3", ",", "n", "+", "1", ")", ")", "ax1", ".", "set_yticks", "(", "[", "i", "+", "barheight", "/", "2", "for", "i", "in", "range", "(", "n", "+", "1", ")", "]", ")", "ax1", ".", "set_yticklabels", "(", "[", "'Reference'", "]", "+", "self", ".", "names", ")", "# Add legend", "mismatch_patch", "=", "patches", ".", "Patch", "(", "color", "=", "'blue'", ",", "label", "=", "'Mismatch'", ")", "insertion_patch", "=", "patches", ".", "Patch", "(", "color", "=", "'red'", ",", "label", "=", "'Insertion'", ")", "deletion_patch", "=", "patches", ".", "Patch", "(", "color", "=", "'green'", ",", "label", "=", "'Deletion'", ")", "plt", ".", "legend", "(", "handles", "=", "[", "mismatch_patch", ",", "insertion_patch", ",", "deletion_patch", "]", ",", "loc", "=", "1", ",", "ncol", "=", "3", ",", "mode", "=", "'expand'", ",", "borderaxespad", "=", "0.", ")", "plt", ".", "show", "(", ")" ]

[ "Make", "a", "summary", "plot", "of", "the", "alignment", "and", "highlight", "nonmatches", "." ]

[ "def", "_analyze_single", "(", "self", ",", "reference", ",", "result", ")", ":", "# TODO: Recalculate coverage based on reference (e.g. sequencing result", "# longer than template", "reference_str", "=", "str", "(", "reference", ")", "result_str", "=", "str", "(", "result", ")", "report", "=", "{", "'mismatches'", ":", "[", "]", ",", "'insertions'", ":", "[", "]", ",", "'deletions'", ":", "[", "]", "}", "for", "i", ",", "(", "ref", ",", "res", ")", "in", "enumerate", "(", "zip", "(", "reference_str", ",", "result_str", ")", ")", ":", "if", "ref", "!=", "res", ":", "# It's a mismatch or indel", "if", "ref", "==", "'-'", ":", "report", "[", "'insertions'", "]", ".", "append", "(", "i", ")", "if", "res", "==", "'-'", ":", "report", "[", "'deletions'", "]", ".", "append", "(", "i", ")", "else", ":", "report", "[", "'mismatches'", "]", ".", "append", "(", "i", ")", "start", "=", "len", "(", "result_str", ")", "-", "len", "(", "result_str", ".", "lstrip", "(", "'-'", ")", ")", "stop", "=", "len", "(", "result_str", ")", "-", "len", "(", "result_str", ".", "rstrip", "(", "'-'", ")", ")", "report", "[", "'coverage'", "]", "=", "[", "start", ",", "stop", "]", "return", "report" ]

[ "Report", "mistmatches", "and", "indels", "for", "a", "single", "(", "aligned", ")", "reference", "and", "result", "." ]

[ "def", "_remove_n", "(", "self", ")", ":", "for", "i", ",", "result", "in", "enumerate", "(", "self", ".", "results", ")", ":", "largest", "=", "max", "(", "str", "(", "result", ")", ".", "split", "(", "'N'", ")", ",", "key", "=", "len", ")", "start", "=", "result", ".", "locate", "(", "largest", ")", "[", "0", "]", "[", "0", "]", "stop", "=", "start", "+", "len", "(", "largest", ")", "if", "start", "!=", "stop", ":", "self", ".", "results", "[", "i", "]", "=", "self", ".", "results", "[", "i", "]", "[", "start", ":", "stop", "]" ]

[ "Remove", "terminal", "Ns", "from", "sequencing", "results", "." ]

[ "def", "random_dna", "(", "n", ")", ":", "return", "coral", ".", "DNA", "(", "''", ".", "join", "(", "[", "random", ".", "choice", "(", "'ATGC'", ")", "for", "i", "in", "range", "(", "n", ")", "]", ")", ")" ]

[ "Generate", "a", "random", "DNA", "sequence", "." ]

[ "def", "random_codons", "(", "peptide", ",", "frequency_cutoff", "=", "0.0", ",", "weighted", "=", "False", ",", "table", "=", "None", ")", ":", "if", "table", "is", "None", ":", "table", "=", "CODON_FREQ_BY_AA", "[", "'sc'", "]", "# Process codon table using frequency_cutoff", "new_table", "=", "_cutoff", "(", "table", ",", "frequency_cutoff", ")", "# Select codons randomly or using weighted distribution", "rna", "=", "''", "for", "amino_acid", "in", "str", "(", "peptide", ")", ":", "codons", "=", "new_table", "[", "amino_acid", ".", "upper", "(", ")", "]", "if", "not", "codons", ":", "raise", "ValueError", "(", "'No {} codons at freq cutoff'", ".", "format", "(", "amino_acid", ")", ")", "if", "weighted", ":", "cumsum", "=", "[", "]", "running_sum", "=", "0", "for", "codon", ",", "frequency", "in", "codons", ".", "iteritems", "(", ")", ":", "running_sum", "+=", "frequency", "cumsum", ".", "append", "(", "running_sum", ")", "random_num", "=", "random", ".", "uniform", "(", "0", ",", "max", "(", "cumsum", ")", ")", "for", "codon", ",", "value", "in", "zip", "(", "codons", ",", "cumsum", ")", ":", "if", "value", ">", "random_num", ":", "selection", "=", "codon", "break", "else", ":", "selection", "=", "random", ".", "choice", "(", "codons", ".", "keys", "(", ")", ")", "rna", "+=", "selection", "return", "coral", ".", "RNA", "(", "rna", ")" ]

[ "Generate", "randomized", "codons", "given", "a", "peptide", "sequence", "." ]

[ "def", "_cutoff", "(", "table", ",", "frequency_cutoff", ")", ":", "new_table", "=", "{", "}", "# IDEA: cutoff should be relative to most-frequent codon, not average?", "for", "amino_acid", ",", "codons", "in", "table", ".", "iteritems", "(", ")", ":", "average_cutoff", "=", "frequency_cutoff", "*", "sum", "(", "codons", ".", "values", "(", ")", ")", "/", "len", "(", "codons", ")", "new_table", "[", "amino_acid", "]", "=", "{", "}", "for", "codon", ",", "frequency", "in", "codons", ".", "iteritems", "(", ")", ":", "if", "frequency", ">", "average_cutoff", ":", "new_table", "[", "amino_acid", "]", "[", "codon", "]", "=", "frequency", "return", "new_table" ]

[ "Generate", "new", "codon", "frequency", "table", "given", "a", "mean", "cutoff", "." ]

[ "def", "fetch_genome", "(", "genome_id", ")", ":", "# TODO: Can strandedness by found in fetched genome attributes?", "# TODO: skip read/write step?", "# Using a dummy email for now - does this violate NCBI guidelines?", "email", "=", "'[email protected]'", "Entrez", ".", "email", "=", "email", "print", "'Downloading Genome...'", "handle", "=", "Entrez", ".", "efetch", "(", "db", "=", "'nucleotide'", ",", "id", "=", "str", "(", "genome_id", ")", ",", "rettype", "=", "'gb'", ",", "retmode", "=", "'text'", ")", "print", "'Genome Downloaded...'", "tmpfile", "=", "os", ".", "path", ".", "join", "(", "mkdtemp", "(", ")", ",", "'tmp.gb'", ")", "with", "open", "(", "tmpfile", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "handle", ".", "read", "(", ")", ")", "genome", "=", "coral", ".", "seqio", ".", "read_dna", "(", "tmpfile", ")", "return", "genome" ]

[ "Acquire", "a", "genome", "from", "Entrez" ]

[ "def", "cofold", "(", "self", ",", "strand1", ",", "strand2", ",", "temp", "=", "37.0", ",", "dangles", "=", "2", ",", "nolp", "=", "False", ",", "nogu", "=", "False", ",", "noclosinggu", "=", "False", ",", "constraints", "=", "None", ",", "canonicalbponly", "=", "False", ",", "partition", "=", "-", "1", ",", "pfscale", "=", "None", ",", "gquad", "=", "False", ")", ":", "cmd_args", "=", "[", "]", "cmd_kwargs", "=", "{", "'--temp='", ":", "str", "(", "temp", ")", "}", "cmd_kwargs", "[", "'--dangles='", "]", "=", "dangles", "if", "nolp", ":", "cmd_args", ".", "append", "(", "'--noLP'", ")", "if", "nogu", ":", "cmd_args", ".", "append", "(", "'--noGU'", ")", "if", "noclosinggu", ":", "cmd_args", ".", "append", "(", "'--noClosingGU'", ")", "if", "constraints", "is", "not", "None", ":", "cmd_args", ".", "append", "(", "'--constraint'", ")", "if", "canonicalbponly", ":", "cmd_args", ".", "append", "(", "'--canonicalBPonly'", ")", "if", "partition", ":", "cmd_args", ".", "append", "(", "'--partfunc'", ")", "if", "pfscale", "is", "not", "None", ":", "cmd_kwargs", "[", "'pfScale'", "]", "=", "float", "(", "pfscale", ")", "if", "gquad", ":", "cmd_args", ".", "append", "(", "'--gquad'", ")", "inputs", "=", "[", "'>strands\\n{}&{}'", ".", "format", "(", "str", "(", "strand1", ")", ",", "str", "(", "strand2", ")", ")", "]", "if", "constraints", "is", "not", "None", ":", "inputs", ".", "append", "(", "constraints", ")", "rnafold_output", "=", "self", ".", "_run", "(", "'RNAcofold'", ",", "inputs", ",", "cmd_args", ",", "cmd_kwargs", ")", "# Process the output", "output", "=", "{", "}", "lines", "=", "rnafold_output", ".", "splitlines", "(", ")", "# Line 1 is the name of the sequence input, line 2 is the sequence", "lines", ".", "pop", "(", "0", ")", "lines", ".", "pop", "(", "0", ")", "# Line 3 is the dotbracket + mfe for strand1", "line3", "=", "lines", ".", "pop", "(", "0", ")", "output", "[", "'dotbracket'", "]", "=", "self", ".", "_lparse", "(", "line3", ",", "'^(.*) \\('", ")", "output", "[", "'mfe'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line3", ",", "' \\((.*)\\)$'", ")", ")", "# Optional outputs", "if", "partition", ":", "# Line 4 is 'a coarse representation of the pair probabilities' and", "# the ensemble free energy", "line4", "=", "lines", ".", "pop", "(", "0", ")", "output", "[", "'coarse'", "]", "=", "self", ".", "_lparse", "(", "line4", ",", "'^(.*) \\['", ")", "output", "[", "'ensemble'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line4", ",", "' \\[(.*)\\]$'", ")", ")", "# Line 5 is the centroid structure, its free energy, and distance", "# to the ensemble", "line5", "=", "lines", ".", "pop", "(", "0", ")", "'ensemble (.*),'", "output", "[", "'frequency'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line5", ",", "'ensemble (.*),'", ")", ")", "output", "[", "'deltaG'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line5", ",", "'binding=(.*)$'", ")", ")", "# Parse the postscript file (the only place the probability matrix", "# is)", "with", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'strands_dp.ps'", ")", ")", "as", "f", ":", "pattern", "=", "'start of base pair probability data\\n(.*)\\nshowpage'", "dotplot_file", "=", "f", ".", "read", "(", ")", "dotplot_data", "=", "re", ".", "search", "(", "pattern", ",", "dotplot_file", ",", "flags", "=", "re", ".", "DOTALL", ")", ".", "group", "(", "1", ")", ".", "split", "(", "'\\n'", ")", "# Dimension of the dotplot - compares seq1, seq2 to self and", "# to each other (concatenation of seq1 and seq2 = axis)", "dim", "=", "len", "(", "strand1", ")", "+", "len", "(", "strand2", ")", "ensemble_probs", "=", "np", ".", "zeros", "(", "(", "dim", ",", "dim", ")", ")", "optimal_probs", "=", "np", ".", "zeros", "(", "(", "dim", ",", "dim", ")", ")", "for", "point", "in", "dotplot_data", ":", "point_split", "=", "point", ".", "split", "(", "' '", ")", "# Use zero indexing", "i", "=", "int", "(", "point_split", "[", "0", "]", ")", "-", "1", "j", "=", "int", "(", "point_split", "[", "1", "]", ")", "-", "1", "sqprob", "=", "float", "(", "point_split", "[", "2", "]", ")", "probtype", "=", "point_split", "[", "3", "]", "if", "probtype", "==", "'ubox'", ":", "ensemble_probs", "[", "i", "]", "[", "j", "]", "=", "sqprob", "**", "2", "else", ":", "optimal_probs", "[", "i", "]", "[", "j", "]", "=", "sqprob", "**", "2", "output", "[", "'ensemble_matrix'", "]", "=", "ensemble_probs", "output", "[", "'optimal_matrix'", "]", "=", "optimal_probs", "return", "output" ]

[ "Run", "the", "RNAcofold", "command", "and", "retrieve", "the", "result", "in", "a", "dictionary", "." ]

[ "def", "fold", "(", "self", ",", "strand", ",", "temp", "=", "37.0", ",", "dangles", "=", "2", ",", "nolp", "=", "False", ",", "nogu", "=", "False", ",", "noclosinggu", "=", "False", ",", "constraints", "=", "None", ",", "canonicalbponly", "=", "False", ",", "partition", "=", "False", ",", "pfscale", "=", "None", ",", "imfeelinglucky", "=", "False", ",", "gquad", "=", "False", ")", ":", "cmd_args", "=", "[", "]", "cmd_kwargs", "=", "{", "'--temp='", ":", "str", "(", "temp", ")", "}", "cmd_kwargs", "[", "'--dangles='", "]", "=", "dangles", "if", "nolp", ":", "cmd_args", ".", "append", "(", "'--noLP'", ")", "if", "nogu", ":", "cmd_args", ".", "append", "(", "'--noGU'", ")", "if", "noclosinggu", ":", "cmd_args", ".", "append", "(", "'--noClosingGU'", ")", "if", "constraints", "is", "not", "None", ":", "cmd_args", ".", "append", "(", "'--constraint'", ")", "if", "canonicalbponly", ":", "cmd_args", ".", "append", "(", "'--canonicalBPonly'", ")", "if", "partition", ":", "cmd_args", ".", "append", "(", "'--partfunc'", ")", "if", "pfscale", "is", "not", "None", ":", "cmd_kwargs", "[", "'pfScale'", "]", "=", "float", "(", "pfscale", ")", "if", "gquad", ":", "cmd_args", ".", "append", "(", "'--gquad'", ")", "inputs", "=", "[", "str", "(", "strand", ")", "]", "if", "constraints", "is", "not", "None", ":", "inputs", ".", "append", "(", "constraints", ")", "if", "strand", ".", "circular", ":", "cmd_args", ".", "append", "(", "'--circ'", ")", "rnafold_output", "=", "self", ".", "_run", "(", "'RNAfold'", ",", "inputs", ",", "cmd_args", ",", "cmd_kwargs", ")", "# Process the output", "output", "=", "{", "}", "lines", "=", "rnafold_output", ".", "splitlines", "(", ")", "# Line 1 is the sequence as RNA", "lines", ".", "pop", "(", "0", ")", "# Line 2 is the dotbracket + mfe", "line2", "=", "lines", ".", "pop", "(", "0", ")", "output", "[", "'dotbracket'", "]", "=", "self", ".", "_lparse", "(", "line2", ",", "'^(.*) \\('", ")", "output", "[", "'mfe'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line2", ",", "' \\((.*)\\)$'", ")", ")", "# Optional outputs", "if", "partition", ":", "# Line 3 is 'a coarse representation of the pair probabilities' and", "# the ensemble free energy", "line3", "=", "lines", ".", "pop", "(", "0", ")", "output", "[", "'coarse'", "]", "=", "self", ".", "_lparse", "(", "line3", ",", "'^(.*) \\['", ")", "output", "[", "'ensemble'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line3", ",", "' \\[(.*)\\]$'", ")", ")", "# Line 4 is the centroid structure, its free energy, and distance", "# to the ensemble", "line4", "=", "lines", ".", "pop", "(", "0", ")", "output", "[", "'centroid'", "]", "=", "self", ".", "_lparse", "(", "line4", ",", "'^(.*) \\{'", ")", "output", "[", "'centroid_fe'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line4", ",", "'^.*{(.*) d'", ")", ")", "output", "[", "'centroid_d'", "]", "=", "float", "(", "self", ".", "_lparse", "(", "line4", ",", "'d=(.*)}$'", ")", ")", "return", "output" ]

[ "Run", "the", "RNAfold", "command", "and", "retrieve", "the", "result", "in", "a", "dictionary", "." ]

[ "def", "dimers", "(", "primer1", ",", "primer2", ",", "concentrations", "=", "[", "5e-7", ",", "3e-11", "]", ")", ":", "# It is not reasonable (yet) to use a long template for doing these", "# computations directly, as NUPACK does an exhaustive calculation and", "# would take too long without a cluster.", "# Instead, this function compares primer-primer binding to", "# primer-complement binding", "# Simulate binding of template vs. primers", "nupack", "=", "coral", ".", "analysis", ".", "NUPACK", "(", "[", "primer1", ".", "primer", "(", ")", ",", "primer2", ".", "primer", "(", ")", ",", "primer1", ".", "primer", "(", ")", ".", "reverse_complement", "(", ")", ",", "primer2", ".", "primer", "(", ")", ".", "reverse_complement", "(", ")", "]", ")", "# Include reverse complement concentration", "primer_concs", "=", "[", "concentrations", "[", "0", "]", "]", "*", "2", "template_concs", "=", "[", "concentrations", "[", "1", "]", "]", "*", "2", "concs", "=", "primer_concs", "+", "template_concs", "nupack_concs", "=", "nupack", ".", "concentrations", "(", "2", ",", "conc", "=", "concs", ")", "dimer_conc", "=", "nupack_concs", "[", "'concentrations'", "]", "[", "5", "]", "#primer1_template = nupack_concs['concentrations'][6]", "#primer2_template = nupack_concs['concentrations'][10]", "return", "dimer_conc", "/", "concs", "[", "0", "]" ]

[ "Calculate", "expected", "fraction", "of", "primer", "dimers", "." ]

[ "def", "read_dna", "(", "path", ")", ":", "filename", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "split", "(", "path", ")", "[", "-", "1", "]", ")", "genbank_exts", "=", "[", "'.gb'", ",", "'.ape'", "]", "fasta_exts", "=", "[", "'.fasta'", ",", "'.fa'", ",", "'.fsa'", ",", "'.seq'", "]", "abi_exts", "=", "[", "'.abi'", ",", "'.ab1'", "]", "if", "any", "(", "[", "ext", "==", "extension", "for", "extension", "in", "genbank_exts", "]", ")", ":", "file_format", "=", "'genbank'", "elif", "any", "(", "[", "ext", "==", "extension", "for", "extension", "in", "fasta_exts", "]", ")", ":", "file_format", "=", "'fasta'", "elif", "any", "(", "[", "ext", "==", "extension", "for", "extension", "in", "abi_exts", "]", ")", ":", "file_format", "=", "'abi'", "else", ":", "raise", "ValueError", "(", "'File format not recognized.'", ")", "seq", "=", "SeqIO", ".", "read", "(", "path", ",", "file_format", ")", "dna", "=", "coral", ".", "DNA", "(", "str", "(", "seq", ".", "seq", ")", ")", "if", "seq", ".", "name", "==", "'.'", ":", "dna", ".", "name", "=", "filename", "else", ":", "dna", ".", "name", "=", "seq", ".", "name", "# Features", "for", "feature", "in", "seq", ".", "features", ":", "try", ":", "dna", ".", "features", ".", "append", "(", "_seqfeature_to_coral", "(", "feature", ")", ")", "except", "FeatureNameError", ":", "pass", "dna", ".", "features", "=", "sorted", "(", "dna", ".", "features", ",", "key", "=", "lambda", "feature", ":", "feature", ".", "start", ")", "# Used to use data_file_division, but it's inconsistent (not always the", "# molecule type)", "dna", ".", "circular", "=", "False", "with", "open", "(", "path", ")", "as", "f", ":", "first_line", "=", "f", ".", "read", "(", ")", ".", "split", "(", ")", "for", "word", "in", "first_line", ":", "if", "word", "==", "'circular'", ":", "dna", ".", "circular", "=", "True", "return", "dna" ]

[ "Read", "DNA", "from", "file", ".", "Uses", "BioPython", "and", "coerces", "to", "coral", "format", "." ]

[ "def", "read_sequencing", "(", "directory", ")", ":", "dirfiles", "=", "os", ".", "listdir", "(", "directory", ")", "seq_exts", "=", "[", "'.seq'", ",", "'.abi'", ",", "'.ab1'", "]", "# Exclude files that aren't sequencing results", "seq_paths", "=", "[", "x", "for", "x", "in", "dirfiles", "if", "os", ".", "path", ".", "splitext", "(", "x", ")", "[", "1", "]", "in", "seq_exts", "]", "paths", "=", "[", "os", ".", "path", ".", "join", "(", "directory", ",", "x", ")", "for", "x", "in", "seq_paths", "]", "sequences", "=", "[", "read_dna", "(", "x", ")", "for", "x", "in", "paths", "]", "return", "sequences" ]

[ "Read", ".", "seq", "and", ".", "abi", "/", ".", "ab1", "results", "files", "from", "a", "dir", "." ]

[ "def", "write_dna", "(", "dna", ",", "path", ")", ":", "# Check if path filetype is valid, remember for later", "ext", "=", "os", ".", "path", ".", "splitext", "(", "path", ")", "[", "1", "]", "if", "ext", "==", "'.gb'", "or", "ext", "==", "'.ape'", ":", "filetype", "=", "'genbank'", "elif", "ext", "==", "'.fa'", "or", "ext", "==", "'.fasta'", ":", "filetype", "=", "'fasta'", "else", ":", "raise", "ValueError", "(", "'Only genbank or fasta files are supported.'", ")", "# Convert features to Biopython form", "# Information lost on conversion:", "# specificity of feature type", "# strandedness", "# topology", "features", "=", "[", "]", "for", "feature", "in", "dna", ".", "features", ":", "features", ".", "append", "(", "_coral_to_seqfeature", "(", "feature", ")", ")", "# Biopython doesn't like 'None' here", "# FIXME: this is a legacy feature - remove?", "bio_id", "=", "dna", ".", "id", "if", "hasattr", "(", "dna", ",", "'id'", ")", "else", "''", "# Maximum length of name is 16", "seq", "=", "SeqRecord", "(", "Seq", "(", "str", "(", "dna", ")", ",", "alphabet", "=", "ambiguous_dna", ")", ",", "id", "=", "bio_id", ",", "name", "=", "dna", ".", "name", "[", "0", ":", "16", "]", ".", "replace", "(", "' '", ",", "'_'", ")", ",", "features", "=", "features", ",", "description", "=", "dna", ".", "name", ")", "if", "dna", ".", "circular", ":", "seq", ".", "annotations", "[", "'data_file_division'", "]", "=", "'circular'", "else", ":", "seq", ".", "annotations", "[", "'data_file_division'", "]", "=", "'linear'", "if", "filetype", "==", "'genbank'", ":", "SeqIO", ".", "write", "(", "seq", ",", "path", ",", "'genbank'", ")", "elif", "filetype", "==", "'fasta'", ":", "SeqIO", ".", "write", "(", "seq", ",", "path", ",", "'fasta'", ")" ]

[ "Write", "DNA", "to", "a", "file", "(", "genbank", "or", "fasta", ")", "." ]

[ "def", "write_primers", "(", "primer_list", ",", "path", ",", "names", "=", "None", ",", "notes", "=", "None", ")", ":", "# Check for notes and names having the right length, apply them to primers", "if", "names", "is", "not", "None", ":", "if", "len", "(", "names", ")", "!=", "len", "(", "primer_list", ")", ":", "names_msg", "=", "'Mismatch in number of notes and primers.'", "raise", "PrimerAnnotationError", "(", "names_msg", ")", "for", "i", ",", "name", "in", "enumerate", "(", "names", ")", ":", "primer_list", "[", "i", "]", ".", "name", "=", "name", "if", "notes", "is", "not", "None", ":", "if", "len", "(", "notes", ")", "!=", "len", "(", "primer_list", ")", ":", "notes_msg", "=", "'Mismatch in number of notes and primers.'", "raise", "PrimerAnnotationError", "(", "notes_msg", ")", "for", "i", ",", "note", "in", "enumerate", "(", "notes", ")", ":", "primer_list", "[", "i", "]", ".", "note", "=", "note", "# Write to csv", "with", "open", "(", "path", ",", "'w'", ")", "as", "csv_file", ":", "writer", "=", "csv", ".", "writer", "(", "csv_file", ")", "writer", ".", "writerow", "(", "[", "'name'", ",", "'sequence'", ",", "'notes'", "]", ")", "for", "primer", "in", "primer_list", ":", "string_rep", "=", "str", "(", "primer", ".", "overhang", ")", ".", "lower", "(", ")", "+", "str", "(", "primer", ".", "anneal", ")", "writer", ".", "writerow", "(", "[", "primer", ".", "name", ",", "string_rep", ",", "primer", ".", "note", "]", ")" ]

[ "Write", "a", "list", "of", "primers", "out", "to", "a", "csv", "file", ".", "The", "first", "three", "columns", "are", "compatible", "with", "the", "current", "IDT", "order", "form", "(", "name", "sequence", "notes", ")", ".", "By", "default", "there", "are", "no", "notes", "which", "is", "an", "optional", "parameter", "." ]

[ "def", "_process_feature_type", "(", "feature_type", ",", "bio_to_coral", "=", "True", ")", ":", "err_msg", "=", "'Unrecognized feature type: {}'", ".", "format", "(", "feature_type", ")", "if", "bio_to_coral", ":", "try", ":", "name", "=", "coral", ".", "constants", ".", "genbank", ".", "TO_CORAL", "[", "feature_type", "]", "except", "KeyError", ":", "raise", "ValueError", "(", "err_msg", ")", "else", ":", "try", ":", "name", "=", "coral", ".", "constants", ".", "genbank", ".", "TO_BIO", "[", "feature_type", "]", "except", "KeyError", ":", "raise", "ValueError", "(", "err_msg", ")", "return", "name" ]

[ "Translate", "genbank", "feature", "types", "into", "usable", "ones", "(", "currently", "identical", ")", ".", "The", "feature", "table", "is", "derived", "from", "the", "official", "genbank", "spec", "(", "gbrel", ".", "txt", ")", "available", "at", "http", ":", "//", "www", ".", "insdc", ".", "org", "/", "documents", "/", "feature", "-", "table" ]

[ "def", "_seqfeature_to_coral", "(", "feature", ")", ":", "# Some genomic sequences don't have a label attribute", "# TODO: handle genomic cases differently than others. Some features lack", "# a label but should still be incorporated somehow.", "qualifiers", "=", "feature", ".", "qualifiers", "if", "'label'", "in", "qualifiers", ":", "feature_name", "=", "qualifiers", "[", "'label'", "]", "[", "0", "]", "elif", "'locus_tag'", "in", "qualifiers", ":", "feature_name", "=", "qualifiers", "[", "'locus_tag'", "]", "[", "0", "]", "else", ":", "raise", "FeatureNameError", "(", "'Unrecognized feature name'", ")", "# Features with gaps are special, require looking at subfeatures", "# Assumption: subfeatures are never more than one level deep", "if", "feature", ".", "location_operator", "==", "'join'", ":", "# Feature has gaps. Have to figure out start/stop from subfeatures,", "# calculate gap indices. A nested feature model may be required", "# eventually.", "# Reorder the sub_feature list by start location", "# Assumption: none of the subfeatures overlap so the last entry in", "# the reordered list also has the final stop point of the feature.", "# FIXME: Getting a deprecation warning about using sub_features", "# instead of feature.location being a CompoundFeatureLocation", "reordered", "=", "sorted", "(", "feature", ".", "location", ".", "parts", ",", "key", "=", "lambda", "location", ":", "location", ".", "start", ")", "starts", "=", "[", "int", "(", "location", ".", "start", ")", "for", "location", "in", "reordered", "]", "stops", "=", "[", "int", "(", "location", ".", "end", ")", "for", "location", "in", "reordered", "]", "feature_start", "=", "starts", ".", "pop", "(", "0", ")", "feature_stop", "=", "stops", ".", "pop", "(", "-", "1", ")", "starts", "=", "[", "start", "-", "feature_start", "for", "start", "in", "starts", "]", "stops", "=", "[", "stop", "-", "feature_start", "for", "stop", "in", "stops", "]", "feature_gaps", "=", "list", "(", "zip", "(", "stops", ",", "starts", ")", ")", "else", ":", "# Feature doesn't have gaps. Ignore subfeatures.", "feature_start", "=", "int", "(", "feature", ".", "location", ".", "start", ")", "feature_stop", "=", "int", "(", "feature", ".", "location", ".", "end", ")", "feature_gaps", "=", "[", "]", "feature_type", "=", "_process_feature_type", "(", "feature", ".", "type", ")", "if", "feature", ".", "location", ".", "strand", "==", "-", "1", ":", "feature_strand", "=", "1", "else", ":", "feature_strand", "=", "0", "if", "'gene'", "in", "qualifiers", ":", "gene", "=", "qualifiers", "[", "'gene'", "]", "else", ":", "gene", "=", "[", "]", "if", "'locus_tag'", "in", "qualifiers", ":", "locus_tag", "=", "qualifiers", "[", "'locus_tag'", "]", "else", ":", "locus_tag", "=", "[", "]", "coral_feature", "=", "coral", ".", "Feature", "(", "feature_name", ",", "feature_start", ",", "feature_stop", ",", "feature_type", ",", "gene", "=", "gene", ",", "locus_tag", "=", "locus_tag", ",", "qualifiers", "=", "qualifiers", ",", "strand", "=", "feature_strand", ",", "gaps", "=", "feature_gaps", ")", "return", "coral_feature" ]

[ "Convert", "a", "Biopython", "SeqFeature", "to", "a", "coral", ".", "Feature", "." ]

[ "def", "_coral_to_seqfeature", "(", "feature", ")", ":", "bio_strand", "=", "1", "if", "feature", ".", "strand", "==", "1", "else", "-", "1", "ftype", "=", "_process_feature_type", "(", "feature", ".", "feature_type", ",", "bio_to_coral", "=", "False", ")", "sublocations", "=", "[", "]", "if", "feature", ".", "gaps", ":", "# There are gaps. Have to define location_operator and add subfeatures", "location_operator", "=", "'join'", "# Feature location means nothing for 'join' sequences?", "# TODO: verify", "location", "=", "FeatureLocation", "(", "ExactPosition", "(", "0", ")", ",", "ExactPosition", "(", "1", ")", ",", "strand", "=", "bio_strand", ")", "# Reconstruct start/stop indices for each subfeature", "stops", ",", "starts", "=", "zip", "(", "*", "feature", ".", "gaps", ")", "starts", "=", "[", "feature", ".", "start", "]", "+", "[", "start", "+", "feature", ".", "start", "for", "start", "in", "starts", "]", "stops", "=", "[", "stop", "+", "feature", ".", "start", "for", "stop", "in", "stops", "]", "+", "[", "feature", ".", "stop", "]", "# Build subfeatures", "for", "start", ",", "stop", "in", "zip", "(", "starts", ",", "stops", ")", ":", "sublocation", "=", "FeatureLocation", "(", "ExactPosition", "(", "start", ")", ",", "ExactPosition", "(", "stop", ")", ",", "strand", "=", "bio_strand", ")", "sublocations", ".", "append", "(", "sublocation", ")", "location", "=", "CompoundLocation", "(", "sublocations", ",", "operator", "=", "'join'", ")", "else", ":", "# No gaps, feature is simple", "location_operator", "=", "''", "location", "=", "FeatureLocation", "(", "ExactPosition", "(", "feature", ".", "start", ")", ",", "ExactPosition", "(", "feature", ".", "stop", ")", ",", "strand", "=", "bio_strand", ")", "qualifiers", "=", "feature", ".", "qualifiers", "qualifiers", "[", "'label'", "]", "=", "[", "feature", ".", "name", "]", "seqfeature", "=", "SeqFeature", "(", "location", ",", "type", "=", "ftype", ",", "qualifiers", "=", "qualifiers", ",", "location_operator", "=", "location_operator", ")", "return", "seqfeature" ]

[ "Convert", "a", "coral", ".", "Feature", "to", "a", "Biopython", "SeqFeature", "." ]

[ "def", "as_ord_matrix", "(", "matrix", ",", "alphabet", ")", ":", "ords", "=", "[", "ord", "(", "c", ")", "for", "c", "in", "alphabet", "]", "ord_matrix", "=", "np", ".", "zeros", "(", "(", "max", "(", "ords", ")", "+", "1", ",", "max", "(", "ords", ")", "+", "1", ")", ",", "dtype", "=", "np", ".", "integer", ")", "for", "i", ",", "row_ord", "in", "enumerate", "(", "ords", ")", ":", "for", "j", ",", "col_ord", "in", "enumerate", "(", "ords", ")", ":", "ord_matrix", "[", "row_ord", ",", "col_ord", "]", "=", "matrix", "[", "i", ",", "j", "]", "return", "ord_matrix" ]

[ "Given", "the", "SubstitutionMatrix", "input", "generate", "an", "equivalent", "matrix", "that", "is", "indexed", "by", "the", "ASCII", "number", "of", "each", "residue", "(", "e", ".", "g", ".", "A", "-", ">", "65", ")", "." ]

[ "def", "aligner", "(", "seqj", ",", "seqi", ",", "method", "=", "'global'", ",", "gap_open", "=", "-", "7", ",", "gap_extend", "=", "-", "7", ",", "gap_double", "=", "-", "7", ",", "matrix", "=", "submat", ".", "DNA_SIMPLE", ".", "matrix", ",", "alphabet", "=", "submat", ".", "DNA_SIMPLE", ".", "alphabet", ")", ":", "amatrix", "=", "as_ord_matrix", "(", "matrix", ",", "alphabet", ")", "NONE", ",", "LEFT", ",", "UP", ",", "DIAG", "=", "range", "(", "4", ")", "# NONE is 0", "max_j", "=", "len", "(", "seqj", ")", "max_i", "=", "len", "(", "seqi", ")", "if", "max_j", ">", "max_i", ":", "flip", "=", "1", "seqi", ",", "seqj", "=", "seqj", ",", "seqi", "max_i", ",", "max_j", "=", "max_j", ",", "max_i", "else", ":", "flip", "=", "0", "F", "=", "np", ".", "zeros", "(", "(", "max_i", "+", "1", ",", "max_j", "+", "1", ")", ",", "dtype", "=", "np", ".", "float32", ")", "I", "=", "np", ".", "ndarray", "(", "(", "max_i", "+", "1", ",", "max_j", "+", "1", ")", ",", "dtype", "=", "np", ".", "float32", ")", "I", ".", "fill", "(", "-", "np", ".", "inf", ")", "J", "=", "np", ".", "ndarray", "(", "(", "max_i", "+", "1", ",", "max_j", "+", "1", ")", ",", "dtype", "=", "np", ".", "float32", ")", "J", ".", "fill", "(", "-", "np", ".", "inf", ")", "pointer", "=", "np", ".", "zeros", "(", "(", "max_i", "+", "1", ",", "max_j", "+", "1", ")", ",", "dtype", "=", "np", ".", "uint", ")", "# NONE", "if", "method", "==", "'global'", ":", "pointer", "[", "0", ",", "1", ":", "]", "=", "LEFT", "pointer", "[", "1", ":", ",", "0", "]", "=", "UP", "F", "[", "0", ",", "1", ":", "]", "=", "gap_open", "+", "gap_extend", "*", "np", ".", "arange", "(", "0", ",", "max_j", ",", "dtype", "=", "np", ".", "float32", ")", "F", "[", "1", ":", ",", "0", "]", "=", "gap_open", "+", "gap_extend", "*", "np", ".", "arange", "(", "0", ",", "max_i", ",", "dtype", "=", "np", ".", "float32", ")", "elif", "method", "==", "'global_cfe'", ":", "pointer", "[", "0", ",", "1", ":", "]", "=", "LEFT", "pointer", "[", "1", ":", ",", "0", "]", "=", "UP", "elif", "method", "==", "'glocal'", ":", "pointer", "[", "0", ",", "1", ":", "]", "=", "LEFT", "F", "[", "0", ",", "1", ":", "]", "=", "gap_open", "+", "gap_extend", "*", "np", ".", "arange", "(", "0", ",", "max_j", ",", "dtype", "=", "np", ".", "float32", ")", "seqi_ord", "=", "[", "ord", "(", "base", ")", "for", "base", "in", "seqi", "]", "seqj_ord", "=", "[", "ord", "(", "base", ")", "for", "base", "in", "seqj", "]", "for", "i", "in", "range", "(", "1", ",", "max_i", "+", "1", ")", ":", "ci", "=", "seqi_ord", "[", "i", "-", "1", "]", "for", "j", "in", "range", "(", "1", ",", "max_j", "+", "1", ")", ":", "cj", "=", "seqj_ord", "[", "j", "-", "1", "]", "# I", "I", "[", "i", ",", "j", "]", "=", "max", "(", "F", "[", "i", ",", "j", "-", "1", "]", "+", "gap_open", ",", "I", "[", "i", ",", "j", "-", "1", "]", "+", "gap_extend", ",", "J", "[", "i", ",", "j", "-", "1", "]", "+", "gap_double", ")", "# J", "J", "[", "i", ",", "j", "]", "=", "max", "(", "F", "[", "i", "-", "1", ",", "j", "]", "+", "gap_open", ",", "J", "[", "i", "-", "1", ",", "j", "]", "+", "gap_extend", ",", "I", "[", "i", "-", "1", ",", "j", "]", "+", "gap_double", ")", "# F", "diag_score", "=", "F", "[", "i", "-", "1", ",", "j", "-", "1", "]", "+", "amatrix", "[", "ci", ",", "cj", "]", "left_score", "=", "I", "[", "i", ",", "j", "]", "up_score", "=", "J", "[", "i", ",", "j", "]", "max_score", "=", "max", "(", "diag_score", ",", "up_score", ",", "left_score", ")", "F", "[", "i", ",", "j", "]", "=", "max", "(", "0", ",", "max_score", ")", "if", "method", "==", "'local'", "else", "max_score", "if", "method", "==", "'local'", ":", "if", "F", "[", "i", ",", "j", "]", "==", "0", ":", "pass", "# point[i,j] = NONE", "elif", "max_score", "==", "diag_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "DIAG", "elif", "max_score", "==", "up_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "UP", "elif", "max_score", "==", "left_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "LEFT", "elif", "method", "==", "'glocal'", ":", "# In a semi-global alignment we want to consume as much as", "# possible of the longer sequence.", "if", "max_score", "==", "up_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "UP", "elif", "max_score", "==", "diag_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "DIAG", "elif", "max_score", "==", "left_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "LEFT", "else", ":", "# global", "if", "max_score", "==", "up_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "UP", "elif", "max_score", "==", "left_score", ":", "pointer", "[", "i", ",", "j", "]", "=", "LEFT", "else", ":", "pointer", "[", "i", ",", "j", "]", "=", "DIAG", "align_j", "=", "[", "]", "align_i", "=", "[", "]", "if", "method", "==", "'local'", ":", "# max anywhere", "i", ",", "j", "=", "max_index", "(", "F", ")", "elif", "method", "==", "'glocal'", ":", "# max in last col", "i", ",", "j", "=", "(", "F", "[", ":", ",", "-", "1", "]", ".", "argmax", "(", ")", ",", "max_j", ")", "elif", "method", "==", "'global_cfe'", ":", "# from i,j to max(max(last row), max(last col)) for free", "row_max", ",", "col_idx", "=", "F", "[", "-", "1", "]", ".", "max", "(", ")", ",", "F", "[", "-", "1", "]", ".", "argmax", "(", ")", "col_max", ",", "row_idx", "=", "F", "[", ":", ",", "-", "1", "]", ".", "max", "(", ")", ",", "F", "[", ":", ",", "-", "1", "]", ".", "argmax", "(", ")", "if", "row_max", ">", "col_max", ":", "pointer", "[", "-", "1", ",", "col_idx", "+", "1", ":", "]", "=", "LEFT", "else", ":", "pointer", "[", "row_idx", "+", "1", ":", ",", "-", "1", "]", "=", "UP", "p", "=", "pointer", "[", "i", ",", "j", "]", "while", "p", "!=", "NONE", ":", "if", "p", "==", "DIAG", ":", "i", "-=", "1", "j", "-=", "1", "align_j", ".", "append", "(", "seqj", "[", "j", "]", ")", "align_i", ".", "append", "(", "seqi", "[", "i", "]", ")", "elif", "p", "==", "LEFT", ":", "j", "-=", "1", "align_j", ".", "append", "(", "seqj", "[", "j", "]", ")", "align_i", ".", "append", "(", "'-'", ")", "elif", "p", "==", "UP", ":", "i", "-=", "1", "align_j", ".", "append", "(", "'-'", ")", "align_i", ".", "append", "(", "seqi", "[", "i", "]", ")", "else", ":", "raise", "Exception", "(", "'wtf!'", ")", "p", "=", "pointer", "[", "i", ",", "j", "]", "align_i", "=", "''", ".", "join", "(", "align_i", "[", ":", ":", "-", "1", "]", ")", "align_j", "=", "''", ".", "join", "(", "align_j", "[", ":", ":", "-", "1", "]", ")", "# np.array(align_i.reverse())", "return", "(", "(", "align_i", ",", "align_j", ")", "if", "flip", "else", "(", "align_j", ",", "align_i", ")", ")" ]

[ "Calculates", "the", "alignment", "of", "two", "sequences", ".", "The", "global", "method", "uses", "a", "global", "Needleman", "-", "Wunsh", "algorithm", "local", "does", "a", "a", "local", "Smith", "-", "Waterman", "alignment", "global_cfe", "does", "a", "global", "alignment", "with", "cost", "-", "free", "ends", "and", "glocal", "does", "an", "alignment", "which", "is", "global", "only", "with", "respect", "to", "the", "shorter", "sequence", "also", "known", "as", "a", "semi", "-", "global", "alignment", ".", "Returns", "the", "aligned", "(", "sub", ")", "sequences", "as", "character", "arrays", "." ]

[ "def", "score_alignment", "(", "a", ",", "b", ",", "gap_open", ",", "gap_extend", ",", "matrix", ")", ":", "al", "=", "a", "bl", "=", "b", "l", "=", "len", "(", "al", ")", "score", "=", "0", "assert", "len", "(", "bl", ")", "==", "l", ",", "'Alignment lengths must be the same'", "mat", "=", "as_ord_matrix", "(", "matrix", ")", "gap_started", "=", "0", "for", "i", "in", "range", "(", "l", ")", ":", "if", "al", "[", "i", "]", "==", "'-'", "or", "bl", "[", "i", "]", "==", "'-'", ":", "score", "+=", "gap_extend", "if", "gap_started", "else", "gap_open", "gap_started", "=", "1", "else", ":", "score", "+=", "mat", "[", "ord", "(", "al", "[", "i", "]", ")", ",", "ord", "(", "bl", "[", "i", "]", ")", "]", "gap_started", "=", "0", "return", "score" ]

[ "Calculate", "the", "alignment", "score", "from", "two", "aligned", "sequences", "." ]

[ "def", "build_docs", "(", "directory", ")", ":", "os", ".", "chdir", "(", "directory", ")", "process", "=", "subprocess", ".", "Popen", "(", "[", "\"make\"", ",", "\"html\"", "]", ",", "cwd", "=", "directory", ")", "process", ".", "communicate", "(", ")" ]

[ "Builds", "sphinx", "docs", "from", "a", "given", "directory", "." ]

[ "def", "gibson_primers", "(", "dna1", ",", "dna2", ",", "overlap", "=", "'mixed'", ",", "maxlen", "=", "80", ",", "overlap_tm", "=", "65.0", ",", "insert", "=", "None", ",", "primer_kwargs", "=", "None", ")", ":", "if", "primer_kwargs", "is", "None", ":", "primer_kwargs", "=", "{", "}", "# Annealing sequences", "# DNA 2 primer is a forward primer", "fwd_anneal", "=", "coral", ".", "design", ".", "primer", "(", "dna2", ",", "*", "*", "primer_kwargs", ")", "# DNA 1 primer is a reverse primer", "rev_anneal", "=", "coral", ".", "design", ".", "primer", "(", "dna1", ".", "flip", "(", ")", ",", "*", "*", "primer_kwargs", ")", "# Overhangs", "if", "insert", "is", "None", ":", "# No insert, so follow split argument", "if", "overlap", "==", "'left'", ":", "# If splitting left, put overhang on forward primer", "overlap_revcomp", "=", "coral", ".", "design", ".", "primer", "(", "dna1", ".", "flip", "(", ")", ",", "tm", "=", "overlap_tm", ",", "tm_undershoot", "=", "0", ")", "fwd_overhang", "=", "overlap_revcomp", ".", "primer", "(", ")", ".", "reverse_complement", "(", ")", "rev_overhang", "=", "None", "elif", "overlap", "==", "'right'", ":", "# If splitting right, put overhang on reverse primer", "overlap", "=", "coral", ".", "design", ".", "primer", "(", "dna2", ",", "tm", "=", "overlap_tm", ",", "tm_undershoot", "=", "0", ")", "fwd_overhang", "=", "None", "rev_overhang", "=", "overlap", ".", "primer", "(", ")", ".", "reverse_complement", "(", ")", "elif", "overlap", "==", "'mixed'", ":", "# If mixed, grow size of both until overlap Tm is reached", "overlap_l", "=", "dna1", "[", "0", ":", "0", "]", "# Empty sequence.DNA", "overlap_r", "=", "dna2", "[", "0", "]", "# First base", "overlap_melt", "=", "overlap_r", ".", "tm", "(", ")", "while", "overlap_melt", "<", "overlap_tm", ":", "rlen", "=", "len", "(", "overlap_r", ")", "llen", "=", "len", "(", "overlap_l", ")", "if", "rlen", ">", "llen", ":", "# Increase left side of overlap", "overlap_l", "=", "dna1", "[", "-", "(", "rlen", "+", "1", ")", ":", "]", "else", ":", "# Increase right side of overlap", "overlap_r", "=", "dna2", "[", ":", "(", "llen", "+", "1", ")", "]", "overlap", "=", "overlap_l", "+", "overlap_r", "overlap_melt", "=", "overlap", ".", "tm", "(", ")", "fwd_overhang", "=", "overlap_l", "rev_overhang", "=", "overlap_r", ".", "reverse_complement", "(", ")", "else", ":", "raise", "ValueError", "(", "'split argument must be left, right, or mixed'", ")", "# Generate primers using anneal, overhang, and tm data", "fwd", "=", "coral", ".", "Primer", "(", "fwd_anneal", ".", "primer", "(", ")", ",", "tm", "=", "fwd_anneal", ".", "tm", ",", "overhang", "=", "fwd_overhang", ")", "rev", "=", "coral", ".", "Primer", "(", "rev_anneal", ".", "primer", "(", ")", ",", "tm", "=", "rev_anneal", ".", "tm", ",", "overhang", "=", "rev_overhang", ")", "else", ":", "# There's an insert to use as the overhang", "overlap", "=", "insert", "fwd_overhang", "=", "insert", ".", "primer", "(", ")", "rev_overhang", "=", "insert", ".", "reverse_complement", "(", ")", ".", "primer", "(", ")", "# Generate primers using anneal, overhang, and tm data", "fwd", "=", "coral", ".", "Primer", "(", "fwd_anneal", ".", "primer", "(", ")", ",", "tm", "=", "fwd_anneal", ".", "tm", ",", "overhang", "=", "fwd_overhang", ")", "rev", "=", "coral", ".", "Primer", "(", "rev_anneal", ".", "primer", "(", ")", ",", "tm", "=", "rev_anneal", ".", "tm", ",", "overhang", "=", "rev_overhang", ")", "left_trim", "=", "0", "# If either primer is too long, try trimming the overhang", "while", "len", "(", "fwd", ")", ">", "maxlen", ":", "# Generate new overlap", "overlap", "=", "insert", "[", "left_trim", ":", "]", "# Tm must be above overlap_tm", "if", "coral", ".", "analysis", ".", "tm", "(", "overlap", ")", "<", "overlap_tm", ":", "raise", "TmError", "(", "'Right primer is too long with this Tm setting.'", ")", "# Regenerate forward overhang", "fwd_overhang", "=", "overlap", ".", "primer", "(", ")", "# Regenerate primer with new overhang", "fwd", "=", "coral", ".", "Primer", "(", "fwd_anneal", ".", "primer", "(", ")", ",", "tm", "=", "fwd_anneal", ".", "tm", ",", "overhang", "=", "fwd_overhang", ")", "# Increase 'trimming' index", "left_trim", "+=", "1", "right_trim", "=", "0", "while", "len", "(", "rev", ")", ">", "maxlen", ":", "# Generate new overlap", "overlap", "=", "insert", "[", ":", "len", "(", "insert", ")", "-", "right_trim", "]", "# Tm must be above overlap_tm", "if", "coral", ".", "analysis", ".", "tm", "(", "overlap", ")", "<", "overlap_tm", ":", "raise", "TmError", "(", "'Left primer is too long with this Tm setting.'", ")", "# Regenerate reverse overhang", "rev_overhang", "=", "overlap", ".", "reverse_complement", "(", ")", ".", "to_ss", "(", ")", "rev", "=", "coral", ".", "Primer", "(", "rev_anneal", ".", "to_ss", "(", ")", ",", "tm", "=", "rev_anneal", ".", "tm", ",", "overhang", "=", "rev_overhang", ")", "# Increase 'trimming' index", "right_trim", "+=", "1", "# Check primer lengths", "if", "any", "(", "[", "len", "(", "primer", ")", ">", "maxlen", "for", "primer", "in", "(", "fwd", ",", "rev", ")", "]", ")", ":", "raise", "LengthError", "(", "'At least one of the primers is longer than maxlen.'", ")", "return", "rev", ",", "fwd" ]

[ "Design", "Gibson", "primers", "given", "two", "DNA", "sequences", "(", "connect", "left", "to", "right", ")" ]

[ "def", "gibson", "(", "seq_list", ",", "circular", "=", "True", ",", "overlaps", "=", "'mixed'", ",", "overlap_tm", "=", "65", ",", "maxlen", "=", "80", ",", "terminal_primers", "=", "True", ",", "primer_kwargs", "=", "None", ")", ":", "# Input checking", "if", "circular", ":", "n_overlaps", "=", "len", "(", "seq_list", ")", "else", ":", "n_overlaps", "=", "len", "(", "seq_list", ")", "-", "1", "if", "type", "(", "overlaps", ")", "is", "str", ":", "overlaps", "=", "[", "overlaps", "]", "*", "n_overlaps", "else", ":", "if", "len", "(", "overlaps", ")", "!=", "n_overlaps", ":", "raise", "ValueError", "(", "'Incorrect number of \\'overlaps\\' entries.'", ")", "else", ":", "for", "overlap", "in", "overlaps", ":", "if", "overlap", "not", "in", "[", "'left'", ",", "'right'", ",", "'mixed'", "]", ":", "raise", "ValueError", "(", "'Invalid \\'overlaps\\' setting.'", ")", "if", "primer_kwargs", "is", "None", ":", "primer_kwargs", "=", "{", "}", "# If here, inputs were good", "# Design primers for linear constructs:", "primers_list", "=", "[", "]", "for", "i", ",", "(", "left", ",", "right", ")", "in", "enumerate", "(", "zip", "(", "seq_list", "[", ":", "-", "1", "]", ",", "seq_list", "[", "1", ":", "]", ")", ")", ":", "primers_list", ".", "append", "(", "gibson_primers", "(", "left", ",", "right", ",", "overlaps", "[", "i", "]", ",", "overlap_tm", "=", "overlap_tm", ",", "primer_kwargs", "=", "primer_kwargs", ")", ")", "if", "circular", ":", "primers_list", ".", "append", "(", "gibson_primers", "(", "seq_list", "[", "-", "1", "]", ",", "seq_list", "[", "0", "]", ",", "overlaps", "[", "-", "1", "]", ",", "overlap_tm", "=", "overlap_tm", ",", "primer_kwargs", "=", "primer_kwargs", ")", ")", "else", ":", "if", "terminal_primers", ":", "primer_f", "=", "coral", ".", "design", ".", "primer", "(", "seq_list", "[", "0", "]", ",", "*", "*", "primer_kwargs", ")", "primer_r", "=", "coral", ".", "design", ".", "primer", "(", "seq_list", "[", "-", "1", "]", ".", "reverse_complement", "(", ")", ",", "*", "*", "primer_kwargs", ")", "primers_list", ".", "append", "(", "(", "primer_r", ",", "primer_f", ")", ")", "# Primers are now in order of 'reverse for seq1, forward for seq2' config", "# Should be in 'forward and reverse primers for seq1, then seq2', etc", "# Just need to rotate one to the right", "flat", "=", "[", "y", "for", "x", "in", "primers_list", "for", "y", "in", "x", "]", "flat", "=", "[", "flat", "[", "-", "1", "]", "]", "+", "flat", "[", ":", "-", "1", "]", "grouped_primers", "=", "[", "(", "flat", "[", "2", "*", "i", "]", ",", "flat", "[", "2", "*", "i", "+", "1", "]", ")", "for", "i", "in", "range", "(", "len", "(", "flat", ")", "/", "2", ")", "]", "return", "grouped_primers" ]

[ "Design", "Gibson", "primers", "given", "a", "set", "of", "sequences" ]

[ "def", "_decompose", "(", "string", ",", "n", ")", ":", "binary", "=", "[", "int", "(", "x", ")", "for", "x", "in", "bin", "(", "n", ")", "[", "2", ":", "]", "]", "new_string", "=", "string", "counter", "=", "1", "while", "counter", "<=", "len", "(", "binary", ")", ":", "if", "binary", "[", "-", "counter", "]", ":", "yield", "new_string", "new_string", "+=", "new_string", "counter", "+=", "1" ]

[ "Given", "string", "and", "multiplier", "n", "find", "m", "**", "2", "decomposition", "." ]

[ "def", "reverse_complement", "(", "sequence", ",", "material", ")", ":", "code", "=", "dict", "(", "COMPLEMENTS", "[", "material", "]", ")", "reverse_sequence", "=", "sequence", "[", ":", ":", "-", "1", "]", "return", "''", ".", "join", "(", "[", "code", "[", "str", "(", "base", ")", "]", "for", "base", "in", "reverse_sequence", "]", ")" ]

[ "Reverse", "complement", "a", "sequence", "." ]

[ "def", "check_alphabet", "(", "seq", ",", "material", ")", ":", "errs", "=", "{", "'dna'", ":", "'DNA'", ",", "'rna'", ":", "'RNA'", ",", "'peptide'", ":", "'peptide'", "}", "if", "material", "==", "'dna'", "or", "material", "==", "'rna'", "or", "material", "==", "'peptide'", ":", "alphabet", "=", "ALPHABETS", "[", "material", "]", "err_msg", "=", "errs", "[", "material", "]", "else", ":", "msg", "=", "'Input material must be \\'dna\\', \\'rna\\', or \\'peptide\\'.'", "raise", "ValueError", "(", "msg", ")", "# This is a bottleneck when modifying sequence - hence the run_checks", "# optional parameter in sequence objects..", "# First attempt with cython was slower. Could also try pypy.", "if", "re", ".", "search", "(", "'[^'", "+", "alphabet", "+", "']'", ",", "seq", ")", ":", "raise", "ValueError", "(", "'Encountered a non-%s character'", "%", "err_msg", ")" ]

[ "Verify", "that", "a", "given", "string", "is", "valid", "DNA", "RNA", "or", "peptide", "characters", "." ]

[ "def", "process_seq", "(", "seq", ",", "material", ")", ":", "check_alphabet", "(", "seq", ",", "material", ")", "seq", "=", "seq", ".", "upper", "(", ")", "return", "seq" ]

[ "Validate", "and", "process", "sequence", "inputs", "." ]

[ "def", "palindrome", "(", "seq", ")", ":", "seq_len", "=", "len", "(", "seq", ")", "if", "seq_len", "%", "2", "==", "0", ":", "# Sequence has even number of bases, can test non-overlapping seqs", "wing", "=", "seq_len", "/", "2", "l_wing", "=", "seq", "[", "0", ":", "wing", "]", "r_wing", "=", "seq", "[", "wing", ":", "]", "if", "l_wing", "==", "r_wing", ".", "reverse_complement", "(", ")", ":", "return", "True", "else", ":", "return", "False", "else", ":", "# Sequence has odd number of bases and cannot be a palindrome", "return", "False" ]

[ "Test", "whether", "a", "sequence", "is", "palindrome", "." ]

[ "def", "copy", "(", "self", ")", ":", "# Significant performance improvements by skipping alphabet check", "return", "type", "(", "self", ")", "(", "self", ".", "seq", ",", "self", ".", "material", ",", "run_checks", "=", "False", ")" ]

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

[ "def", "locate", "(", "self", ",", "pattern", ")", ":", "if", "len", "(", "pattern", ")", ">", "len", "(", "self", ")", ":", "raise", "ValueError", "(", "'Search pattern longer than searchable '", "+", "'sequence.'", ")", "seq", "=", "self", ".", "seq", "pattern", "=", "str", "(", "pattern", ")", ".", "upper", "(", ")", "re_pattern", "=", "'(?='", "+", "pattern", "+", "')'", "matches", "=", "[", "index", ".", "start", "(", ")", "%", "len", "(", "self", ")", "for", "index", "in", "re", ".", "finditer", "(", "re_pattern", ",", "seq", ")", "]", "return", "matches" ]

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

[ "def", "copy", "(", "self", ")", ":", "return", "type", "(", "self", ")", "(", "self", ".", "name", ",", "self", ".", "start", ",", "self", ".", "stop", ",", "self", ".", "feature_type", ",", "gene", "=", "self", ".", "gene", ",", "locus_tag", "=", "self", ".", "locus_tag", ",", "qualifiers", "=", "self", ".", "qualifiers", ",", "strand", "=", "self", ".", "strand", ")" ]

[ "Return", "a", "copy", "of", "the", "Feature", "." ]

[ "def", "nupack_multi", "(", "seqs", ",", "material", ",", "cmd", ",", "arguments", ",", "report", "=", "True", ")", ":", "nupack_pool", "=", "multiprocessing", ".", "Pool", "(", ")", "try", ":", "args", "=", "[", "{", "'seq'", ":", "seq", ",", "'cmd'", ":", "cmd", ",", "'material'", ":", "material", ",", "'arguments'", ":", "arguments", "}", "for", "seq", "in", "seqs", "]", "nupack_iterator", "=", "nupack_pool", ".", "imap", "(", "run_nupack", ",", "args", ")", "total", "=", "len", "(", "seqs", ")", "msg", "=", "' calculations complete.'", "passed", "=", "4", "while", "report", ":", "completed", "=", "nupack_iterator", ".", "_index", "if", "(", "completed", "==", "total", ")", ":", "break", "else", ":", "if", "passed", ">=", "4", ":", "print", "'({0}/{1}) '", ".", "format", "(", "completed", ",", "total", ")", "+", "msg", "passed", "=", "0", "passed", "+=", "1", "time", ".", "sleep", "(", "1", ")", "multi_output", "=", "[", "x", "for", "x", "in", "nupack_iterator", "]", "nupack_pool", ".", "close", "(", ")", "nupack_pool", ".", "join", "(", ")", "except", "KeyboardInterrupt", ":", "nupack_pool", ".", "terminate", "(", ")", "nupack_pool", ".", "close", "(", ")", "raise", "KeyboardInterrupt", "return", "multi_output" ]

[ "Split", "Nupack", "commands", "over", "processors", "." ]

[ "def", "run_nupack", "(", "kwargs", ")", ":", "run", "=", "NUPACK", "(", "kwargs", "[", "'seq'", "]", ")", "output", "=", "getattr", "(", "run", ",", "kwargs", "[", "'cmd'", "]", ")", "(", "*", "*", "kwargs", "[", "'arguments'", "]", ")", "return", "output" ]

[ "Run", "picklable", "Nupack", "command", "." ]

[ "def", "pfunc_multi", "(", "self", ",", "strands", ",", "permutation", "=", "None", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strands", ",", "material", ",", "multi", "=", "True", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "True", ")", "# Set up the input file and run the command", "if", "permutation", "is", "None", ":", "permutation", "=", "range", "(", "1", ",", "len", "(", "strands", ")", "+", "1", ")", "lines", "=", "self", ".", "_multi_lines", "(", "strands", ",", "permutation", ")", "stdout", "=", "self", ".", "_run", "(", "'pfunc'", ",", "cmd_args", ",", "lines", ")", ".", "split", "(", "'\\n'", ")", "return", "(", "float", "(", "stdout", "[", "-", "3", "]", ")", ",", "float", "(", "stdout", "[", "-", "2", "]", ")", ")" ]

[ "Compute", "the", "partition", "function", "for", "an", "ordered", "complex", "of", "strands", ".", "Runs", "the", "\\", "pfunc", "\\", "command", "." ]

[ "def", "pairs", "(", "self", ",", "strand", ",", "cutoff", "=", "0.001", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strand", ",", "material", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "False", ")", "# Set up the input file and run the command. Note: no STDOUT", "lines", "=", "[", "str", "(", "strand", ")", "]", "self", ".", "_run", "(", "'pairs'", ",", "cmd_args", ",", "lines", ")", "# Read the output from file", "ppairs", "=", "self", ".", "_read_tempfile", "(", "'pairs.ppairs'", ")", "data", "=", "re", ".", "search", "(", "'\\n\\n\\d*\\n(.*)'", ",", "ppairs", ",", "flags", "=", "re", ".", "DOTALL", ")", ".", "group", "(", "1", ")", "N", "=", "len", "(", "strand", ")", "data_lines", "=", "[", "line", ".", "split", "(", "'\\t'", ")", "for", "line", "in", "data", ".", "split", "(", "'\\n'", ")", "if", "line", "]", "prob_matrix", "=", "self", ".", "_pairs_to_np", "(", "data_lines", ",", "N", ")", "return", "prob_matrix" ]

[ "Compute", "the", "pair", "probabilities", "for", "an", "ordered", "complex", "of", "strands", ".", "Runs", "the", "\\", "pairs", "\\", "command", "." ]

[ "def", "pairs_multi", "(", "self", ",", "strands", ",", "cutoff", "=", "0.001", ",", "permutation", "=", "None", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strands", ",", "material", ",", "multi", "=", "True", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "True", ")", "# Set up the input file and run the command. Note: no STDOUT", "if", "permutation", "is", "None", ":", "permutation", "=", "range", "(", "1", ",", "len", "(", "strands", ")", "+", "1", ")", "lines", "=", "self", ".", "_multi_lines", "(", "strands", ",", "permutation", ")", "self", ".", "_run", "(", "'pairs'", ",", "cmd_args", ",", "lines", ")", "# Read the output from file", "N", "=", "sum", "(", "[", "len", "(", "s", ")", "for", "s", "in", "strands", "]", ")", "matrices", "=", "[", "]", "for", "mat_type", "in", "[", "'ppairs'", ",", "'epairs'", "]", ":", "data", "=", "self", ".", "_read_tempfile", "(", "'pairs.'", "+", "mat_type", ")", "probs", "=", "re", ".", "search", "(", "'\\n\\n\\d*\\n(.*)'", ",", "data", ",", "flags", "=", "re", ".", "DOTALL", ")", ".", "group", "(", "1", ")", "lines", "=", "probs", ".", "split", "(", "'\\n'", ")", "# Remove the last line (empty)", "lines", ".", "pop", "(", ")", "pairlist", "=", "[", "line", ".", "split", "(", "'\\t'", ")", "for", "line", "in", "lines", "]", "prob_matrix", "=", "self", ".", "_pairs_to_np", "(", "pairlist", ",", "N", ")", "matrices", ".", "append", "(", "prob_matrix", ")", "return", "matrices" ]

[ "Compute", "the", "pair", "probabilities", "for", "an", "ordered", "complex", "of", "strands", ".", "Runs", "the", "\\", "pairs", "\\", "command", "." ]

[ "def", "mfe", "(", "self", ",", "strand", ",", "degenerate", "=", "False", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strand", ",", "material", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "False", ")", "if", "degenerate", ":", "cmd_args", ".", "append", "(", "'-degenerate'", ")", "# Set up the input file and run the command. Note: no STDOUT", "lines", "=", "[", "str", "(", "strand", ")", "]", "self", ".", "_run", "(", "'mfe'", ",", "cmd_args", ",", "lines", ")", "# Read the output from file", "structures", "=", "self", ".", "_process_mfe", "(", "self", ".", "_read_tempfile", "(", "'mfe.mfe'", ")", ")", "if", "degenerate", ":", "return", "structures", "else", ":", "return", "structures", "[", "0", "]" ]

[ "Compute", "the", "MFE", "for", "an", "ordered", "complex", "of", "strands", ".", "Runs", "the", "\\", "mfe", "\\", "command", "." ]

[ "def", "mfe_multi", "(", "self", ",", "strands", ",", "permutation", "=", "None", ",", "degenerate", "=", "False", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strands", ",", "material", ",", "multi", "=", "True", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "True", ")", "if", "degenerate", ":", "cmd_args", ".", "append", "(", "'-degenerate'", ")", "# Set up the input file and run the command. Note: no STDOUT", "if", "permutation", "is", "None", ":", "permutation", "=", "range", "(", "1", ",", "len", "(", "strands", ")", "+", "1", ")", "lines", "=", "self", ".", "_multi_lines", "(", "strands", ",", "permutation", ")", "self", ".", "_run", "(", "'mfe'", ",", "cmd_args", ",", "lines", ")", "# Read the output from file", "structures", "=", "self", ".", "_process_mfe", "(", "self", ".", "_read_tempfile", "(", "'mfe.mfe'", ")", ")", "if", "degenerate", ":", "return", "structures", "else", ":", "return", "structures", "[", "0", "]" ]

[ "Compute", "the", "MFE", "for", "an", "ordered", "complex", "of", "strands", ".", "Runs", "the", "\\", "mfe", "\\", "command", "." ]

[ "def", "subopt", "(", "self", ",", "strand", ",", "gap", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strand", ",", "material", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "False", ")", "# Set up the input file and run the command. Note: no STDOUT", "lines", "=", "[", "str", "(", "strand", ")", ",", "str", "(", "gap", ")", "]", "self", ".", "_run", "(", "'subopt'", ",", "cmd_args", ",", "lines", ")", "# Read the output from file", "structures", "=", "self", ".", "_process_mfe", "(", "self", ".", "_read_tempfile", "(", "'subopt.subopt'", ")", ")", "return", "structures" ]

[ "Compute", "the", "suboptimal", "structures", "within", "a", "defined", "energy", "gap", "of", "the", "MFE", ".", "Runs", "the", "\\", "subopt", "\\", "command", "." ]

[ "def", "count", "(", "self", ",", "strand", ",", "pseudo", "=", "False", ")", ":", "# Set up command flags", "if", "pseudo", ":", "cmd_args", "=", "[", "'-pseudo'", "]", "else", ":", "cmd_args", "=", "[", "]", "# Set up the input file and run the command", "stdout", "=", "self", ".", "_run", "(", "'count'", ",", "cmd_args", ",", "[", "str", "(", "strand", ")", "]", ")", ".", "split", "(", "'\\n'", ")", "# Return the count", "return", "int", "(", "float", "(", "stdout", "[", "-", "2", "]", ")", ")" ]

[ "Enumerates", "the", "total", "number", "of", "secondary", "structures", "over", "the", "structural", "ensemble", "Ω", "(", "π", ")", ".", "Runs", "the", "\\", "count", "\\", "command", "." ]

[ "def", "count_multi", "(", "self", ",", "strands", ",", "permutation", "=", "None", ",", "pseudo", "=", "False", ")", ":", "# Set up command flags", "cmd_args", "=", "[", "'-multi'", "]", "if", "pseudo", ":", "cmd_args", ".", "append", "(", "'-pseudo'", ")", "# Set up the input file and run the command", "if", "permutation", "is", "None", ":", "permutation", "=", "range", "(", "1", ",", "len", "(", "strands", ")", "+", "1", ")", "lines", "=", "self", ".", "_multi_lines", "(", "strands", ",", "permutation", ")", "stdout", "=", "self", ".", "_run", "(", "'count'", ",", "cmd_args", ",", "lines", ")", ".", "split", "(", "'\\n'", ")", "return", "int", "(", "float", "(", "stdout", "[", "-", "2", "]", ")", ")" ]

[ "Enumerates", "the", "total", "number", "of", "secondary", "structures", "over", "the", "structural", "ensemble", "Ω", "(", "π", ")", "with", "an", "ordered", "permutation", "of", "strands", ".", "Runs", "the", "\\", "count", "\\", "command", "." ]

[ "def", "energy", "(", "self", ",", "strand", ",", "dotparens", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# Set the material (will be used to set command material flag)", "material", "=", "self", ".", "_set_material", "(", "strand", ",", "material", ")", "# Set up command flags", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "False", ")", "# Set up the input file and run the command. Note: no STDOUT", "lines", "=", "[", "str", "(", "strand", ")", ",", "dotparens", "]", "stdout", "=", "self", ".", "_run", "(", "'energy'", ",", "cmd_args", ",", "lines", ")", ".", "split", "(", "'\\n'", ")", "# Return the energy", "return", "float", "(", "stdout", "[", "-", "2", "]", ")" ]

[ "Calculate", "the", "free", "energy", "of", "a", "given", "sequence", "structure", ".", "Runs", "the", "\\", "energy", "\\", "command", "." ]

[ "def", "complexes", "(", "self", ",", "strands", ",", "max_size", ",", "ordered", "=", "False", ",", "pairs", "=", "False", ",", "mfe", "=", "False", ",", "cutoff", "=", "0.001", ",", "degenerate", "=", "False", ",", "temp", "=", "37.0", ",", "pseudo", "=", "False", ",", "material", "=", "None", ",", "dangles", "=", "'some'", ",", "sodium", "=", "1.0", ",", "magnesium", "=", "0.0", ")", ":", "# TODO: Consider returning a pandas dataframe in this (and other)", "# situations to make sorting/selection between results easier.", "material", "=", "self", ".", "_set_material", "(", "strands", ",", "material", ",", "multi", "=", "True", ")", "cmd_args", "=", "self", ".", "_prep_cmd_args", "(", "temp", ",", "dangles", ",", "material", ",", "pseudo", ",", "sodium", ",", "magnesium", ",", "multi", "=", "False", ")", "cmd_args", ".", "append", "(", "'-quiet'", ")", "if", "mfe", ":", "cmd_args", ".", "append", "(", "'-mfe'", ")", "ordered", "=", "True", "if", "degenerate", ":", "cmd_args", ".", "append", "(", "'-degenerate'", ")", "if", "ordered", ":", "cmd_args", ".", "append", "(", "'-ordered'", ")", "if", "pairs", ":", "cmd_args", ".", "append", "(", "'-pairs'", ")", "cmd_args", ".", "append", "(", "'-cutoff'", ")", "cmd_args", ".", "append", "(", "cutoff", ")", "dim", "=", "sum", "(", "[", "len", "(", "s", ")", "for", "s", "in", "strands", "]", ")", "nstrands", "=", "len", "(", "strands", ")", "# Set up the input file and run the command", "lines", "=", "self", ".", "_multi_lines", "(", "strands", ",", "[", "max_size", "]", ")", "self", ".", "_run", "(", "'complexes'", ",", "cmd_args", ",", "lines", ")", "# Read the output from file(s)", "if", "ordered", ":", "ocx_lines", "=", "self", ".", "_read_tempfile", "(", "'complexes.ocx'", ")", ".", "split", "(", "'\\n'", ")", "# Process each lines", "output", "=", "[", "]", "for", "line", "in", "ocx_lines", ":", "if", "line", "and", "not", "line", ".", "startswith", "(", "'%'", ")", ":", "data", "=", "line", ".", "split", "(", "'\\t'", ")", "energy", "=", "float", "(", "data", "[", "-", "1", "]", ")", "complexes", "=", "[", "int", "(", "d", ")", "for", "d", "in", "data", "[", "2", ":", "2", "+", "nstrands", "]", "]", "permutation", "=", "int", "(", "data", "[", "1", "]", ")", "output", ".", "append", "(", "{", "'energy'", ":", "energy", ",", "'complex'", ":", "complexes", ",", "'permutation'", ":", "permutation", "}", ")", "key_lines", "=", "self", ".", "_read_tempfile", "(", "'complexes.ocx-key'", ")", ".", "split", "(", "'\\n'", ")", "data_lines", "=", "[", "l", "for", "l", "in", "key_lines", "if", "not", "l", ".", "startswith", "(", "'%'", ")", "]", "data_lines", ".", "pop", "(", ")", "for", "i", ",", "line", "in", "enumerate", "(", "data_lines", ")", ":", "data", "=", "line", ".", "split", "(", "'\\t'", ")", "keys", "=", "[", "int", "(", "d", ")", "for", "d", "in", "data", "[", "2", ":", "-", "1", "]", "]", "output", "[", "i", "]", "[", "'order'", "]", "=", "keys", "if", "pairs", ":", "epairs_data", "=", "self", ".", "_read_tempfile", "(", "'complexes.ocx-epairs'", ")", "pairslist", "=", "self", ".", "_process_epairs", "(", "epairs_data", ")", "for", "i", ",", "pairs", "in", "enumerate", "(", "pairslist", ")", ":", "output", "[", "i", "]", "[", "'epairs'", "]", "=", "self", ".", "_pairs_to_np", "(", "pairs", ",", "dim", ")", "# TODO: add ocx-ppairs as well", "if", "mfe", ":", "mfe_data", "=", "self", ".", "_read_tempfile", "(", "'complexes.ocx-mfe'", ")", "if", "degenerate", ":", "return", "NotImplementedError", "(", "'Not implemented for complexes'", ")", "else", ":", "mfe_output", "=", "self", ".", "_process_mfe", "(", "mfe_data", ",", "complexes", "=", "True", ")", "for", "i", ",", "mfedat", "in", "enumerate", "(", "mfe_output", ")", ":", "output", "[", "i", "]", "[", "'mfe'", "]", "=", "mfedat", "[", "'mfe'", "]", "output", "[", "i", "]", "[", "'dotparens'", "]", "=", "mfedat", "[", "'dotparens'", "]", "output", "[", "i", "]", "[", "'pairlist'", "]", "=", "mfedat", "[", "'pairlist'", "]", "else", ":", "cx_lines", "=", "self", ".", "_read_tempfile", "(", "'complexes.cx'", ")", ".", "split", "(", "'\\n'", ")", "# Remove empty last line", "cx_lines", ".", "pop", "(", ")", "output", "=", "[", "]", "for", "line", "in", "cx_lines", ":", "if", "not", "line", ".", "startswith", "(", "'%'", ")", ":", "data", "=", "line", ".", "split", "(", "'\\t'", ")", "energy", "=", "float", "(", "data", "[", "-", "1", "]", ")", "complexes", "=", "[", "int", "(", "d", ")", "for", "d", "in", "data", "[", "1", ":", "1", "+", "len", "(", "strands", ")", "]", "]", "output", ".", "append", "(", "{", "'energy'", ":", "energy", ",", "'complex'", ":", "complexes", "}", ")", "if", "pairs", ":", "# Process epairs", "epairs_data", "=", "self", ".", "_read_tempfile", "(", "'complexes.cx-epairs'", ")", "pairslist", "=", "self", ".", "_process_epairs", "(", "epairs_data", ")", "for", "i", ",", "pairs", "in", "enumerate", "(", "pairslist", ")", ":", "proba_mat", "=", "self", ".", "_pairs_to_np", "(", "pairs", ",", "dim", ")", "output", "[", "i", "]", "[", "'epairs'", "]", "=", "proba_mat", "# Add strands (for downstream concentrations)", "for", "cx", "in", "output", ":", "cx", "[", "'strands'", "]", "=", "[", "s", ".", "copy", "(", ")", "for", "s", "in", "strands", "]", "return", "output" ]

[ ":", "param", "strands", ":", "Strands", "on", "which", "to", "run", "energy", ".", "Strands", "must", "be", "either", "coral", ".", "DNA", "or", "coral", ".", "RNA", ")", ".", ":", "type", "strands", ":", "list", "of", "coral", ".", "DNA", "or", "coral", ".", "RNA", ":", "param", "max_size", ":", "Maximum", "complex", "size", "to", "consider", "(", "maximum", "number", "of", "strand", "species", "in", "complex", ")", ".", ":", "type", "max_size", ":", "int", ":", "param", "ordered", ":", "Consider", "distinct", "ordered", "complexes", "-", "all", "distinct", "circular", "permutations", "of", "each", "complex", ".", ":", "type", "ordered", ":", "bool", ":", "param", "pairs", ":", "Calculate", "base", "-", "pairing", "observables", "as", "with", ".", "pairs", "()", ".", ":", "type", "pairs", ":", "bool", ":", "param", "cutoff", ":", "A", "setting", "when", "pairs", "is", "set", "to", "True", "-", "only", "probabilities", "above", "this", "threshold", "will", "be", "returned", ".", ":", "type", "cutoff", ":", "float", ":", "param", "degenerate", ":", "Applies", "only", "when", "\\", "mfe", "\\", "is", "set", "to", "True", ".", "If", "set", "to", "True", "the", "mfe", "value", "associated", "with", "each", "complex", "will", "be", "a", "list", "of", "degenerate", "MFEs", "(", "as", "in", "the", "case", "of", ".", "mfe", "()", ")", ".", ":", "type", "degenerate", ":", "bool", ":", "param", "temp", ":", "Temperature", ".", ":", "type", "temp", ":", "float", ":", "param", "pseudo", ":", "Enable", "pseudoknots", ".", ":", "type", "pseudo", ":", "bool", ":", "param", "material", ":", "The", "material", "setting", "to", "use", "in", "the", "computation", ".", "If", "set", "to", "None", "(", "the", "default", ")", "the", "material", "type", "is", "inferred", "from", "the", "strands", ".", "Other", "settings", "available", ":", "dna", "for", "DNA", "parameters", "rna", "for", "RNA", "(", "1995", ")", "parameters", "and", "rna1999", "for", "the", "RNA", "1999", "parameters", ".", ":", "type", "material", ":", "str", ":", "param", "dangles", ":", "How", "to", "treat", "dangles", "in", "the", "computation", ".", "From", "the", "user", "guide", ":", "For", "\\", "none", "\\", ":", "Dangle", "energies", "are", "ignored", ".", "For", "\\", "some", "\\", ":", "\\", "A", "dangle", "energy", "is", "incorporated", "for", "each", "unpaired", "base", "flanking", "a", "duplex", "\\", ".", "For", "all", ":", "all", "dangle", "energy", "is", "considered", ".", ":", "type", "dangles", ":", "str", ":", "param", "sodium", ":", "Sodium", "concentration", "in", "solution", "(", "molar", ")", "only", "applies", "to", "DNA", ".", ":", "type", "sodium", ":", "float", ":", "param", "magnesium", ":", "Magnesium", "concentration", "in", "solution", "(", "molar", ")", "only", "applies", "to", "DNA", ">", ":", "type", "magnesium", ":", "float", ":", "returns", ":", "A", "list", "of", "dictionaries", "containing", "at", "least", "energy", "complex", "and", "strands", "keys", ".", "If", "ordered", "is", "True", "the", "different", "possible", "ordered", "permutations", "of", "complexes", "are", "considered", ".", "In", "addition", "with", "ordered", "set", "to", "True", "an", "additional", "order", "key", "describing", "the", "exact", "order", "of", "strands", "and", "a", "permutation", "index", "(", "integer", ")", "are", "added", ".", "If", "pairs", "is", "True", "there", "is", "an", "additional", "epairs", "key", "containing", "the", "base", "-", "pairing", "expectation", "values", ".", "If", "mfe", "is", "selected", "mfe", "dotparens", "and", "pairlist", "keys", "in", "the", "same", "as", ".", "mfe", "()", ".", "In", "addition", "mfe", "sets", "the", "-", "ordered", "flag", "so", "the", "same", "keys", "as", "when", "ordered", "is", "set", "to", "True", "are", "added", ".", ":", "rtype", ":", "float" ]

[ "def", "complexes_timeonly", "(", "self", ",", "strands", ",", "max_size", ")", ":", "cmd_args", "=", "[", "'-quiet'", ",", "'-timeonly'", "]", "lines", "=", "self", ".", "_multi_lines", "(", "strands", ",", "[", "max_size", "]", ")", "stdout", "=", "self", ".", "_run", "(", "'complexes'", ",", "cmd_args", ",", "lines", ")", "return", "float", "(", "re", ".", "search", "(", "'calculation\\: (.*) seconds'", ",", "stdout", ")", ".", "group", "(", "1", ")", ")" ]

[ "Estimate", "the", "amount", "of", "time", "it", "will", "take", "to", "calculate", "all", "the", "partition", "functions", "for", "each", "circular", "permutation", "-", "estimate", "the", "time", "the", "actual", "\\", "complexes", "\\", "command", "will", "take", "to", "run", "." ]

[ "def", "concentrations", "(", "self", ",", "complexes", ",", "concs", ",", "ordered", "=", "False", ",", "pairs", "=", "False", ",", "cutoff", "=", "0.001", ",", "temp", "=", "37.0", ")", ":", "# Check inputs", "nstrands", "=", "len", "(", "complexes", "[", "0", "]", "[", "'strands'", "]", ")", "try", ":", "if", "len", "(", "concs", ")", "!=", "nstrands", ":", "raise", "ValueError", "(", "'concs argument not same length as strands.'", ")", "except", "TypeError", ":", "concs", "=", "[", "concs", "for", "i", "in", "range", "(", "len", "(", "complexes", "[", "'strands'", "]", ")", ")", "]", "# Set up command-line arguments", "cmd_args", "=", "[", "'-quiet'", "]", "if", "ordered", ":", "cmd_args", ".", "append", "(", "'-ordered'", ")", "# Write .con file", "with", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'concentrations.con'", ")", ")", "as", "f", ":", "f", ".", "writelines", "(", "concs", ")", "# Write .cx or .ocx file", "header", "=", "[", "'%t Number of strands: {}'", ".", "format", "(", "nstrands", ")", ",", "'%\\tid\\tsequence'", "]", "for", "i", ",", "strand", "in", "enumerate", "(", "complexes", "[", "'strands'", "]", ")", ":", "header", ".", "append", "(", "'%\\t{}\\t{}'", ".", "format", "(", "i", "+", "1", ",", "strand", ")", ")", "header", ".", "append", "(", "'%\\tT = {}'", ".", "format", "(", "temp", ")", ")", "body", "=", "[", "]", "for", "i", ",", "cx", "in", "enumerate", "(", "complexes", ")", ":", "permutation", "=", "'\\t'", ".", "join", "(", "complexes", "[", "'complex'", "]", ")", "line", "=", "'{}\\t{}\\t{}'", ".", "format", "(", "i", "+", "1", ",", "permutation", ",", "complexes", "[", "'energy'", "]", ")", "body", ".", "append", "(", "line", ")", "if", "ordered", ":", "cxfile", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'concentrations.ocx'", ")", "else", ":", "cxfile", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'concentrations.cx'", ")", "with", "open", "(", "cxfile", ")", "as", "f", ":", "f", ".", "writelines", "(", "header", "+", "body", ")", "# Run 'concentrations'", "self", ".", "_run", "(", "'concentrations'", ",", "cmd_args", ",", "None", ")", "# Parse the .eq (concentrations) file", "eq_lines", "=", "self", ".", "_read_tempfile", "(", "'concentrations.eq'", ")", ".", "split", "(", "'\\n'", ")", "tsv_lines", "=", "[", "l", "for", "l", "in", "eq_lines", "if", "not", "l", ".", "startswith", "(", "'%'", ")", "]", "output", "=", "[", "]", "for", "i", ",", "line", "in", "enumerate", "(", "tsv_lines", ")", ":", "# It's a TSV", "data", "=", "line", ".", "split", "(", "'\\t'", ")", "# Column 0 is an index", "# Columns 1-nstrands is the complex", "cx", "=", "[", "int", "(", "c", ")", "for", "c", "in", "data", "[", "1", ":", "nstrands", "]", "]", "# Column nstrands + 1 is the complex energy", "# Column nstrands + 2 is the equilibrium concentration", "eq", "=", "float", "(", "data", "[", "nstrands", "+", "2", "]", ")", "output", "[", "i", "]", "=", "{", "'complex'", ":", "cx", ",", "'concentration'", ":", "eq", "}", "if", "pairs", ":", "# Read the .fpairs file", "pairs", "=", "self", ".", "_read_tempfile", "(", "'concentrations.fpairs'", ")", "pairs_tsv", "=", "[", "l", "for", "l", "in", "pairs", ".", "split", "(", "'\\n'", ")", "if", "not", "l", ".", "startswith", "(", "'%'", ")", "]", "# Remove first line (n complexes)", "dim", "=", "int", "(", "pairs_tsv", ".", "pop", "(", "0", ")", ")", "pprob", "=", "[", "[", "int", "(", "p", "[", "0", "]", ")", ",", "int", "(", "p", "[", "1", "]", ")", ",", "float", "(", "p", "[", "2", "]", ")", "]", "for", "p", "in", "pairs_tsv", "]", "# Convert to augmented numpy matrix", "fpairs_mat", "=", "self", ".", "pairs_to_np", "(", "pprob", ",", "dim", ")", "for", "i", ",", "out", "in", "enumerate", "(", "output", ")", ":", "output", "[", "i", "]", "[", "'fpairs'", "]", "=", "fpairs_mat", "return", "output" ]

[ ":", "param", "complexes", ":", "A", "list", "of", "the", "type", "returned", "by", "the", "complexes", "()", "method", ".", ":", "type", "complexes", ":", "list", ":", "param", "concs", ":", "The", "concentration", "(", "s", ")", "of", "each", "strand", "species", "in", "the", "initial", "complex", ".", "If", "they", "are", "all", "the", "same", "a", "single", "float", "can", "be", "used", "here", ".", ":", "type", "concs", ":", "list", "of", "floats", "or", "float", ":", "param", "ordered", ":", "Consider", "distinct", "ordered", "complexes", "-", "all", "distinct", "circular", "permutations", "of", "each", "complex", ".", ":", "type", "ordered", ":", "bool", ":", "param", "pairs", ":", "Calculate", "base", "-", "pairing", "observables", "as", "with", ".", "pairs", "()", ".", ":", "type", "pairs", ":", "bool", ":", "param", "cutoff", ":", "A", "setting", "when", "pairs", "is", "set", "to", "True", "-", "only", "probabilities", "above", "this", "threshold", "will", "be", "returned", ".", ":", "type", "cutoff", ":", "float", ":", "param", "temp", ":", "Temperature", "in", "C", ".", ":", "type", "temp", ":", "float", ":", "returns", ":", "A", "list", "of", "dictionaries", "containing", "(", "at", "least", ")", "a", "concentrations", "key", ".", "If", "pairs", "is", "True", "an", "fpairs", "key", "is", "added", ".", ":", "rtype", ":", "list" ]

[ "def", "distributions", "(", "self", ",", "complexes", ",", "counts", ",", "volume", ",", "maxstates", "=", "1e7", ",", "ordered", "=", "False", ",", "temp", "=", "37.0", ")", ":", "# Check inputs", "nstrands", "=", "len", "(", "complexes", "[", "0", "]", "[", "'strands'", "]", ")", "if", "len", "(", "counts", ")", "!=", "nstrands", ":", "raise", "ValueError", "(", "'counts argument not same length as strands.'", ")", "# Set up command-line arguments", "cmd_args", "=", "[", "]", "if", "ordered", ":", "cmd_args", ".", "append", "(", "'-ordered'", ")", "# Write .count file", "countpath", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'distributions.count'", ")", "with", "open", "(", "countpath", ",", "'w'", ")", "as", "f", ":", "f", ".", "writelines", "(", "[", "str", "(", "c", ")", "for", "c", "in", "counts", "]", "+", "[", "str", "(", "volume", ")", "]", ")", "# Write .cx or .ocx file", "header", "=", "[", "'%t Number of strands: {}'", ".", "format", "(", "nstrands", ")", ",", "'%\\tid\\tsequence'", "]", "for", "i", ",", "strand", "in", "enumerate", "(", "complexes", "[", "'strands'", "]", ")", ":", "header", ".", "append", "(", "'%\\t{}\\t{}'", ".", "format", "(", "i", "+", "1", ",", "strand", ")", ")", "header", ".", "append", "(", "'%\\tT = {}'", ".", "format", "(", "temp", ")", ")", "body", "=", "[", "]", "for", "i", ",", "cx", "in", "enumerate", "(", "complexes", ")", ":", "permutation", "=", "'\\t'", ".", "join", "(", "complexes", "[", "'complex'", "]", ")", "line", "=", "'{}\\t{}\\t{}'", ".", "format", "(", "i", "+", "1", ",", "permutation", ",", "complexes", "[", "'energy'", "]", ")", "body", ".", "append", "(", "line", ")", "if", "ordered", ":", "cxfile", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'distributions.ocx'", ")", "else", ":", "cxfile", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "'distributions.cx'", ")", "with", "open", "(", "cxfile", ")", "as", "f", ":", "f", ".", "writelines", "(", "header", "+", "body", ")", "# Run 'distributions'", "stdout", "=", "self", ".", "_run", "(", "'distributions'", ",", "cmd_args", ",", "None", ")", "# Parse STDOUT", "stdout_lines", "=", "stdout", ".", "split", "(", "'\\n'", ")", "if", "stdout_lines", "[", "0", "]", ".", "startswith", "(", "'Exceeded maximum number'", ")", ":", "raise", "LambdaError", "(", "'Exceeded maxstates combinations.'", ")", "# pop_search = re.search('There are (*) pop', stdout_lines[0]).group(1)", "# populations = int(pop_search)", "# kT_search = re.search('of the box: (*) kT', stdout_lines[1]).group(1)", "# kT = float(kT_search)", "# Parse .dist file (comments header + TSV)", "dist_lines", "=", "self", ".", "_read_tempfile", "(", "'distributions.dist'", ")", ".", "split", "(", "'\\n'", ")", "tsv_lines", "=", "[", "l", "for", "l", "in", "dist_lines", "if", "not", "l", ".", "startswith", "(", "'%'", ")", "]", "tsv_lines", ".", "pop", "(", ")", "output", "=", "[", "]", "for", "i", ",", "line", "in", "enumerate", "(", "tsv_lines", ")", ":", "data", "=", "line", ".", "split", "(", "'\\t'", ")", "# Column 0 is an index", "# Columns 1-nstrands are complexes", "cx", "=", "[", "int", "(", "d", ")", "for", "d", "in", "data", "[", "1", ":", "nstrands", "]", "]", "# Column nstrands + 1 is expected value of complex", "ev", "=", "float", "(", "data", "[", "nstrands", "+", "1", "]", ")", "# Columns nstrands + 2 and on are probability columns", "probcols", "=", "[", "float", "(", "d", ")", "for", "d", "in", "data", "[", "nstrands", "+", "2", ":", "]", "]", "output", "[", "i", "]", "[", "'complex'", "]", "=", "cx", "output", "[", "i", "]", "[", "'ev'", "]", "=", "ev", "output", "[", "i", "]", "[", "'probcols'", "]", "=", "probcols", "return", "output" ]

[ "Runs", "the", "\\", "distributions", "\\", "NUPACK", "command", ".", "Note", ":", "this", "is", "intended", "for", "a", "relatively", "small", "number", "of", "species", "(", "on", "the", "order", "of", "~20", "total", "strands", "for", "complex", "size", "~14", ")", "." ]

[ "def", "_multi_lines", "(", "self", ",", "strands", ",", "permutation", ")", ":", "lines", "=", "[", "]", "# Write the total number of distinct strands", "lines", ".", "append", "(", "str", "(", "len", "(", "strands", ")", ")", ")", "# Write the distinct strands", "lines", "+=", "[", "str", "(", "strand", ")", "for", "strand", "in", "strands", "]", "# Write the permutation", "lines", ".", "append", "(", "' '", ".", "join", "(", "str", "(", "p", ")", "for", "p", "in", "permutation", ")", ")", "return", "lines" ]

[ "Prepares", "lines", "to", "write", "to", "file", "for", "pfunc", "command", "input", "." ]

[ "def", "_read_tempfile", "(", "self", ",", "filename", ")", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_tempdir", ",", "filename", ")", ")", "as", "f", ":", "return", "f", ".", "read", "(", ")" ]

[ "Read", "in", "and", "return", "file", "that", "s", "in", "the", "tempdir", "." ]

[ "def", "_pairs_to_np", "(", "self", ",", "pairlist", ",", "dim", ")", ":", "mat", "=", "np", ".", "zeros", "(", "(", "dim", ",", "dim", "+", "1", ")", ")", "for", "line", "in", "pairlist", ":", "i", "=", "int", "(", "line", "[", "0", "]", ")", "-", "1", "j", "=", "int", "(", "line", "[", "1", "]", ")", "-", "1", "prob", "=", "float", "(", "line", "[", "2", "]", ")", "mat", "[", "i", ",", "j", "]", "=", "prob", "return", "mat" ]

[ "Given", "a", "set", "of", "pair", "probability", "lines", "construct", "a", "numpy", "array", "." ]

[ "def", "_flip_feature", "(", "self", ",", "feature", ",", "parent_len", ")", ":", "copy", "=", "feature", ".", "copy", "(", ")", "# Put on the other strand", "if", "copy", ".", "strand", "==", "0", ":", "copy", ".", "strand", "=", "1", "else", ":", "copy", ".", "strand", "=", "0", "# Adjust locations - guarantee that start is always less than end", "copy", ".", "start", "=", "parent_len", "-", "copy", ".", "start", "copy", ".", "stop", "=", "parent_len", "-", "copy", ".", "stop", "copy", ".", "start", ",", "copy", ".", "stop", "=", "copy", ".", "stop", ",", "copy", ".", "start", "return", "copy" ]

[ "Adjust", "a", "feature", "s", "location", "when", "flipping", "DNA", "." ]