Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "repartition", "(", "self", ",", "npartitions", ")", ":", "rdd", "=", "self", ".", "_rdd", ".", "repartition", "(", "npartitions", ")", "return", "self", ".", "_constructor", "(", "rdd", ",", "ordered", "=", "False", ")", ".", "__finalize__", "(", "self", ")" ]

[ "Repartitions", "the", "underlying", "RDD" ]

[ "def", "get", "(", "self", ",", "sid", ")", ":", "return", "SigningKeyContext", "(", "self", ".", "_version", ",", "account_sid", "=", "self", ".", "_solution", "[", "'account_sid'", "]", ",", "sid", "=", "sid", ",", ")" ]

[ "Constructs", "a", "SigningKeyContext" ]

[ "def", "_build_color_variants", "(", "cls", ")", ":", "# Get the basic frame types first.", "frametypes", "=", "cls", ".", "sets", "(", "registered", "=", "False", ")", "_colornames", "=", "[", "# 'black', disabled for now, it won't show on my terminal.", "'red'", ",", "'green'", ",", "'yellow'", ",", "'blue'", ",", "'magenta'", ",", "'cyan'", ",", "'white'", ",", "]", "_colornames", ".", "extend", "(", "'light{}'", ".", "format", "(", "s", ")", "for", "s", "in", "_colornames", "[", ":", "]", ")", "for", "colorname", "in", "_colornames", ":", "for", "framesobj", "in", "frametypes", ":", "framename", "=", "'{}_{}'", ".", "format", "(", "framesobj", ".", "name", ",", "colorname", ")", "cls", ".", "register", "(", "framesobj", ".", "as_colr", "(", "fore", "=", "colorname", ")", ",", "name", "=", "framename", ",", ")" ]

[ "Build", "colorized", "variants", "of", "all", "frames", "and", "return", "a", "list", "of", "all", "frame", "object", "names", "." ]

[ "def", "insertReadGroupSet", "(", "self", ",", "readGroupSet", ")", ":", "programsJson", "=", "json", ".", "dumps", "(", "[", "protocol", ".", "toJsonDict", "(", "program", ")", "for", "program", "in", "readGroupSet", ".", "getPrograms", "(", ")", "]", ")", "statsJson", "=", "json", ".", "dumps", "(", "protocol", ".", "toJsonDict", "(", "readGroupSet", ".", "getStats", "(", ")", ")", ")", "try", ":", "models", ".", "Readgroupset", ".", "create", "(", "id", "=", "readGroupSet", ".", "getId", "(", ")", ",", "datasetid", "=", "readGroupSet", ".", "getParentContainer", "(", ")", ".", "getId", "(", ")", ",", "referencesetid", "=", "readGroupSet", ".", "getReferenceSet", "(", ")", ".", "getId", "(", ")", ",", "name", "=", "readGroupSet", ".", "getLocalId", "(", ")", ",", "programs", "=", "programsJson", ",", "stats", "=", "statsJson", ",", "dataurl", "=", "readGroupSet", ".", "getDataUrl", "(", ")", ",", "indexfile", "=", "readGroupSet", ".", "getIndexFile", "(", ")", ",", "attributes", "=", "json", ".", "dumps", "(", "readGroupSet", ".", "getAttributes", "(", ")", ")", ")", "for", "readGroup", "in", "readGroupSet", ".", "getReadGroups", "(", ")", ":", "self", ".", "insertReadGroup", "(", "readGroup", ")", "except", "Exception", "as", "e", ":", "raise", "exceptions", ".", "RepoManagerException", "(", "e", ")" ]

[ "Inserts", "a", "the", "specified", "readGroupSet", "into", "this", "repository", "." ]

[ "def", "processor_groups", "(", "mesh_shape", ",", "group_dims", ")", ":", "group_numbers", "=", "[", "pnum_to_group", "(", "mesh_shape", ",", "group_dims", ",", "pnum", ")", "for", "pnum", "in", "xrange", "(", "mesh_shape", ".", "size", ")", "]", "ret", "=", "[", "]", "for", "pnum", ",", "g", "in", "enumerate", "(", "group_numbers", ")", ":", "while", "len", "(", "ret", ")", "<=", "g", ":", "ret", ".", "append", "(", "[", "]", ")", "ret", "[", "g", "]", ".", "append", "(", "pnum", ")", "return", "ret" ]

[ "Groups", "of", "processors", "which", "differ", "only", "in", "the", "given", "dimensions", "." ]

[ "def", "aStockQoutation", "(", "self", ",", "code", ")", ":", "#设置监听-->订阅-->调用接口", "# 分时", "self", ".", "quote_ctx", ".", "set_handler", "(", "RTDataTest", "(", ")", ")", "self", ".", "quote_ctx", ".", "subscribe", "(", "code", ",", "SubType", ".", "RT_DATA", ")", "ret_code_rt_data", ",", "ret_data_rt_data", "=", "self", ".", "quote_ctx", ".", "get_rt_data", "(", "code", ")", "# 逐笔", "self", ".", "quote_ctx", ".", "set_handler", "(", "TickerTest", "(", ")", ")", "self", ".", "quote_ctx", ".", "subscribe", "(", "code", ",", "SubType", ".", "TICKER", ")", "ret_code_rt_ticker", ",", "ret_data_rt_ticker", "=", "self", ".", "quote_ctx", ".", "get_rt_ticker", "(", "code", ")", "# 报价", "self", ".", "quote_ctx", ".", "set_handler", "(", "StockQuoteTest", "(", ")", ")", "self", ".", "quote_ctx", ".", "subscribe", "(", "code", ",", "SubType", ".", "QUOTE", ")", "ret_code_stock_quote", ",", "ret_data_stock_quote", "=", "self", ".", "quote_ctx", ".", "get_stock_quote", "(", "[", "code", "]", ")", "# 实时K线", "self", ".", "quote_ctx", ".", "set_handler", "(", "CurKlineTest", "(", ")", ")", "kTypes", "=", "[", "SubType", ".", "K_1M", ",", "SubType", ".", "K_5M", ",", "SubType", ".", "K_15M", ",", "SubType", ".", "K_30M", ",", "SubType", ".", "K_60M", ",", "SubType", ".", "K_DAY", ",", "SubType", ".", "K_WEEK", ",", "SubType", ".", "K_MON", "]", "auTypes", "=", "[", "AuType", ".", "NONE", ",", "AuType", ".", "QFQ", ",", "AuType", ".", "HFQ", "]", "num", "=", "10", "ret_code_cur_kline", "=", "RET_OK", "for", "kType", "in", "kTypes", ":", "self", ".", "quote_ctx", ".", "subscribe", "(", "code", ",", "kType", ")", "for", "auType", "in", "auTypes", ":", "ret_code_cur_kline_temp", ",", "ret_data_cur_kline", "=", "self", ".", "quote_ctx", ".", "get_cur_kline", "(", "code", ",", "num", ",", "kType", ",", "auType", ")", "if", "ret_code_cur_kline_temp", "is", "RET_ERROR", ":", "ret_code_cur_kline", "=", "RET_ERROR", "# 摆盘", "self", ".", "quote_ctx", ".", "set_handler", "(", "OrderBookTest", "(", ")", ")", "self", ".", "quote_ctx", ".", "subscribe", "(", "code", ",", "SubType", ".", "ORDER_BOOK", ")", "ret_code_order_book", ",", "ret_data_order_book", "=", "self", ".", "quote_ctx", ".", "get_order_book", "(", "code", ")", "# 经纪队列", "self", ".", "quote_ctx", ".", "set_handler", "(", "BrokerTest", "(", ")", ")", "self", ".", "quote_ctx", ".", "subscribe", "(", "code", ",", "SubType", ".", "BROKER", ")", "ret_code_broker_queue", ",", "bid_frame_table", ",", "ask_frame_table", "=", "self", ".", "quote_ctx", ".", "get_broker_queue", "(", "code", ")", "return", "ret_code_rt_data", "+", "ret_code_rt_ticker", "+", "ret_code_stock_quote", "+", "ret_code_cur_kline", "+", "ret_code_order_book", "+", "ret_code_broker_queue" ]

[ "订阅一只股票的实时行情数据，接收推送", ":", "param", "code", ":", "股票代码", ":", "return", ":" ]

[ "def", "_findUniqueMappingValues", "(", "mapping", ")", ":", "uniqueMappingValues", "=", "set", "(", ")", "for", "entries", "in", "viewvalues", "(", "mapping", ")", ":", "if", "len", "(", "entries", ")", "==", "1", ":", "uniqueMappingValues", ".", "update", "(", "entries", ")", "return", "uniqueMappingValues" ]

[ "Find", "mapping", "entries", "that", "are", "unique", "for", "one", "key", "(", "value", "length", "of", "1", ")", "." ]

[ "def", "fail_hosts", "(", "self", ",", "hosts_to_fail", ",", "activated_count", "=", "None", ")", ":", "if", "not", "hosts_to_fail", ":", "return", "activated_count", "=", "activated_count", "or", "len", "(", "self", ".", "activated_hosts", ")", "logger", ".", "debug", "(", "'Failing hosts: {0}'", ".", "format", "(", "', '", ".", "join", "(", "(", "host", ".", "name", "for", "host", "in", "hosts_to_fail", ")", ",", ")", ")", ")", "# Remove the failed hosts from the inventory", "self", ".", "active_hosts", "-=", "hosts_to_fail", "# Check we're not above the fail percent", "active_hosts", "=", "self", ".", "active_hosts", "# No hosts left!", "if", "not", "active_hosts", ":", "raise", "PyinfraError", "(", "'No hosts remaining!'", ")", "if", "self", ".", "config", ".", "FAIL_PERCENT", "is", "not", "None", ":", "percent_failed", "=", "(", "1", "-", "len", "(", "active_hosts", ")", "/", "activated_count", ")", "*", "100", "if", "percent_failed", ">", "self", ".", "config", ".", "FAIL_PERCENT", ":", "raise", "PyinfraError", "(", "'Over {0}% of hosts failed ({1}%)'", ".", "format", "(", "self", ".", "config", ".", "FAIL_PERCENT", ",", "int", "(", "round", "(", "percent_failed", ")", ")", ",", ")", ")" ]

[ "Flag", "a", "set", "of", "hosts", "as", "failed", "error", "for", "config", ".", "FAIL_PERCENT", "." ]

[ "def", "write_headers", "(", "self", ",", "fp", ",", "headers", ",", "mute", "=", "None", ")", ":", "if", "headers", ":", "if", "not", "mute", ":", "mute", "=", "[", "]", "fmt", "=", "'%%-%ds %%s\\n'", "%", "(", "max", "(", "len", "(", "k", ")", "for", "k", "in", "headers", ")", "+", "1", ")", "for", "key", "in", "sorted", "(", "headers", ")", ":", "if", "key", "in", "mute", ":", "continue", "fp", ".", "write", "(", "fmt", "%", "(", "key", ".", "title", "(", ")", "+", "':'", ",", "headers", "[", "key", "]", ")", ")", "fp", ".", "flush", "(", ")" ]

[ "Convenience", "function", "to", "output", "headers", "in", "a", "formatted", "fashion", "to", "a", "file", "-", "like", "fp", "optionally", "muting", "any", "headers", "in", "the", "mute", "list", "." ]

[ "def", "performApplicationPrelaunchCheck", "(", "self", ",", "pchAppKey", ")", ":", "fn", "=", "self", ".", "function_table", ".", "performApplicationPrelaunchCheck", "result", "=", "fn", "(", "pchAppKey", ")", "return", "result" ]

[ "Returns", "errors", "that", "would", "prevent", "the", "specified", "application", "from", "launching", "immediately", ".", "Calling", "this", "function", "will", "cause", "the", "current", "scene", "application", "to", "quit", "so", "only", "call", "it", "when", "you", "are", "actually", "about", "to", "launch", "something", "else", ".", "What", "the", "caller", "should", "do", "about", "these", "failures", "depends", "on", "the", "failure", ":", "VRApplicationError_OldApplicationQuitting", "-", "An", "existing", "application", "has", "been", "told", "to", "quit", ".", "Wait", "for", "a", "VREvent_ProcessQuit", "and", "try", "again", ".", "VRApplicationError_ApplicationAlreadyStarting", "-", "This", "application", "is", "already", "starting", ".", "This", "is", "a", "permanent", "failure", ".", "VRApplicationError_LaunchInProgress", "-", "A", "different", "application", "is", "already", "starting", ".", "This", "is", "a", "permanent", "failure", ".", "VRApplicationError_None", "-", "Go", "ahead", "and", "launch", ".", "Everything", "is", "clear", "." ]

[ "def", "make_palette_chunks", "(", "palette", ")", ":", "p", "=", "bytearray", "(", ")", "t", "=", "bytearray", "(", ")", "for", "x", "in", "palette", ":", "p", ".", "extend", "(", "x", "[", "0", ":", "3", "]", ")", "if", "len", "(", "x", ")", ">", "3", ":", "t", ".", "append", "(", "x", "[", "3", "]", ")", "if", "t", ":", "return", "p", ",", "t", "return", "p", ",", "None" ]

[ "Create", "the", "byte", "sequences", "for", "a", "PLTE", "and", "if", "necessary", "a", "tRNS", "chunk", ".", "Returned", "as", "a", "pair", "(", "*", "p", "*", "*", "t", "*", ")", ".", "*", "t", "*", "will", "be", "None", "if", "no", "tRNS", "chunk", "is", "necessary", "." ]

[ "def", "msregularize", "(", "msname", ",", "newname", ")", ":", "# Find out all baselines.", "t", "=", "table", "(", "msname", ")", "t1", "=", "t", ".", "sort", "(", "'unique ANTENNA1,ANTENNA2'", ")", "nadded", "=", "0", "# Now iterate in time,band over the MS.", "for", "tsub", "in", "t", ".", "iter", "(", "[", "'TIME'", ",", "'DATA_DESC_ID'", "]", ")", ":", "nmissing", "=", "t1", ".", "nrows", "(", ")", "-", "tsub", ".", "nrows", "(", ")", "if", "nmissing", "<", "0", ":", "raise", "ValueError", "(", "\"A time/band chunk has too many rows\"", ")", "if", "nmissing", ">", "0", ":", "# Rows needs to be added for the missing baselines.", "ant1", "=", "str", "(", "t1", ".", "getcol", "(", "'ANTENNA1'", ")", ")", ".", "replace", "(", "' '", ",", "','", ")", "ant2", "=", "str", "(", "t1", ".", "getcol", "(", "'ANTENNA2'", ")", ")", ".", "replace", "(", "' '", ",", "','", ")", "ant1", "=", "tsub", ".", "getcol", "(", "'ANTENNA1'", ")", "ant2", "=", "tsub", ".", "getcol", "(", "'ANTENNA2'", ")", "t2", "=", "taql", "(", "'select from $t1 where !any(ANTENNA1 == $ant1 &&'", "+", "' ANTENNA2 == $ant2)'", ")", "six", ".", "print_", "(", "nmissing", ",", "t1", ".", "nrows", "(", ")", ",", "tsub", ".", "nrows", "(", ")", ",", "t2", ".", "nrows", "(", ")", ")", "if", "t2", ".", "nrows", "(", ")", "!=", "nmissing", ":", "raise", "ValueError", "(", "\"A time/band chunk behaves strangely\"", ")", "# If nothing added yet, create a new table.", "# (which has to be reopened for read/write).", "# Otherwise append to that new table.", "if", "nadded", "==", "0", ":", "tnew", "=", "t2", ".", "copy", "(", "newname", "+", "\"_add\"", ",", "deep", "=", "True", ")", "tnew", "=", "table", "(", "newname", "+", "\"_add\"", ",", "readonly", "=", "False", ")", "else", ":", "t2", ".", "copyrows", "(", "tnew", ")", "# Set the correct time and band in the new rows.", "tnew", ".", "putcell", "(", "'TIME'", ",", "range", "(", "nadded", ",", "nadded", "+", "nmissing", ")", ",", "tsub", ".", "getcell", "(", "'TIME'", ",", "0", ")", ")", "tnew", ".", "putcell", "(", "'DATA_DESC_ID'", ",", "range", "(", "nadded", ",", "nadded", "+", "nmissing", ")", ",", "tsub", ".", "getcell", "(", "'DATA_DESC_ID'", ",", "0", ")", ")", "nadded", "+=", "nmissing", "# Combine the existing table and new table.", "if", "nadded", ">", "0", ":", "# First initialize data and flags in the added rows.", "taql", "(", "'update $tnew set DATA=0+0i'", ")", "taql", "(", "'update $tnew set FLAG=True'", ")", "tcomb", "=", "table", "(", "[", "t", ",", "tnew", "]", ")", "tcomb", ".", "rename", "(", "newname", "+", "'_adds'", ")", "tcombs", "=", "tcomb", ".", "sort", "(", "'TIME,DATA_DESC_ID,ANTENNA1,ANTENNA2'", ")", "else", ":", "tcombs", "=", "t", ".", "query", "(", "offset", "=", "0", ")", "tcombs", ".", "rename", "(", "newname", ")", "six", ".", "print_", "(", "newname", ",", "'has been created; it references the original MS'", ")", "if", "nadded", ">", "0", ":", "six", ".", "print_", "(", "' and'", ",", "newname", "+", "'_adds'", ",", "'containing'", ",", "nadded", ",", "'new rows'", ")", "else", ":", "six", ".", "print_", "(", "' no rows needed to be added'", ")" ]

[ "Regularize", "an", "MS" ]

[ "async", "def", "get_upstream_dns", "(", "cls", ")", "->", "list", ":", "data", "=", "await", "cls", ".", "get_config", "(", "\"upstream_dns\"", ")", "return", "[", "]", "if", "data", "is", "None", "else", "re", ".", "split", "(", "r'[,\\s]+'", ",", "data", ")" ]

[ "Upstream", "DNS", "server", "addresses", "." ]

[ "def", "get_script_from_egg", "(", "name", ",", "dist", ")", ":", "if", "dist", ".", "metadata_isdir", "(", "'scripts'", ")", "and", "name", "in", "dist", ".", "metadata_listdir", "(", "'scripts'", ")", ":", "return", "(", "os", ".", "path", ".", "join", "(", "dist", ".", "egg_info", ",", "'scripts'", ",", "name", ")", ",", "dist", ".", "get_metadata", "(", "'scripts/%s'", "%", "name", ")", ".", "replace", "(", "'\\r\\n'", ",", "'\\n'", ")", ".", "replace", "(", "'\\r'", ",", "'\\n'", ")", ")", "return", "None", ",", "None" ]

[ "Returns", "location", "content", "of", "script", "in", "distribution", "or", "(", "None", "None", ")", "if", "not", "there", "." ]

[ "def", "_getClassInstance", "(", "path", ",", "args", "=", "None", ")", ":", "if", "not", "path", ".", "endswith", "(", "\".py\"", ")", ":", "return", "None", "if", "args", "is", "None", ":", "args", "=", "{", "}", "classname", "=", "AtomShieldsScanner", ".", "_getClassName", "(", "path", ")", "basename", "=", "os", ".", "path", ".", "basename", "(", "path", ")", ".", "replace", "(", "\".py\"", ",", "\"\"", ")", "sys", ".", "path", ".", "append", "(", "os", ".", "path", ".", "dirname", "(", "path", ")", ")", "try", ":", "mod", "=", "__import__", "(", "basename", ",", "globals", "(", ")", ",", "locals", "(", ")", ",", "[", "classname", "]", ",", "-", "1", ")", "class_", "=", "getattr", "(", "mod", ",", "classname", ")", "instance", "=", "class_", "(", "*", "*", "args", ")", "except", "Exception", "as", "e", ":", "AtomShieldsScanner", ".", "_debug", "(", "\"[!] %s\"", "%", "e", ")", "return", "None", "finally", ":", "sys", ".", "path", ".", "remove", "(", "os", ".", "path", ".", "dirname", "(", "path", ")", ")", "return", "instance" ]

[ "Returns", "a", "class", "instance", "from", "a", ".", "py", "file", "." ]

[ "def", "is_mod_class", "(", "mod", ",", "cls", ")", ":", "return", "inspect", ".", "isclass", "(", "cls", ")", "and", "inspect", ".", "getmodule", "(", "cls", ")", "==", "mod" ]

[ "Checks", "if", "a", "class", "in", "a", "module", "was", "declared", "in", "that", "module", "." ]

[ "def", "get_related_ids", "(", "self", ",", "content_id", ",", "min_strength", "=", "None", ")", ":", "related_labels", "=", "self", ".", "get_related", "(", "content_id", ",", "min_strength", "=", "min_strength", ")", "related_idents", "=", "set", "(", ")", "for", "label", "in", "related_labels", ":", "related_idents", ".", "add", "(", "label", ".", "other", "(", "content_id", ")", ")", "return", "list", "(", "related_idents", ")" ]

[ "Get", "identifiers", "for", "related", "identifiers", "." ]

[ "def", "remove_selected", "(", "self", ",", "*", "args", ")", ":", "self", ".", "collapse_nested", "(", "self", ".", "selected", ")", "self", ".", "remove", "(", "self", ".", "selected", ")" ]

[ "Remove", "the", "selected", "catalog", "-", "allow", "the", "passing", "of", "arbitrary", "args", "so", "that", "buttons", "work", ".", "Also", "remove", "any", "nested", "catalogs", "." ]

[ "def", "modelsGetFieldsForCheckpointed", "(", "self", ",", "jobID", ",", "fields", ")", ":", "assert", "len", "(", "fields", ")", ">=", "1", ",", "\"fields is empty\"", "# Get a database connection and cursor", "with", "ConnectionFactory", ".", "get", "(", ")", "as", "conn", ":", "dbFields", "=", "[", "self", ".", "_models", ".", "pubToDBNameDict", "[", "f", "]", "for", "f", "in", "fields", "]", "dbFieldStr", "=", "\", \"", ".", "join", "(", "dbFields", ")", "query", "=", "'SELECT model_id, {fields} from {models}'", "' WHERE job_id=%s AND model_checkpoint_id IS NOT NULL'", ".", "format", "(", "fields", "=", "dbFieldStr", ",", "models", "=", "self", ".", "modelsTableName", ")", "conn", ".", "cursor", ".", "execute", "(", "query", ",", "[", "jobID", "]", ")", "rows", "=", "conn", ".", "cursor", ".", "fetchall", "(", ")", "return", "[", "(", "r", "[", "0", "]", ",", "list", "(", "r", "[", "1", ":", "]", ")", ")", "for", "r", "in", "rows", "]" ]

[ "Gets", "fields", "from", "all", "models", "in", "a", "job", "that", "have", "been", "checkpointed", ".", "This", "is", "used", "to", "figure", "out", "whether", "or", "not", "a", "new", "model", "should", "be", "checkpointed", "." ]

[ "def", "_get_environment_updates", "(", "self", ",", "display_all_distributions", "=", "False", ")", ":", "updates", "=", "[", "]", "for", "distribution", "in", "self", ".", "pip", ".", "get_installed_distributions", "(", ")", ":", "versions", "=", "self", ".", "get_available_versions", "(", "distribution", ".", "project_name", ")", "max_version", "=", "max", "(", "versions", ".", "keys", "(", ")", ")", "if", "versions", "else", "UNKNOW_NUM", "update", "=", "None", "distribution_version", "=", "self", ".", "_parse_version", "(", "distribution", ".", "version", ")", "if", "versions", "and", "max_version", ">", "distribution_version", ":", "update", "=", "Update", "(", "distribution", ".", "project_name", ",", "distribution", ".", "version", ",", "versions", "[", "max_version", "]", ",", "prelease", "=", "max_version", "[", "-", "1", "]", ")", "elif", "(", "display_all_distributions", "and", "max_version", "==", "distribution_version", ")", ":", "update", "=", "Update", "(", "distribution", ".", "project_name", ",", "distribution", ".", "version", ",", "versions", "[", "max_version", "]", ",", ")", "elif", "display_all_distributions", ":", "update", "=", "Update", "(", "distribution", ".", "project_name", ",", "distribution", ".", "version", ",", "UNKNOWN", ")", "if", "update", ":", "updates", ".", "append", "(", "update", ")", "return", "sorted", "(", "updates", ",", "key", "=", "lambda", "x", ":", "x", ".", "name", ")" ]

[ "Check", "all", "pacakges", "installed", "in", "the", "environment", "to", "see", "if", "there", "are", "any", "updates", "availalble", "." ]

[ "def", "getVariances", "(", "self", ")", ":", "var", "=", "[", "]", "var", ".", "append", "(", "self", ".", "Cr", ".", "K", "(", ")", ".", "diagonal", "(", ")", ")", "if", "self", ".", "bgRE", ":", "var", ".", "append", "(", "self", ".", "Cg", ".", "K", "(", ")", ".", "diagonal", "(", ")", ")", "var", ".", "append", "(", "self", ".", "Cn", ".", "K", "(", ")", ".", "diagonal", "(", ")", ")", "var", "=", "sp", ".", "array", "(", "var", ")", "return", "var" ]

[ "get", "variances" ]

[ "def", "dcos_version", "(", ")", ":", "url", "=", "_gen_url", "(", "'dcos-metadata/dcos-version.json'", ")", "response", "=", "dcos", ".", "http", ".", "request", "(", "'get'", ",", "url", ")", "if", "response", ".", "status_code", "==", "200", ":", "return", "response", ".", "json", "(", ")", "[", "'version'", "]", "else", ":", "return", "None" ]

[ "Return", "the", "version", "of", "the", "running", "cluster", ".", ":", "return", ":", "DC", "/", "OS", "cluster", "version", "as", "a", "string" ]

[ "def", "_has_valid_positional_setitem_indexer", "(", "self", ",", "indexer", ")", ":", "if", "isinstance", "(", "indexer", ",", "dict", ")", ":", "raise", "IndexError", "(", "\"{0} cannot enlarge its target object\"", ".", "format", "(", "self", ".", "name", ")", ")", "else", ":", "if", "not", "isinstance", "(", "indexer", ",", "tuple", ")", ":", "indexer", "=", "self", ".", "_tuplify", "(", "indexer", ")", "for", "ax", ",", "i", "in", "zip", "(", "self", ".", "obj", ".", "axes", ",", "indexer", ")", ":", "if", "isinstance", "(", "i", ",", "slice", ")", ":", "# should check the stop slice?", "pass", "elif", "is_list_like_indexer", "(", "i", ")", ":", "# should check the elements?", "pass", "elif", "is_integer", "(", "i", ")", ":", "if", "i", ">=", "len", "(", "ax", ")", ":", "raise", "IndexError", "(", "\"{name} cannot enlarge its target \"", "\"object\"", ".", "format", "(", "name", "=", "self", ".", "name", ")", ")", "elif", "isinstance", "(", "i", ",", "dict", ")", ":", "raise", "IndexError", "(", "\"{name} cannot enlarge its target object\"", ".", "format", "(", "name", "=", "self", ".", "name", ")", ")", "return", "True" ]

[ "validate", "that", "an", "positional", "indexer", "cannot", "enlarge", "its", "target", "will", "raise", "if", "needed", "does", "not", "modify", "the", "indexer", "externally" ]

[ "def", "_resolve_lbs", "(", "load_balancers", ")", ":", "lb_args", "=", "[", "]", "if", "not", "isinstance", "(", "load_balancers", ",", "list", ")", ":", "lbs", "=", "[", "load_balancers", "]", "else", ":", "lbs", "=", "load_balancers", "for", "lb", "in", "lbs", ":", "if", "isinstance", "(", "lb", ",", "dict", ")", ":", "lb_args", ".", "append", "(", "lb", ")", "elif", "isinstance", "(", "lb", ",", "CloudLoadBalancer", ")", ":", "lb_args", ".", "append", "(", "{", "\"loadBalancerId\"", ":", "lb", ".", "id", ",", "\"port\"", ":", "lb", ".", "port", ",", "}", ")", "elif", "isinstance", "(", "lb", ",", "tuple", ")", ":", "lb_args", ".", "append", "(", "{", "\"loadBalancerId\"", ":", "lb", "[", "0", "]", ",", "\"port\"", ":", "lb", "[", "1", "]", "}", ")", "else", ":", "# See if it's an ID for a Load Balancer", "try", ":", "instance", "=", "pyrax", ".", "cloud_loadbalancers", ".", "get", "(", "lb", ")", "except", "Exception", ":", "raise", "exc", ".", "InvalidLoadBalancer", "(", "\"Received an invalid \"", "\"specification for a Load Balancer: '%s'\"", "%", "lb", ")", "lb_args", ".", "append", "(", "{", "\"loadBalancerId\"", ":", "instance", ".", "id", ",", "\"port\"", ":", "instance", ".", "port", ",", "}", ")", "return", "lb_args" ]

[ "Takes", "either", "a", "single", "LB", "reference", "or", "a", "list", "of", "references", "and", "returns", "the", "dictionary", "required", "for", "creating", "a", "Scaling", "Group", "." ]

[ "def", "has_equal_ast", "(", "state", ",", "incorrect_msg", "=", "\"Check the {ast_path}. {extra}\"", ",", "sql", "=", "None", ",", "start", "=", "[", "\"expression\"", ",", "\"subquery\"", ",", "\"sql_script\"", "]", "[", "0", "]", ",", "exact", "=", "None", ",", ")", ":", "ast", "=", "state", ".", "ast_dispatcher", ".", "ast_mod", "sol_ast", "=", "state", ".", "solution_ast", "if", "sql", "is", "None", "else", "ast", ".", "parse", "(", "sql", ",", "start", ")", "# if sql is set, exact defaults to False.", "# if sql not set, exact defaults to True.", "if", "exact", "is", "None", ":", "exact", "=", "sql", "is", "None", "stu_rep", "=", "repr", "(", "state", ".", "student_ast", ")", "sol_rep", "=", "repr", "(", "sol_ast", ")", "def", "get_str", "(", "ast", ",", "code", ",", "sql", ")", ":", "if", "sql", ":", "return", "sql", "if", "isinstance", "(", "ast", ",", "str", ")", ":", "return", "ast", "try", ":", "return", "ast", ".", "get_text", "(", "code", ")", "except", ":", "return", "None", "sol_str", "=", "get_str", "(", "state", ".", "solution_ast", ",", "state", ".", "solution_code", ",", "sql", ")", "_msg", "=", "incorrect_msg", ".", "format", "(", "ast_path", "=", "state", ".", "get_ast_path", "(", ")", "or", "\"highlighted code\"", ",", "extra", "=", "\"The checker expected to find `{}` in there.\"", ".", "format", "(", "sol_str", ")", "if", "sol_str", "else", "\"Something is missing.\"", ",", ")", "if", "(", "exact", "and", "(", "sol_rep", "!=", "stu_rep", ")", ")", "or", "(", "not", "exact", "and", "(", "sol_rep", "not", "in", "stu_rep", ")", ")", ":", "state", ".", "report", "(", "Feedback", "(", "_msg", ")", ")", "return", "state" ]

[ "Test", "whether", "the", "student", "and", "solution", "code", "have", "identical", "AST", "representations" ]

[ "def", "get_time", "(", "self", ")", ":", "if", "(", "self", ".", "steam_time_offset", "is", "None", "or", "(", "self", ".", "align_time_every", "and", "(", "time", "(", ")", "-", "self", ".", "_offset_last_check", ")", ">", "self", ".", "align_time_every", ")", ")", ":", "self", ".", "steam_time_offset", "=", "get_time_offset", "(", ")", "if", "self", ".", "steam_time_offset", "is", "not", "None", ":", "self", ".", "_offset_last_check", "=", "time", "(", ")", "return", "int", "(", "time", "(", ")", "+", "(", "self", ".", "steam_time_offset", "or", "0", ")", ")" ]

[ ":", "return", ":", "Steam", "aligned", "timestamp", ":", "rtype", ":", "int" ]

[ "def", "_provision_network", "(", "self", ",", "port_id", ",", "net_uuid", ",", "network_type", ",", "physical_network", ",", "segmentation_id", ")", ":", "LOG", ".", "info", "(", "\"Provisioning network %s\"", ",", "net_uuid", ")", "vswitch_name", "=", "self", ".", "_get_vswitch_name", "(", "network_type", ",", "physical_network", ")", "vswitch_map", "=", "{", "'network_type'", ":", "network_type", ",", "'vswitch_name'", ":", "vswitch_name", ",", "'ports'", ":", "[", "]", ",", "'vlan_id'", ":", "segmentation_id", "}", "self", ".", "_network_vswitch_map", "[", "net_uuid", "]", "=", "vswitch_map" ]

[ "Provision", "the", "network", "with", "the", "received", "information", "." ]

[ "def", "dropHistoricalTable", "(", "apps", ",", "schema_editor", ")", ":", "table_name", "=", "'sap_success_factors_historicalsapsuccessfactorsenterprisecus80ad'", "if", "table_name", "in", "connection", ".", "introspection", ".", "table_names", "(", ")", ":", "migrations", ".", "DeleteModel", "(", "name", "=", "table_name", ",", ")" ]

[ "Drops", "the", "historical", "sap_success_factors", "table", "named", "herein", "." ]

[ "def", "compile_select", "(", "self", ",", "query", ")", ":", "sql", "=", "super", "(", "MySqlQueryGrammar", ",", "self", ")", ".", "compile_select", "(", "query", ")", "if", "query", ".", "unions", ":", "sql", "=", "'(%s) %s'", "%", "(", "sql", ",", "self", ".", "_compile_unions", "(", "query", ")", ")", "return", "sql" ]

[ "Compile", "a", "select", "query", "into", "SQL" ]

[ "def", "unpack_response", "(", "self", ",", "cursor_id", "=", "None", ",", "codec_options", "=", "_UNICODE_REPLACE_CODEC_OPTIONS", ",", "user_fields", "=", "None", ",", "legacy_response", "=", "False", ")", ":", "# If _OpMsg is in-use, this cannot be a legacy response.", "assert", "not", "legacy_response", "return", "bson", ".", "_decode_all_selective", "(", "self", ".", "payload_document", ",", "codec_options", ",", "user_fields", ")" ]

[ "Unpack", "a", "OP_MSG", "command", "response", "." ]

[ "def", "is_creation_model", "(", "instance", ",", "attribute", ",", "value", ")", ":", "creation_name", "=", "value", ".", "get", "(", "'name'", ")", "if", "not", "isinstance", "(", "creation_name", ",", "str", ")", ":", "instance_name", "=", "instance", ".", "__class__", ".", "__name__", "err_str", "=", "(", "\"'name' must be given as a string in the '{attr}' \"", "\"parameter of a '{cls}'. Given \"", "\"'{value}'\"", ")", ".", "format", "(", "attr", "=", "attribute", ".", "name", ",", "cls", "=", "instance_name", ",", "value", "=", "creation_name", ")", "raise", "ModelDataError", "(", "err_str", ")" ]

[ "Must", "include", "at", "least", "a", "name", "key", "." ]

[ "def", "send", "(", "token", ",", "title", ",", "*", "*", "kwargs", ")", ":", "headers", "=", "{", "\"Content-type\"", ":", "\"application/x-www-form-urlencoded\"", ",", "\"User-Agent\"", ":", "\"DBMail/%s\"", "%", "get_version", "(", ")", ",", "}", "data", "=", "{", "\"user_credentials\"", ":", "token", ",", "\"notification[title]\"", ":", "from_unicode", "(", "title", ")", ",", "\"notification[sound]\"", ":", "\"notifier-2\"", "}", "for", "k", ",", "v", "in", "kwargs", ".", "items", "(", ")", ":", "data", "[", "'notification[%s]'", "%", "k", "]", "=", "from_unicode", "(", "v", ")", "http", "=", "HTTPSConnection", "(", "kwargs", ".", "pop", "(", "\"api_url\"", ",", "\"new.boxcar.io\"", ")", ")", "http", ".", "request", "(", "\"POST\"", ",", "\"/api/notifications\"", ",", "headers", "=", "headers", ",", "body", "=", "urlencode", "(", "data", ")", ")", "response", "=", "http", ".", "getresponse", "(", ")", "if", "response", ".", "status", "!=", "201", ":", "raise", "BoxcarError", "(", "response", ".", "reason", ")", "return", "True" ]

[ "Site", ":", "https", ":", "//", "boxcar", ".", "io", "/", "API", ":", "http", ":", "//", "help", ".", "boxcar", ".", "io", "/", "knowledgebase", "/", "topics", "/", "48115", "-", "boxcar", "-", "api", "Desc", ":", "Best", "app", "for", "system", "administrators" ]

[ "def", "show_plain_text", "(", "self", ",", "text", ")", ":", "self", ".", "switch_to_plugin", "(", ")", "self", ".", "switch_to_plain_text", "(", ")", "self", ".", "set_plain_text", "(", "text", ",", "is_code", "=", "False", ")" ]

[ "Show", "text", "in", "plain", "mode" ]

[ "def", "_generate_branching_index", "(", "self", ")", ":", "branch_count", "=", "np", ".", "array", "(", "[", "len", "(", "self", ".", "slip", ")", ",", "len", "(", "self", ".", "msr", ")", ",", "len", "(", "self", ".", "shear_modulus", ")", ",", "len", "(", "self", ".", "disp_length_ratio", ")", ",", "len", "(", "self", ".", "msr_sigma", ")", ",", "len", "(", "self", ".", "config", ")", "]", ")", "n_levels", "=", "len", "(", "branch_count", ")", "number_branches", "=", "np", ".", "prod", "(", "branch_count", ")", "branch_index", "=", "np", ".", "zeros", "(", "[", "number_branches", ",", "n_levels", "]", ",", "dtype", "=", "int", ")", "cumval", "=", "1", "dstep", "=", "1E-9", "for", "iloc", "in", "range", "(", "0", ",", "n_levels", ")", ":", "idx", "=", "np", ".", "linspace", "(", "0.", ",", "float", "(", "branch_count", "[", "iloc", "]", ")", "-", "dstep", ",", "number_branches", "//", "cumval", ")", "branch_index", "[", ":", ",", "iloc", "]", "=", "np", ".", "reshape", "(", "np", ".", "tile", "(", "idx", ",", "[", "cumval", ",", "1", "]", ")", ",", "number_branches", ")", "cumval", "*=", "branch_count", "[", "iloc", "]", "return", "branch_index", ".", "tolist", "(", ")", ",", "number_branches" ]

[ "Generates", "a", "branching", "index", "(", "i", ".", "e", ".", "a", "list", "indicating", "the", "number", "of", "branches", "in", "each", "branching", "level", ".", "Current", "branching", "levels", "are", ":", "1", ")", "Slip", "2", ")", "MSR", "3", ")", "Shear", "Modulus", "4", ")", "DLR", "5", ")", "MSR_Sigma", "6", ")", "Config" ]

[ "def", "change_password", "(", "self", ",", "old_password", ",", "new_password", ")", ":", "try", ":", "user", "=", "this", ".", "user", "except", "self", ".", "user_model", ".", "DoesNotExist", ":", "self", ".", "auth_failed", "(", ")", "user", "=", "auth", ".", "authenticate", "(", "username", "=", "user", ".", "get_username", "(", ")", ",", "password", "=", "self", ".", "get_password", "(", "old_password", ")", ",", ")", "if", "user", "is", "None", ":", "self", ".", "auth_failed", "(", ")", "else", ":", "user", ".", "set_password", "(", "self", ".", "get_password", "(", "new_password", ")", ")", "user", ".", "save", "(", ")", "password_changed", ".", "send", "(", "sender", "=", "__name__", ",", "request", "=", "this", ".", "request", ",", "user", "=", "user", ",", ")", "return", "{", "\"passwordChanged\"", ":", "True", "}" ]

[ "Change", "password", "." ]

[ "async", "def", "download_file", "(", "self", ",", "Bucket", ",", "Key", ",", "Filename", ",", "ExtraArgs", "=", "None", ",", "Callback", "=", "None", ",", "Config", "=", "None", ")", ":", "with", "open", "(", "Filename", ",", "'wb'", ")", "as", "open_file", ":", "await", "download_fileobj", "(", "self", ",", "Bucket", ",", "Key", ",", "open_file", ",", "ExtraArgs", "=", "ExtraArgs", ",", "Callback", "=", "Callback", ",", "Config", "=", "Config", ")" ]

[ "Download", "an", "S3", "object", "to", "a", "file", "." ]

[ "def", "recursively_get_files_from_directory", "(", "directory", ")", ":", "return", "[", "os", ".", "path", ".", "join", "(", "root", ",", "filename", ")", "for", "root", ",", "directories", ",", "filenames", "in", "os", ".", "walk", "(", "directory", ")", "for", "filename", "in", "filenames", "]" ]

[ "Return", "all", "filenames", "under", "recursively", "found", "in", "a", "directory" ]

[ "def", "rename_script", "(", "rename", "=", "None", ")", ":", "# noqa: E501", "if", "connexion", ".", "request", ".", "is_json", ":", "rename", "=", "Rename", ".", "from_dict", "(", "connexion", ".", "request", ".", "get_json", "(", ")", ")", "# noqa: E501", "return", "'do some magic!'" ]

[ "Rename", "a", "script" ]

[ "def", "validate_account_id", "(", "sts_client", ",", "account_id", ")", ":", "resp", "=", "sts_client", ".", "get_caller_identity", "(", ")", "if", "'Account'", "in", "resp", ":", "if", "resp", "[", "'Account'", "]", "==", "account_id", ":", "LOGGER", ".", "info", "(", "'Verified current AWS account matches required '", "'account id %s.'", ",", "account_id", ")", "else", ":", "LOGGER", ".", "error", "(", "'Current AWS account %s does not match '", "'required account %s in Runway config.'", ",", "resp", "[", "'Account'", "]", ",", "account_id", ")", "sys", ".", "exit", "(", "1", ")", "else", ":", "LOGGER", ".", "error", "(", "'Error checking current account ID'", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Exit", "if", "get_caller_identity", "doesn", "t", "match", "account_id", "." ]

[ "def", "all_apps", "(", "self", ")", ":", "cmd", "=", "[", "\"heroku\"", ",", "\"apps\"", ",", "\"--json\"", "]", "if", "self", ".", "team", ":", "cmd", ".", "extend", "(", "[", "\"--team\"", ",", "self", ".", "team", "]", ")", "return", "json", ".", "loads", "(", "self", ".", "_result", "(", "cmd", ")", ")" ]

[ "Capture", "a", "backup", "of", "the", "app", "." ]

[ "def", "get_chunk_meta_item", "(", "self", ",", "chunk_meta", ",", "grp", ",", "pug", ",", "chk", ")", ":", "num_chk", "=", "self", ".", "envs", "[", "\"NUM_CHK\"", "]", "num_pu", "=", "self", ".", "envs", "[", "\"NUM_PU\"", "]", "index", "=", "grp", "*", "num_pu", "*", "num_chk", "+", "pug", "*", "num_chk", "+", "chk", "return", "chunk_meta", "[", "index", "]" ]

[ "Get", "item", "of", "chunk", "meta", "table" ]

[ "def", "explanation", "(", "matchAmbiguous", ",", "concise", ",", "showLengths", ",", "showGaps", ",", "showNs", ")", ":", "result", "=", "[", "\"\"\"\n<h1>Sequence versus sequence identity table</h1>\n\n<p>\n\nThe table cells below show the nucleotide identity fraction for the sequences\n(<span class=\"best\">like this</span> for the best value in each row). The\nidentity fraction numerator is the sum of the number of identical\n \"\"\"", "]", "if", "matchAmbiguous", ":", "result", ".", "append", "(", "'nucleotides plus the number of ambiguously matching '", "'nucleotides.'", ")", "else", ":", "result", ".", "append", "(", "'nucleotides.'", ")", "result", ".", "append", "(", "\"\"\"The denominator\nis the length of the sequence <em>for the row</em>. Sequence gaps\nare not included when calculating their lengths.\n\n</p>\n \"\"\"", ")", "if", "showLengths", "or", "showGaps", "or", "showNs", "or", "matchAmbiguous", "or", "not", "concise", ":", "result", ".", "append", "(", "\"\"\"\n<p>\n\nKey to abbreviations:\n <ul>\n \"\"\"", ")", "if", "showLengths", ":", "result", ".", "append", "(", "'<li>L: sequence Length.</li>'", ")", "if", "showGaps", ":", "result", ".", "append", "(", "'<li>G: number of Gaps in sequence.</li>'", ")", "if", "showNs", ":", "result", ".", "append", "(", "'<li>N: number of N characters in sequence.</li>'", ")", "if", "not", "concise", ":", "result", ".", "append", "(", "'<li>IM: Identical nucleotide Matches.</li>'", ")", "if", "matchAmbiguous", ":", "result", ".", "append", "(", "'<li>AM: Ambiguous nucleotide Matches.</li>'", ")", "result", ".", "append", "(", "\"\"\"\n <li>GG: Gap/Gap matches (both sequences have gaps).</li>\n <li>G?: Gap/Non-gap mismatches (one sequence has a gap).</li>\n <li>NE: Non-equal nucleotide mismatches.</li>\n </ul>\n</p>\n\"\"\"", ")", "return", "'\\n'", ".", "join", "(", "result", ")" ]

[ "Make", "an", "explanation", "of", "the", "output", "HTML", "table", "." ]

[ "def", "register_eventclass", "(", "event_id", ")", ":", "def", "register", "(", "cls", ")", ":", "if", "not", "issubclass", "(", "cls", ",", "Event", ")", ":", "raise", "MessageException", "(", "(", "'Cannot register a class that'", "' is not a subclass of Event'", ")", ")", "EVENT_REGISTRY", "[", "event_id", "]", "=", "cls", "logger", ".", "debug", "(", "'######### Event registry is now: {0}'", ".", "format", "(", "EVENT_REGISTRY", ")", ")", "return", "cls", "return", "register" ]

[ "Decorator", "for", "registering", "event", "classes", "for", "parsing" ]

[ "def", "full_task", "(", "self", ",", "token_id", ",", "presented_pronunciation", ",", "pronunciation", ",", "pronunciation_probability", ",", "warn", "=", "True", ",", "default", "=", "True", ")", ":", "if", "pronunciation_probability", "is", "not", "None", "and", "not", "0.", "<", "pronunciation_probability", "<", "1.", "and", "warn", ":", "logging", ".", "warning", "(", "'Setting a probability of [{}] to pronunciation [{}] for token [{}].\\n '", "'Using probabilities of 0.0 or 1.0 '", "'may lead to likelihoods of -Infinity'", ".", "format", "(", "pronunciation_probability", ",", "pronunciation", ",", "token_id", ")", ")", "key", "=", "pronunciation", "if", "isinstance", "(", "key", ",", "list", ")", ":", "if", "not", "all", "(", "[", "isinstance", "(", "phoneme", ",", "basestring", ")", "for", "phoneme", "in", "key", "]", ")", ":", "raise", "ValueError", "(", "'The pronunciation must be of type string (a sequence of space separated phonemes) '", "'or of type list (containing phonemes of type strings).'", "'User supplied: {}'", ".", "format", "(", "key", ")", ")", "key", "=", "' '", ".", "join", "(", "pronunciation", ")", "default_preds", "=", "self", ".", "_full_default", "(", "presented_pronunciation", ")", "if", "default", "else", "{", "}", "self", "[", "'tokens'", "]", ".", "setdefault", "(", "token_id", ",", "{", "}", ")", ".", "setdefault", "(", "'full'", ",", "default_preds", ")", "if", "key", "is", "not", "None", ":", "if", "pronunciation_probability", "is", "not", "None", ":", "self", "[", "'tokens'", "]", "[", "token_id", "]", "[", "'full'", "]", "[", "key", "]", "=", "pronunciation_probability", "else", ":", "if", "key", "in", "default_preds", ":", "self", "[", "'tokens'", "]", "[", "token_id", "]", "[", "'full'", "]", "[", "key", "]", "=", "default_preds", "[", "key", "]", "else", ":", "self", "[", "'tokens'", "]", "[", "token_id", "]", "[", "'full'", "]", ".", "pop", "(", "key", ")" ]

[ "Provide", "the", "prediction", "of", "the", "full", "task", "." ]

[ "def", "read", "(", "self", ",", "size", "=", "-", "1", ")", ":", "if", "size", "<", "0", ":", "size", "=", "self", ".", "read_available", "data", "=", "self", ".", "_ffi", ".", "new", "(", "'unsigned char[]'", ",", "size", "*", "self", ".", "elementsize", ")", "size", "=", "self", ".", "readinto", "(", "data", ")", "return", "self", ".", "_ffi", ".", "buffer", "(", "data", ",", "size", "*", "self", ".", "elementsize", ")" ]

[ "Read", "data", "from", "the", "ring", "buffer", "into", "a", "new", "buffer", "." ]

[ "def", "_set_path_to_configs", "(", "cls", ",", "path_to_config", ")", ":", "if", "not", "path_to_config", ".", "endswith", "(", "PyFunceble", ".", "directory_separator", ")", ":", "# The path to the config does not ends with the directory separator.", "# We initiate the default and the parsed variable with the directory separator.", "default", "=", "parsed", "=", "path_to_config", "+", "PyFunceble", ".", "directory_separator", "else", ":", "# The path to the config does ends with the directory separator.", "# We initiate the default and the parsed variable.", "default", "=", "parsed", "=", "path_to_config", "# We append the `CONFIGURATION_FILENAME` to the parsed variable.", "parsed", "+=", "PyFunceble", ".", "CONFIGURATION_FILENAME", "# And we append the `DEFAULT_CONFIGURATION_FILENAME` to the default variable.", "default", "+=", "PyFunceble", ".", "DEFAULT_CONFIGURATION_FILENAME", "# We finaly return a tuple which contain both informations.", "return", "(", "parsed", ",", "default", ")" ]

[ "Set", "the", "paths", "to", "the", "configuration", "files", "." ]

[ "def", "run_3to2", "(", "args", "=", "None", ")", ":", "args", "=", "BASE_ARGS_3TO2", "if", "args", "is", "None", "else", "BASE_ARGS_3TO2", "+", "args", "try", ":", "proc", "=", "subprocess", ".", "Popen", "(", "[", "'3to2'", "]", "+", "args", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "except", "OSError", ":", "for", "path", "in", "glob", ".", "glob", "(", "'*.egg'", ")", ":", "if", "os", ".", "path", ".", "isdir", "(", "path", ")", "and", "path", "not", "in", "sys", ".", "path", ":", "sys", ".", "path", ".", "append", "(", "path", ")", "try", ":", "from", "lib3to2", ".", "main", "import", "main", "as", "lib3to2_main", "except", "ImportError", ":", "raise", "OSError", "(", "'3to2 script is unavailable.'", ")", "else", ":", "if", "lib3to2_main", "(", "'lib3to2.fixes'", ",", "args", ")", ":", "raise", "Exception", "(", "'lib3to2 parsing error'", ")", "else", ":", "# HACK: workaround for 3to2 never returning non-zero", "# when using the -j option.", "num_errors", "=", "0", "while", "proc", ".", "poll", "(", ")", "is", "None", ":", "line", "=", "proc", ".", "stderr", ".", "readline", "(", ")", "sys", ".", "stderr", ".", "write", "(", "line", ")", "num_errors", "+=", "line", ".", "count", "(", "': ParseError: '", ")", "if", "proc", ".", "returncode", "or", "num_errors", ":", "raise", "Exception", "(", "'lib3to2 parsing error'", ")" ]

[ "Convert", "Python", "files", "using", "lib3to2", "." ]

[ "def", "velocity_confidence", "(", "data", ",", "vkey", "=", "'velocity'", ",", "copy", "=", "False", ")", ":", "adata", "=", "data", ".", "copy", "(", ")", "if", "copy", "else", "data", "if", "vkey", "not", "in", "adata", ".", "layers", ".", "keys", "(", ")", ":", "raise", "ValueError", "(", "'You need to run `tl.velocity` first.'", ")", "idx", "=", "np", ".", "array", "(", "adata", ".", "var", "[", "vkey", "+", "'_genes'", "]", ".", "values", ",", "dtype", "=", "bool", ")", "X", ",", "V", "=", "adata", ".", "layers", "[", "'Ms'", "]", "[", ":", ",", "idx", "]", ".", "copy", "(", ")", ",", "adata", ".", "layers", "[", "vkey", "]", "[", ":", ",", "idx", "]", ".", "copy", "(", ")", "indices", "=", "get_indices", "(", "dist", "=", "adata", ".", "uns", "[", "'neighbors'", "]", "[", "'distances'", "]", ")", "[", "0", "]", "V", "-=", "V", ".", "mean", "(", "1", ")", "[", ":", ",", "None", "]", "V_norm", "=", "norm", "(", "V", ")", "R", "=", "np", ".", "zeros", "(", "adata", ".", "n_obs", ")", "for", "i", "in", "range", "(", "adata", ".", "n_obs", ")", ":", "Vi_neighs", "=", "V", "[", "indices", "[", "i", "]", "]", "Vi_neighs", "-=", "Vi_neighs", ".", "mean", "(", "1", ")", "[", ":", ",", "None", "]", "R", "[", "i", "]", "=", "np", ".", "mean", "(", "np", ".", "einsum", "(", "'ij, j'", ",", "Vi_neighs", ",", "V", "[", "i", "]", ")", "/", "(", "norm", "(", "Vi_neighs", ")", "*", "V_norm", "[", "i", "]", ")", "[", "None", ",", ":", "]", ")", "adata", ".", "obs", "[", "vkey", "+", "'_length'", "]", "=", "V_norm", ".", "round", "(", "2", ")", "adata", ".", "obs", "[", "vkey", "+", "'_confidence'", "]", "=", "R", "logg", ".", "hint", "(", "'added \\''", "+", "vkey", "+", "'_confidence\\' (adata.obs)'", ")", "if", "vkey", "+", "'_confidence_transition'", "not", "in", "adata", ".", "obs", ".", "keys", "(", ")", ":", "velocity_confidence_transition", "(", "adata", ",", "vkey", ")", "return", "adata", "if", "copy", "else", "None" ]

[ "Computes", "confidences", "of", "velocities", "." ]

[ "def", "create_object", "(", "self", ",", "name", ",", "image_sets", ")", ":", "# Create a new object identifier", "identifier", "=", "str", "(", "uuid", ".", "uuid4", "(", ")", ")", ".", "replace", "(", "'-'", ",", "''", ")", "properties", "=", "{", "datastore", ".", "PROPERTY_NAME", ":", "name", "}", "# Create the image group object and store it in the database before", "# returning it.", "obj", "=", "PredictionImageSetHandle", "(", "identifier", ",", "properties", ",", "image_sets", ")", "self", ".", "insert_object", "(", "obj", ")", "return", "obj" ]

[ "Create", "a", "prediction", "image", "set", "list", "." ]

[ "def", "TENSES", "(", "self", ")", ":", "a", "=", "set", "(", "TENSES", "[", "id", "]", "for", "id", "in", "self", ".", "_format", ")", "a", "=", "a", ".", "union", "(", "set", "(", "TENSES", "[", "id", "]", "for", "id", "in", "self", ".", "_default", ".", "keys", "(", ")", ")", ")", "a", "=", "a", ".", "union", "(", "set", "(", "TENSES", "[", "id", "]", "for", "id", "in", "self", ".", "_default", ".", "values", "(", ")", ")", ")", "a", "=", "sorted", "(", "x", "[", ":", "-", "2", "]", "for", "x", "in", "a", "if", "x", "[", "-", "2", "]", "is", "False", ")", "# Exclude negation.", "return", "a" ]

[ "Yields", "a", "list", "of", "tenses", "for", "this", "language", "excluding", "negations", ".", "Each", "tense", "is", "a", "(", "tense", "person", "number", "mood", "aspect", ")", "-", "tuple", "." ]

[ "def", "get_diff_str", "(", "self", ",", "element", ",", "length", ")", ":", "spaces", "=", "' '", "*", "(", "self", ".", "get_width", "(", "element", ")", "-", "length", ")", "return", "spaces", "+", "element", ".", "get", "(", "'diff'", ")" ]

[ "get_diff_str" ]

[ "def", "circmean", "(", "dts", ",", "axis", "=", "2", ")", ":", "return", "np", ".", "exp", "(", "1.0j", "*", "dts", ")", ".", "mean", "(", "axis", "=", "axis", ")", ".", "angle", "(", ")" ]

[ "Circular", "mean", "phase" ]

[ "def", "multiselect", "(", "self", ",", "window_name", ",", "object_name", ",", "row_text_list", ",", "partial_match", "=", "False", ")", ":", "object_handle", "=", "self", ".", "_get_object_handle", "(", "window_name", ",", "object_name", ")", "if", "not", "object_handle", ".", "AXEnabled", ":", "raise", "LdtpServerException", "(", "u\"Object %s state disabled\"", "%", "object_name", ")", "object_handle", ".", "activate", "(", ")", "selected", "=", "False", "try", ":", "window", "=", "self", ".", "_get_front_most_window", "(", ")", "except", "(", "IndexError", ",", ")", ":", "window", "=", "self", ".", "_get_any_window", "(", ")", "for", "row_text", "in", "row_text_list", ":", "selected", "=", "False", "for", "cell", "in", "object_handle", ".", "AXRows", ":", "parent_cell", "=", "cell", "cell", "=", "self", ".", "_getfirstmatchingchild", "(", "cell", ",", "\"(AXTextField|AXStaticText)\"", ")", "if", "not", "cell", ":", "continue", "if", "re", ".", "match", "(", "row_text", ",", "cell", ".", "AXValue", ")", ":", "selected", "=", "True", "if", "not", "parent_cell", ".", "AXSelected", ":", "x", ",", "y", ",", "width", ",", "height", "=", "self", ".", "_getobjectsize", "(", "parent_cell", ")", "window", ".", "clickMouseButtonLeftWithMods", "(", "(", "x", "+", "width", "/", "2", ",", "y", "+", "height", "/", "2", ")", ",", "[", "'<command_l>'", "]", ")", "# Following selection doesn't work", "# parent_cell.AXSelected=True", "self", ".", "wait", "(", "0.5", ")", "else", ":", "# Selected", "pass", "break", "if", "not", "selected", ":", "raise", "LdtpServerException", "(", "u\"Unable to select row: %s\"", "%", "row_text", ")", "if", "not", "selected", ":", "raise", "LdtpServerException", "(", "u\"Unable to select any row\"", ")", "return", "1" ]

[ "Select", "multiple", "row" ]

[ "def", "get_arg_name", "(", "self", ",", "param", ")", ":", "if", "self", ".", "current_command", "in", "self", ".", "cmdtab", ":", "for", "arg", "in", "self", ".", "cmdtab", "[", "self", ".", "current_command", "]", ".", "arguments", ":", "for", "name", "in", "self", ".", "cmdtab", "[", "self", ".", "current_command", "]", ".", "arguments", "[", "arg", "]", ".", "options_list", ":", "if", "name", "==", "param", ":", "return", "arg", "return", "None" ]

[ "gets", "the", "argument", "name", "used", "in", "the", "command", "table", "for", "a", "parameter" ]

[ "def", "create_args", "(", "line", ",", "namespace", ")", ":", "args", "=", "[", "]", "# Using shlex.split handles quotes args and escape characters.", "for", "arg", "in", "shlex", ".", "split", "(", "line", ")", ":", "if", "not", "arg", ":", "continue", "if", "arg", "[", "0", "]", "==", "'$'", ":", "var_name", "=", "arg", "[", "1", ":", "]", "if", "var_name", "in", "namespace", ":", "args", ".", "append", "(", "(", "namespace", "[", "var_name", "]", ")", ")", "else", ":", "raise", "Exception", "(", "'Undefined variable referenced in command line: %s'", "%", "arg", ")", "else", ":", "args", ".", "append", "(", "arg", ")", "return", "args" ]

[ "Expand", "any", "meta", "-", "variable", "references", "in", "the", "argument", "list", "." ]

[ "def", "create_badge_blueprint", "(", "allowed_types", ")", ":", "from", "invenio_formatter", ".", "context_processors", ".", "badges", "import", "generate_badge_png", ",", "generate_badge_svg", "blueprint", "=", "Blueprint", "(", "'invenio_formatter_badges'", ",", "__name__", ",", "template_folder", "=", "'templates'", ",", ")", "@", "blueprint", ".", "route", "(", "'/badge/<any({0}):title>/<path:value>.<any(svg, png):ext>'", ".", "format", "(", "', '", ".", "join", "(", "allowed_types", ")", ")", ")", "def", "badge", "(", "title", ",", "value", ",", "ext", "=", "'svg'", ")", ":", "\"\"\"Generate a badge response.\"\"\"", "if", "ext", "==", "'svg'", ":", "generator", "=", "generate_badge_svg", "mimetype", "=", "'image/svg+xml'", "elif", "ext", "==", "'png'", ":", "generator", "=", "generate_badge_png", "mimetype", "=", "'image/png'", "badge_title_mapping", "=", "current_app", ".", "config", "[", "'FORMATTER_BADGES_TITLE_MAPPING'", "]", ".", "get", "(", "title", ",", "title", ")", "response", "=", "Response", "(", "generator", "(", "badge_title_mapping", ",", "value", ")", ",", "mimetype", "=", "mimetype", ")", "# Generate Etag from badge title and value.", "hashable_badge", "=", "\"{0}.{1}\"", ".", "format", "(", "badge_title_mapping", ",", "value", ")", ".", "encode", "(", "'utf-8'", ")", "response", ".", "set_etag", "(", "hashlib", ".", "sha1", "(", "hashable_badge", ")", ".", "hexdigest", "(", ")", ")", "# Add headers to prevent caching.", "response", ".", "headers", "[", "\"Pragma\"", "]", "=", "\"no-cache\"", "response", ".", "cache_control", ".", "no_cache", "=", "True", "response", ".", "cache_control", ".", "max_age", "=", "current_app", ".", "config", "[", "'FORMATTER_BADGES_MAX_CACHE_AGE'", "]", "response", ".", "last_modified", "=", "dt", ".", "utcnow", "(", ")", "extra", "=", "timedelta", "(", "seconds", "=", "current_app", ".", "config", "[", "'FORMATTER_BADGES_MAX_CACHE_AGE'", "]", ")", "response", ".", "expires", "=", "response", ".", "last_modified", "+", "extra", "return", "response", ".", "make_conditional", "(", "request", ")", "return", "blueprint" ]

[ "Create", "the", "badge", "blueprint", "." ]

[ "def", "create_mypassword", "(", "self", ",", "data", ")", ":", "# http://teampasswordmanager.com/docs/api-my-passwords/#create_password", "log", ".", "info", "(", "'Create MyPassword with %s'", "%", "data", ")", "NewID", "=", "self", ".", "post", "(", "'my_passwords.json'", ",", "data", ")", ".", "get", "(", "'id'", ")", "log", ".", "info", "(", "'MyPassword has been created with %s'", "%", "NewID", ")", "return", "NewID" ]

[ "Create", "my", "password", "." ]

[ "def", "columns_used", "(", "self", ")", ":", "return", "list", "(", "tz", ".", "unique", "(", "tz", ".", "concatv", "(", "util", ".", "columns_in_filters", "(", "self", ".", "fit_filters", ")", ",", "util", ".", "columns_in_filters", "(", "self", ".", "predict_filters", ")", ",", "util", ".", "columns_in_formula", "(", "self", ".", "model_expression", ")", ")", ")", ")" ]

[ "Returns", "all", "the", "columns", "used", "in", "this", "model", "for", "filtering", "and", "in", "the", "model", "expression", "." ]

[ "def", "_kip_cont2", "(", "self", ",", "sparse", ",", "cycle_start", "=", "0", ",", "cycle_end", "=", "0", ",", "plot", "=", "[", "'dcoeff'", "]", ",", "thresholds", "=", "[", "1.0E+12", "]", ",", "xax", "=", "'log_time_left'", ",", "alphas", "=", "[", "1.0", "]", ",", "yllim", "=", "0.", ",", "yulim", "=", "0.", ",", "y_res", "=", "2000", ",", "xllim", "=", "0.", ",", "xulim", "=", "0.", ",", "age", "=", "'seconds'", ",", "sparse_intrinsic", "=", "20", ",", "engen", "=", "False", ",", "netnuc_name", "=", "'eps_nuc'", ",", "engenalpha", "=", "0.6", ",", "outfile", "=", "'plot.pdf'", ",", "annotation", "=", "''", ",", "KEPLER", "=", "False", ")", ":", "# Organize cycles and ages:", "original_cyclelist", "=", "self", ".", "se", ".", "cycles", "if", "cycle_end", "==", "0.", ":", "cycle_end", "=", "original_cyclelist", "[", "-", "1", "]", "cycle_end", "=", "old_div", "(", "int", "(", "cycle_end", ")", ",", "sparse_intrinsic", ")", "-", "1", "if", "cycle_start", "==", "0", ":", "pass", "else", ":", "cycle_start", "=", "old_div", "(", "int", "(", "cycle_start", ")", ",", "sparse_intrinsic", ")", "-", "1", "cyclelist", "=", "original_cyclelist", "[", "cycle_start", ":", "cycle_end", ":", "sparse", "]", "# fix for KEPLER restart counting at O burning:", "original_ages", "=", "self", ".", "se", ".", "ages", "age_at_restart", "=", "0.", "age_at_restart_idx", "=", "0", "if", "KEPLER", "==", "True", ":", "for", "i", "in", "range", "(", "1", ",", "len", "(", "original_ages", ")", ")", ":", "if", "(", "original_ages", "[", "i", "]", "-", "original_ages", "[", "i", "-", "1", "]", ")", "<", "0.", ":", "age_at_restart_idx", "=", "i", "-", "1", "age_at_restart", "=", "original_ages", "[", "i", "-", "1", "]", "print", "(", "'age restart found at cycle = '", "+", "str", "(", "age_at_restart_idx", ")", "+", "', age = '", "+", "str", "(", "age_at_restart", ")", ")", "KEPLER", "=", "True", "break", "for", "i", "in", "range", "(", "age_at_restart_idx", "+", "1", ",", "len", "(", "original_ages", ")", ")", ":", "original_ages", "[", "i", "]", "=", "original_ages", "[", "i", "]", "+", "age_at_restart", "# Figure:", "fig", "=", "pl", ".", "figure", "(", ")", "ax", "=", "pl", ".", "axes", "(", ")", "params", "=", "{", "'axes.labelsize'", ":", "15", ",", "'text.fontsize'", ":", "15", ",", "'legend.fontsize'", ":", "15", ",", "'xtick.labelsize'", ":", "15", ",", "'ytick.labelsize'", ":", "15", ",", "'text.usetex'", ":", "False", "}", "fsize", "=", "18", "pl", ".", "rcParams", ".", "update", "(", "params", ")", "# X-axis:", "if", "xax", "==", "'log_time_left'", ":", "if", "KEPLER", "==", "True", ":", "xxtmp", "=", "original_ages", "[", "cycle_start", ":", "cycle_end", ":", "sparse", "]", "else", ":", "xxtmp", "=", "self", ".", "se", ".", "ages", "[", "cycle_start", ":", "cycle_end", ":", "sparse", "]", "if", "age", "==", "'years'", ":", "if", "KEPLER", "==", "True", ":", "pass", "else", ":", "xxtmp", "=", "self", ".", "se", ".", "ages", "[", "cycle_start", ":", "cycle_end", ":", "sparse", "]", "elif", "age", "==", "'seconds'", ":", "if", "KEPLER", "==", "True", ":", "for", "i", "in", "range", "(", "len", "(", "cyclelist", ")", ")", ":", "xxtmp", "[", "i", "]", "=", "old_div", "(", "original_ages", "[", "cycle_start", ":", "cycle_end", ":", "sparse", "]", "[", "i", "]", ",", "31558149.984", ")", "else", ":", "for", "i", "in", "range", "(", "len", "(", "cyclelist", ")", ")", ":", "xxtmp", "[", "i", "]", "=", "old_div", "(", "self", ".", "se", ".", "ages", "[", "cycle_start", ":", "cycle_end", ":", "sparse", "]", "[", "i", "]", ",", "31558149.984", ")", "if", "xax", "==", "'cycles'", ":", "xx", "=", "cyclelist", "xxtmp", "=", "cyclelist", "# Set up x-axis according to whether ages are in years or seconds and", "# re-write as log(time left). The last entry will always be -inf in this", "# way so we calculate it by extrapolating the anti-penultimate and", "# penultimate entries.", "# Modified from the GENEC gdic (R. Hirschi)", "if", "xax", "==", "'log_time_left'", ":", "xx", "=", "np", ".", "zeros", "(", "len", "(", "xxtmp", ")", ")", "agemin", "=", "max", "(", "old_div", "(", "abs", "(", "xxtmp", "[", "-", "1", "]", "-", "xxtmp", "[", "-", "2", "]", ")", ",", "5.", ")", ",", "1.e-10", ")", "for", "i", "in", "np", ".", "arange", "(", "len", "(", "xxtmp", ")", ")", ":", "if", "xxtmp", "[", "-", "1", "]", "-", "xxtmp", "[", "i", "]", ">", "agemin", ":", "xx", "[", "i", "]", "=", "np", ".", "log10", "(", "xxtmp", "[", "-", "1", "]", "-", "xxtmp", "[", "i", "]", "+", "agemin", ")", "else", ":", "xx", "[", "i", "]", "=", "np", ".", "log10", "(", "agemin", ")", "ax", ".", "set_xlabel", "(", "'$log_\\mathrm{10}(t_\\mathrm{end}-t)\\;[\\mathrm{yr}]$'", ",", "fontsize", "=", "fsize", "-", "1", ")", "if", "xax", "==", "'cycles'", ":", "ax", ".", "set_xlabel", "(", "'$\\mathrm{CYCLE}$'", ",", "fontsize", "=", "fsize", "-", "1", ")", "# Y-axis limits and resolution:", "totalmass", "=", "[", "]", "try", ":", "m_ini", "=", "float", "(", "self", ".", "se", ".", "get", "(", "'mini'", ")", ")", "except", ":", "mini", "=", "m", ".", "se", ".", "get", "(", "0", ",", "'total_mass'", ")", "mini", "=", "old_div", "(", "mini", ",", "constants", ".", "mass_sun", ")", "print", "(", "'getting Mini from 1st cycle'", ")", "if", "yulim", "==", "0.", ":", "yulim", "=", "m_ini", "dy", "=", "old_div", "(", "m_ini", ",", "float", "(", "y_res", ")", ")", "vlinetol", "=", "1.0E-8", "# Set up (y-axis) vector and a 3-D (hist) array to store all of the", "# contours.", "y", "=", "np", ".", "arange", "(", "0.", ",", "m_ini", ",", "dy", ")", "if", "engen", "==", "True", ":", "Z", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "xxtmp", ")", ",", "len", "(", "plot", ")", "+", "2", "]", ",", "float", ")", "else", ":", "Z", "=", "np", ".", "zeros", "(", "[", "len", "(", "y", ")", ",", "len", "(", "xxtmp", ")", ",", "len", "(", "plot", ")", "]", ",", "float", ")", "# Define function extracting the contour boundaries which will be", "# called for every cycle in cyclelist, for every variable to be plotted", "# along with its corresponding threshold(s).", "def", "getlims", "(", "variable_array", ",", "thresh", ",", "massco_array", ")", ":", "\"\"\"This function returns the variable boundaries (in mass) for a cycle,\n given the cycle's variable and mass columns, ensuring that the boundaries\n are ordered centre to surface (as some .se.h5 files are the opposite).\"\"\"", "plotlims", "=", "[", "]", "# Just a fix for some get problem I was having:", "if", "len", "(", "massco_array", ")", "==", "2", ":", "massco_array", "=", "massco_array", "[", "0", "]", "if", "len", "(", "variable_array", ")", "==", "2", ":", "variable_array", "=", "variable_array", "[", "0", "]", "if", "massco_array", "[", "0", "]", ">", "massco_array", "[", "-", "1", "]", ":", "for", "j", "in", "range", "(", "-", "1", ",", "-", "len", "(", "variable_array", ")", "-", "1", ",", "-", "1", ")", ":", "if", "j", "==", "-", "1", ":", "if", "variable_array", "[", "j", "]", ">=", "thresh", ":", "plotlims", ".", "append", "(", "massco_array", "[", "j", "]", ")", "else", ":", "pass", "elif", "(", "variable_array", "[", "j", "]", "-", "thresh", ")", "*", "(", "variable_array", "[", "j", "+", "1", "]", "-", "thresh", ")", "<", "0", ":", "plotlims", ".", "append", "(", "massco_array", "[", "j", "]", ")", "if", "j", "==", "-", "len", "(", "variable_array", ")", ":", "if", "variable_array", "[", "j", "]", ">=", "thresh", ":", "plotlims", ".", "append", "(", "massco_array", "[", "j", "]", ")", "return", "plotlims", "else", ":", "for", "j", "in", "range", "(", "len", "(", "variable_array", ")", ")", ":", "if", "j", "==", "0", ":", "if", "variable_array", "[", "j", "]", ">=", "thresh", ":", "plotlims", ".", "append", "(", "massco_array", "[", "j", "]", ")", "else", ":", "pass", "elif", "(", "variable_array", "[", "j", "]", "-", "thresh", ")", "*", "(", "variable_array", "[", "j", "-", "1", "]", "-", "thresh", ")", "<", "0", ":", "plotlims", ".", "append", "(", "massco_array", "[", "j", "]", ")", "if", "j", "==", "len", "(", "variable_array", ")", "-", "1", ":", "if", "variable_array", "[", "j", "]", ">=", "thresh", ":", "plotlims", ".", "append", "(", "massco_array", "[", "j", "]", ")", "return", "plotlims", "# Flag preventing plotting any other variables on an energy generation", "# Kippenhahn plot:", "if", "engen", "==", "True", ":", "plot", "=", "[", "'dcoeff'", "]", "# This loop gets the mass co-ordinate array and the variable arrays,", "# calls to get the boundaries in order, and populates the contour array.", "ypscoeff", "=", "[", "-", "1", ",", "-", "1", ",", "-", "1", "]", "# this should have same length as plot - quick fix for yps.", "total_massco", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "cyclelist", ")", ")", ":", "# print 'CYCLE: ', cyclelist[i]", "massco", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "'mass'", ")", "total_massco", ".", "append", "(", "max", "(", "massco", ")", ")", "plotlimits", "=", "[", "]", "for", "j", "in", "range", "(", "len", "(", "plot", ")", ")", ":", "if", "plot", "[", "j", "]", "[", "1", "]", "==", "'-'", "or", "plot", "[", "j", "]", "[", "2", "]", "==", "'-'", ":", "# Assume file has yps, not iso_massf", "ypsthere", "=", "True", "try", ":", "variables", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "'yps'", ")", "# If this is not the case, do the usual se calls for iso_massf", "except", "KeyError", ":", "variables", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "plot", "[", "j", "]", ")", "ypsthere", "=", "False", "# If yps is there, ask which indices correspond to the", "# elements that are to be plotted, one by one.", "if", "ypsthere", "==", "True", ":", "if", "ypscoeff", "[", "j", "]", "==", "-", "1", ":", "ypscoeff", "[", "j", "]", "=", "int", "(", "input", "(", "\"What integer is your element \"", "+", "str", "(", "plot", "[", "j", "]", ")", "+", "\" in the 'yps' array? \"", ")", ")", "else", ":", "pass", "variables", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "'yps'", ")", "[", ":", ",", "ypscoeff", "[", "j", "]", "]", "else", ":", "variables", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "plot", "[", "j", "]", ")", "plotlims", "=", "getlims", "(", "variables", ",", "thresholds", "[", "j", "]", ",", "massco", ")", "plotlimits", ".", "append", "(", "plotlims", ")", "percent", "=", "int", "(", "i", "*", "100", "/", "len", "(", "cyclelist", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\rcreating color map \"", "+", "\"...%d%%\"", "%", "percent", ")", "for", "g", "in", "range", "(", "len", "(", "plot", ")", ")", ":", "for", "k", "in", "range", "(", "0", ",", "len", "(", "plotlimits", "[", "g", "]", ")", ",", "2", ")", ":", "llimit", "=", "plotlimits", "[", "g", "]", "[", "k", "]", "ulimit", "=", "plotlimits", "[", "g", "]", "[", "k", "+", "1", "]", "#if xx[i] >= 0:", "for", "f", "in", "range", "(", "y_res", ")", ":", "if", "llimit", "<=", "y", "[", "f", "]", "and", "ulimit", ">", "y", "[", "f", "]", ":", "Z", "[", "f", ",", "i", ",", "g", "]", "=", "1.", "#else:", "# ax.axvline(xx[i],ymin=llimit/m_ini,ymax=ulimit/m_ini,color='#8B8386',alpha=alphas[0],linewidth=0.5)", "# This function determines the adjacent two mass cells to a point in the", "# y-vector (which contains mass co-ordinates centre to surface, split into", "# y_res chunks), returning their index in the mass co-ordinate vector for", "# that timestep/cycle.", "def", "find_nearest", "(", "array", ",", "value", ")", ":", "\"\"\"\n Returns [lower,upper] indexes locating adjacent mass cells\n (in the massco vector) around y-value (one of y_res points\n equally spaced between centre and surface).\n\n \"\"\"", "idx", "=", "(", "np", ".", "abs", "(", "array", "-", "value", ")", ")", ".", "argmin", "(", ")", "lims", "=", "np", ".", "zeros", "(", "[", "2", "]", ",", "int", ")", "if", "idx", "==", "len", "(", "array", ")", "-", "1", ":", "# SJONES post-mod", "lims", "[", "0", "]", "=", "idx", "-", "1", "# SJONES post-mod", "lims", "[", "1", "]", "=", "idx", "# SJONES post-mod", "return", "lims", "if", "array", "[", "idx", "]", "<", "value", ":", "if", "array", "[", "idx", "]", "-", "array", "[", "idx", "+", "1", "]", "<", "0.", ":", "lims", "[", "0", "]", "=", "idx", "lims", "[", "1", "]", "=", "idx", "-", "1", "return", "lims", "else", ":", "lims", "[", "0", "]", "=", "idx", "lims", "[", "1", "]", "=", "idx", "+", "1", "return", "lims", "elif", "array", "[", "idx", "]", ">", "value", ":", "if", "array", "[", "idx", "]", "-", "array", "[", "idx", "+", "1", "]", "<", "0.", ":", "lims", "[", "0", "]", "=", "idx", "+", "1", "lims", "[", "1", "]", "=", "idx", "return", "lims", "else", ":", "lims", "[", "0", "]", "=", "idx", "-", "1", "lims", "[", "1", "]", "=", "idx", "return", "lims", "# This flag enebles the loop below it to populate the contour array for", "# energy generation. It does not take threshold arguments, as the array", "# contains the log of the energy generation rather than \"above\" or \"below\".", "# Because of this, contour boundaries are automatically calculated", "# according to the max energy generation in the model.", "dummy_engen", "=", "[", "]", "engen_signs", "=", "[", "]", "if", "engen", "==", "True", ":", "# Requires eps_nuc array in the data. Produces energy generation contour", "# by linearly interpolating eps_nuc between mass co-ordinates according", "# to the y-resolution:", "for", "i", "in", "range", "(", "len", "(", "cyclelist", ")", ")", ":", "# print 'CYCLE: ', cyclelist[i]", "max_energy_gen", "=", "0.", "min_energy_gen", "=", "0.", "massco", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "'mass'", ")", "if", "len", "(", "massco", ")", "<=", "10", ":", "massco", "=", "massco", "[", "0", "]", "dummy_engen", "=", "self", ".", "se", ".", "get", "(", "cyclelist", "[", "i", "]", ",", "netnuc_name", ")", "if", "len", "(", "dummy_engen", ")", "<=", "10", ":", "dummy_engen", "=", "dummy_engen", "[", "0", "]", "for", "f", "in", "range", "(", "len", "(", "dummy_engen", ")", ")", ":", "# make all values absolute, but note in engen_signs which were negative:", "if", "dummy_engen", "[", "f", "]", "==", "0.", ":", "engen_signs", ".", "append", "(", "1.", ")", "else", ":", "engen_signs", ".", "append", "(", "old_div", "(", "dummy_engen", "[", "f", "]", ",", "abs", "(", "dummy_engen", "[", "f", "]", ")", ")", ")", "if", "abs", "(", "engen_signs", "[", "f", "]", ")", "!=", "1.", ":", "print", "(", "'engen sign not +/- 1!!'", ")", "print", "(", "'engen_signs['", "+", "str", "(", "f", ")", "+", "'] = '", ",", "engen_signs", "[", "f", "]", ")", "print", "(", "'dummy_engen[f] = '", ",", "dummy_engen", "[", "f", "]", ")", "sys", ".", "exit", "(", ")", "dummy_engen", "[", "f", "]", "=", "abs", "(", "dummy_engen", "[", "f", "]", ")", "log_epsnuc", "=", "np", ".", "log10", "(", "dummy_engen", ")", "# now insert the correct signs again:", "for", "f", "in", "range", "(", "len", "(", "log_epsnuc", ")", ")", ":", "log_epsnuc", "[", "f", "]", "=", "log_epsnuc", "[", "f", "]", "*", "engen_signs", "[", "f", "]", "#for f in range(len(log_epsnuc)):", "#if str(log_epsnuc[f]) == 'nan': log_epsnuc[f] = 0.", "# print log_epsnuc", "percent", "=", "int", "(", "i", "*", "100", "/", "len", "(", "cyclelist", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\rcreating color map \"", "+", "\"...%d%%\"", "%", "percent", ")", "for", "j", "in", "range", "(", "len", "(", "y", ")", ")", ":", "if", "j", "==", "len", "(", "y", ")", "-", "1", ":", "energy_here", "=", "0.", "elif", "j", "==", "0", ":", "energy_here", "=", "log_epsnuc", "[", "-", "1", "]", "elif", "y", "[", "j", "]", ">", "max", "(", "massco", ")", ":", "energy_here", "=", "0.", "else", ":", "lims", "=", "find_nearest", "(", "massco", ",", "y", "[", "j", "]", ")", "frac", "=", "old_div", "(", "(", "y", "[", "j", "]", "-", "massco", "[", "lims", "[", "0", "]", "]", ")", ",", "(", "massco", "[", "lims", "[", "1", "]", "]", "-", "massco", "[", "lims", "[", "0", "]", "]", ")", ")", "energy_here", "=", "frac", "*", "(", "log_epsnuc", "[", "lims", "[", "1", "]", "]", "-", "log_epsnuc", "[", "lims", "[", "0", "]", "]", ")", "+", "log_epsnuc", "[", "lims", "[", "0", "]", "]", "if", "energy_here", ">", "max_energy_gen", ":", "max_energy_gen", "=", "energy_here", "if", "energy_here", "<", "min_energy_gen", ":", "min_energy_gen", "=", "energy_here", "if", "abs", "(", "max_energy_gen", ")", ">", "100.", ":", "print", "(", "y", "[", "j", "]", ")", "print", "(", "engen_signs", "[", "f", "]", ",", "log_epsnuc", "[", "f", "]", ",", "frac", ",", "lims", "[", "0", "]", ",", "lims", "[", "1", "]", ",", "massco", "[", "lims", "[", "0", "]", "]", ",", "massco", "[", "lims", "[", "1", "]", "]", ")", "print", "(", "(", "massco", "[", "lims", "[", "1", "]", "]", "-", "massco", "[", "lims", "[", "0", "]", "]", ")", ",", "(", "y", "[", "j", "]", "-", "massco", "[", "lims", "[", "0", "]", "]", ")", ")", "print", "(", "max_energy_gen", ")", "print", "(", "'exit due to energy generation > 100'", ")", "sys", ".", "exit", "(", ")", "# print energy_here", "# print max_energy_gen", "# if energy_here >= 0.:", "#Z[j,i,1] = 10**energy_here #SJONES comment", "if", "energy_here", "<", "0.", ":", "energy_here", "=", "0.", "Z", "[", "j", ",", "i", ",", "1", "]", "=", "energy_here", "# if energy_here < 0.:", "# Z[j,i,2] = 10**energy_here", "# Here we define the colourmap for the energy generation and an array", "# containing a list of colours in which to plot each variable (in the", "# order that the variables appear in \"plots\") iso_colours is obsolete", "# but was for when we tried plotting isotopes with just their boundary", "# lines as opposed to shading (for clarity). Colourmaps of these choices", "# are written to cmap (array).", "engen_cmap", "=", "mpl", ".", "cm", ".", "get_cmap", "(", "'Blues'", ")", "engen_cmap", ".", "set_under", "(", "color", "=", "'w'", ",", "alpha", "=", "engenalpha", ")", "enloss_cmap", "=", "mpl", ".", "cm", ".", "get_cmap", "(", "'Reds'", ")", "colours", "=", "[", "'#8B8386'", ",", "'m'", ",", "'g'", ",", "'b'", "]", "iso_colours", "=", "[", "'b'", ",", "'r'", ",", "'y'", "]", "cmap", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "plot", ")", ")", ":", "cmap", ".", "append", "(", "mpl", ".", "colors", ".", "ListedColormap", "(", "[", "'w'", ",", "colours", "[", "i", "]", "]", ")", ")", "print", "(", "'plotting contours'", ")", "if", "xllim", "==", "0.", "and", "xulim", "==", "0.", ":", "ax", ".", "axis", "(", "[", "float", "(", "xx", "[", "0", "]", ")", ",", "float", "(", "xx", "[", "-", "1", "]", ")", ",", "yllim", ",", "yulim", "]", ")", "else", ":", "ax", ".", "axis", "(", "[", "xllim", ",", "xulim", ",", "yllim", ",", "yulim", "]", ")", "# Plot all of the contours. Levels indicates to only plot the shaded", "# regions and not plot the white regions, so that they are essentially", "# transparent. If engen=True, then the energy generation levels", "# (boundary values) are calculated (in dex) from 2 to the maximum in", "# steps of 2.", "for", "i", "in", "range", "(", "len", "(", "plot", ")", ")", ":", "ax", ".", "contourf", "(", "xx", ",", "y", ",", "Z", "[", ":", ",", ":", ",", "i", "]", ",", "levels", "=", "[", "0.5", ",", "1.5", "]", ",", "colors", "=", "colours", "[", "i", "]", ",", "alpha", "=", "alphas", "[", "i", "]", ")", "if", "engen", "==", "True", ":", "#ceiling = int(max_energy_gen+1)", "#floor = int(min_energy_gen+1)", "#cburn = ax.contourf(xx,y,Z[:,:,1],cmap=engen_cmap,locator=mpl.ticker.LogLocator(),alpha=engenalpha) # SJONES comment", "cburn", "=", "ax", ".", "contourf", "(", "xx", ",", "y", ",", "Z", "[", ":", ",", ":", ",", "1", "]", ",", "cmap", "=", "engen_cmap", ",", "alpha", "=", "engenalpha", ",", "levels", "=", "list", "(", "range", "(", "5", ",", "32", ",", "5", ")", ")", ")", "cbarburn", "=", "pl", ".", "colorbar", "(", "cburn", ")", "# if min_energy_gen != 0:", "# closs = ax.contourf(xx,y,Z[:,:,2],cmap=enloss_cmap,locator=mpl.ticker.LogLocator(),alpha=engenalpha)", "# cbarloss = pl.colorbar(closs)", "# cbarburn.set_label('$\\epsilon_\\mathrm{nuc}-\\epsilon_{\\\\nu} \\; (\\mathrm{erg\\,g}^{-1}\\mathrm{\\,s}^{-1})$, > 0',fontsize=fsize)", "cbarburn", ".", "set_label", "(", "'$log_{10}(\\epsilon_\\mathrm{nuc}) \\; (\\mathrm{erg\\,g}^{-1}\\mathrm{\\,s}^{-1})$, > 0'", ",", "fontsize", "=", "fsize", ")", "pl", ".", "plot", "(", "xx", ",", "total_massco", ",", "color", "=", "'k'", ")", "pl", ".", "text", "(", "0.9", ",", "0.9", ",", "annotation", ",", "horizontalalignment", "=", "'right'", ",", "transform", "=", "ax", ".", "transAxes", ",", "fontsize", "=", "fsize", ")", "pl", ".", "ylabel", "(", "'", "\\m", "\\;", "o", "dot", "]", "$", "'", ",", "fontsize", "=", "fsize", "-", "1", ")", "pl", ".", "savefig", "(", "outfile", ")", "print", "(", "outfile", "+", "' is done.'", ")", "pl", ".", "show", "(", ")" ]

[ "!!", "EXPERIMENTAL", "FEATURE", "(", "flagged", "as", "private", ")", "!!" ]

[ "def", "nas_auto_qos_set_cos", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "nas", "=", "ET", ".", "SubElement", "(", "config", ",", "\"nas\"", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-qos\"", ")", "auto_qos", "=", "ET", ".", "SubElement", "(", "nas", ",", "\"auto-qos\"", ")", "set", "=", "ET", ".", "SubElement", "(", "auto_qos", ",", "\"set\"", ")", "cos", "=", "ET", ".", "SubElement", "(", "set", ",", "\"cos\"", ")", "cos", ".", "text", "=", "kwargs", ".", "pop", "(", "'cos'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

[ "Auto", "Generated", "Code" ]

[ "def", "chat_update", "(", "self", ",", "room_id", ",", "msg_id", ",", "text", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "__call_api_post", "(", "'chat.update'", ",", "roomId", "=", "room_id", ",", "msgId", "=", "msg_id", ",", "text", "=", "text", ",", "kwargs", "=", "kwargs", ")" ]

[ "Updates", "the", "text", "of", "the", "chat", "message", "." ]

[ "def", "set", "(", "self", ",", "mode", "=", "None", ")", ":", "# Detect from the environment if no mode given (only once)", "if", "mode", "is", "None", ":", "# Nothing to do if already detected", "if", "self", ".", "_mode", "is", "not", "None", ":", "return", "# Detect from the environment variable COLOR", "try", ":", "mode", "=", "int", "(", "os", ".", "environ", "[", "\"COLOR\"", "]", ")", "except", "StandardError", ":", "mode", "=", "COLOR_AUTO", "elif", "mode", "<", "0", "or", "mode", ">", "2", ":", "raise", "RuntimeError", "(", "\"Invalid color mode '{0}'\"", ".", "format", "(", "mode", ")", ")", "self", ".", "_mode", "=", "mode", "log", ".", "debug", "(", "\"Coloring {0} ({1})\"", ".", "format", "(", "\"enabled\"", "if", "self", ".", "enabled", "(", ")", "else", "\"disabled\"", ",", "self", ".", "MODES", "[", "self", ".", "_mode", "]", ")", ")" ]

[ "Set", "the", "coloring", "mode" ]

[ "def", "setModelData", "(", "self", ",", "spinBox", ",", "model", ",", "index", ")", ":", "spinBox", ".", "interpretText", "(", ")", "value", "=", "spinBox", ".", "value", "(", ")", "model", ".", "setData", "(", "index", ",", "value", ",", "QtCore", ".", "Qt", ".", "EditRole", ")" ]

[ "Gets", "data", "from", "the", "editor", "widget", "and", "stores", "it", "in", "the", "specified", "model", "at", "the", "item", "index", "." ]

[ "def", "_RealGetContents", "(", "self", ")", ":", "fp", "=", "self", ".", "fp", "endrec", "=", "_EndRecData", "(", "fp", ")", "if", "not", "endrec", ":", "raise", "BadZipfile", "(", "\"File is not a zip file\"", ")", "if", "self", ".", "debug", ">", "1", ":", "print", "(", "endrec", ")", "size_cd", "=", "endrec", "[", "_ECD_SIZE", "]", "# bytes in central directory", "offset_cd", "=", "endrec", "[", "_ECD_OFFSET", "]", "# offset of central directory", "self", ".", "comment", "=", "endrec", "[", "_ECD_COMMENT", "]", "# archive comment", "# \"concat\" is zero, unless zip was concatenated to another file", "concat", "=", "endrec", "[", "_ECD_LOCATION", "]", "-", "size_cd", "-", "offset_cd", "if", "endrec", "[", "_ECD_SIGNATURE", "]", "==", "stringEndArchive64", ":", "# If Zip64 extension structures are present, account for them", "concat", "-=", "(", "sizeEndCentDir64", "+", "sizeEndCentDir64Locator", ")", "if", "self", ".", "debug", ">", "2", ":", "inferred", "=", "concat", "+", "offset_cd", "print", "(", "\"given, inferred, offset\"", ",", "offset_cd", ",", "inferred", ",", "concat", ")", "# self.start_dir: Position of start of central directory", "self", ".", "start_dir", "=", "offset_cd", "+", "concat", "fp", ".", "seek", "(", "self", ".", "start_dir", ",", "0", ")", "data", "=", "fp", ".", "read", "(", "size_cd", ")", "fp", "=", "cStringIO", ".", "StringIO", "(", "data", ")", "total", "=", "0", "while", "total", "<", "size_cd", ":", "centdir", "=", "fp", ".", "read", "(", "sizeCentralDir", ")", "if", "centdir", "[", "0", ":", "4", "]", "!=", "stringCentralDir", ":", "raise", "BadZipfile", "(", "\"Bad magic number for central directory\"", ")", "centdir", "=", "struct", ".", "unpack", "(", "structCentralDir", ",", "centdir", ")", "if", "self", ".", "debug", ">", "2", ":", "print", "(", "centdir", ")", "filename", "=", "fp", ".", "read", "(", "centdir", "[", "_CD_FILENAME_LENGTH", "]", ")", "# Create ZipInfo instance to store file information", "x", "=", "ZipInfo", "(", "filename", ")", "x", ".", "extra", "=", "fp", ".", "read", "(", "centdir", "[", "_CD_EXTRA_FIELD_LENGTH", "]", ")", "x", ".", "comment", "=", "fp", ".", "read", "(", "centdir", "[", "_CD_COMMENT_LENGTH", "]", ")", "x", ".", "header_offset", "=", "centdir", "[", "_CD_LOCAL_HEADER_OFFSET", "]", "(", "x", ".", "create_version", ",", "x", ".", "create_system", ",", "x", ".", "extract_version", ",", "x", ".", "reserved", ",", "x", ".", "flag_bits", ",", "x", ".", "compress_type", ",", "t", ",", "d", ",", "x", ".", "CRC", ",", "x", ".", "compress_size", ",", "x", ".", "file_size", ")", "=", "centdir", "[", "1", ":", "12", "]", "x", ".", "volume", ",", "x", ".", "internal_attr", ",", "x", ".", "external_attr", "=", "centdir", "[", "15", ":", "18", "]", "# Convert date/time code to (year, month, day, hour, min, sec)", "x", ".", "_raw_time", "=", "t", "x", ".", "date_time", "=", "(", "(", "d", ">>", "9", ")", "+", "1980", ",", "(", "d", ">>", "5", ")", "&", "0xF", ",", "d", "&", "0x1F", ",", "t", ">>", "11", ",", "(", "t", ">>", "5", ")", "&", "0x3F", ",", "(", "t", "&", "0x1F", ")", "*", "2", ")", "x", ".", "_decodeExtra", "(", ")", "x", ".", "header_offset", "=", "x", ".", "header_offset", "+", "concat", "x", ".", "filename", "=", "x", ".", "_decodeFilename", "(", ")", "self", ".", "filelist", ".", "append", "(", "x", ")", "self", ".", "NameToInfo", "[", "x", ".", "filename", "]", "=", "x", "# update total bytes read from central directory", "total", "=", "(", "total", "+", "sizeCentralDir", "+", "centdir", "[", "_CD_FILENAME_LENGTH", "]", "+", "centdir", "[", "_CD_EXTRA_FIELD_LENGTH", "]", "+", "centdir", "[", "_CD_COMMENT_LENGTH", "]", ")", "if", "self", ".", "debug", ">", "2", ":", "print", "(", "\"total\"", ",", "total", ")" ]

[ "Read", "in", "the", "table", "of", "contents", "for", "the", "ZIP", "file", "." ]

[ "def", "from_points", "(", "lons", ",", "lats", ")", ":", "north", ",", "west", "=", "max", "(", "lats", ")", ",", "min", "(", "lons", ")", "south", ",", "east", "=", "min", "(", "lats", ")", ",", "max", "(", "lons", ")", "return", "BoundingBox", "(", "north", "=", "north", ",", "west", "=", "west", ",", "south", "=", "south", ",", "east", "=", "east", ")" ]

[ "Compute", "the", "BoundingBox", "from", "a", "set", "of", "latitudes", "and", "longitudes" ]

[ "def", "dag_runs", "(", "dag_id", ")", ":", "try", ":", "state", "=", "request", ".", "args", ".", "get", "(", "'state'", ")", "dagruns", "=", "get_dag_runs", "(", "dag_id", ",", "state", ")", "except", "AirflowException", "as", "err", ":", "_log", ".", "info", "(", "err", ")", "response", "=", "jsonify", "(", "error", "=", "\"{}\"", ".", "format", "(", "err", ")", ")", "response", ".", "status_code", "=", "400", "return", "response", "return", "jsonify", "(", "dagruns", ")" ]

[ "Returns", "a", "list", "of", "Dag", "Runs", "for", "a", "specific", "DAG", "ID", ".", ":", "query", "param", "state", ":", "a", "query", "string", "parameter", "?state", "=", "queued|running|success", "...", ":", "param", "dag_id", ":", "String", "identifier", "of", "a", "DAG", ":", "return", ":", "List", "of", "DAG", "runs", "of", "a", "DAG", "with", "requested", "state", "or", "all", "runs", "if", "the", "state", "is", "not", "specified" ]

[ "def", "add_key", "(", "self", ",", "key", ")", ":", "if", "key", "not", "in", "self", ".", "value", ":", "self", ".", "value", "[", "key", "]", "=", "ReducedMetric", "(", "self", ".", "reducer", ")" ]

[ "Adds", "a", "new", "key", "to", "this", "metric" ]

[ "def", "load_configs", "(", "files", ",", "cwd", "=", "os", ".", "getcwd", "(", ")", ")", ":", "repos", "=", "[", "]", "for", "f", "in", "files", ":", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "f", ")", "conf", "=", "kaptan", ".", "Kaptan", "(", "handler", "=", "ext", ".", "lstrip", "(", "'.'", ")", ")", ".", "import_config", "(", "f", ")", "newrepos", "=", "extract_repos", "(", "conf", ".", "export", "(", "'dict'", ")", ",", "cwd", ")", "if", "not", "repos", ":", "repos", ".", "extend", "(", "newrepos", ")", "continue", "dupes", "=", "detect_duplicate_repos", "(", "repos", ",", "newrepos", ")", "if", "dupes", ":", "msg", "=", "(", "'repos with same path + different VCS detected!'", ",", "dupes", ")", "raise", "exc", ".", "VCSPullException", "(", "msg", ")", "repos", ".", "extend", "(", "newrepos", ")", "return", "repos" ]

[ "Return", "repos", "from", "a", "list", "of", "files", "." ]

[ "def", "check_type_of_nest_spec_keys_and_values", "(", "nest_spec", ")", ":", "try", ":", "assert", "all", "(", "[", "isinstance", "(", "k", ",", "str", ")", "for", "k", "in", "nest_spec", "]", ")", "assert", "all", "(", "[", "isinstance", "(", "nest_spec", "[", "k", "]", ",", "list", ")", "for", "k", "in", "nest_spec", "]", ")", "except", "AssertionError", ":", "msg", "=", "\"All nest_spec keys/values must be strings/lists.\"", "raise", "TypeError", "(", "msg", ")", "return", "None" ]

[ "Ensures", "that", "the", "keys", "and", "values", "of", "nest_spec", "are", "strings", "and", "lists", ".", "Raises", "a", "helpful", "ValueError", "if", "they", "are", "." ]

[ "def", "read", "(", "self", ",", "source", "=", "None", ",", "*", "*", "options", ")", ":", "message", "=", "self", ".", "read_header", "(", "source", ")", "message", ".", "data", "=", "self", ".", "read_data", "(", "message", ".", "size", ",", "message", ".", "is_compressed", ",", "*", "*", "options", ")", "return", "message" ]

[ "Reads", "and", "optionally", "parses", "a", "single", "message", ".", ":", "Parameters", ":", "-", "source", "-", "optional", "data", "buffer", "to", "be", "read", "if", "not", "specified", "data", "is", "read", "from", "the", "wrapped", "stream", ":", "Options", ":", "-", "raw", "(", "boolean", ")", "-", "indicates", "whether", "read", "data", "should", "parsed", "or", "returned", "in", "raw", "byte", "form", "-", "numpy_temporals", "(", "boolean", ")", "-", "if", "False", "temporal", "vectors", "are", "backed", "by", "raw", "q", "representation", "(", ":", "class", ":", ".", "QTemporalList", ":", "class", ":", ".", "QTemporal", ")", "instances", "otherwise", "are", "represented", "as", "numpy", "datetime64", "/", "timedelta64", "arrays", "and", "atoms", "**", "Default", "**", ":", "False", ":", "returns", ":", ":", "class", ":", ".", "QMessage", "-", "read", "data", "(", "parsed", "or", "raw", "byte", "form", ")", "along", "with", "meta", "information" ]

[ "def", "send_buffered_operations", "(", "self", ")", ":", "with", "self", ".", "lock", ":", "try", ":", "action_buffer", "=", "self", ".", "BulkBuffer", ".", "get_buffer", "(", ")", "if", "action_buffer", ":", "successes", ",", "errors", "=", "bulk", "(", "self", ".", "elastic", ",", "action_buffer", ")", "LOG", ".", "debug", "(", "\"Bulk request finished, successfully sent %d \"", "\"operations\"", ",", "successes", ")", "if", "errors", ":", "LOG", ".", "error", "(", "\"Bulk request finished with errors: %r\"", ",", "errors", ")", "except", "es_exceptions", ".", "ElasticsearchException", ":", "LOG", ".", "exception", "(", "\"Bulk request failed with exception\"", ")" ]

[ "Send", "buffered", "operations", "to", "Elasticsearch", "." ]

[ "def", "check_task", "(", "taskid", ",", "timeout", "=", "DEFAULT_TASK_TIMEOUT", ",", "wait", "=", "2", ")", ":", "max_attempts", "=", "int", "(", "timeout", "/", "wait", ")", "try", ":", "return", "retry_call", "(", "partial", "(", "_check_task", ",", "taskid", ")", ",", "max_attempts", "=", "max_attempts", ",", "wait", "=", "wait", ",", "exceptions", "=", "(", "AssertionError", ",", "ValueError", ")", ",", ")", "except", "ValueError", ":", "raise", "SpinnakerTaskInconclusiveError", "(", "'Task failed to complete in {0} seconds: {1}'", ".", "format", "(", "timeout", ",", "taskid", ")", ")" ]

[ "Wrap", "check_task", "." ]

[ "def", "plot_prep_methods", "(", "df", ",", "prep", ",", "prepi", ",", "out_file_base", ",", "outtype", ",", "title", "=", "None", ",", "size", "=", "None", ")", ":", "samples", "=", "df", "[", "(", "df", "[", "\"bamprep\"", "]", "==", "prep", ")", "]", "[", "\"sample\"", "]", ".", "unique", "(", ")", "assert", "len", "(", "samples", ")", ">=", "1", ",", "samples", "out_file", "=", "\"%s-%s.%s\"", "%", "(", "out_file_base", ",", "samples", "[", "0", "]", ",", "outtype", ")", "df", "=", "df", "[", "df", "[", "\"category\"", "]", ".", "isin", "(", "cat_labels", ")", "]", "_seaborn", "(", "df", ",", "prep", ",", "prepi", ",", "out_file", ",", "title", ",", "size", ")", "return", "out_file" ]

[ "Plot", "comparison", "between", "BAM", "preparation", "methods", "." ]

[ "def", "setLevel", "(", "self", ",", "level", ")", ":", "if", "logging", ".", "DEBUG", ">=", "level", ":", "formatter", "=", "logging", ".", "Formatter", "(", "\"%(asctime)s [%(levelname)-8s] %(message)s (in %(module)s.%(funcName)s:%(lineno)s)\"", ",", "\"%d.%m.%Y %H:%M:%S\"", ")", "self", ".", "_handler", ".", "setFormatter", "(", "formatter", ")", "else", ":", "formatter", "=", "logging", ".", "Formatter", "(", "\"%(asctime)s [%(levelname)-8s] %(message)s\"", ",", "\"%d.%m.%Y %H:%M:%S\"", ")", "self", ".", "_handler", ".", "setFormatter", "(", "formatter", ")", "NativeLogger", ".", "setLevel", "(", "self", ",", "level", ")" ]

[ "r", "Overrides", "the", "parent", "method", "to", "adapt", "the", "formatting", "string", "to", "the", "level", ".", "Parameters", "----------", "level", ":", "int", "The", "new", "log", "level", "to", "set", ".", "See", "the", "logging", "levels", "in", "the", "logging", "module", "for", "details", ".", "Examples", "--------", ">>>", "import", "logging", ">>>", "Logger", ".", "setLevel", "(", "logging", ".", "DEBUG", ")" ]

[ "def", "is_safe", "(", "self", ")", ":", "self", ".", "log", "(", "u\"Checking if this container is safe\"", ")", "for", "entry", "in", "self", ".", "entries", ":", "if", "not", "self", ".", "is_entry_safe", "(", "entry", ")", ":", "self", ".", "log", "(", "[", "u\"This container is not safe: found unsafe entry '%s'\"", ",", "entry", "]", ")", "return", "False", "self", ".", "log", "(", "u\"This container is safe\"", ")", "return", "True" ]

[ "Return", "True", "if", "the", "container", "can", "be", "safely", "extracted", "that", "is", "if", "all", "its", "entries", "are", "safe", "False", "otherwise", "." ]

[ "def", "_get_reference", "(", "self", ")", ":", "super", "(", ")", ".", "_get_reference", "(", ")", "# indices for joints in qpos, qvel", "self", ".", "robot_joints", "=", "list", "(", "self", ".", "mujoco_robot", ".", "joints", ")", "self", ".", "_ref_joint_pos_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "get_joint_qpos_addr", "(", "x", ")", "for", "x", "in", "self", ".", "robot_joints", "]", "self", ".", "_ref_joint_vel_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "get_joint_qvel_addr", "(", "x", ")", "for", "x", "in", "self", ".", "robot_joints", "]", "if", "self", ".", "use_indicator_object", ":", "ind_qpos", "=", "self", ".", "sim", ".", "model", ".", "get_joint_qpos_addr", "(", "\"pos_indicator\"", ")", "self", ".", "_ref_indicator_pos_low", ",", "self", ".", "_ref_indicator_pos_high", "=", "ind_qpos", "ind_qvel", "=", "self", ".", "sim", ".", "model", ".", "get_joint_qvel_addr", "(", "\"pos_indicator\"", ")", "self", ".", "_ref_indicator_vel_low", ",", "self", ".", "_ref_indicator_vel_high", "=", "ind_qvel", "self", ".", "indicator_id", "=", "self", ".", "sim", ".", "model", ".", "body_name2id", "(", "\"pos_indicator\"", ")", "# indices for grippers in qpos, qvel", "if", "self", ".", "has_gripper_left", ":", "self", ".", "gripper_left_joints", "=", "list", "(", "self", ".", "gripper_left", ".", "joints", ")", "self", ".", "_ref_gripper_left_joint_pos_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "get_joint_qpos_addr", "(", "x", ")", "for", "x", "in", "self", ".", "gripper_left_joints", "]", "self", ".", "_ref_gripper_left_joint_vel_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "get_joint_qvel_addr", "(", "x", ")", "for", "x", "in", "self", ".", "gripper_left_joints", "]", "self", ".", "left_eef_site_id", "=", "self", ".", "sim", ".", "model", ".", "site_name2id", "(", "\"l_g_grip_site\"", ")", "if", "self", ".", "has_gripper_right", ":", "self", ".", "gripper_right_joints", "=", "list", "(", "self", ".", "gripper_right", ".", "joints", ")", "self", ".", "_ref_gripper_right_joint_pos_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "get_joint_qpos_addr", "(", "x", ")", "for", "x", "in", "self", ".", "gripper_right_joints", "]", "self", ".", "_ref_gripper_right_joint_vel_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "get_joint_qvel_addr", "(", "x", ")", "for", "x", "in", "self", ".", "gripper_right_joints", "]", "self", ".", "right_eef_site_id", "=", "self", ".", "sim", ".", "model", ".", "site_name2id", "(", "\"grip_site\"", ")", "# indices for joint pos actuation, joint vel actuation, gripper actuation", "self", ".", "_ref_joint_pos_actuator_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "actuator_name2id", "(", "actuator", ")", "for", "actuator", "in", "self", ".", "sim", ".", "model", ".", "actuator_names", "if", "actuator", ".", "startswith", "(", "\"pos\"", ")", "]", "self", ".", "_ref_joint_vel_actuator_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "actuator_name2id", "(", "actuator", ")", "for", "actuator", "in", "self", ".", "sim", ".", "model", ".", "actuator_names", "if", "actuator", ".", "startswith", "(", "\"vel\"", ")", "]", "if", "self", ".", "has_gripper_left", ":", "self", ".", "_ref_joint_gripper_left_actuator_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "actuator_name2id", "(", "actuator", ")", "for", "actuator", "in", "self", ".", "sim", ".", "model", ".", "actuator_names", "if", "actuator", ".", "startswith", "(", "\"gripper_l\"", ")", "]", "if", "self", ".", "has_gripper_right", ":", "self", ".", "_ref_joint_gripper_right_actuator_indexes", "=", "[", "self", ".", "sim", ".", "model", ".", "actuator_name2id", "(", "actuator", ")", "for", "actuator", "in", "self", ".", "sim", ".", "model", ".", "actuator_names", "if", "actuator", ".", "startswith", "(", "\"gripper_r\"", ")", "]", "if", "self", ".", "has_gripper_right", ":", "# IDs of sites for gripper visualization", "self", ".", "eef_site_id", "=", "self", ".", "sim", ".", "model", ".", "site_name2id", "(", "\"grip_site\"", ")", "self", ".", "eef_cylinder_id", "=", "self", ".", "sim", ".", "model", ".", "site_name2id", "(", "\"grip_site_cylinder\"", ")" ]

[ "Sets", "up", "references", "for", "robots", "grippers", "and", "objects", "." ]

[ "def", "i2c_read", "(", "self", ",", "address", ",", "register", ",", "number_of_bytes", ",", "read_type", ",", "cb", "=", "None", ")", ":", "data", "=", "[", "address", ",", "read_type", ",", "register", "&", "0x7f", ",", "(", "register", ">>", "7", ")", "&", "0x7f", ",", "number_of_bytes", "&", "0x7f", ",", "(", "number_of_bytes", ">>", "7", ")", "&", "0x7f", "]", "# add or update entry in i2c_map for reply", "self", ".", "_command_handler", ".", "i2c_map", "[", "address", "]", "=", "[", "cb", ",", "None", "]", "self", ".", "_command_handler", ".", "send_sysex", "(", "self", ".", "_command_handler", ".", "I2C_REQUEST", ",", "data", ")" ]

[ "This", "method", "requests", "the", "read", "of", "an", "i2c", "device", ".", "Results", "are", "retrieved", "by", "a", "call", "to", "i2c_get_read_data", "()", ".", "If", "a", "callback", "method", "is", "provided", "when", "data", "is", "received", "from", "the", "device", "it", "will", "be", "sent", "to", "the", "callback", "method" ]

[ "def", "unchunk", "(", "self", ")", ":", "if", "self", ".", "padding", "!=", "len", "(", "self", ".", "shape", ")", "*", "(", "0", ",", ")", ":", "shape", "=", "self", ".", "values", ".", "shape", "arr", "=", "empty", "(", "shape", ",", "dtype", "=", "object", ")", "for", "inds", "in", "product", "(", "*", "[", "arange", "(", "s", ")", "for", "s", "in", "shape", "]", ")", ":", "slices", "=", "[", "]", "for", "i", ",", "p", ",", "n", "in", "zip", "(", "inds", ",", "self", ".", "padding", ",", "shape", ")", ":", "start", "=", "None", "if", "(", "i", "==", "0", "or", "p", "==", "0", ")", "else", "p", "stop", "=", "None", "if", "(", "i", "==", "n", "-", "1", "or", "p", "==", "0", ")", "else", "-", "p", "slices", ".", "append", "(", "slice", "(", "start", ",", "stop", ",", "None", ")", ")", "arr", "[", "inds", "]", "=", "self", ".", "values", "[", "inds", "]", "[", "tuple", "(", "slices", ")", "]", "else", ":", "arr", "=", "self", ".", "values", "return", "allstack", "(", "arr", ".", "tolist", "(", ")", ")" ]

[ "Reconstitute", "the", "chunked", "array", "back", "into", "a", "full", "ndarray", "." ]

[ "def", "isbn10", "(", "self", ")", ":", "if", "self", ".", "_id", "[", "0", ":", "3", "]", "!=", "'978'", ":", "raise", "ISBNError", "(", "\"Invalid Bookland code: {}\"", ".", "format", "(", "self", ".", "_id", "[", "0", ":", "3", "]", ")", ")", "digit10", "=", "_digit10", "(", "self", ".", "_id", "[", "3", ":", "12", "]", ")", "if", "digit10", "==", "10", ":", "return", "self", ".", "_id", "[", "3", ":", "12", "]", "+", "'X'", "else", ":", "return", "self", ".", "_id", "[", "3", ":", "12", "]", "+", "str", "(", "digit10", ")" ]

[ "Encode", "ISBN", "number", "in", "ISBN10", "format", "Raises", "exception", "if", "Bookland", "number", "different", "from", "978" ]

[ "def", "get_consumer_action", "(", "self", ",", "consumer_id", ",", "consumer_action_id", ",", "publisher_id", "=", "None", ")", ":", "route_values", "=", "{", "}", "if", "consumer_id", "is", "not", "None", ":", "route_values", "[", "'consumerId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'consumer_id'", ",", "consumer_id", ",", "'str'", ")", "if", "consumer_action_id", "is", "not", "None", ":", "route_values", "[", "'consumerActionId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'consumer_action_id'", ",", "consumer_action_id", ",", "'str'", ")", "query_parameters", "=", "{", "}", "if", "publisher_id", "is", "not", "None", ":", "query_parameters", "[", "'publisherId'", "]", "=", "self", ".", "_serialize", ".", "query", "(", "'publisher_id'", ",", "publisher_id", ",", "'str'", ")", "response", "=", "self", ".", "_send", "(", "http_method", "=", "'GET'", ",", "location_id", "=", "'c3428e90-7a69-4194-8ed8-0f153185ee0d'", ",", "version", "=", "'5.0'", ",", "route_values", "=", "route_values", ",", "query_parameters", "=", "query_parameters", ")", "return", "self", ".", "_deserialize", "(", "'ConsumerAction'", ",", "response", ")" ]

[ "GetConsumerAction", ".", "Get", "details", "about", "a", "specific", "consumer", "action", ".", ":", "param", "str", "consumer_id", ":", "ID", "for", "a", "consumer", ".", ":", "param", "str", "consumer_action_id", ":", "ID", "for", "a", "consumerActionId", ".", ":", "param", "str", "publisher_id", ":", ":", "rtype", ":", ":", "class", ":", "<ConsumerAction", ">", "<azure", ".", "devops", ".", "v5_0", ".", "service_hooks", ".", "models", ".", "ConsumerAction", ">" ]

[ "def", "handle_submit", "(", "self", ")", ":", "wst_uid", "=", "self", ".", "request", ".", "form", ".", "get", "(", "\"getWorksheetTemplate\"", ")", "if", "not", "wst_uid", ":", "return", "False", "layout", "=", "self", ".", "context", ".", "getLayout", "(", ")", "wst", "=", "api", ".", "get_object_by_uid", "(", "wst_uid", ")", "self", ".", "request", "[", "\"context_uid\"", "]", "=", "api", ".", "get_uid", "(", "self", ".", "context", ")", "self", ".", "context", ".", "applyWorksheetTemplate", "(", "wst", ")", "if", "len", "(", "self", ".", "context", ".", "getLayout", "(", ")", ")", "==", "len", "(", "layout", ")", ":", "return", "False", "return", "True" ]

[ "Handle", "form", "submission" ]

[ "def", "_make_padded_ramp", "(", "self", ",", "v1", ",", "v2", ",", "pad_velocity", ",", "total_time", ")", ":", "# The time taken to ramp from v1 to pad_velocity", "t1", "=", "self", ".", "acceleration_time", "(", "v1", ",", "pad_velocity", ")", "# Then on to v2", "t2", "=", "self", ".", "acceleration_time", "(", "pad_velocity", ",", "v2", ")", "# The distance during the pad", "tp", "=", "total_time", "-", "t1", "-", "t2", "# Yield the points", "yield", "t1", ",", "pad_velocity", "yield", "tp", ",", "pad_velocity", "yield", "t2", ",", "v2" ]

[ "Makes", "a", "ramp", "that", "looks", "like", "this", ":" ]

[ "def", "fetch_or_load", "(", "spec_path", ")", ":", "headers", "=", "{", "}", "try", ":", "modified", "=", "datetime", ".", "utcfromtimestamp", "(", "os", ".", "path", ".", "getmtime", "(", "spec_path", ")", ")", "date", "=", "modified", ".", "strftime", "(", "\"%a, %d %b %Y %I:%M:%S UTC\"", ")", "headers", "[", "\"If-Modified-Since\"", "]", "=", "date", "except", "OSError", "as", "error", ":", "if", "error", ".", "errno", "!=", "errno", ".", "ENOENT", ":", "raise", "request", "=", "urllib", ".", "Request", "(", "VALIDATION_SPEC", ",", "headers", "=", "headers", ")", "response", "=", "urllib", ".", "urlopen", "(", "request", ",", "cafile", "=", "certifi", ".", "where", "(", ")", ")", "if", "response", ".", "code", "==", "200", ":", "with", "open", "(", "spec_path", ",", "\"w+b\"", ")", "as", "spec", ":", "spec", ".", "writelines", "(", "response", ")", "spec", ".", "seek", "(", "0", ")", "return", "html", ".", "parse", "(", "spec", ")", "with", "open", "(", "spec_path", ")", "as", "spec", ":", "return", "html", ".", "parse", "(", "spec", ")" ]

[ "Fetch", "a", "new", "specification", "or", "use", "the", "cache", "if", "it", "s", "current", "." ]

[ "def", "switch_on", "(", "self", ")", ":", "success", "=", "self", ".", "set_status", "(", "CONST", ".", "STATUS_ON_INT", ")", "if", "success", ":", "self", ".", "_json_state", "[", "'status'", "]", "=", "CONST", ".", "STATUS_ON", "return", "success" ]

[ "Turn", "the", "switch", "on", "." ]

[ "def", "_validate", "(", "self", ")", ":", "variable_names", ",", "_unused", "=", "getExprNames", "(", "self", ".", "_expr", ",", "{", "}", ")", "expr_indices", "=", "[", "]", "for", "name", "in", "variable_names", ":", "if", "name", "==", "'inf'", ":", "continue", "match", "=", "_VARIABLE_NAME_RE", ".", "match", "(", "name", ")", "if", "not", "match", ":", "raise", "ValueError", "(", "\"%r is not a valid variable name\"", "%", "name", ")", "expr_indices", ".", "append", "(", "int", "(", "match", ".", "group", "(", "2", ")", ")", ")", "expr_indices", ".", "sort", "(", ")", "expected_indices", "=", "list", "(", "range", "(", "len", "(", "self", ".", "inputs", ")", ")", ")", "if", "expr_indices", "!=", "expected_indices", ":", "raise", "ValueError", "(", "\"Expected %s for variable indices, but got %s\"", "%", "(", "expected_indices", ",", "expr_indices", ",", ")", ")", "super", "(", "NumericalExpression", ",", "self", ")", ".", "_validate", "(", ")" ]

[ "Ensure", "that", "our", "expression", "string", "has", "variables", "of", "the", "form", "x_0", "x_1", "...", "x_", "(", "N", "-", "1", ")", "where", "N", "is", "the", "length", "of", "our", "inputs", "." ]

[ "def", "copy", "(", "self", ")", ":", "a", ",", "b", "=", "it", ".", "tee", "(", "self", ".", "_data", ")", "# 2 generators, not thread-safe", "self", ".", "_data", "=", "a", "return", "Stream", "(", "b", ")" ]

[ "Returns", "a", "T", "(", "tee", ")", "copy", "of", "the", "given", "stream", "allowing", "the", "calling", "stream", "to", "continue", "being", "used", "." ]

[ "def", "delimited", "(", "items", ",", "character", "=", "'|'", ")", ":", "return", "'|'", ".", "join", "(", "items", ")", "if", "type", "(", "items", ")", "in", "(", "list", ",", "tuple", ",", "set", ")", "else", "items" ]

[ "Returns", "a", "character", "delimited", "version", "of", "the", "provided", "list", "as", "a", "Python", "string" ]

[ "def", "related", "(", "self", ",", "reltype", ")", ":", "parts", "=", "[", "]", "package", "=", "getattr", "(", "self", ",", "'package'", ",", "None", ")", "or", "self", "for", "rel", "in", "self", ".", "relationships", ".", "types", ".", "get", "(", "reltype", ",", "[", "]", ")", ":", "parts", ".", "append", "(", "package", "[", "posixpath", ".", "join", "(", "self", ".", "base", ",", "rel", ".", "target", ")", "]", ")", "return", "parts" ]

[ "Return", "a", "list", "of", "parts", "related", "to", "this", "one", "via", "reltype", "." ]

[ "def", "edit_distance_matrix", "(", "train_x", ",", "train_y", "=", "None", ")", ":", "if", "train_y", "is", "None", ":", "ret", "=", "np", ".", "zeros", "(", "(", "train_x", ".", "shape", "[", "0", "]", ",", "train_x", ".", "shape", "[", "0", "]", ")", ")", "for", "x_index", ",", "x", "in", "enumerate", "(", "train_x", ")", ":", "for", "y_index", ",", "y", "in", "enumerate", "(", "train_x", ")", ":", "if", "x_index", "==", "y_index", ":", "ret", "[", "x_index", "]", "[", "y_index", "]", "=", "0", "elif", "x_index", "<", "y_index", ":", "ret", "[", "x_index", "]", "[", "y_index", "]", "=", "edit_distance", "(", "x", ",", "y", ")", "else", ":", "ret", "[", "x_index", "]", "[", "y_index", "]", "=", "ret", "[", "y_index", "]", "[", "x_index", "]", "return", "ret", "ret", "=", "np", ".", "zeros", "(", "(", "train_x", ".", "shape", "[", "0", "]", ",", "train_y", ".", "shape", "[", "0", "]", ")", ")", "for", "x_index", ",", "x", "in", "enumerate", "(", "train_x", ")", ":", "for", "y_index", ",", "y", "in", "enumerate", "(", "train_y", ")", ":", "ret", "[", "x_index", "]", "[", "y_index", "]", "=", "edit_distance", "(", "x", ",", "y", ")", "return", "ret" ]

[ "Calculate", "the", "edit", "distance", ".", "Args", ":", "train_x", ":", "A", "list", "of", "neural", "architectures", ".", "train_y", ":", "A", "list", "of", "neural", "architectures", ".", "Returns", ":", "An", "edit", "-", "distance", "matrix", "." ]

[ "def", "limit_result_set", "(", "self", ",", "start", ",", "end", ")", ":", "if", "not", "isinstance", "(", "start", ",", "int", ")", "or", "not", "isinstance", "(", "end", ",", "int", ")", ":", "raise", "errors", ".", "InvalidArgument", "(", "'start and end arguments must be integers.'", ")", "if", "end", "<=", "start", ":", "raise", "errors", ".", "InvalidArgument", "(", "'End must be greater than start.'", ")", "# because Python is 0 indexed", "# Spec says that passing in (1, 25) should include 25 entries (1 - 25)", "# Python indices 0 - 24", "# Python [#:##] stops before the last index, but does not include it", "self", ".", "_limit_result_set_start", "=", "start", "-", "1", "self", ".", "_limit_result_set_end", "=", "end" ]

[ "By", "default", "searches", "return", "all", "matching", "results", "." ]

[ "def", "_to_dict", "(", "self", ")", ":", "_dict", "=", "{", "}", "if", "hasattr", "(", "self", ",", "'width'", ")", "and", "self", ".", "width", "is", "not", "None", ":", "_dict", "[", "'width'", "]", "=", "self", ".", "width", "if", "hasattr", "(", "self", ",", "'height'", ")", "and", "self", ".", "height", "is", "not", "None", ":", "_dict", "[", "'height'", "]", "=", "self", ".", "height", "if", "hasattr", "(", "self", ",", "'left'", ")", "and", "self", ".", "left", "is", "not", "None", ":", "_dict", "[", "'left'", "]", "=", "self", ".", "left", "if", "hasattr", "(", "self", ",", "'top'", ")", "and", "self", ".", "top", "is", "not", "None", ":", "_dict", "[", "'top'", "]", "=", "self", ".", "top", "return", "_dict" ]

[ "Return", "a", "json", "dictionary", "representing", "this", "model", "." ]

[ "def", "data_dir", "(", "default", "=", "'data'", ")", ":", "if", "'OPENSHIFT_DATA_DIR'", "in", "os", ".", "environ", ":", "return", "os", ".", "environ", "[", "'OPENSHIFT_DATA_DIR'", "]", "if", "'GONDOR_DATA_DIR'", "in", "os", ".", "environ", ":", "return", "os", ".", "environ", "[", "'GONDOR_DATA_DIR'", "]", "if", "provider", ".", "detect", "(", ")", "==", "provider", ".", "DOTCLOUD", ":", "return", "os", ".", "path", ".", "expanduser", "(", "'~/data'", ")", "return", "default" ]

[ "Return", "persistent", "data", "directory", "or", "default", "if", "not", "found", "Warning", ":", "Do", "not", "use", "this", "directory", "to", "store", "sqlite", "databases", "in", "producction" ]

[ "def", "can_handle", "(", "self", ",", "input_dict", ")", ":", "return", "input_dict", "is", "not", "None", "and", "isinstance", "(", "input_dict", ",", "dict", ")", "and", "len", "(", "input_dict", ")", "==", "1", "and", "self", ".", "intrinsic_name", "in", "input_dict" ]

[ "Validates", "that", "the", "input", "dictionary", "contains", "only", "one", "key", "and", "is", "of", "the", "given", "intrinsic_name" ]

[ "def", "intervals", "(", "self", ",", "reverse", ",", "thr", "=", "0", ")", ":", "d", "=", "[", "(", "thr", ",", "thr", ")", "]", "dl", "=", "0", "for", "tup", "in", "self", ".", "cigar_iter", "(", "reverse", ")", ":", "if", "tup", "[", "1", "]", "==", "\"D\"", ":", "dl", "=", "tup", "[", "0", "]", "else", ":", "s", "=", "d", "[", "-", "1", "]", "[", "1", "]", "+", "dl", "d", ".", "append", "(", "(", "s", ",", "s", "+", "tup", "[", "0", "]", ")", ")", "assert", "d", "[", "0", "]", "==", "(", "thr", ",", "thr", ")", "# assert that nr. of Ms in the interval == sum of produced intervals", "assert", "sum", "(", "t", "[", "0", "]", "for", "t", "in", "self", ".", "cigar_iter", "(", "False", ")", "if", "t", "[", "1", "]", "==", "\"M\"", ")", "==", "sum", "(", "t", "[", "1", "]", "-", "t", "[", "0", "]", "for", "t", "in", "d", ")", "d_sum", "=", "sum", "(", "t", "[", "1", "]", "-", "t", "[", "0", "]", "for", "t", "in", "d", ")", "assert", "self", ".", "end", "-", "self", ".", "start", "+", "1", "==", "d_sum", ",", "\"[ (%d, %d) = %d ] != %d\"", "%", "(", "self", ".", "start", ",", "self", ".", "end", ",", "self", ".", "end", "-", "self", ".", "start", "+", "1", ",", "d_sum", ")", "return", "d", "[", "1", ":", "]" ]

[ "return", "a", "list", "of", "(", "0", "-", "based", "half", "-", "open", ")", "intervals", "representing", "the", "match", "regions", "of", "the", "cigar" ]

[ "def", "get_prev_sibling", "(", "self", ")", ":", "try", ":", "return", "self", ".", "get_siblings", "(", ")", ".", "filter", "(", "path__lt", "=", "self", ".", "path", ")", ".", "reverse", "(", ")", "[", "0", "]", "except", "IndexError", ":", "return", "None" ]

[ ":", "returns", ":", "The", "previous", "node", "s", "sibling", "or", "None", "if", "it", "was", "the", "leftmost", "sibling", "." ]

[ "def", "load", "(", "fp", ",", "*", "*", "kwargs", ")", "->", "BioCCollection", ":", "obj", "=", "json", ".", "load", "(", "fp", ",", "*", "*", "kwargs", ")", "return", "parse_collection", "(", "obj", ")" ]

[ "Deserialize", "fp", "(", "a", ".", "read", "()", "-", "supporting", "text", "file", "or", "binary", "file", "containing", "a", "JSON", "document", ")", "to", "a", "BioCCollection", "object", "Args", ":", "fp", ":", "a", "file", "containing", "a", "JSON", "document", "**", "kwargs", ":", "Returns", ":", "BioCCollection", ":", "a", "collection" ]

[ "def", "api", "(", "self", ",", "name", ")", ":", "assert", "name", ",", "'name is none'", "if", "flow", ".", "__name__", "==", "name", ":", "api", "=", "flow", ".", "FlowApi", "(", ")", "elif", "sign", ".", "__name__", "==", "name", ":", "api", "=", "sign", ".", "SignApi", "(", ")", "elif", "sms", ".", "__name__", "==", "name", ":", "api", "=", "sms", ".", "SmsApi", "(", ")", "elif", "tpl", ".", "__name__", "==", "name", ":", "api", "=", "tpl", ".", "TplApi", "(", ")", "elif", "user", ".", "__name__", "==", "name", ":", "api", "=", "user", ".", "UserApi", "(", ")", "elif", "voice", ".", "__name__", "==", "name", ":", "api", "=", "voice", ".", "VoiceApi", "(", ")", "assert", "api", ",", "\"not found api-\"", "+", "name", "api", ".", "_init", "(", "self", ".", "_clnt", ")", "return", "api" ]

[ "return", "special", "API", "by", "package", "s", "name" ]

[ "def", "asyncPipeItembuilder", "(", "context", "=", "None", ",", "_INPUT", "=", "None", ",", "conf", "=", "None", ",", "*", "*", "kwargs", ")", ":", "pkwargs", "=", "cdicts", "(", "opts", ",", "kwargs", ")", "asyncFuncs", "=", "yield", "asyncGetSplits", "(", "None", ",", "conf", "[", "'attrs'", "]", ",", "*", "*", "pkwargs", ")", "_input", "=", "yield", "_INPUT", "finite", "=", "utils", ".", "finitize", "(", "_input", ")", "inputs", "=", "imap", "(", "DotDict", ",", "finite", ")", "pieces", "=", "yield", "asyncImap", "(", "asyncFuncs", "[", "0", "]", ",", "inputs", ")", "results", "=", "imap", "(", "utils", ".", "parse_params", ",", "pieces", ")", "_OUTPUT", "=", "imap", "(", "DotDict", ",", "results", ")", "returnValue", "(", "_OUTPUT", ")" ]

[ "A", "source", "that", "asynchronously", "builds", "an", "item", ".", "Loopable", "." ]

[ "def", "Left", "(", "self", ",", "n", "=", "1", ",", "dl", "=", "0", ")", ":", "self", ".", "Delay", "(", "dl", ")", "self", ".", "keyboard", ".", "tap_key", "(", "self", ".", "keyboard", ".", "left_key", ",", "n", ")" ]

[ "左方向键n次" ]

[ "def", "deploy_annotation", "(", "filename", ",", "module_name", ",", "hash_check", "=", "True", ",", "auth", "=", "None", ")", ":", "return", "_deploy_helper", "(", "filename", ",", "module_name", ",", "get_annotation_module_url", ",", "get_annotation_today", ",", "hash_check", "=", "hash_check", ",", "auth", "=", "auth", ")" ]

[ "Deploy", "a", "file", "to", "the", "Artifactory", "BEL", "annotation", "cache", "." ]