Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "generate", "(", "self", ",", "project", ")", ":", "for", "assignment", "in", "self", ".", "s2n_mapping", ":", "if", "assignment", "[", "\"ipprefix\"", "]", "==", "project", ":", "self", ".", "_name", "=", "assignment", "[", "\"package\"", "]", "return", "self", "#", "# github.com -> github", "# code.google.com/p/ -> googlecode", "# golang.org/x/ -> golangorg", "# gopkg.in/check.v1 -> gopkg-check", "# camlistore.org", "#", "name", "=", "project", "if", "name", ".", "startswith", "(", "\"github.com\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"^github\\.com\"", ",", "\"github\"", ",", "name", ")", "if", "name", ".", "startswith", "(", "\"gopkg.in\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"gopkg\\.in\"", ",", "\"gopkg\"", ",", "name", ")", "# any version marks?", "name", "=", "re", ".", "sub", "(", "r\"\\.v\\d\"", ",", "\"\"", ",", "name", ")", "name", "=", "re", ".", "sub", "(", "r\"/v\\d/\"", ",", "\"/\"", ",", "name", ")", "if", "name", ".", "startswith", "(", "\"code.google.com/p\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"^code\\.google\\.com/p\"", ",", "\"googlecode\"", ",", "name", ")", "if", "name", ".", "startswith", "(", "\"golang.org/x\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"^golang\\.org/x\"", ",", "\"golangorg\"", ",", "name", ")", "if", "name", ".", "startswith", "(", "\"google.golang.org\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"^google\\.golang\\.org\"", ",", "\"googlegolangorg\"", ",", "name", ")", "if", "name", ".", "startswith", "(", "\"bitbucket.org\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"^bitbucket\\.org\"", ",", "\"bitbucket\"", ",", "name", ")", "if", "name", ".", "startswith", "(", "\"k8s.io\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"^k8s\\.io\"", ",", "\"k8s\"", ",", "name", ")", "if", "name", ".", "endswith", "(", "\".org\"", ")", ":", "name", "=", "re", ".", "sub", "(", "r\"\\.org$\"", ",", "\"\"", ",", "name", ")", "name", "=", "name", ".", "replace", "(", "\"/\"", ",", "\"-\"", ")", "self", ".", "_name", "=", "\"golang-%s\"", "%", "name", "return", "self" ]

[ "Package", "name", "construction", "is", "based", "on", "provider", "not", "on", "prefix", ".", "Prefix", "does", "not", "have", "to", "equal", "provider_prefix", "." ]

[ "def", "setUdpJoinerPort", "(", "self", ",", "portNumber", ")", ":", "print", "'%s call setUdpJoinerPort'", "%", "self", ".", "port", "cmd", "=", "'joinerport %d'", "%", "portNumber", "print", "cmd", "return", "self", ".", "__sendCommand", "(", "cmd", ")", "[", "0", "]", "==", "'Done'" ]

[ "set", "Joiner", "UDP", "Port" ]

[ "def", "convert_noun_phrases", "(", "self", ",", "id_run", ",", "pos_run", ")", ":", "i", "=", "0", "rv", "=", "[", "]", "while", "i", "<", "len", "(", "id_run", ")", ":", "phrase_id", ",", "offset", "=", "PhraseDictionary", ".", "return_max_phrase", "(", "id_run", ",", "i", ",", "self", ")", "if", "phrase_id", ":", "if", "pos_run", "[", "i", "]", "in", "(", "'JJ'", ",", "'JJR'", ",", "'JJS'", ",", "'NN'", ",", "'NNS'", ",", "'NNP'", ",", "'NNPS'", ",", "'SYM'", ",", "'CD'", ",", "'VBG'", ",", "'FW'", ",", "'NP'", ")", ":", "print", "\"MERGED\"", ",", "pos_run", "[", "i", "]", ",", "self", ".", "get_phrase", "(", "phrase_id", ")", "rv", ".", "append", "(", "(", "phrase_id", ",", "'NP'", ")", ")", "i", "=", "offset", "else", ":", "print", "\"SKIPPED\"", ",", "pos_run", "[", "i", "]", ",", "self", ".", "get_phrase", "(", "phrase_id", ")", "rv", ".", "append", "(", "(", "id_run", "[", "i", "]", ",", "pos_run", "[", "i", "]", ")", ")", "i", "+=", "1", "else", ":", "rv", ".", "append", "(", "(", "id_run", "[", "i", "]", ",", "pos_run", "[", "i", "]", ")", ")", "i", "+=", "1", "return", "rv" ]

[ "Converts", "any", "identified", "phrases", "in", "the", "run", "into", "phrase_ids", ".", "The", "dictionary", "provides", "all", "acceptable", "phrases", ":", "param", "id_run", ":", "a", "run", "of", "token", "ids", ":", "param", "dictionary", ":", "a", "dictionary", "of", "acceptable", "phrases", "described", "as", "there", "component", "token", "ids", ":", "return", ":", "a", "run", "of", "token", "and", "phrase", "ids", "." ]

[ "def", "slow_augment", "(", "n", ",", "ii", ",", "jj", ",", "idx", ",", "count", ",", "x", ",", "y", ",", "u", ",", "v", ",", "c", ")", ":", "##################################################", "#", "# Augment procedure: from the Jonker paper.", "#", "# Note:", "# cred [i,j] = c [i,j] - u [i] - v[j]", "#", "# procedure AUGMENT;", "# begin", "# for all unassigned i* do", "# begin", "# for j:= 1 ... n do ", "# begin d[j] := c[i*,j] - v[j] ; pred[j] := i* end;", "# READY: = { ) ; SCAN: = { } ; TODO: = { 1 ... n} ;", "# repeat", "# if SCAN = { } then", "# begin", "# u = min {d[j] for j in TODO} ; ", "# SCAN: = {j | d[j] = u} ;", "# TODO: = TODO - SCAN;", "# for j in SCAN do if y[j]==0 then go to augment", "# end;", "# select any j* in SCAN;", "# i := y[j*]; SCAN := SCAN - {j*} ; READY: = READY + {j*} ;", "# for all j in TODO do if u + cred[i,j] < d[j] then", "# begin", "# d[j] := u + cred[i,j]; pred[j] := i;", "# if d[j] = u then", "# if y[j] is unassigned then go to augment else", "# begin SCAN: = SCAN + {j} ; TODO: = TODO - {j} end", "# end", "# until false; (* repeat always ends with go to augment *)", "#augment:", "# (* price updating *)", "# for k in READY do v[k]: = v[k] + d[k] - u;", "# (* augmentation *)", "# repeat", "# i: = pred[j]; y[ j ] := i ; k:=j; j:=x[i]; x[i]:= k", "# until i = i*", "# end", "#end", "inf", "=", "np", ".", "sum", "(", "c", ")", "+", "1", "d", "=", "np", ".", "zeros", "(", "n", ")", "cc", "=", "np", ".", "zeros", "(", "(", "n", ",", "n", ")", ")", "cc", "[", ":", ",", ":", "]", "=", "inf", "for", "i", "in", "range", "(", "n", ")", ":", "cc", "[", "i", ",", "jj", "[", "idx", "[", "i", "]", ":", "(", "idx", "[", "i", "]", "+", "count", "[", "i", "]", ")", "]", "]", "=", "c", "[", "idx", "[", "i", "]", ":", "(", "idx", "[", "i", "]", "+", "count", "[", "i", "]", ")", "]", "c", "=", "cc", "for", "i", "in", "ii", ":", "print", "(", "\"Processing i=%d\"", "%", "i", ")", "j", "=", "jj", "[", "idx", "[", "i", "]", ":", "(", "idx", "[", "i", "]", "+", "count", "[", "i", "]", ")", "]", "d", "=", "c", "[", "i", ",", ":", "]", "-", "v", "pred", "=", "np", ".", "ones", "(", "n", ",", "int", ")", "*", "i", "on_deck", "=", "[", "]", "ready", "=", "[", "]", "scan", "=", "[", "]", "to_do", "=", "list", "(", "range", "(", "n", ")", ")", "try", ":", "while", "True", ":", "print", "(", "\"Evaluating i=%d, n_scan = %d\"", "%", "(", "i", ",", "len", "(", "scan", ")", ")", ")", "if", "len", "(", "scan", ")", "==", "0", ":", "ready", "+=", "on_deck", "on_deck", "=", "[", "]", "umin", "=", "np", ".", "min", "(", "[", "d", "[", "jjj", "]", "for", "jjj", "in", "to_do", "]", ")", "print", "(", "\"umin = %f\"", "%", "umin", ")", "scan", "=", "[", "jjj", "for", "jjj", "in", "to_do", "if", "d", "[", "jjj", "]", "==", "umin", "]", "to_do", "=", "[", "jjj", "for", "jjj", "in", "to_do", "if", "d", "[", "jjj", "]", "!=", "umin", "]", "for", "j1", "in", "scan", ":", "if", "y", "[", "j1", "]", "==", "n", ":", "raise", "StopIteration", "(", ")", "j1", "=", "scan", "[", "0", "]", "iii", "=", "y", "[", "j1", "]", "print", "(", "\"Consider replacing i=%d, j=%d\"", "%", "(", "iii", ",", "j1", ")", ")", "scan", "=", "scan", "[", "1", ":", "]", "on_deck", "+=", "[", "j1", "]", "u1", "=", "c", "[", "iii", ",", "j1", "]", "-", "v", "[", "j1", "]", "-", "umin", "for", "j1", "in", "list", "(", "to_do", ")", ":", "h", "=", "c", "[", "iii", ",", "j1", "]", "-", "v", "[", "j1", "]", "-", "u1", "print", "(", "\"Consider j=%d as replacement, c[%d,%d]=%f,v[%d]=%f,h=%f, d[j]= %f\"", "%", "(", "j1", ",", "iii", ",", "j1", ",", "c", "[", "iii", ",", "j1", "]", ",", "j1", ",", "v", "[", "j1", "]", ",", "h", ",", "d", "[", "j1", "]", ")", ")", "if", "h", "<", "d", "[", "j1", "]", ":", "print", "(", "\"Add to chain\"", ")", "pred", "[", "j1", "]", "=", "iii", "if", "h", "==", "umin", ":", "if", "y", "[", "j1", "]", "==", "n", ":", "raise", "StopIteration", "(", ")", "print", "(", "\"Add to scan\"", ")", "scan", "+=", "[", "j1", "]", "to_do", ".", "remove", "(", "j1", ")", "d", "[", "j1", "]", "=", "h", "except", "StopIteration", ":", "# Augment", "print", "(", "\"Augmenting %d\"", "%", "j1", ")", "for", "k", "in", "ready", ":", "temp", "=", "v", "[", "k", "]", "v", "[", "k", "]", "=", "v", "[", "k", "]", "+", "d", "[", "k", "]", "-", "umin", "print", "(", "\"v[%d] %f -> %f\"", "%", "(", "k", ",", "temp", ",", "v", "[", "k", "]", ")", ")", "while", "True", ":", "iii", "=", "pred", "[", "j1", "]", "print", "(", "\"y[%d] %d -> %d\"", "%", "(", "j1", ",", "y", "[", "j1", "]", ",", "iii", ")", ")", "y", "[", "j1", "]", "=", "iii", "j1", ",", "x", "[", "iii", "]", "=", "x", "[", "iii", "]", ",", "j1", "if", "iii", "==", "i", ":", "break", "#", "# Re-establish slackness since we didn't pay attention to u", "#", "for", "i", "in", "range", "(", "n", ")", ":", "j", "=", "x", "[", "i", "]", "u", "[", "i", "]", "=", "c", "[", "i", ",", "j", "]", "-", "v", "[", "j", "]" ]

[ "Perform", "the", "augmentation", "step", "to", "assign", "unassigned", "i", "and", "j", "n", "-", "the", "#", "of", "i", "and", "j", "also", "the", "marker", "of", "unassigned", "x", "and", "y", "ii", "-", "the", "unassigned", "i", "jj", "-", "the", "ragged", "arrays", "of", "j", "for", "each", "i", "idx", "-", "the", "index", "of", "the", "first", "j", "for", "each", "i", "count", "-", "the", "number", "of", "j", "for", "each", "i", "x", "-", "the", "assignments", "of", "j", "for", "each", "i", "y", "-", "the", "assignments", "of", "i", "for", "each", "j", "u", "v", "-", "the", "dual", "variables", "c", "-", "the", "costs" ]

[ "def", "add_group", "(", "self", ",", "group_name", ",", "payment_address", ")", ":", "if", "(", "self", ".", "is_group_name_exists", "(", "group_name", ")", ")", ":", "raise", "Exception", "(", "\"the group \\\"%s\\\" is already present\"", "%", "str", "(", "group_name", ")", ")", "group_id_base64", "=", "base64", ".", "b64encode", "(", "secrets", ".", "token_bytes", "(", "32", ")", ")", "self", ".", "m", "[", "\"groups\"", "]", "+=", "[", "{", "\"group_name\"", ":", "group_name", ",", "\"group_id\"", ":", "group_id_base64", ".", "decode", "(", "\"ascii\"", ")", ",", "\"payment_address\"", ":", "payment_address", "}", "]", "return", "group_id_base64" ]

[ "Return", "new", "group_id", "in", "base64" ]

[ "def", "_build_likelihood", "(", "self", ")", ":", "# get the (marginals of) q(f): exactly predicting!", "fmean", ",", "fvar", "=", "self", ".", "_build_predict", "(", "self", ".", "X", ",", "full_cov", "=", "False", ")", "return", "tf", ".", "reduce_sum", "(", "self", ".", "likelihood", ".", "variational_expectations", "(", "fmean", ",", "fvar", ",", "self", ".", "Y", ")", ")" ]

[ "This", "function", "computes", "the", "optimal", "density", "for", "v", "q", "*", "(", "v", ")", "up", "to", "a", "constant" ]

[ "def", "scoreatpercentile", "(", "inlist", ",", "percent", ")", ":", "if", "percent", ">", "1", ":", "print", "(", "\"\\nDividing percent>1 by 100 in lscoreatpercentile().\\n\"", ")", "percent", "=", "percent", "/", "100.0", "targetcf", "=", "percent", "*", "len", "(", "inlist", ")", "h", ",", "lrl", ",", "binsize", ",", "extras", "=", "histogram", "(", "inlist", ")", "cumhist", "=", "cumsum", "(", "copy", ".", "deepcopy", "(", "h", ")", ")", "for", "i", "in", "range", "(", "len", "(", "cumhist", ")", ")", ":", "if", "cumhist", "[", "i", "]", ">=", "targetcf", ":", "break", "score", "=", "binsize", "*", "(", "(", "targetcf", "-", "cumhist", "[", "i", "-", "1", "]", ")", "/", "float", "(", "h", "[", "i", "]", ")", ")", "+", "(", "lrl", "+", "binsize", "*", "i", ")", "return", "score" ]

[ "Returns", "the", "score", "at", "a", "given", "percentile", "relative", "to", "the", "distribution", "given", "by", "inlist", "." ]

[ "def", "itemData", "(", "self", ",", "treeItem", ",", "column", ",", "role", "=", "Qt", ".", "DisplayRole", ")", ":", "if", "role", "==", "Qt", ".", "DisplayRole", ":", "if", "column", "==", "self", ".", "COL_NODE_NAME", ":", "return", "treeItem", ".", "nodeName", "elif", "column", "==", "self", ".", "COL_NODE_PATH", ":", "return", "treeItem", ".", "nodePath", "elif", "column", "==", "self", ".", "COL_SHAPE", ":", "if", "treeItem", ".", "isSliceable", ":", "return", "\" x \"", ".", "join", "(", "str", "(", "elem", ")", "for", "elem", "in", "treeItem", ".", "arrayShape", ")", "else", ":", "return", "\"\"", "elif", "column", "==", "self", ".", "COL_IS_OPEN", ":", "# Only show for RTIs that actually open resources.", "# TODO: this must be clearer. Use CanFetchChildren? Set is Open to None by default?", "if", "treeItem", ".", "hasChildren", "(", ")", ":", "return", "str", "(", "treeItem", ".", "isOpen", ")", "else", ":", "return", "\"\"", "elif", "column", "==", "self", ".", "COL_ELEM_TYPE", ":", "return", "treeItem", ".", "elementTypeName", "elif", "column", "==", "self", ".", "COL_FILE_NAME", ":", "return", "treeItem", ".", "fileName", "if", "hasattr", "(", "treeItem", ",", "'fileName'", ")", "else", "''", "elif", "column", "==", "self", ".", "COL_UNIT", ":", "return", "treeItem", ".", "unit", "elif", "column", "==", "self", ".", "COL_MISSING_DATA", ":", "return", "to_string", "(", "treeItem", ".", "missingDataValue", ",", "noneFormat", "=", "''", ")", "# empty str for Nones", "elif", "column", "==", "self", ".", "COL_RTI_TYPE", ":", "return", "type_name", "(", "treeItem", ")", "elif", "column", "==", "self", ".", "COL_EXCEPTION", ":", "return", "str", "(", "treeItem", ".", "exception", ")", "if", "treeItem", ".", "exception", "else", "''", "else", ":", "raise", "ValueError", "(", "\"Invalid column: {}\"", ".", "format", "(", "column", ")", ")", "elif", "role", "==", "Qt", ".", "ToolTipRole", ":", "if", "treeItem", ".", "exception", ":", "return", "str", "(", "treeItem", ".", "exception", ")", "if", "column", "==", "self", ".", "COL_NODE_NAME", ":", "return", "treeItem", ".", "nodePath", "# Also path when hovering over the name", "elif", "column", "==", "self", ".", "COL_NODE_PATH", ":", "return", "treeItem", ".", "nodePath", "elif", "column", "==", "self", ".", "COL_SHAPE", ":", "if", "treeItem", ".", "isSliceable", ":", "return", "\" x \"", ".", "join", "(", "str", "(", "elem", ")", "for", "elem", "in", "treeItem", ".", "arrayShape", ")", "else", ":", "return", "\"\"", "elif", "column", "==", "self", ".", "COL_UNIT", ":", "return", "treeItem", ".", "unit", "elif", "column", "==", "self", ".", "COL_MISSING_DATA", ":", "return", "to_string", "(", "treeItem", ".", "missingDataValue", ",", "noneFormat", "=", "''", ")", "# empty str for Nones", "elif", "column", "==", "self", ".", "COL_RTI_TYPE", ":", "return", "type_name", "(", "treeItem", ")", "elif", "column", "==", "self", ".", "COL_ELEM_TYPE", ":", "return", "treeItem", ".", "elementTypeName", "elif", "column", "==", "self", ".", "COL_FILE_NAME", ":", "return", "treeItem", ".", "fileName", "if", "hasattr", "(", "treeItem", ",", "'fileName'", ")", "else", "''", "else", ":", "return", "None", "else", ":", "return", "super", "(", "RepoTreeModel", ",", "self", ")", ".", "itemData", "(", "treeItem", ",", "column", ",", "role", "=", "role", ")" ]

[ "Returns", "the", "data", "stored", "under", "the", "given", "role", "for", "the", "item", ".", "O" ]

[ "def", "prodmix", "(", "I", ",", "K", ",", "a", ",", "p", ",", "epsilon", ",", "LB", ")", ":", "model", "=", "Model", "(", "\"robust product mix\"", ")", "x", ",", "rhs", "=", "{", "}", ",", "{", "}", "for", "i", "in", "I", ":", "x", "[", "i", "]", "=", "model", ".", "addVar", "(", "vtype", "=", "\"C\"", ",", "name", "=", "\"x(%s)\"", "%", "i", ")", "for", "k", "in", "K", ":", "rhs", "[", "k", "]", "=", "model", ".", "addVar", "(", "vtype", "=", "\"C\"", ",", "name", "=", "\"rhs(%s)\"", "%", "k", ")", "model", ".", "addCons", "(", "quicksum", "(", "x", "[", "i", "]", "for", "i", "in", "I", ")", "==", "1", ")", "for", "k", "in", "K", ":", "model", ".", "addCons", "(", "rhs", "[", "k", "]", "==", "-", "LB", "[", "k", "]", "+", "quicksum", "(", "a", "[", "i", ",", "k", "]", "*", "x", "[", "i", "]", "for", "i", "in", "I", ")", ")", "model", ".", "addCons", "(", "quicksum", "(", "epsilon", "*", "epsilon", "*", "x", "[", "i", "]", "*", "x", "[", "i", "]", "for", "i", "in", "I", ")", "<=", "rhs", "[", "k", "]", "*", "rhs", "[", "k", "]", ")", "model", ".", "setObjective", "(", "quicksum", "(", "p", "[", "i", "]", "*", "x", "[", "i", "]", "for", "i", "in", "I", ")", ",", "\"minimize\"", ")", "model", ".", "data", "=", "x", ",", "rhs", "return", "model" ]

[ "prodmix", ":", "robust", "production", "planning", "using", "soco", "Parameters", ":", "I", "-", "set", "of", "materials", "K", "-", "set", "of", "components", "a", "[", "i", "]", "[", "k", "]", "-", "coef", ".", "matrix", "p", "[", "i", "]", "-", "price", "of", "material", "i", "LB", "[", "k", "]", "-", "amount", "needed", "for", "k", "Returns", "a", "model", "ready", "to", "be", "solved", "." ]

[ "def", "get_context_data", "(", "self", ",", "*", "*", "kwargs", ")", ":", "context", "=", "super", "(", "BaseEntryChannel", ",", "self", ")", ".", "get_context_data", "(", "*", "*", "kwargs", ")", "context", ".", "update", "(", "{", "'query'", ":", "self", ".", "query", "}", ")", "return", "context" ]

[ "Add", "query", "in", "context", "." ]

[ "def", "initialize_weights", "(", "self", ",", "save_file", ")", ":", "tf", ".", "train", ".", "Saver", "(", ")", ".", "restore", "(", "self", ".", "sess", ",", "save_file", ")" ]

[ "Initialize", "the", "weights", "from", "the", "given", "save_file", ".", "Assumes", "that", "the", "graph", "has", "been", "constructed", "and", "the", "save_file", "contains", "weights", "that", "match", "the", "graph", ".", "Used", "to", "set", "the", "weights", "to", "a", "different", "version", "of", "the", "player", "without", "redifining", "the", "entire", "graph", "." ]

[ "def", "dot_n", "(", "x", ",", "y", ")", ":", "if", "x", ".", "ndim", "==", "2", ":", "if", "y", ".", "ndim", "==", "2", ":", "return", "np", ".", "dot", "(", "x", ",", "y", ")", "x3", "=", "False", "y3", "=", "True", "nlen", "=", "y", ".", "shape", "[", "0", "]", "elif", "y", ".", "ndim", "==", "2", ":", "nlen", "=", "x", ".", "shape", "[", "0", "]", "x3", "=", "True", "y3", "=", "False", "else", ":", "assert", "x", ".", "shape", "[", "0", "]", "==", "y", ".", "shape", "[", "0", "]", "nlen", "=", "x", ".", "shape", "[", "0", "]", "x3", "=", "True", "y3", "=", "True", "assert", "x", ".", "shape", "[", "1", "+", "x3", "]", "==", "y", ".", "shape", "[", "0", "+", "y3", "]", "n", ",", "i", ",", "j", ",", "k", "=", "np", ".", "mgrid", "[", "0", ":", "nlen", ",", "0", ":", "x", ".", "shape", "[", "0", "+", "x3", "]", ",", "0", ":", "y", ".", "shape", "[", "1", "+", "y3", "]", ",", "0", ":", "y", ".", "shape", "[", "0", "+", "y3", "]", "]", "return", "np", ".", "sum", "(", "(", "x", "[", "n", ",", "i", ",", "k", "]", "if", "x3", "else", "x", "[", "i", ",", "k", "]", ")", "*", "(", "y", "[", "n", ",", "k", ",", "j", "]", "if", "y3", "else", "y", "[", "k", ",", "j", "]", ")", ",", "3", ")" ]

[ "given", "two", "tensors", "N", "x", "I", "x", "K", "and", "N", "x", "K", "x", "J", "return", "N", "dot", "products" ]

[ "def", "write", "(", "self", ",", "buffer_size", ",", "window_size", ",", "x", ",", "y", ",", "p", ",", "address", ",", "data", ")", ":", "# While there is still data perform a write: get the block to write", "# this time around, determine the data type, perform the write and", "# increment the address", "def", "packets", "(", "address", ",", "data", ")", ":", "end", "=", "len", "(", "data", ")", "pos", "=", "0", "while", "pos", "<", "end", ":", "block", "=", "data", "[", "pos", ":", "pos", "+", "buffer_size", "]", "block_size", "=", "len", "(", "block", ")", "dtype", "=", "consts", ".", "address_length_dtype", "[", "(", "address", "%", "4", ",", "block_size", "%", "4", ")", "]", "yield", "scpcall", "(", "x", ",", "y", ",", "p", ",", "consts", ".", "SCPCommands", ".", "write", ",", "address", ",", "block_size", ",", "dtype", ",", "block", ")", "address", "+=", "block_size", "pos", "+=", "block_size", "# Run the event loop and then return the retrieved data", "self", ".", "send_scp_burst", "(", "buffer_size", ",", "window_size", ",", "list", "(", "packets", "(", "address", ",", "data", ")", ")", ")" ]

[ "Write", "a", "bytestring", "to", "an", "address", "in", "memory", "." ]

[ "def", "import_tracks", "(", "self", ",", "import_tracks", ")", ":", "if", "isinstance", "(", "import_tracks", ",", "tracks", ".", "Track", ")", ":", "import_tracks", "=", "[", "import_tracks", "]", "idx_mapping", "=", "{", "}", "for", "track", "in", "import_tracks", ":", "idx_mapping", "[", "track", ".", "idx", "]", "=", "track", "# Add index to idx if already existing", "if", "track", ".", "idx", "in", "self", ".", "_tracks", ".", "keys", "(", ")", ":", "track", ".", "idx", "=", "naming", ".", "index_name_if_in_list", "(", "track", ".", "idx", ",", "self", ".", "_tracks", ".", "keys", "(", ")", ")", "self", ".", "_tracks", "[", "track", ".", "idx", "]", "=", "track", "return", "idx_mapping" ]

[ "Add", "the", "given", "tracks", "/", "track", "to", "the", "corpus", ".", "If", "any", "of", "the", "given", "track", "-", "ids", "already", "exists", "a", "suffix", "is", "appended", "so", "it", "is", "unique", "." ]

[ "def", "clear_tips", "(", "self", ")", ":", "for", "instrument", "in", "self", ".", "_instruments", ".", "values", "(", ")", ":", "if", "instrument", ".", "tip_attached", ":", "instrument", ".", "_remove_tip", "(", "instrument", ".", "_tip_length", ")" ]

[ "If", "reset", "is", "called", "with", "a", "tip", "attached", "the", "tip", "must", "be", "removed", "before", "the", "poses", "and", "_instruments", "members", "are", "cleared", ".", "If", "the", "tip", "is", "not", "removed", "the", "effective", "length", "of", "the", "pipette", "remains", "increased", "by", "the", "length", "of", "the", "tip", "and", "subsequent", "_add_tip", "calls", "will", "increase", "the", "length", "in", "addition", "to", "this", ".", "This", "should", "be", "fixed", "by", "changing", "pose", "tracking", "to", "that", "it", "tracks", "the", "tip", "as", "a", "separate", "node", "rather", "than", "adding", "and", "subtracting", "the", "tip", "length", "to", "the", "pipette", "length", "." ]

[ "def", "parse_multirsp", "(", "self", ",", "tup_tree", ")", ":", "# pylint: disable=unused-argument", "raise", "CIMXMLParseError", "(", "_format", "(", "\"Internal Error: Parsing support for element {0!A} is not \"", "\"implemented\"", ",", "name", "(", "tup_tree", ")", ")", ",", "conn_id", "=", "self", ".", "conn_id", ")" ]

[ "This", "function", "not", "implemented", ".", "Because", "this", "request", "is", "generally", "not", "implemented", ".", "It", "will", "probably", "never", "be", "implemented", "." ]

[ "def", "get_folder", "(", "self", ",", "si", ",", "path", ",", "root", "=", "None", ")", ":", "search_index", "=", "si", ".", "content", ".", "searchIndex", "sub_folder", "=", "root", "if", "root", "else", "si", ".", "content", ".", "rootFolder", "if", "not", "path", ":", "return", "sub_folder", "paths", "=", "[", "p", "for", "p", "in", "path", ".", "split", "(", "\"/\"", ")", "if", "p", "]", "child", "=", "None", "try", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "except", ":", "child", "=", "None", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "self", ".", "ChildEntity", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "self", ".", "VM", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ".", "vmFolder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "self", ".", "Datastore", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ".", "datastoreFolder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "self", ".", "Network", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ".", "networkFolder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "self", ".", "Host", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ".", "hostFolder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "self", ".", "Datacenter", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ".", "datacenterFolder", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "if", "child", "is", "None", "and", "hasattr", "(", "sub_folder", ",", "'resourcePool'", ")", ":", "new_root", "=", "search_index", ".", "FindChild", "(", "sub_folder", ".", "resourcePool", ",", "paths", "[", "0", "]", ")", "if", "new_root", ":", "child", "=", "self", ".", "get_folder", "(", "si", ",", "'/'", ".", "join", "(", "paths", "[", "1", ":", "]", ")", ",", "new_root", ")", "return", "child" ]

[ "Finds", "folder", "in", "the", "vCenter", "or", "returns", "None" ]

[ "def", "versions", "(", "self", ",", "rev", "=", "None", ",", "index", "=", "None", ")", ":", "raise", "NotImplementedError", "_revisions", "=", "[", "line", ".", "split", "(", ")", "[", "0", "]", "for", "line", "in", "self", ".", "log", ".", "split", "(", "'\\n'", ")", "if", "line", "]", "_versions", "=", "[", "Version", "(", "self", ".", "obj", ".", "repo", ".", "commit", "(", "r", ")", ")", "for", "r", "in", "_revisions", "if", "rev", "is", "None", "or", "r", ".", "startswith", "(", "rev", ")", "]", "if", "index", "is", "not", "None", "and", "len", "(", "_versions", ")", ">", "index", ":", "_versions", "=", "_versions", "[", "index", "]", "return", "_versions" ]

[ ":", "return", ":", "List", "of", "Versions", "for", "this", "Item" ]

[ "def", "config_merge_tree", "(", "source", "=", "'running'", ",", "merge_config", "=", "None", ",", "merge_path", "=", "None", ",", "saltenv", "=", "'base'", ")", ":", "config_txt", "=", "__salt__", "[", "'net.config'", "]", "(", "source", "=", "source", ")", "[", "'out'", "]", "[", "source", "]", "return", "__salt__", "[", "'iosconfig.merge_tree'", "]", "(", "initial_config", "=", "config_txt", ",", "merge_config", "=", "merge_config", ",", "merge_path", "=", "merge_path", ",", "saltenv", "=", "saltenv", ")" ]

[ "..", "versionadded", "::", "2019", ".", "2", ".", "0" ]

[ "def", "_process_get_perm_resp", "(", "url", ",", "post_response", ",", "campus", ",", "calendarid", ")", ":", "request_id", "=", "\"%s %s CalendarID:%s\"", "%", "(", "campus", ",", "url", ",", "calendarid", ")", "data", "=", "_load_json", "(", "request_id", ",", "post_response", ")", "permission_list", "=", "[", "]", "if", "data", "[", "'d'", "]", "[", "'Users'", "]", "is", "not", "None", "and", "len", "(", "data", "[", "'d'", "]", "[", "'Users'", "]", ")", ">", "0", ":", "_load_permissions", "(", "campus", ",", "calendarid", ",", "data", "[", "'d'", "]", "[", "'Users'", "]", ",", "permission_list", ")", "return", "sorted", "(", "permission_list", ")" ]

[ ":", "return", ":", "a", "list", "of", "trumba", ".", "Permission", "objects", "sorted", "by", "descending", "level", "and", "ascending", "uwnetid", "None", "if", "error", "[]", "if", "not", "exists", "If", "the", "response", "is", "successful", "process", "the", "response", "data", "and", "load", "into", "the", "return", "objects", "otherwise", "raise", "DataFailureException" ]

[ "def", "paint", "(", "self", ",", "painter", ",", "option", ",", "index", ")", ":", "if", "option", ".", "state", "&", "QStyle", ".", "State_MouseOver", ":", "styleSheet", "=", "self", ".", "__style", ".", "hover", "elif", "option", ".", "state", "&", "QStyle", ".", "State_Selected", ":", "styleSheet", "=", "self", ".", "__style", ".", "highlight", "else", ":", "styleSheet", "=", "self", ".", "__style", ".", "default", "self", ".", "__label", ".", "setStyleSheet", "(", "styleSheet", ")", "data", "=", "index", ".", "model", "(", ")", ".", "data", "(", "index", ",", "Qt", ".", "DisplayRole", ")", "self", ".", "__label", ".", "setText", "(", "umbra", ".", "ui", ".", "common", ".", "QVariant_to_string", "(", "data", ")", ")", "self", ".", "__label", ".", "setFixedSize", "(", "option", ".", "rect", ".", "size", "(", ")", ")", "painter", ".", "save", "(", ")", "painter", ".", "translate", "(", "option", ".", "rect", ".", "topLeft", "(", ")", ")", "self", ".", "__label", ".", "render", "(", "painter", ")", "painter", ".", "restore", "(", ")" ]

[ "Reimplements", "the", ":", "meth", ":", "QStyledItemDelegate", ".", "paint", "method", "." ]

[ "def", "enable_host_notifications", "(", "self", ",", "host", ")", ":", "if", "not", "host", ".", "notifications_enabled", ":", "host", ".", "modified_attributes", "|=", "DICT_MODATTR", "[", "\"MODATTR_NOTIFICATIONS_ENABLED\"", "]", ".", "value", "host", ".", "notifications_enabled", "=", "True", "self", ".", "send_an_element", "(", "host", ".", "get_update_status_brok", "(", ")", ")" ]

[ "Enable", "notifications", "for", "a", "host", "Format", "of", "the", "line", "that", "triggers", "function", "call", "::" ]

[ "def", "_base_request", "(", "self", ",", "method", ")", ":", "request", "=", "E", ".", "Element", "(", "method", ")", "request", ".", "set", "(", "'xmlns'", ",", "'AnetApi/xml/v1/schema/AnetApiSchema.xsd'", ")", "request", ".", "append", "(", "self", ".", "client_auth", ")", "return", "request" ]

[ "Factory", "method", "for", "generating", "the", "base", "XML", "requests", "." ]

[ "def", "guess_currency_from_address", "(", "address", ")", ":", "if", "is_py2", ":", "fixer", "=", "lambda", "x", ":", "int", "(", "x", ".", "encode", "(", "'hex'", ")", ",", "16", ")", "else", ":", "fixer", "=", "lambda", "x", ":", "x", "# does nothing", "first_byte", "=", "fixer", "(", "b58decode_check", "(", "address", ")", "[", "0", "]", ")", "double_first_byte", "=", "fixer", "(", "b58decode_check", "(", "address", ")", "[", ":", "2", "]", ")", "hits", "=", "[", "]", "for", "currency", ",", "data", "in", "crypto_data", ".", "items", "(", ")", ":", "if", "hasattr", "(", "data", ",", "'get'", ")", ":", "# skip incomplete data listings", "version", "=", "data", ".", "get", "(", "'address_version_byte'", ",", "None", ")", "if", "version", "is", "not", "None", "and", "version", "in", "[", "double_first_byte", ",", "first_byte", "]", ":", "hits", ".", "append", "(", "[", "currency", ",", "data", "[", "'name'", "]", "]", ")", "if", "hits", ":", "return", "hits", "raise", "ValueError", "(", "\"Unknown Currency with first byte: %s\"", "%", "first_byte", ")" ]

[ "Given", "a", "crypto", "address", "find", "which", "currency", "it", "likely", "belongs", "to", ".", "Raises", "an", "exception", "if", "it", "can", "t", "find", "a", "match", ".", "Raises", "exception", "if", "address", "is", "invalid", "." ]

[ "def", "clone_workspace", "(", "from_namespace", ",", "from_workspace", ",", "to_namespace", ",", "to_workspace", ",", "authorizationDomain", "=", "\"\"", ")", ":", "if", "authorizationDomain", ":", "if", "isinstance", "(", "authorizationDomain", ",", "string_types", ")", ":", "authDomain", "=", "[", "{", "\"membersGroupName\"", ":", "authorizationDomain", "}", "]", "else", ":", "authDomain", "=", "[", "{", "\"membersGroupName\"", ":", "authDomain", "}", "for", "authDomain", "in", "authorizationDomain", "]", "else", ":", "authDomain", "=", "[", "]", "body", "=", "{", "\"namespace\"", ":", "to_namespace", ",", "\"name\"", ":", "to_workspace", ",", "\"attributes\"", ":", "dict", "(", ")", ",", "\"authorizationDomain\"", ":", "authDomain", ",", "}", "uri", "=", "\"workspaces/{0}/{1}/clone\"", ".", "format", "(", "from_namespace", ",", "from_workspace", ")", "return", "__post", "(", "uri", ",", "json", "=", "body", ")" ]

[ "Clone", "a", "FireCloud", "workspace", "." ]

[ "def", "html_for_env_var", "(", "key", ")", ":", "value", "=", "os", ".", "getenv", "(", "key", ")", "return", "KEY_VALUE_TEMPLATE", ".", "format", "(", "key", ",", "value", ")" ]

[ "Returns", "an", "HTML", "snippet", "for", "an", "environment", "variable", "." ]

[ "def", "_redraw", "(", "self", ")", ":", "# Only draw when no sub application was started.", "if", "self", ".", "_is_running", "and", "self", ".", "_sub_cli", "is", "None", ":", "self", ".", "render_counter", "+=", "1", "self", ".", "renderer", ".", "render", "(", "self", ",", "self", ".", "layout", ",", "is_done", "=", "self", ".", "is_done", ")", "# Fire render event.", "self", ".", "on_render", ".", "fire", "(", ")" ]

[ "Render", "the", "command", "line", "again", ".", "(", "Not", "thread", "safe!", ")", "(", "From", "other", "threads", "or", "if", "unsure", "use", ":", "meth", ":", ".", "CommandLineInterface", ".", "invalidate", ".", ")" ]

[ "def", "zipfiles", "(", "self", ",", "path", "=", "None", ",", "arcdirname", "=", "'data'", ")", ":", "if", "path", ":", "fp", "=", "open", "(", "path", ",", "'w+b'", ")", "else", ":", "prefix", "=", "'%s-'", "%", "arcdirname", "fp", "=", "tempfile", ".", "NamedTemporaryFile", "(", "prefix", "=", "prefix", ",", "suffix", "=", "'.zip'", ")", "with", "zipfile", ".", "ZipFile", "(", "fp", ",", "mode", "=", "'w'", ")", "as", "zf", ":", "for", "obj", "in", "self", ":", "img", "=", "obj", ".", "image", "arcname", "=", "os", ".", "path", ".", "join", "(", "arcdirname", ",", "os", ".", "path", ".", "basename", "(", "img", ".", "name", ")", ")", "try", ":", "zf", ".", "write", "(", "img", ".", "path", ",", "arcname", "=", "arcname", ")", "except", "OSError", ":", "img", ".", "seek", "(", "0", ")", "zf", ".", "writestr", "(", "arcname", ",", "img", ".", "read", "(", ")", ")", "img", ".", "close", "(", ")", "fp", ".", "seek", "(", "0", ")", "zobj", "=", "self", ".", "model", "(", "image", "=", "fp", ")", "return", "[", "zobj", "]" ]

[ "Returns", "a", ".", "zip", "archive", "of", "selected", "rasters", "." ]

[ "def", "_on_interface_opened", "(", "self", ",", "success", ",", "result", ",", "failure_reason", ",", "context", ",", "next_characteristic", "=", "None", ")", ":", "if", "not", "success", ":", "self", ".", "connections", ".", "finish_operation", "(", "context", "[", "'connection_id'", "]", ",", "False", ",", "failure_reason", ")", "return", "if", "next_characteristic", "is", "not", "None", ":", "self", ".", "bable", ".", "set_notification", "(", "enabled", "=", "True", ",", "connection_handle", "=", "context", "[", "'connection_handle'", "]", ",", "characteristic", "=", "next_characteristic", ",", "on_notification_set", "=", "[", "self", ".", "_on_interface_opened", ",", "context", "]", ",", "on_notification_received", "=", "self", ".", "_on_notification_received", ",", "sync", "=", "False", ")", "else", ":", "self", ".", "connections", ".", "finish_operation", "(", "context", "[", "'connection_id'", "]", ",", "True", ",", "None", ")" ]

[ "Callback", "function", "called", "when", "the", "notification", "related", "to", "an", "interface", "has", "been", "enabled", ".", "It", "is", "executed", "in", "the", "baBLE", "working", "thread", ":", "should", "not", "be", "blocking", "." ]

[ "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", "_search_inasafe_layer", "(", "self", ")", ":", "selected_nodes", "=", "self", ".", "iface", ".", "layerTreeView", "(", ")", ".", "selectedNodes", "(", ")", "for", "selected_node", "in", "selected_nodes", ":", "tree_layers", "=", "[", "child", "for", "child", "in", "selected_node", ".", "children", "(", ")", "if", "(", "isinstance", "(", "child", ",", "QgsLayerTreeLayer", ")", ")", "]", "for", "tree_layer", "in", "tree_layers", ":", "layer", "=", "tree_layer", ".", "layer", "(", ")", "keywords", "=", "self", ".", "keyword_io", ".", "read_keywords", "(", "layer", ")", "if", "keywords", ".", "get", "(", "'inasafe_fields'", ")", ":", "return", "layer" ]

[ "Search", "for", "an", "inasafe", "layer", "in", "an", "active", "group", "." ]

[ "def", "print_cmd", "(", "ctx", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "backend", "=", "ctx", ".", "meta", ".", "get", "(", "'BACKEND'", ",", "'pyusb'", ")", "model", "=", "ctx", ".", "meta", ".", "get", "(", "'MODEL'", ")", "printer", "=", "ctx", ".", "meta", ".", "get", "(", "'PRINTER'", ")", "from", "brother_ql", ".", "conversion", "import", "convert", "from", "brother_ql", ".", "backends", ".", "helpers", "import", "send", "from", "brother_ql", ".", "raster", "import", "BrotherQLRaster", "qlr", "=", "BrotherQLRaster", "(", "model", ")", "qlr", ".", "exception_on_warning", "=", "True", "kwargs", "[", "'cut'", "]", "=", "not", "kwargs", "[", "'no_cut'", "]", "del", "kwargs", "[", "'no_cut'", "]", "instructions", "=", "convert", "(", "qlr", "=", "qlr", ",", "*", "*", "kwargs", ")", "send", "(", "instructions", "=", "instructions", ",", "printer_identifier", "=", "printer", ",", "backend_identifier", "=", "backend", ",", "blocking", "=", "True", ")" ]

[ "Print", "a", "label", "of", "the", "provided", "IMAGE", "." ]

[ "def", "connect", "(", "self", ")", ":", "log", ".", "debug", "(", "\"Connecting to ldap server %s\"", "%", "self", ".", "config", "[", "'URI'", "]", ")", "self", ".", "conn", "=", "ldap", ".", "initialize", "(", "self", ".", "config", "[", "'URI'", "]", ")", "# There are some settings that can't be changed at runtime without a context restart.", "# It's possible to refresh the context and apply the settings by setting OPT_X_TLS_NEWCTX", "# to 0, but this needs to be the last option set, and since the config dictionary is not", "# sorted, this is not necessarily true. Sort the list of options so that if OPT_X_TLS_NEWCTX", "# is present, it is applied last.", "options", "=", "self", ".", "config", ".", "get", "(", "'OPTIONS'", ",", "{", "}", ")", ".", "items", "(", ")", "options", ".", "sort", "(", "key", "=", "lambda", "x", ":", "x", "[", "0", "]", "==", "'OPT_X_TLS_NEWCTX'", ")", "for", "opt", ",", "value", "in", "options", ":", "if", "isinstance", "(", "opt", ",", "str", ")", ":", "opt", "=", "getattr", "(", "ldap", ",", "opt", ")", "try", ":", "if", "isinstance", "(", "value", ",", "str", ")", ":", "value", "=", "getattr", "(", "ldap", ",", "value", ")", "except", "AttributeError", ":", "pass", "self", ".", "conn", ".", "set_option", "(", "opt", ",", "value", ")", "if", "self", ".", "config", ".", "get", "(", "'START_TLS'", ")", ":", "log", ".", "debug", "(", "\"Starting TLS\"", ")", "self", ".", "conn", ".", "start_tls_s", "(", ")" ]

[ "initialize", "ldap", "connection", "and", "set", "options" ]

[ "def", "a2b_base58", "(", "s", ")", ":", "v", ",", "prefix", "=", "to_long", "(", "BASE58_BASE", ",", "lambda", "c", ":", "BASE58_LOOKUP", "[", "c", "]", ",", "s", ".", "encode", "(", "\"utf8\"", ")", ")", "return", "from_long", "(", "v", ",", "prefix", ",", "256", ",", "lambda", "x", ":", "x", ")" ]

[ "Convert", "base58", "to", "binary", "using", "BASE58_ALPHABET", "." ]

[ "def", "query", "(", "params", ")", ":", "r", "=", "requests_get", "(", "QUERY_URL", ",", "verify", "=", "True", ")", "return", "HospitalCollection", "(", "r", ".", "json", "(", ")", ",", "params", ")" ]

[ "params", "is", "a", "city", "name", "or", "a", "city", "name", "+", "hospital", "name", "." ]

[ "def", "_normalized_levenshtein_distance", "(", "s1", ",", "s2", ",", "acceptable_differences", ")", ":", "if", "len", "(", "s1", ")", ">", "len", "(", "s2", ")", ":", "s1", ",", "s2", "=", "s2", ",", "s1", "acceptable_differences", "=", "set", "(", "-", "i", "for", "i", "in", "acceptable_differences", ")", "distances", "=", "range", "(", "len", "(", "s1", ")", "+", "1", ")", "for", "index2", ",", "num2", "in", "enumerate", "(", "s2", ")", ":", "new_distances", "=", "[", "index2", "+", "1", "]", "for", "index1", ",", "num1", "in", "enumerate", "(", "s1", ")", ":", "if", "num2", "-", "num1", "in", "acceptable_differences", ":", "new_distances", ".", "append", "(", "distances", "[", "index1", "]", ")", "else", ":", "new_distances", ".", "append", "(", "1", "+", "min", "(", "(", "distances", "[", "index1", "]", ",", "distances", "[", "index1", "+", "1", "]", ",", "new_distances", "[", "-", "1", "]", ")", ")", ")", "distances", "=", "new_distances", "return", "distances", "[", "-", "1", "]" ]

[ "This", "function", "calculates", "the", "levenshtein", "distance", "but", "allows", "for", "elements", "in", "the", "lists", "to", "be", "different", "by", "any", "number", "in", "the", "set", "acceptable_differences", "." ]

[ "def", "cascade", "(", "sequence", ",", "full", "=", "False", ")", ":", "if", "len", "(", "sequence", ")", "==", "1", ":", "return", "sequence", "[", "0", "]", "left", "=", "sequence", "[", "0", "]", "if", "full", ":", "intermed", "=", "[", "]", "for", "cdiff", "in", "sequence", "[", "1", ":", "]", ":", "right", "=", "restore", "(", "cdiff", ",", "left", ")", "if", "full", ":", "intermed", ".", "append", "(", "right", ")", "left", "=", "right", "return", "left" ]

[ "Restores", "a", "sequence", "of", "string", "definitions", "using", "the", "first", "entry", "as", "the", "original", "and", "then", "applying", "a", "series", "of", ":", "func", ":", "~acorn", ".", "logging", ".", "diff", ".", "restore", "calls", "." ]

[ "def", "is_not_inf", "(", "self", ")", ":", "self", ".", "_validate_number", "(", ")", "self", ".", "_validate_real", "(", ")", "if", "math", ".", "isinf", "(", "self", ".", "val", ")", ":", "self", ".", "_err", "(", "'Expected not <Inf>, but was.'", ")", "return", "self" ]

[ "Asserts", "that", "val", "is", "real", "number", "and", "not", "Inf", "(", "infinity", ")", "." ]

[ "def", "translate", "(", "value", ")", ":", "if", "isinstance", "(", "value", ",", "BaseValidator", ")", ":", "return", "value", "if", "value", "is", "None", ":", "return", "Anything", "(", ")", "if", "isinstance", "(", "value", ",", "type", ")", ":", "return", "IsA", "(", "value", ")", "if", "type", "(", "value", ")", "in", "compat", ".", "func_types", ":", "real_value", "=", "value", "(", ")", "return", "IsA", "(", "type", "(", "real_value", ")", ",", "default", "=", "real_value", ")", "if", "isinstance", "(", "value", ",", "list", ")", ":", "if", "value", "==", "[", "]", ":", "# no inner spec, just an empty list as the default value", "return", "IsA", "(", "list", ")", "elif", "len", "(", "value", ")", "==", "1", ":", "# the only item as spec for each item of the collection", "return", "ListOf", "(", "translate", "(", "value", "[", "0", "]", ")", ")", "else", ":", "raise", "StructureSpecificationError", "(", "'Expected a list containing exactly 1 item; '", "'got {cnt}: {spec}'", ".", "format", "(", "cnt", "=", "len", "(", "value", ")", ",", "spec", "=", "value", ")", ")", "if", "isinstance", "(", "value", ",", "dict", ")", ":", "if", "not", "value", ":", "return", "IsA", "(", "dict", ")", "items", "=", "[", "]", "for", "k", ",", "v", "in", "value", ".", "items", "(", ")", ":", "if", "isinstance", "(", "k", ",", "BaseValidator", ")", ":", "k_validator", "=", "k", "else", ":", "k_validator", "=", "translate", "(", "k", ")", "default", "=", "k_validator", ".", "get_default_for", "(", "None", ")", "if", "default", "is", "not", "None", ":", "k_validator", "=", "Equals", "(", "default", ")", "v_validator", "=", "translate", "(", "v", ")", "items", ".", "append", "(", "(", "k_validator", ",", "v_validator", ")", ")", "return", "DictOf", "(", "items", ")", "return", "IsA", "(", "type", "(", "value", ")", ",", "default", "=", "value", ")" ]

[ "Translates", "given", "schema", "from", "pythonic", "syntax", "to", "a", "validator", "." ]

[ "def", "deprecated_name", "(", "name", ")", ":", "def", "decorator", "(", "func", ")", ":", "\"\"\"Decorator function.\"\"\"", "def", "func_wrapper", "(", "self", ")", ":", "\"\"\"Wrapper for original function.\"\"\"", "if", "hasattr", "(", "self", ",", "name", ")", ":", "# Return the old property", "return", "getattr", "(", "self", ",", "name", ")", "else", ":", "return", "func", "(", "self", ")", "return", "func_wrapper", "return", "decorator" ]

[ "Allow", "old", "method", "names", "for", "backwards", "compatability", "." ]

[ "def", "clip_eta", "(", "eta", ",", "ord", ",", "eps", ")", ":", "# Clipping perturbation eta to self.ord norm ball", "if", "ord", "not", "in", "[", "np", ".", "inf", ",", "1", ",", "2", "]", ":", "raise", "ValueError", "(", "'ord must be np.inf, 1, or 2.'", ")", "reduc_ind", "=", "list", "(", "xrange", "(", "1", ",", "len", "(", "eta", ".", "get_shape", "(", ")", ")", ")", ")", "avoid_zero_div", "=", "1e-12", "if", "ord", "==", "np", ".", "inf", ":", "eta", "=", "clip_by_value", "(", "eta", ",", "-", "eps", ",", "eps", ")", "else", ":", "if", "ord", "==", "1", ":", "raise", "NotImplementedError", "(", "\"The expression below is not the correct way\"", "\" to project onto the L1 norm ball.\"", ")", "norm", "=", "tf", ".", "maximum", "(", "avoid_zero_div", ",", "reduce_sum", "(", "tf", ".", "abs", "(", "eta", ")", ",", "reduc_ind", ",", "keepdims", "=", "True", ")", ")", "elif", "ord", "==", "2", ":", "# avoid_zero_div must go inside sqrt to avoid a divide by zero", "# in the gradient through this operation", "norm", "=", "tf", ".", "sqrt", "(", "tf", ".", "maximum", "(", "avoid_zero_div", ",", "reduce_sum", "(", "tf", ".", "square", "(", "eta", ")", ",", "reduc_ind", ",", "keepdims", "=", "True", ")", ")", ")", "# We must *clip* to within the norm ball, not *normalize* onto the", "# surface of the ball", "factor", "=", "tf", ".", "minimum", "(", "1.", ",", "div", "(", "eps", ",", "norm", ")", ")", "eta", "=", "eta", "*", "factor", "return", "eta" ]

[ "Helper", "function", "to", "clip", "the", "perturbation", "to", "epsilon", "norm", "ball", ".", ":", "param", "eta", ":", "A", "tensor", "with", "the", "current", "perturbation", ".", ":", "param", "ord", ":", "Order", "of", "the", "norm", "(", "mimics", "Numpy", ")", ".", "Possible", "values", ":", "np", ".", "inf", "1", "or", "2", ".", ":", "param", "eps", ":", "Epsilon", "bound", "of", "the", "perturbation", "." ]

[ "def", "parse_requirement", "(", "req", ")", ":", "remaining", "=", "req", ".", "strip", "(", ")", "if", "not", "remaining", "or", "remaining", ".", "startswith", "(", "'#'", ")", ":", "return", "None", "m", "=", "IDENTIFIER", ".", "match", "(", "remaining", ")", "if", "not", "m", ":", "raise", "SyntaxError", "(", "'name expected: %s'", "%", "remaining", ")", "distname", "=", "m", ".", "groups", "(", ")", "[", "0", "]", "remaining", "=", "remaining", "[", "m", ".", "end", "(", ")", ":", "]", "extras", "=", "mark_expr", "=", "versions", "=", "uri", "=", "None", "if", "remaining", "and", "remaining", "[", "0", "]", "==", "'['", ":", "i", "=", "remaining", ".", "find", "(", "']'", ",", "1", ")", "if", "i", "<", "0", ":", "raise", "SyntaxError", "(", "'unterminated extra: %s'", "%", "remaining", ")", "s", "=", "remaining", "[", "1", ":", "i", "]", "remaining", "=", "remaining", "[", "i", "+", "1", ":", "]", ".", "lstrip", "(", ")", "extras", "=", "[", "]", "while", "s", ":", "m", "=", "IDENTIFIER", ".", "match", "(", "s", ")", "if", "not", "m", ":", "raise", "SyntaxError", "(", "'malformed extra: %s'", "%", "s", ")", "extras", ".", "append", "(", "m", ".", "groups", "(", ")", "[", "0", "]", ")", "s", "=", "s", "[", "m", ".", "end", "(", ")", ":", "]", "if", "not", "s", ":", "break", "if", "s", "[", "0", "]", "!=", "','", ":", "raise", "SyntaxError", "(", "'comma expected in extras: %s'", "%", "s", ")", "s", "=", "s", "[", "1", ":", "]", ".", "lstrip", "(", ")", "if", "not", "extras", ":", "extras", "=", "None", "if", "remaining", ":", "if", "remaining", "[", "0", "]", "==", "'@'", ":", "# it's a URI", "remaining", "=", "remaining", "[", "1", ":", "]", ".", "lstrip", "(", ")", "m", "=", "NON_SPACE", ".", "match", "(", "remaining", ")", "if", "not", "m", ":", "raise", "SyntaxError", "(", "'invalid URI: %s'", "%", "remaining", ")", "uri", "=", "m", ".", "groups", "(", ")", "[", "0", "]", "t", "=", "urlparse", "(", "uri", ")", "# there are issues with Python and URL parsing, so this test", "# is a bit crude. See bpo-20271, bpo-23505. Python doesn't", "# always parse invalid URLs correctly - it should raise", "# exceptions for malformed URLs", "if", "not", "(", "t", ".", "scheme", "and", "t", ".", "netloc", ")", ":", "raise", "SyntaxError", "(", "'Invalid URL: %s'", "%", "uri", ")", "remaining", "=", "remaining", "[", "m", ".", "end", "(", ")", ":", "]", ".", "lstrip", "(", ")", "else", ":", "def", "get_versions", "(", "ver_remaining", ")", ":", "\"\"\"\n Return a list of operator, version tuples if any are\n specified, else None.\n \"\"\"", "m", "=", "COMPARE_OP", ".", "match", "(", "ver_remaining", ")", "versions", "=", "None", "if", "m", ":", "versions", "=", "[", "]", "while", "True", ":", "op", "=", "m", ".", "groups", "(", ")", "[", "0", "]", "ver_remaining", "=", "ver_remaining", "[", "m", ".", "end", "(", ")", ":", "]", "m", "=", "VERSION_IDENTIFIER", ".", "match", "(", "ver_remaining", ")", "if", "not", "m", ":", "raise", "SyntaxError", "(", "'invalid version: %s'", "%", "ver_remaining", ")", "v", "=", "m", ".", "groups", "(", ")", "[", "0", "]", "versions", ".", "append", "(", "(", "op", ",", "v", ")", ")", "ver_remaining", "=", "ver_remaining", "[", "m", ".", "end", "(", ")", ":", "]", "if", "not", "ver_remaining", "or", "ver_remaining", "[", "0", "]", "!=", "','", ":", "break", "ver_remaining", "=", "ver_remaining", "[", "1", ":", "]", ".", "lstrip", "(", ")", "m", "=", "COMPARE_OP", ".", "match", "(", "ver_remaining", ")", "if", "not", "m", ":", "raise", "SyntaxError", "(", "'invalid constraint: %s'", "%", "ver_remaining", ")", "if", "not", "versions", ":", "versions", "=", "None", "return", "versions", ",", "ver_remaining", "if", "remaining", "[", "0", "]", "!=", "'('", ":", "versions", ",", "remaining", "=", "get_versions", "(", "remaining", ")", "else", ":", "i", "=", "remaining", ".", "find", "(", "')'", ",", "1", ")", "if", "i", "<", "0", ":", "raise", "SyntaxError", "(", "'unterminated parenthesis: %s'", "%", "remaining", ")", "s", "=", "remaining", "[", "1", ":", "i", "]", "remaining", "=", "remaining", "[", "i", "+", "1", ":", "]", ".", "lstrip", "(", ")", "# As a special diversion from PEP 508, allow a version number", "# a.b.c in parentheses as a synonym for ~= a.b.c (because this", "# is allowed in earlier PEPs)", "if", "COMPARE_OP", ".", "match", "(", "s", ")", ":", "versions", ",", "_", "=", "get_versions", "(", "s", ")", "else", ":", "m", "=", "VERSION_IDENTIFIER", ".", "match", "(", "s", ")", "if", "not", "m", ":", "raise", "SyntaxError", "(", "'invalid constraint: %s'", "%", "s", ")", "v", "=", "m", ".", "groups", "(", ")", "[", "0", "]", "s", "=", "s", "[", "m", ".", "end", "(", ")", ":", "]", ".", "lstrip", "(", ")", "if", "s", ":", "raise", "SyntaxError", "(", "'invalid constraint: %s'", "%", "s", ")", "versions", "=", "[", "(", "'~='", ",", "v", ")", "]", "if", "remaining", ":", "if", "remaining", "[", "0", "]", "!=", "';'", ":", "raise", "SyntaxError", "(", "'invalid requirement: %s'", "%", "remaining", ")", "remaining", "=", "remaining", "[", "1", ":", "]", ".", "lstrip", "(", ")", "mark_expr", ",", "remaining", "=", "parse_marker", "(", "remaining", ")", "if", "remaining", "and", "remaining", "[", "0", "]", "!=", "'#'", ":", "raise", "SyntaxError", "(", "'unexpected trailing data: %s'", "%", "remaining", ")", "if", "not", "versions", ":", "rs", "=", "distname", "else", ":", "rs", "=", "'%s %s'", "%", "(", "distname", ",", "', '", ".", "join", "(", "[", "'%s %s'", "%", "con", "for", "con", "in", "versions", "]", ")", ")", "return", "Container", "(", "name", "=", "distname", ",", "extras", "=", "extras", ",", "constraints", "=", "versions", ",", "marker", "=", "mark_expr", ",", "url", "=", "uri", ",", "requirement", "=", "rs", ")" ]

[ "Parse", "a", "requirement", "passed", "in", "as", "a", "string", ".", "Return", "a", "Container", "whose", "attributes", "contain", "the", "various", "parts", "of", "the", "requirement", "." ]

[ "def", "get_registered_layer", "(", "name", ")", ":", "ret", "=", "_LAYER_REGISTRY", ".", "get", "(", "name", ",", "None", ")", "if", "ret", "==", "_NameConflict", ":", "raise", "KeyError", "(", "\"Layer named '{}' is registered with `@layer_register` more than once!\"", ".", "format", "(", "name", ")", ")", "return", "ret" ]

[ "Args", ":", "name", "(", "str", ")", ":", "the", "name", "of", "the", "layer", "e", ".", "g", ".", "Conv2D", "Returns", ":", "the", "wrapped", "layer", "function", "or", "None", "if", "not", "registered", "." ]

[ "def", "_project_TH3", "(", "self", ",", "hist", ":", "Hist", ")", "->", "Any", ":", "# Axis length validation", "if", "len", "(", "self", ".", "projection_axes", ")", "<", "1", "or", "len", "(", "self", ".", "projection_axes", ")", ">", "2", ":", "raise", "ValueError", "(", "len", "(", "self", ".", "projection_axes", ")", ",", "\"Invalid number of axes\"", ")", "# Need to concatenate the names of the axes together", "projection_axis_name", "=", "\"\"", "for", "axis", "in", "self", ".", "projection_axes", ":", "# Determine the axis name based on the name of the axis type.", "# [:1] returns just the first letter. For example, we could get \"xy\" if the first axis as", "# x_axis and the second was y_axis.", "# NOTE: Careful. This depends on the name of the enumerated values!!! Since this isn't terribly", "# safe, we then perform additional validation on the same to ensure that it is one of the", "# expected axis names.", "proj_axis_name", "=", "axis", ".", "axis_type", ".", "name", "[", ":", "1", "]", "if", "proj_axis_name", "not", "in", "[", "\"x\"", ",", "\"y\"", ",", "\"z\"", "]", ":", "raise", "ValueError", "(", "f\"Projection axis name {proj_axis_name} is not 'x', 'y', or 'z'. Please check your configuration.\"", ")", "projection_axis_name", "+=", "proj_axis_name", "# Handle ROOT Project3D quirk...", "# 2D projection are called as (y, x, options), so we should reverse the order so it performs", "# as expected.", "# NOTE: This isn't well documented in TH3. It is instead described in THnBase.Projection(...)", "if", "len", "(", "self", ".", "projection_axes", ")", "==", "2", ":", "# Reverse the axes", "projection_axis_name", "=", "projection_axis_name", "[", ":", ":", "-", "1", "]", "# Do the actual projection", "logger", ".", "info", "(", "f\"Projecting onto axes \\\"{projection_axis_name}\\\" from hist {hist.GetName()}\"", ")", "projected_hist", "=", "hist", ".", "Project3D", "(", "projection_axis_name", ")", "return", "projected_hist" ]

[ "Perform", "the", "actual", "TH3", "-", ">", "TH1", "projection", "." ]

[ "def", "cyl_to_rect", "(", "R", ",", "phi", ",", "Z", ")", ":", "return", "(", "R", "*", "sc", ".", "cos", "(", "phi", ")", ",", "R", "*", "sc", ".", "sin", "(", "phi", ")", ",", "Z", ")" ]

[ "NAME", ":" ]

[ "def", "find_bus_controls", "(", "sub_network", ")", ":", "network", "=", "sub_network", ".", "network", "find_slack_bus", "(", "sub_network", ")", "gens", "=", "sub_network", ".", "generators", "(", ")", "buses_i", "=", "sub_network", ".", "buses_i", "(", ")", "#default bus control is PQ", "network", ".", "buses", ".", "loc", "[", "buses_i", ",", "\"control\"", "]", "=", "\"PQ\"", "#find all buses with one or more gens with PV", "pvs", "=", "gens", "[", "gens", ".", "control", "==", "'PV'", "]", ".", "index", ".", "to_series", "(", ")", "if", "len", "(", "pvs", ")", ">", "0", ":", "pvs", "=", "pvs", ".", "groupby", "(", "gens", ".", "bus", ")", ".", "first", "(", ")", "network", ".", "buses", ".", "loc", "[", "pvs", ".", "index", ",", "\"control\"", "]", "=", "\"PV\"", "network", ".", "buses", ".", "loc", "[", "pvs", ".", "index", ",", "\"generator\"", "]", "=", "pvs", "network", ".", "buses", ".", "loc", "[", "sub_network", ".", "slack_bus", ",", "\"control\"", "]", "=", "\"Slack\"", "network", ".", "buses", ".", "loc", "[", "sub_network", ".", "slack_bus", ",", "\"generator\"", "]", "=", "sub_network", ".", "slack_generator", "buses_control", "=", "network", ".", "buses", ".", "loc", "[", "buses_i", ",", "\"control\"", "]", "sub_network", ".", "pvs", "=", "buses_control", ".", "index", "[", "buses_control", "==", "\"PV\"", "]", "sub_network", ".", "pqs", "=", "buses_control", ".", "index", "[", "buses_control", "==", "\"PQ\"", "]", "sub_network", ".", "pvpqs", "=", "sub_network", ".", "pvs", ".", "append", "(", "sub_network", ".", "pqs", ")", "# order buses", "sub_network", ".", "buses_o", "=", "sub_network", ".", "pvpqs", ".", "insert", "(", "0", ",", "sub_network", ".", "slack_bus", ")" ]

[ "Find", "slack", "and", "all", "PV", "and", "PQ", "buses", "for", "a", "sub_network", ".", "This", "function", "also", "fixes", "sub_network", ".", "buses_o", "a", "DataFrame", "ordered", "by", "control", "type", "." ]

[ "def", "filterRead", "(", "self", ",", "read", ")", ":", "for", "filterFunc", "in", "self", ".", "_filters", ":", "filteredRead", "=", "filterFunc", "(", "read", ")", "if", "filteredRead", "is", "False", ":", "return", "False", "else", ":", "read", "=", "filteredRead", "return", "read" ]

[ "Filter", "a", "read", "according", "to", "our", "set", "of", "filters", "." ]

[ "def", "childDataReceived", "(", "self", ",", "childFD", ",", "data", ")", ":", "protocol", "=", "getattr", "(", "self", ",", "'protocol'", ",", "None", ")", "if", "protocol", ":", "protocol", ".", "dataReceived", "(", "data", ")", "else", ":", "self", ".", "data", ".", "append", "(", "(", "childFD", ",", "data", ")", ")" ]

[ "Relay", "data", "received", "on", "any", "file", "descriptor", "to", "the", "process" ]

[ "def", "update_group_alias", "(", "self", ",", "entity_id", ",", "name", ",", "mount_accessor", "=", "\"\"", ",", "canonical_id", "=", "\"\"", ",", "mount_point", "=", "DEFAULT_MOUNT_POINT", ")", ":", "params", "=", "{", "'name'", ":", "name", ",", "'mount_accessor'", ":", "mount_accessor", ",", "'canonical_id'", ":", "canonical_id", ",", "}", "api_path", "=", "'/v1/{mount_point}/group-alias/id/{id}'", ".", "format", "(", "mount_point", "=", "mount_point", ",", "id", "=", "entity_id", ",", ")", "return", "self", ".", "_adapter", ".", "post", "(", "url", "=", "api_path", ",", "json", "=", "params", ",", ")" ]

[ "Update", "an", "existing", "group", "alias", "." ]

[ "def", "evaluate_expression", "(", "dbg", ",", "frame", ",", "expression", ",", "is_exec", ")", ":", "if", "frame", "is", "None", ":", "return", "# Not using frame.f_globals because of https://sourceforge.net/tracker2/?func=detail&aid=2541355&group_id=85796&atid=577329", "# (Names not resolved in generator expression in method)", "# See message: http://mail.python.org/pipermail/python-list/2009-January/526522.html", "updated_globals", "=", "{", "}", "updated_globals", ".", "update", "(", "frame", ".", "f_globals", ")", "updated_globals", ".", "update", "(", "frame", ".", "f_locals", ")", "# locals later because it has precedence over the actual globals", "try", ":", "expression", "=", "str", "(", "expression", ".", "replace", "(", "'@LINE@'", ",", "'\\n'", ")", ")", "if", "is_exec", ":", "try", ":", "# try to make it an eval (if it is an eval we can print it, otherwise we'll exec it and", "# it will have whatever the user actually did)", "compiled", "=", "compile", "(", "expression", ",", "'<string>'", ",", "'eval'", ")", "except", ":", "Exec", "(", "expression", ",", "updated_globals", ",", "frame", ".", "f_locals", ")", "pydevd_save_locals", ".", "save_locals", "(", "frame", ")", "else", ":", "result", "=", "eval", "(", "compiled", ",", "updated_globals", ",", "frame", ".", "f_locals", ")", "if", "result", "is", "not", "None", ":", "# Only print if it's not None (as python does)", "sys", ".", "stdout", ".", "write", "(", "'%s\\n'", "%", "(", "result", ",", ")", ")", "return", "else", ":", "return", "eval_in_context", "(", "expression", ",", "updated_globals", ",", "frame", ".", "f_locals", ")", "finally", ":", "# Should not be kept alive if an exception happens and this frame is kept in the stack.", "del", "updated_globals", "del", "frame" ]

[ "returns", "the", "result", "of", "the", "evaluated", "expression" ]

[ "def", "_process_counter_example", "(", "self", ",", "mma", ",", "w_string", ")", ":", "w_string", "=", "self", ".", "_find_bad_transition", "(", "mma", ",", "w_string", ")", "diff", "=", "len", "(", "w_string", ")", "same", "=", "0", "while", "True", ":", "i", "=", "(", "same", "+", "diff", ")", "/", "2", "access_string", "=", "self", ".", "_run_in_hypothesis", "(", "mma", ",", "w_string", ",", "i", ")", "is_diff", "=", "self", ".", "_check_suffix", "(", "w_string", ",", "access_string", ",", "i", ")", "if", "is_diff", ":", "diff", "=", "i", "else", ":", "same", "=", "i", "if", "diff", "-", "same", "==", "1", ":", "break", "exp", "=", "w_string", "[", "diff", ":", "]", "self", ".", "observation_table", ".", "em_vector", ".", "append", "(", "exp", ")", "for", "row", "in", "self", ".", "observation_table", ".", "sm_vector", "+", "self", ".", "observation_table", ".", "smi_vector", ":", "self", ".", "_fill_table_entry", "(", "row", ",", "exp", ")" ]

[ "Process", "a", "counterexample", "in", "the", "Rivest", "-", "Schapire", "way", ".", "Args", ":", "mma", "(", "DFA", ")", ":", "The", "hypothesis", "automaton", "w_string", "(", "str", ")", ":", "The", "examined", "string", "to", "be", "consumed", "Returns", ":", "None" ]

[ "def", "get_port_channel_detail_input_request_type_get_next_request_last_aggregator_id", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "get_port_channel_detail", "=", "ET", ".", "Element", "(", "\"get_port_channel_detail\"", ")", "config", "=", "get_port_channel_detail", "input", "=", "ET", ".", "SubElement", "(", "get_port_channel_detail", ",", "\"input\"", ")", "request_type", "=", "ET", ".", "SubElement", "(", "input", ",", "\"request-type\"", ")", "get_next_request", "=", "ET", ".", "SubElement", "(", "request_type", ",", "\"get-next-request\"", ")", "last_aggregator_id", "=", "ET", ".", "SubElement", "(", "get_next_request", ",", "\"last-aggregator-id\"", ")", "last_aggregator_id", ".", "text", "=", "kwargs", ".", "pop", "(", "'last_aggregator_id'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "is_eulerian_tour", "(", "graph", ",", "tour", ")", ":", "m", "=", "len", "(", "tour", ")", "-", "1", "arcs", "=", "set", "(", "(", "tour", "[", "i", "]", ",", "tour", "[", "i", "+", "1", "]", ")", "for", "i", "in", "range", "(", "m", ")", ")", "if", "len", "(", "arcs", ")", "!=", "m", ":", "return", "False", "for", "(", "u", ",", "v", ")", "in", "arcs", ":", "if", "v", "not", "in", "graph", "[", "u", "]", ":", "return", "False", "return", "True" ]

[ "Eulerian", "tour", "on", "an", "undirected", "graph" ]

[ "def", "start", "(", "controller_class", ")", ":", "args", "=", "parser", ".", "parse", "(", ")", "obj", "=", "controller_class", "(", "args", ",", "platform", ".", "operating_system", "(", ")", ")", "if", "args", ".", "foreground", ":", "try", ":", "obj", ".", "start", "(", ")", "except", "KeyboardInterrupt", ":", "obj", ".", "stop", "(", ")", "else", ":", "try", ":", "with", "platform", ".", "Daemon", "(", "obj", ")", "as", "daemon", ":", "daemon", ".", "start", "(", ")", "except", "(", "OSError", ",", "ValueError", ")", "as", "error", ":", "sys", ".", "stderr", ".", "write", "(", "'\\nError starting %s: %s\\n\\n'", "%", "(", "sys", ".", "argv", "[", "0", "]", ",", "error", ")", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Start", "the", "Helper", "controller", "either", "in", "the", "foreground", "or", "as", "a", "daemon", "process", "." ]

[ "def", "check_is_uuid", "(", "self", ",", "uuid_str", ":", "str", ")", ":", "# check uuid type", "if", "not", "isinstance", "(", "uuid_str", ",", "str", ")", ":", "raise", "TypeError", "(", "\"'uuid_str' expected a str value.\"", ")", "else", ":", "pass", "# handle Isogeo specific UUID in XML exports", "if", "\"isogeo:metadata\"", "in", "uuid_str", ":", "uuid_str", "=", "\"urn:uuid:{}\"", ".", "format", "(", "uuid_str", ".", "split", "(", "\":\"", ")", "[", "-", "1", "]", ")", "else", ":", "pass", "# test it", "try", ":", "uid", "=", "UUID", "(", "uuid_str", ")", "return", "uid", ".", "hex", "==", "uuid_str", ".", "replace", "(", "\"-\"", ",", "\"\"", ")", ".", "replace", "(", "\"urn:uuid:\"", ",", "\"\"", ")", "except", "ValueError", "as", "e", ":", "logging", ".", "error", "(", "\"uuid ValueError. {} ({}) -- {}\"", ".", "format", "(", "type", "(", "uuid_str", ")", ",", "uuid_str", ",", "e", ")", ")", "return", "False" ]

[ "Check", "if", "it", "s", "an", "Isogeo", "UUID", "handling", "specific", "form", "." ]

[ "def", "_add_escape_character_for_quote_prime_character", "(", "self", ",", "text", ")", ":", "if", "text", "is", "not", "None", ":", "if", "\"'\"", "in", "text", ":", "return", "text", ".", "replace", "(", "\"'\"", ",", "\"\\\\'\"", ")", "elif", "'\"'", "in", "text", ":", "return", "text", ".", "replace", "(", "'\"'", ",", "'\\\\\"'", ")", "else", ":", "return", "text", "else", ":", "return", "text" ]

[ "Fix", "for", "https", ":", "//", "github", ".", "com", "/", "openatx", "/", "facebook", "-", "wda", "/", "issues", "/", "33", "Returns", ":", "string", "with", "properly", "formated", "quotes", "or", "non", "changed", "text" ]

[ "def", "is_local", "(", "path", ")", ":", "# type: (str) -> bool", "if", "not", "running_under_virtualenv", "(", ")", ":", "return", "True", "return", "normalize_path", "(", "path", ")", ".", "startswith", "(", "normalize_path", "(", "sys", ".", "prefix", ")", ")" ]

[ "Return", "True", "if", "path", "is", "within", "sys", ".", "prefix", "if", "we", "re", "running", "in", "a", "virtualenv", "." ]

[ "def", "getElementsByTagName", "(", "self", ",", "tagName", ",", "root", "=", "'root'", ",", "useIndex", "=", "True", ")", ":", "(", "root", ",", "isFromRoot", ")", "=", "self", ".", "_handleRootArg", "(", "root", ")", "if", "useIndex", "is", "True", "and", "self", ".", "indexTagNames", "is", "True", ":", "elements", "=", "self", ".", "_tagNameMap", ".", "get", "(", "tagName", ",", "[", "]", ")", "# Use .get here as to not create a lot of extra indexes on the defaultdict for misses", "if", "isFromRoot", "is", "False", ":", "_hasTagInParentLine", "=", "self", ".", "_hasTagInParentLine", "elements", "=", "[", "x", "for", "x", "in", "elements", "if", "_hasTagInParentLine", "(", "x", ",", "root", ")", "]", "return", "TagCollection", "(", "elements", ")", "return", "AdvancedHTMLParser", ".", "getElementsByTagName", "(", "self", ",", "tagName", ",", "root", ")" ]

[ "getElementsByTagName", "-", "Searches", "and", "returns", "all", "elements", "with", "a", "specific", "tag", "name", "." ]

[ "def", "_iraw_client_configs", "(", "cfg", ")", ":", "client_names", "=", "cfg", ".", "get", "(", "\"dyndnsc\"", ",", "\"configs\"", ")", ".", "split", "(", "\",\"", ")", "_preset_prefix", "=", "\"preset:\"", "_use_preset", "=", "\"use_preset\"", "for", "client_name", "in", "(", "x", ".", "strip", "(", ")", "for", "x", "in", "client_names", "if", "x", ".", "strip", "(", ")", ")", ":", "client_cfg_dict", "=", "dict", "(", "cfg", ".", "items", "(", "client_name", ")", ")", "if", "cfg", ".", "has_option", "(", "client_name", ",", "_use_preset", ")", ":", "prf", "=", "dict", "(", "cfg", ".", "items", "(", "_preset_prefix", "+", "cfg", ".", "get", "(", "client_name", ",", "_use_preset", ")", ")", ")", "prf", ".", "update", "(", "client_cfg_dict", ")", "client_cfg_dict", "=", "prf", "else", ":", "# raw config with NO preset in use, so no updating of dict", "pass", "logging", ".", "debug", "(", "\"raw config for '%s': %r\"", ",", "client_name", ",", "client_cfg_dict", ")", "if", "_use_preset", "in", "client_cfg_dict", ":", "del", "client_cfg_dict", "[", "_use_preset", "]", "yield", "client_name", ",", "client_cfg_dict" ]

[ "Generate", "(", "client_name", "client_cfg_dict", ")", "tuples", "from", "the", "configuration", "." ]

[ "def", "value_count", "(", "self", ",", "key", ")", ":", "check_not_none", "(", "key", ",", "\"key can't be None\"", ")", "key_data", "=", "self", ".", "_to_data", "(", "key", ")", "return", "self", ".", "_encode_invoke_on_key", "(", "multi_map_value_count_codec", ",", "key_data", ",", "key", "=", "key_data", ",", "thread_id", "=", "thread_id", "(", ")", ")" ]

[ "Returns", "the", "number", "of", "values", "that", "match", "the", "given", "key", "in", "the", "multimap", "." ]

[ "def", "get_last_id", "(", "self", ",", "cur", ",", "table", "=", "'reaction'", ")", ":", "cur", ".", "execute", "(", "\"SELECT seq FROM sqlite_sequence WHERE name='{0}'\"", ".", "format", "(", "table", ")", ")", "result", "=", "cur", ".", "fetchone", "(", ")", "if", "result", "is", "not", "None", ":", "id", "=", "result", "[", "0", "]", "else", ":", "id", "=", "0", "return", "id" ]

[ "Get", "the", "id", "of", "the", "last", "written", "row", "in", "table" ]

[ "def", "rename", "(", "self", ",", "new_relation", ")", ":", "# Relations store this stuff inside their `path` dict. But they", "# also store a table_name, and usually use it in their .render(),", "# so we need to update that as well. It doesn't appear that", "# table_name is ever anything but the identifier (via .create())", "self", ".", "inner", "=", "self", ".", "inner", ".", "incorporate", "(", "path", "=", "{", "'database'", ":", "new_relation", ".", "inner", ".", "database", ",", "'schema'", ":", "new_relation", ".", "inner", ".", "schema", ",", "'identifier'", ":", "new_relation", ".", "inner", ".", "identifier", "}", ",", "table_name", "=", "new_relation", ".", "inner", ".", "identifier", ")" ]

[ "Rename", "this", "cached", "relation", "to", "new_relation", ".", "Note", "that", "this", "will", "change", "the", "output", "of", "key", "()", "all", "refs", "must", "be", "updated!" ]

[ "def", "make_string", "(", "seq", ")", ":", "string", "=", "''", "for", "c", "in", "seq", ":", "# Screen out non-printing characters", "try", ":", "if", "32", "<=", "c", "and", "c", "<", "256", ":", "string", "+=", "chr", "(", "c", ")", "except", "TypeError", ":", "pass", "# If no printing chars", "if", "not", "string", ":", "return", "str", "(", "seq", ")", "return", "string" ]

[ "Don", "t", "throw", "an", "exception", "when", "given", "an", "out", "of", "range", "character", "." ]

[ "def", "MGMT_ACTIVE_GET", "(", "self", ",", "Addr", "=", "''", ",", "TLVs", "=", "[", "]", ")", ":", "print", "'%s call MGMT_ACTIVE_GET'", "%", "self", ".", "port", "try", ":", "cmd", "=", "WPANCTL_CMD", "+", "'dataset mgmt-get-active'", "if", "len", "(", "TLVs", ")", "!=", "0", ":", "tlvs", "=", "\"\"", ".", "join", "(", "hex", "(", "tlv", ")", ".", "lstrip", "(", "\"0x\"", ")", ".", "zfill", "(", "2", ")", "for", "tlv", "in", "TLVs", ")", "setTLVCmd", "=", "WPANCTL_CMD", "+", "'setprop Dataset:RawTlvs '", "+", "tlvs", "if", "self", ".", "__sendCommand", "(", "setTLVCmd", ")", "[", "0", "]", "==", "'Fail'", ":", "return", "False", "else", ":", "if", "self", ".", "__sendCommand", "(", "WPANCTL_CMD", "+", "'dataset erase'", ")", "[", "0", "]", "==", "'Fail'", ":", "return", "False", "if", "Addr", "!=", "''", ":", "setAddressCmd", "=", "WPANCTL_CMD", "+", "'setprop Dataset:DestIpAddress '", "+", "Addr", "if", "self", ".", "__sendCommand", "(", "setAddressCmd", ")", "[", "0", "]", "==", "'Fail'", ":", "return", "False", "print", "cmd", "return", "self", ".", "__sendCommand", "(", "cmd", ")", "[", "0", "]", "!=", "'Fail'", "except", "Exception", ",", "e", ":", "ModuleHelper", ".", "WriteIntoDebugLogger", "(", "'MGMT_ACTIVE_GET() Error: '", "+", "str", "(", "e", ")", ")" ]

[ "send", "MGMT_ACTIVE_GET", "command" ]

[ "def", "copy_snapshot", "(", "kwargs", "=", "None", ",", "call", "=", "None", ")", ":", "if", "call", "!=", "'function'", ":", "log", ".", "error", "(", "'The copy_snapshot function must be called with -f or --function.'", ")", "return", "False", "if", "'source_region'", "not", "in", "kwargs", ":", "log", ".", "error", "(", "'A source_region must be specified to copy a snapshot.'", ")", "return", "False", "if", "'source_snapshot_id'", "not", "in", "kwargs", ":", "log", ".", "error", "(", "'A source_snapshot_id must be specified to copy a snapshot.'", ")", "return", "False", "if", "'description'", "not", "in", "kwargs", ":", "kwargs", "[", "'description'", "]", "=", "''", "params", "=", "{", "'Action'", ":", "'CopySnapshot'", "}", "if", "'source_region'", "in", "kwargs", ":", "params", "[", "'SourceRegion'", "]", "=", "kwargs", "[", "'source_region'", "]", "if", "'source_snapshot_id'", "in", "kwargs", ":", "params", "[", "'SourceSnapshotId'", "]", "=", "kwargs", "[", "'source_snapshot_id'", "]", "if", "'description'", "in", "kwargs", ":", "params", "[", "'Description'", "]", "=", "kwargs", "[", "'description'", "]", "log", ".", "debug", "(", "params", ")", "data", "=", "aws", ".", "query", "(", "params", ",", "return_url", "=", "True", ",", "location", "=", "get_location", "(", ")", ",", "provider", "=", "get_provider", "(", ")", ",", "opts", "=", "__opts__", ",", "sigver", "=", "'4'", ")", "return", "data" ]

[ "Copy", "a", "snapshot" ]

[ "def", "execute_concurrent_with_args", "(", "session", ",", "statement", ",", "parameters", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "execute_concurrent", "(", "session", ",", "zip", "(", "cycle", "(", "(", "statement", ",", ")", ")", ",", "parameters", ")", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Like", ":", "meth", ":", "~cassandra", ".", "concurrent", ".", "execute_concurrent", "()", "but", "takes", "a", "single", "statement", "and", "a", "sequence", "of", "parameters", ".", "Each", "item", "in", "parameters", "should", "be", "a", "sequence", "or", ":", "const", ":", "None", "." ]

[ "def", "airline_delay", "(", "data_set", "=", "'airline_delay'", ",", "num_train", "=", "700000", ",", "num_test", "=", "100000", ",", "seed", "=", "default_seed", ")", ":", "if", "not", "data_available", "(", "data_set", ")", ":", "download_data", "(", "data_set", ")", "dir_path", "=", "os", ".", "path", ".", "join", "(", "data_path", ",", "data_set", ")", "filename", "=", "os", ".", "path", ".", "join", "(", "dir_path", ",", "'filtered_data.pickle'", ")", "# 1. Load the dataset", "import", "pandas", "as", "pd", "data", "=", "pd", ".", "read_pickle", "(", "filename", ")", "# WARNING: removing year", "data", ".", "pop", "(", "'Year'", ")", "# Get data matrices", "Yall", "=", "data", ".", "pop", "(", "'ArrDelay'", ")", ".", "values", "[", ":", ",", "None", "]", "Xall", "=", "data", ".", "values", "# Subset the data (memory!!)", "all_data", "=", "num_train", "+", "num_test", "Xall", "=", "Xall", "[", ":", "all_data", "]", "Yall", "=", "Yall", "[", ":", "all_data", "]", "# Get testing points", "np", ".", "random", ".", "seed", "(", "seed", "=", "seed", ")", "N_shuffled", "=", "permute", "(", "Yall", ".", "shape", "[", "0", "]", ")", "train", ",", "test", "=", "N_shuffled", "[", "num_test", ":", "]", ",", "N_shuffled", "[", ":", "num_test", "]", "X", ",", "Y", "=", "Xall", "[", "train", "]", ",", "Yall", "[", "train", "]", "Xtest", ",", "Ytest", "=", "Xall", "[", "test", "]", ",", "Yall", "[", "test", "]", "covariates", "=", "[", "'month'", ",", "'day of month'", ",", "'day of week'", ",", "'departure time'", ",", "'arrival time'", ",", "'air time'", ",", "'distance to travel'", ",", "'age of aircraft / years'", "]", "response", "=", "[", "'delay'", "]", "return", "data_details_return", "(", "{", "'X'", ":", "X", ",", "'Y'", ":", "Y", ",", "'Xtest'", ":", "Xtest", ",", "'Ytest'", ":", "Ytest", ",", "'seed'", ":", "seed", ",", "'info'", ":", "\"Airline delay data used for demonstrating Gaussian processes for big data.\"", ",", "'covariates'", ":", "covariates", ",", "'response'", ":", "response", "}", ",", "data_set", ")" ]

[ "Airline", "delay", "data", "used", "in", "Gaussian", "Processes", "for", "Big", "Data", "by", "Hensman", "Fusi", "and", "Lawrence" ]

[ "def", "position", "(", "self", ")", ":", "return", "{", "k", ".", "upper", "(", ")", ":", "v", "for", "k", ",", "v", "in", "self", ".", "_position", ".", "items", "(", ")", "}" ]

[ "Instead", "of", "sending", "M114", ".", "2", "we", "are", "storing", "target", "values", "in", "self", ".", "_position", "since", "movement", "and", "home", "commands", "are", "blocking", "and", "assumed", "to", "go", "the", "correct", "place", "." ]

[ "def", "validate", "(", "style", ",", "value", ",", "scalar", "=", "False", ")", ":", "validator", "=", "get_validator", "(", "style", ")", "if", "validator", "is", "None", ":", "return", "None", "if", "isinstance", "(", "value", ",", "(", "np", ".", "ndarray", ",", "list", ")", ")", ":", "if", "scalar", ":", "return", "False", "return", "all", "(", "validator", "(", "v", ")", "for", "v", "in", "value", ")", "return", "validator", "(", "value", ")" ]

[ "Validates", "a", "style", "and", "associated", "value", "." ]

[ "def", "dumpfile", "(", "item", ",", "path", ")", ":", "with", "io", ".", "open", "(", "path", ",", "'wb'", ")", "as", "fd", ":", "fd", ".", "write", "(", "en", "(", "item", ")", ")" ]

[ "Dump", "an", "object", "to", "a", "file", "by", "path", "." ]

[ "def", "_parse_children", "(", "self", ",", "recurse", "=", "False", ")", ":", "try", ":", "self", ".", "children", "=", "[", "]", "if", "self", ".", "_contents", "is", "None", ":", "return", "contents_length", "=", "len", "(", "self", ".", "_contents", ")", "child_pointer", "=", "0", "while", "child_pointer", "<", "contents_length", ":", "parts", ",", "child_pointer", "=", "_parse", "(", "self", ".", "_contents", ",", "contents_length", ",", "pointer", "=", "child_pointer", ")", "if", "self", ".", "_child_spec", ":", "child", "=", "parts", "+", "(", "self", ".", "_child_spec", ",", ")", "else", ":", "child", "=", "parts", "if", "recurse", ":", "child", "=", "_build", "(", "*", "child", ")", "if", "isinstance", "(", "child", ",", "(", "Sequence", ",", "SequenceOf", ")", ")", ":", "child", ".", "_parse_children", "(", "recurse", "=", "True", ")", "self", ".", "children", ".", "append", "(", "child", ")", "except", "(", "ValueError", ",", "TypeError", ")", "as", "e", ":", "self", ".", "children", "=", "None", "args", "=", "e", ".", "args", "[", "1", ":", "]", "e", ".", "args", "=", "(", "e", ".", "args", "[", "0", "]", "+", "'\\n while parsing %s'", "%", "type_name", "(", "self", ")", ",", ")", "+", "args", "raise", "e" ]

[ "Parses", "the", "contents", "and", "generates", "Asn1Value", "objects", "based", "on", "the", "definitions", "from", "_child_spec", "." ]

[ "def", "hacking_docstring_summary", "(", "physical_line", ",", "previous_logical", ",", "tokens", ")", ":", "docstring", "=", "is_docstring", "(", "tokens", ",", "previous_logical", ")", "if", "docstring", ":", "if", "'\\n'", "not", "in", "docstring", ":", "# not a multi line docstring", "return", "lines", "=", "docstring", ".", "split", "(", "'\\n'", ")", "if", "len", "(", "lines", ")", ">", "1", "and", "len", "(", "lines", "[", "1", "]", ".", "strip", "(", ")", ")", "is", "not", "0", ":", "# docstrings get tokenized on the last line of the docstring, so", "# we don't know the exact position.", "return", "(", "0", ",", "\"H405: multi line docstring \"", "\"summary not separated with an empty line\"", ")" ]

[ "r", "Check", "multi", "line", "docstring", "summary", "is", "separated", "with", "empty", "line", "." ]

[ "def", "get_host_post_state", "(", "self", ")", ":", "sushy_system", "=", "self", ".", "_get_sushy_system", "(", "PROLIANT_SYSTEM_ID", ")", "return", "GET_POST_STATE_MAP", ".", "get", "(", "sushy_system", ".", "post_state", ")" ]

[ "Get", "the", "current", "state", "of", "system", "POST", "." ]

[ "def", "plot_ts", "(", "ax", ",", "agemin", ",", "agemax", ",", "timescale", "=", "'gts12'", ",", "ylabel", "=", "\"Age (Ma)\"", ")", ":", "ax", ".", "set_title", "(", "timescale", ".", "upper", "(", ")", ")", "ax", ".", "axis", "(", "[", "-", ".25", ",", "1.5", ",", "agemax", ",", "agemin", "]", ")", "ax", ".", "axes", ".", "get_xaxis", "(", ")", ".", "set_visible", "(", "False", ")", "# get dates and chron names for timescale", "TS", ",", "Chrons", "=", "pmag", ".", "get_ts", "(", "timescale", ")", "X", ",", "Y", ",", "Y2", "=", "[", "0", ",", "1", "]", ",", "[", "]", ",", "[", "]", "cnt", "=", "0", "if", "agemin", "<", "TS", "[", "1", "]", ":", "# in the Brunhes", "Y", "=", "[", "agemin", ",", "agemin", "]", "# minimum age", "Y1", "=", "[", "TS", "[", "1", "]", ",", "TS", "[", "1", "]", "]", "# age of the B/M boundary", "ax", ".", "fill_between", "(", "X", ",", "Y", ",", "Y1", ",", "facecolor", "=", "'black'", ")", "# color in Brunhes, black", "for", "d", "in", "TS", "[", "1", ":", "]", ":", "pol", "=", "cnt", "%", "2", "cnt", "+=", "1", "if", "d", "<=", "agemax", "and", "d", ">=", "agemin", ":", "ind", "=", "TS", ".", "index", "(", "d", ")", "Y", "=", "[", "TS", "[", "ind", "]", ",", "TS", "[", "ind", "]", "]", "Y1", "=", "[", "TS", "[", "ind", "+", "1", "]", ",", "TS", "[", "ind", "+", "1", "]", "]", "if", "pol", ":", "# fill in every other time", "ax", ".", "fill_between", "(", "X", ",", "Y", ",", "Y1", ",", "facecolor", "=", "'black'", ")", "ax", ".", "plot", "(", "[", "0", ",", "1", ",", "1", ",", "0", ",", "0", "]", ",", "[", "agemin", ",", "agemin", ",", "agemax", ",", "agemax", ",", "agemin", "]", ",", "'k-'", ")", "plt", ".", "yticks", "(", "np", ".", "arange", "(", "agemin", ",", "agemax", "+", "1", ",", "1", ")", ")", "if", "ylabel", "!=", "\"\"", ":", "ax", ".", "set_ylabel", "(", "ylabel", ")", "ax2", "=", "ax", ".", "twinx", "(", ")", "ax2", ".", "axis", "(", "'off'", ")", "for", "k", "in", "range", "(", "len", "(", "Chrons", ")", "-", "1", ")", ":", "c", "=", "Chrons", "[", "k", "]", "cnext", "=", "Chrons", "[", "k", "+", "1", "]", "d", "=", "cnext", "[", "1", "]", "-", "(", "cnext", "[", "1", "]", "-", "c", "[", "1", "]", ")", "/", "3.", "if", "d", ">=", "agemin", "and", "d", "<", "agemax", ":", "# make the Chron boundary tick", "ax2", ".", "plot", "(", "[", "1", ",", "1.5", "]", ",", "[", "c", "[", "1", "]", ",", "c", "[", "1", "]", "]", ",", "'k-'", ")", "ax2", ".", "text", "(", "1.05", ",", "d", ",", "c", "[", "0", "]", ")", "ax2", ".", "axis", "(", "[", "-", ".25", ",", "1.5", ",", "agemax", ",", "agemin", "]", ")" ]

[ "Make", "a", "time", "scale", "plot", "between", "specified", "ages", "." ]

[ "def", "copy", "(", "self", ")", ":", "markovchain_copy", "=", "MarkovChain", "(", "variables", "=", "list", "(", "self", ".", "cardinalities", ".", "keys", "(", ")", ")", ",", "card", "=", "list", "(", "self", ".", "cardinalities", ".", "values", "(", ")", ")", ",", "start_state", "=", "self", ".", "state", ")", "if", "self", ".", "transition_models", ":", "markovchain_copy", ".", "transition_models", "=", "self", ".", "transition_models", ".", "copy", "(", ")", "return", "markovchain_copy" ]

[ "Returns", "a", "copy", "of", "Markov", "Chain", "Model", "." ]

[ "def", "render_to_string", "(", "template_name", ",", "context", "=", "None", ",", "request", "=", "None", ",", "using", "=", "None", ")", ":", "if", "isinstance", "(", "template_name", ",", "(", "list", ",", "tuple", ")", ")", ":", "template", "=", "select_template", "(", "template_name", ",", "using", "=", "using", ")", "else", ":", "template", "=", "get_template", "(", "template_name", ",", "using", "=", "using", ")", "return", "template", ".", "render", "(", "context", ",", "request", ")" ]

[ "Loads", "a", "template", "and", "renders", "it", "with", "a", "context", ".", "Returns", "a", "string", ".", "template_name", "may", "be", "a", "string", "or", "a", "list", "of", "strings", "." ]

[ "def", "calibrate_band_pass_N1", "(", "self", ")", ":", "band_pass", "=", "np", ".", "median", "(", "self", ".", "data", ".", "squeeze", "(", ")", ",", "axis", "=", "0", ")", "self", ".", "data", "=", "self", ".", "data", "/", "band_pass" ]

[ "One", "way", "to", "calibrate", "the", "band", "pass", "is", "to", "take", "the", "median", "value", "for", "every", "frequency", "fine", "channel", "and", "divide", "by", "it", "." ]

[ "def", "set_widgets", "(", "self", ")", ":", "self", ".", "tblFunctions1", ".", "horizontalHeader", "(", ")", ".", "setSectionResizeMode", "(", "QHeaderView", ".", "Stretch", ")", "self", ".", "tblFunctions1", ".", "verticalHeader", "(", ")", ".", "setSectionResizeMode", "(", "QHeaderView", ".", "Stretch", ")", "self", ".", "populate_function_table_1", "(", ")" ]

[ "Set", "widgets", "on", "the", "Impact", "Functions", "Table", "1", "tab", "." ]

[ "def", "label", "(", "self", ")", ":", "if", "self", ".", "valuetype_class", ".", "is_label", "(", ")", ":", "return", "self", "for", "c", "in", "self", ".", "table", ".", "columns", ":", "if", "c", ".", "parent", "==", "self", ".", "name", "and", "c", ".", "valuetype_class", ".", "is_label", "(", ")", ":", "return", "c", "return", "None" ]

[ "Return", "first", "child", "of", "the", "column", "that", "is", "marked", "as", "a", "label", ".", "Returns", "self", "if", "the", "column", "is", "a", "label" ]

[ "def", "checkseq", "(", "sequence", ":", "str", "=", "None", ",", "code", "=", "\"ATGC\"", ")", "->", "bool", ":", "for", "base", "in", "sequence", ":", "if", "base", "not", "in", "code", ":", "return", "False", "return", "True" ]

[ ":", "param", "sequence", ":", "The", "input", "sequence", ".", ":", "type", "sequence", ":", "Seq", ":", "rtype", ":", "bool" ]

[ "def", "template_runner", "(", "client", ",", "parser", ",", "args", ")", ":", "if", "args", ".", "builtin_list", ":", "aomi", ".", "template", ".", "builtin_list", "(", ")", "elif", "args", ".", "builtin_info", ":", "aomi", ".", "template", ".", "builtin_info", "(", "args", ".", "builtin_info", ")", "elif", "args", ".", "template", "and", "args", ".", "destination", "and", "args", ".", "vault_paths", ":", "aomi", ".", "render", ".", "template", "(", "client", ",", "args", ".", "template", ",", "args", ".", "destination", ",", "args", ".", "vault_paths", ",", "args", ")", "else", ":", "parser", ".", "print_usage", "(", ")", "sys", ".", "exit", "(", "2", ")", "sys", ".", "exit", "(", "0", ")" ]

[ "Executes", "template", "related", "operations" ]

[ "def", "render_GET", "(", "self", ",", "request", ")", ":", "request", ".", "setHeader", "(", "b'accept-ranges'", ",", "b'bytes'", ")", "producer", "=", "self", ".", "makeProducer", "(", "request", ",", "self", ".", "fileObject", ")", "if", "request", ".", "method", "==", "b'HEAD'", ":", "return", "b''", "def", "done", "(", "ign", ")", ":", "producer", ".", "stopProducing", "(", ")", "request", ".", "notifyFinish", "(", ")", ".", "addCallbacks", "(", "done", ",", "done", ")", "producer", ".", "start", "(", ")", "# and make sure the connection doesn't get closed", "return", "server", ".", "NOT_DONE_YET" ]

[ "Begin", "sending", "the", "contents", "of", "this", "L", "{", "File", "}", "(", "or", "a", "subset", "of", "the", "contents", "based", "on", "the", "range", "header", ")", "to", "the", "given", "request", "." ]

[ "def", "get_args", "(", "self", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "self", ".", "_desc", ",", "formatter_class", "=", "MyUniversalHelpFormatter", ")", "# default args", "if", "self", ".", "_no_clean", ":", "parser", ".", "add_argument", "(", "'--no-clean'", ",", "action", "=", "'store_true'", ",", "help", "=", "'If this flag is used, temporary work directory is not '", "'cleaned.'", ")", "if", "self", ".", "_resume", ":", "parser", ".", "add_argument", "(", "'--resume'", ",", "action", "=", "'store_true'", ",", "help", "=", "'If this flag is used, a previously uncleaned workflow in the'", "' same directory will be resumed'", ")", "return", "parser" ]

[ "Use", "this", "context", "manager", "to", "add", "arguments", "to", "an", "argparse", "object", "with", "the", "add_argument", "method", ".", "Arguments", "must", "be", "defined", "before", "the", "command", "is", "defined", ".", "Note", "that", "no", "-", "clean", "and", "resume", "are", "added", "upon", "exit", "and", "should", "not", "be", "added", "in", "the", "context", "manager", ".", "For", "more", "info", "about", "these", "default", "arguments", "see", "below", "." ]

[ "def", "serve", "(", "application", ",", "host", "=", "'127.0.0.1'", ",", "port", "=", "8080", ",", "socket", "=", "None", ",", "*", "*", "options", ")", ":", "# Allow either on-disk socket (recommended) or TCP/IP socket use.", "if", "not", "socket", ":", "bindAddress", "=", "(", "host", ",", "int", "(", "port", ")", ")", "else", ":", "bindAddress", "=", "socket", "# Bind and start the blocking web server interface.", "WSGIServer", "(", "application", ",", "bindAddress", "=", "bindAddress", ",", "*", "*", "options", ")", ".", "run", "(", ")" ]

[ "Basic", "FastCGI", "support", "via", "flup", ".", "This", "web", "server", "has", "many", "many", "options", ".", "Please", "see", "the", "Flup", "project", "documentation", "for", "details", "." ]

[ "def", "fileopenbox", "(", "msg", "=", "None", ",", "title", "=", "None", ",", "default", "=", "'*'", ",", "filetypes", "=", "None", ",", "multiple", "=", "False", ")", ":", "localRoot", "=", "Tk", "(", ")", "localRoot", ".", "withdraw", "(", ")", "initialbase", ",", "initialfile", ",", "initialdir", ",", "filetypes", "=", "fileboxSetup", "(", "default", ",", "filetypes", ")", "# ------------------------------------------------------------", "# if initialfile contains no wildcards; we don't want an", "# initial file. It won't be used anyway.", "# Also: if initialbase is simply \"*\", we don't want an", "# initialfile; it is not doing any useful work.", "# ------------------------------------------------------------", "if", "(", "initialfile", ".", "find", "(", "\"*\"", ")", "<", "0", ")", "and", "(", "initialfile", ".", "find", "(", "\"?\"", ")", "<", "0", ")", ":", "initialfile", "=", "None", "elif", "initialbase", "==", "\"*\"", ":", "initialfile", "=", "None", "func", "=", "ut", ".", "tk_FileDialog", ".", "askopenfilenames", "if", "multiple", "else", "ut", ".", "tk_FileDialog", ".", "askopenfilename", "ret_val", "=", "func", "(", "parent", "=", "localRoot", ",", "title", "=", "getFileDialogTitle", "(", "msg", ",", "title", ")", ",", "initialdir", "=", "initialdir", ",", "initialfile", "=", "initialfile", ",", "filetypes", "=", "filetypes", ")", "if", "multiple", ":", "f", "=", "[", "os", ".", "path", ".", "normpath", "(", "x", ")", "for", "x", "in", "localRoot", ".", "tk", ".", "splitlist", "(", "ret_val", ")", "]", "else", ":", "f", "=", "os", ".", "path", ".", "normpath", "(", "ret_val", ")", "localRoot", ".", "destroy", "(", ")", "if", "not", "f", ":", "return", "None", "return", "f" ]

[ "A", "dialog", "to", "get", "a", "file", "name", "." ]

[ "def", "state_to_xarray", "(", "state", ")", ":", "from", "climlab", ".", "domain", ".", "field", "import", "Field", "ds", "=", "Dataset", "(", ")", "for", "name", ",", "field", "in", "state", ".", "items", "(", ")", ":", "if", "isinstance", "(", "field", ",", "Field", ")", ":", "ds", "[", "name", "]", "=", "Field_to_xarray", "(", "field", ")", "dom", "=", "field", ".", "domain", "for", "axname", ",", "ax", "in", "dom", ".", "axes", ".", "items", "(", ")", ":", "bounds_name", "=", "axname", "+", "'_bounds'", "ds", ".", "coords", "[", "bounds_name", "]", "=", "DataArray", "(", "ax", ".", "bounds", ",", "dims", "=", "[", "bounds_name", "]", ",", "coords", "=", "{", "bounds_name", ":", "ax", ".", "bounds", "}", ")", "try", ":", "ds", "[", "bounds_name", "]", ".", "attrs", "[", "'units'", "]", "=", "ax", ".", "units", "except", ":", "pass", "else", ":", "warnings", ".", "warn", "(", "'{} excluded from Dataset because it is not a Field variable.'", ".", "format", "(", "name", ")", ")", "return", "ds" ]

[ "Convert", "a", "dictionary", "of", "climlab", ".", "Field", "objects", "to", "xarray", ".", "Dataset" ]

[ "def", "keys", "(", "self", ",", "element", "=", "None", ",", "mode", "=", "None", ")", ":", "if", "mode", "is", "None", ":", "return", "super", "(", ")", ".", "keys", "(", ")", "element", "=", "self", ".", "_parse_element", "(", "element", "=", "element", ")", "allowed", "=", "[", "'props'", ",", "'labels'", "]", "if", "'all'", "in", "mode", ":", "mode", "=", "allowed", "mode", "=", "self", ".", "_parse_mode", "(", "mode", "=", "mode", ",", "allowed", "=", "allowed", ")", "keys", "=", "super", "(", ")", ".", "keys", "(", ")", "temp", "=", "[", "]", "if", "'props'", "in", "mode", ":", "temp", ".", "extend", "(", "[", "i", "for", "i", "in", "keys", "if", "self", ".", "get", "(", "i", ")", ".", "dtype", "!=", "bool", "]", ")", "if", "'labels'", "in", "mode", ":", "temp", ".", "extend", "(", "[", "i", "for", "i", "in", "keys", "if", "self", ".", "get", "(", "i", ")", ".", "dtype", "==", "bool", "]", ")", "if", "element", ":", "temp", "=", "[", "i", "for", "i", "in", "temp", "if", "i", ".", "split", "(", "'.'", ")", "[", "0", "]", "in", "element", "]", "return", "temp" ]

[ "r", "This", "subclass", "works", "exactly", "like", "keys", "when", "no", "arguments", "are", "passed", "but", "optionally", "accepts", "an", "element", "and", "/", "or", "a", "mode", "which", "filters", "the", "output", "to", "only", "the", "requested", "keys", "." ]

[ "def", "_remote_connection", "(", "server", ",", "opts", ",", "argparser_", ")", ":", "global", "CONN", "# pylint: disable=global-statement", "if", "opts", ".", "timeout", "is", "not", "None", ":", "if", "opts", ".", "timeout", "<", "0", "or", "opts", ".", "timeout", ">", "300", ":", "argparser_", ".", "error", "(", "'timeout option(%s) out of range'", "%", "opts", ".", "timeout", ")", "# mock only uses the namespace timeout and statistics options from the", "# original set of options. It ignores the url", "if", "opts", ".", "mock_server", ":", "CONN", "=", "FakedWBEMConnection", "(", "default_namespace", "=", "opts", ".", "namespace", ",", "timeout", "=", "opts", ".", "timeout", ",", "stats_enabled", "=", "opts", ".", "statistics", ")", "try", ":", "build_mock_repository", "(", "CONN", ",", "opts", ".", "mock_server", ",", "opts", ".", "verbose", ")", "except", "ValueError", "as", "ve", ":", "argparser_", ".", "error", "(", "'Build Repository failed: %s'", "%", "ve", ")", "return", "CONN", "if", "server", "[", "0", "]", "==", "'/'", ":", "url", "=", "server", "elif", "re", ".", "match", "(", "r\"^https{0,1}://\"", ",", "server", ")", "is", "not", "None", ":", "url", "=", "server", "elif", "re", ".", "match", "(", "r\"^[a-zA-Z0-9]+://\"", ",", "server", ")", "is", "not", "None", ":", "argparser_", ".", "error", "(", "'Invalid scheme on server argument.'", "' Use \"http\" or \"https\"'", ")", "else", ":", "url", "=", "'%s://%s'", "%", "(", "'https'", ",", "server", ")", "creds", "=", "None", "if", "opts", ".", "key_file", "is", "not", "None", "and", "opts", ".", "cert_file", "is", "None", ":", "argparser_", ".", "error", "(", "'keyfile option requires certfile option'", ")", "if", "opts", ".", "user", "is", "not", "None", "and", "opts", ".", "password", "is", "None", ":", "opts", ".", "password", "=", "_getpass", ".", "getpass", "(", "'Enter password for %s: '", "%", "opts", ".", "user", ")", "if", "opts", ".", "user", "is", "not", "None", "or", "opts", ".", "password", "is", "not", "None", ":", "creds", "=", "(", "opts", ".", "user", ",", "opts", ".", "password", ")", "# if client cert and key provided, create dictionary for", "# wbem connection", "x509_dict", "=", "None", "if", "opts", ".", "cert_file", "is", "not", "None", ":", "x509_dict", "=", "{", "\"cert_file\"", ":", "opts", ".", "cert_file", "}", "if", "opts", ".", "key_file", "is", "not", "None", ":", "x509_dict", ".", "update", "(", "{", "'key_file'", ":", "opts", ".", "key_file", "}", ")", "CONN", "=", "WBEMConnection", "(", "url", ",", "creds", ",", "default_namespace", "=", "opts", ".", "namespace", ",", "no_verification", "=", "opts", ".", "no_verify_cert", ",", "x509", "=", "x509_dict", ",", "ca_certs", "=", "opts", ".", "ca_certs", ",", "timeout", "=", "opts", ".", "timeout", ",", "stats_enabled", "=", "opts", ".", "statistics", ")", "CONN", ".", "debug", "=", "True", "return", "CONN" ]

[ "Initiate", "a", "remote", "connection", "via", "PyWBEM", ".", "Arguments", "for", "the", "request", "are", "part", "of", "the", "command", "line", "arguments", "and", "include", "user", "name", "password", "namespace", "etc", "." ]

[ "def", "drain", "(", "self", ",", "sid", "=", "None", ")", ":", "if", "self", ".", "is_draining", ":", "return", "if", "self", ".", "is_closed", ":", "raise", "ErrConnectionClosed", "if", "self", ".", "is_connecting", "or", "self", ".", "is_reconnecting", ":", "raise", "ErrConnectionReconnecting", "if", "sid", "is", "not", "None", ":", "return", "self", ".", "_drain_sub", "(", "sid", ")", "# Start draining the subscriptions", "self", ".", "_status", "=", "Client", ".", "DRAINING_SUBS", "drain_tasks", "=", "[", "]", "for", "ssid", ",", "sub", "in", "self", ".", "_subs", ".", "items", "(", ")", ":", "task", "=", "self", ".", "_drain_sub", "(", "ssid", ")", "drain_tasks", ".", "append", "(", "task", ")", "drain_is_done", "=", "asyncio", ".", "gather", "(", "*", "drain_tasks", ")", "try", ":", "yield", "from", "asyncio", ".", "wait_for", "(", "drain_is_done", ",", "self", ".", "options", "[", "\"drain_timeout\"", "]", ")", "except", "asyncio", ".", "TimeoutError", ":", "drain_is_done", ".", "exception", "(", ")", "drain_is_done", ".", "cancel", "(", ")", "if", "self", ".", "_error_cb", "is", "not", "None", ":", "yield", "from", "self", ".", "_error_cb", "(", "ErrDrainTimeout", ")", "except", "asyncio", ".", "CancelledError", ":", "pass", "finally", ":", "self", ".", "_status", "=", "Client", ".", "DRAINING_PUBS", "yield", "from", "self", ".", "flush", "(", ")", "yield", "from", "self", ".", "_close", "(", "Client", ".", "CLOSED", ")" ]

[ "Drain", "will", "put", "a", "connection", "into", "a", "drain", "state", ".", "All", "subscriptions", "will", "immediately", "be", "put", "into", "a", "drain", "state", ".", "Upon", "completion", "the", "publishers", "will", "be", "drained", "and", "can", "not", "publish", "any", "additional", "messages", ".", "Upon", "draining", "of", "the", "publishers", "the", "connection", "will", "be", "closed", ".", "Use", "the", "closed_cb", "option", "to", "know", "when", "the", "connection", "has", "moved", "from", "draining", "to", "closed", "." ]

[ "def", "normalize", "(", "num_in", ",", "lower", "=", "0", ",", "upper", "=", "360", ",", "b", "=", "False", ")", ":", "if", "lower", ">=", "upper", ":", "ValueError", "(", "\"lower must be lesser than upper\"", ")", "if", "not", "b", ":", "if", "not", "(", "(", "lower", "+", "upper", "==", "0", ")", "or", "(", "lower", "==", "0", ")", ")", ":", "raise", "ValueError", "(", "'When b=False lower=0 or range must be symmetric about 0.'", ")", "else", ":", "if", "not", "(", "lower", "+", "upper", "==", "0", ")", ":", "raise", "ValueError", "(", "'When b=True range must be symmetric about 0.'", ")", "# abs(num + upper) and abs(num - lower) are needed, instead of", "# abs(num), since the lower and upper limits need not be 0. We need", "# to add half size of the range, so that the final result is lower +", "# <value> or upper - <value>, respectively.", "if", "not", "hasattr", "(", "num_in", ",", "\"__iter__\"", ")", ":", "num_in", "=", "np", ".", "asarray", "(", "[", "num_in", "]", ",", "dtype", "=", "np", ".", "float", ")", "res", "=", "[", "]", "for", "num", "in", "num_in", ":", "if", "not", "b", ":", "if", "num", ">", "upper", "or", "num", "==", "lower", ":", "num", "=", "lower", "+", "abs", "(", "num", "+", "upper", ")", "%", "(", "abs", "(", "lower", ")", "+", "abs", "(", "upper", ")", ")", "if", "num", "<", "lower", "or", "num", "==", "upper", ":", "num", "=", "upper", "-", "abs", "(", "num", "-", "lower", ")", "%", "(", "abs", "(", "lower", ")", "+", "abs", "(", "upper", ")", ")", "res", ".", "append", "(", "lower", "if", "num", "==", "upper", "else", "num", ")", "else", ":", "total_length", "=", "abs", "(", "lower", ")", "+", "abs", "(", "upper", ")", "if", "num", "<", "-", "total_length", ":", "num", "+=", "ceil", "(", "num", "/", "(", "-", "2", "*", "total_length", ")", ")", "*", "2", "*", "total_length", "if", "num", ">", "total_length", ":", "num", "-=", "floor", "(", "num", "/", "(", "2", "*", "total_length", ")", ")", "*", "2", "*", "total_length", "if", "num", ">", "upper", ":", "num", "=", "total_length", "-", "num", "if", "num", "<", "lower", ":", "num", "=", "-", "total_length", "-", "num", "res", ".", "append", "(", "num", ")", "return", "np", ".", "asarray", "(", "res", ",", "dtype", "=", "np", ".", "float", ")" ]

[ "Normalize", "number", "to", "range", "[", "lower", "upper", ")", "or", "[", "lower", "upper", "]", "." ]

[ "def", "get_default_prefix", "(", "self", ",", "instance", "=", "None", ")", ":", "if", "instance", "is", "None", "and", "hasattr", "(", "self", ",", "'instance'", ")", ":", "instance", "=", "self", ".", "instance", "if", "instance", "and", "instance", ".", "id", "is", "not", "None", ":", "# it's an existing instance, use the instance prefix", "instance_prefix", "=", "self", ".", "default_instance_prefix", "if", "instance_prefix", "is", "None", ":", "instance_prefix", "=", "self", ".", "__class__", ".", "__name__", ".", "lower", "(", ")", "+", "'i-'", "return", "'{0}{1}'", ".", "format", "(", "instance_prefix", ",", "instance", ".", "id", ")", "if", "self", ".", "default_new_prefix", "is", "not", "None", ":", "return", "self", ".", "default_new_prefix", "return", "self", ".", "__class__", ".", "__name__", ".", "lower", "(", ")", "+", "'new-'" ]

[ "Gets", "the", "prefix", "for", "this", "form", "." ]

[ "def", "draw_qubit_graph", "(", "G", ",", "layout", ",", "linear_biases", "=", "{", "}", ",", "quadratic_biases", "=", "{", "}", ",", "nodelist", "=", "None", ",", "edgelist", "=", "None", ",", "cmap", "=", "None", ",", "edge_cmap", "=", "None", ",", "vmin", "=", "None", ",", "vmax", "=", "None", ",", "edge_vmin", "=", "None", ",", "edge_vmax", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "linear_biases", "or", "quadratic_biases", ":", "# if linear biases and/or quadratic biases are provided, then color accordingly.", "try", ":", "import", "matplotlib", ".", "pyplot", "as", "plt", "import", "matplotlib", "as", "mpl", "except", "ImportError", ":", "raise", "ImportError", "(", "\"Matplotlib and numpy required for draw_qubit_graph()\"", ")", "if", "nodelist", "is", "None", ":", "nodelist", "=", "G", ".", "nodes", "(", ")", "if", "edgelist", "is", "None", ":", "edgelist", "=", "G", ".", "edges", "(", ")", "if", "cmap", "is", "None", ":", "cmap", "=", "plt", ".", "get_cmap", "(", "'coolwarm'", ")", "if", "edge_cmap", "is", "None", ":", "edge_cmap", "=", "plt", ".", "get_cmap", "(", "'coolwarm'", ")", "# any edges or nodes with an unspecified bias default to 0", "def", "edge_color", "(", "u", ",", "v", ")", ":", "c", "=", "0.", "if", "(", "u", ",", "v", ")", "in", "quadratic_biases", ":", "c", "+=", "quadratic_biases", "[", "(", "u", ",", "v", ")", "]", "if", "(", "v", ",", "u", ")", "in", "quadratic_biases", ":", "c", "+=", "quadratic_biases", "[", "(", "v", ",", "u", ")", "]", "return", "c", "def", "node_color", "(", "v", ")", ":", "c", "=", "0.", "if", "v", "in", "linear_biases", ":", "c", "+=", "linear_biases", "[", "v", "]", "if", "(", "v", ",", "v", ")", "in", "quadratic_biases", ":", "c", "+=", "quadratic_biases", "[", "(", "v", ",", "v", ")", "]", "return", "c", "node_color", "=", "[", "node_color", "(", "v", ")", "for", "v", "in", "nodelist", "]", "edge_color", "=", "[", "edge_color", "(", "u", ",", "v", ")", "for", "u", ",", "v", "in", "edgelist", "]", "kwargs", "[", "'edge_color'", "]", "=", "edge_color", "kwargs", "[", "'node_color'", "]", "=", "node_color", "# the range of the color map is shared for nodes/edges and is symmetric", "# around 0.", "vmag", "=", "max", "(", "max", "(", "abs", "(", "c", ")", "for", "c", "in", "node_color", ")", ",", "max", "(", "abs", "(", "c", ")", "for", "c", "in", "edge_color", ")", ")", "if", "vmin", "is", "None", ":", "vmin", "=", "-", "1", "*", "vmag", "if", "vmax", "is", "None", ":", "vmax", "=", "vmag", "if", "edge_vmin", "is", "None", ":", "edge_vmin", "=", "-", "1", "*", "vmag", "if", "edge_vmax", "is", "None", ":", "edge_vmax", "=", "vmag", "draw", "(", "G", ",", "layout", ",", "nodelist", "=", "nodelist", ",", "edgelist", "=", "edgelist", ",", "cmap", "=", "cmap", ",", "edge_cmap", "=", "edge_cmap", ",", "vmin", "=", "vmin", ",", "vmax", "=", "vmax", ",", "edge_vmin", "=", "edge_vmin", ",", "edge_vmax", "=", "edge_vmax", ",", "*", "*", "kwargs", ")", "# if the biases are provided, then add a legend explaining the color map", "if", "linear_biases", "or", "quadratic_biases", ":", "fig", "=", "plt", ".", "figure", "(", "1", ")", "# cax = fig.add_axes([])", "cax", "=", "fig", ".", "add_axes", "(", "[", ".9", ",", "0.2", ",", "0.04", ",", "0.6", "]", ")", "# left, bottom, width, height", "mpl", ".", "colorbar", ".", "ColorbarBase", "(", "cax", ",", "cmap", "=", "cmap", ",", "norm", "=", "mpl", ".", "colors", ".", "Normalize", "(", "vmin", "=", "-", "1", "*", "vmag", ",", "vmax", "=", "vmag", ",", "clip", "=", "False", ")", ",", "orientation", "=", "'vertical'", ")" ]

[ "Draws", "graph", "G", "according", "to", "layout", "." ]

[ "def", "validate_object", "(", "brain_or_object", ",", "data", ")", ":", "obj", "=", "get_object", "(", "brain_or_object", ")", "# Call the validator of AT Content Types", "if", "is_at_content", "(", "obj", ")", ":", "return", "obj", ".", "validate", "(", "data", "=", "data", ")", "return", "{", "}" ]

[ "Validate", "the", "entire", "object" ]

[ "def", "_overlapping_channels", "(", "self", ",", "wavelengths", ")", ":", "sizes", "=", "self", ".", "meta", "[", "\"channel_sizes\"", "]", "min_a", ",", "max_a", "=", "wavelengths", ".", "min", "(", ")", ",", "wavelengths", ".", "max", "(", ")", "matched_channel_names", "=", "[", "]", "for", "i", ",", "(", "name", ",", "size", ")", "in", "enumerate", "(", "zip", "(", "self", ".", "channel_names", ",", "sizes", ")", ")", ":", "si", "=", "sum", "(", "sizes", "[", ":", "i", "]", ")", "min_b", ",", "max_b", "=", "self", ".", "wavelengths", "[", "[", "si", ",", "si", "+", "size", "-", "1", "]", "]", "if", "max_a", ">", "min_b", "and", "min_a", "<", "max_b", ":", "matched_channel_names", ".", "append", "(", "name", ")", "return", "matched_channel_names" ]

[ "Return", "the", "channels", "that", "match", "the", "given", "wavelength", "array", "." ]

[ "def", "obtain_band_edges", "(", "self", ")", ":", "orbitals", "=", "self", ".", "aos_as_list", "(", ")", "electrons", "=", "Composition", "(", "self", ".", "composition", ")", ".", "total_electrons", "partial_filled", "=", "[", "]", "for", "orbital", "in", "orbitals", ":", "if", "electrons", "<=", "0", ":", "break", "if", "'s'", "in", "orbital", "[", "1", "]", ":", "electrons", "+=", "-", "2", "elif", "'p'", "in", "orbital", "[", "1", "]", ":", "electrons", "+=", "-", "6", "elif", "'d'", "in", "orbital", "[", "1", "]", ":", "electrons", "+=", "-", "10", "elif", "'f'", "in", "orbital", "[", "1", "]", ":", "electrons", "+=", "-", "14", "partial_filled", ".", "append", "(", "orbital", ")", "if", "electrons", "!=", "0", ":", "homo", "=", "partial_filled", "[", "-", "1", "]", "lumo", "=", "partial_filled", "[", "-", "1", "]", "else", ":", "homo", "=", "partial_filled", "[", "-", "1", "]", "try", ":", "lumo", "=", "orbitals", "[", "len", "(", "partial_filled", ")", "]", "except", ":", "lumo", "=", "None", "if", "homo", "==", "lumo", ":", "metal", "=", "True", "else", ":", "metal", "=", "False", "return", "{", "'HOMO'", ":", "homo", ",", "'LUMO'", ":", "lumo", ",", "'metal'", ":", "metal", "}" ]

[ "Fill", "up", "the", "atomic", "orbitals", "with", "available", "electrons", ".", "Return", "HOMO", "LUMO", "and", "whether", "it", "s", "a", "metal", "." ]

[ "def", "gauge", "(", "self", ",", "name", ",", "description", ",", "labels", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_track", "(", "Gauge", ",", "lambda", "metric", ",", "time", ":", "metric", ".", "dec", "(", ")", ",", "kwargs", ",", "name", ",", "description", ",", "labels", ",", "registry", "=", "self", ".", "registry", ",", "before", "=", "lambda", "metric", ":", "metric", ".", "inc", "(", ")", ")" ]

[ "Use", "a", "Gauge", "to", "track", "the", "number", "of", "invocations", "in", "progress", "for", "the", "method", "." ]

[ "def", "get_message_content", "(", "self", ",", "message_id", ",", "timeout", "=", "None", ")", ":", "response", "=", "self", ".", "_get", "(", "'/v2/bot/message/{message_id}/content'", ".", "format", "(", "message_id", "=", "message_id", ")", ",", "stream", "=", "True", ",", "timeout", "=", "timeout", ")", "return", "Content", "(", "response", ")" ]

[ "Call", "get", "content", "API", "." ]

[ "def", "check_overlap", "(", "current", ",", "hit", ",", "overlap", "=", "200", ")", ":", "for", "prev", "in", "current", ":", "p_coords", "=", "prev", "[", "2", ":", "4", "]", "coords", "=", "hit", "[", "2", ":", "4", "]", "if", "get_overlap", "(", "coords", ",", "p_coords", ")", ">=", "overlap", ":", "return", "True", "return", "False" ]

[ "determine", "if", "sequence", "has", "already", "hit", "the", "same", "part", "of", "the", "model", "indicating", "that", "this", "hit", "is", "for", "another", "16S", "rRNA", "gene" ]

[ "def", "getKw", "(", "self", ",", "kw", ")", ":", "ikw", "=", "kw", ".", "lower", "(", ")", "line_continue_flag", "=", "''", "appendflag", "=", "False", "try", ":", "for", "line", "in", "self", ".", "file_lines", ":", "if", "line", ".", "strip", "(", ")", "==", "''", ":", "continue", "line", "=", "' '", ".", "join", "(", "line", ".", "strip", "(", ")", ".", "split", "(", ")", ")", ".", "strip", "(", "'\\n; '", ")", "if", "line", ".", "startswith", "(", "'!'", ")", ":", "continue", "if", "line", ".", "lower", "(", ")", ".", "startswith", "(", "ikw", "+", "' :'", ")", "or", "line", ".", "lower", "(", ")", ".", "startswith", "(", "ikw", "+", "':'", ")", ":", "conflist", "=", "[", "]", "# list to put into element configuration", "conflist", ".", "append", "(", "line", ")", "appendflag", "=", "True", "elif", "appendflag", "and", "line_continue_flag", "==", "'&'", ":", "conflist", ".", "append", "(", "line", ")", "line_continue_flag", "=", "line", "[", "-", "1", "]", "if", "line_continue_flag", "!=", "'&'", ":", "appendflag", "=", "False", "conf_str", "=", "''", ".", "join", "(", "conflist", ")", ".", "replace", "(", "'&'", ",", "','", ")", "if", "'line'", "in", "conf_str", ".", "lower", "(", ")", ".", "split", "(", "'='", ")", "[", "0", "]", ":", "# if bl defines lattice", "conf_str", "=", "conf_str", ".", "lower", "(", ")", ".", "replace", "(", "','", ",", "' '", ")", "[", ":", ":", "-", "1", "]", ".", "replace", "(", "'enil'", ",", "'beamline,lattice'", "[", ":", ":", "-", "1", "]", ",", "1", ")", "[", ":", ":", "-", "1", "]", "# avoid the case with bl keyword has 'line'", "except", ":", "conf_str", "=", "''", "# print conf_str", "# split('!epics'): second part is epics control conf", "splitedparts", "=", "conf_str", ".", "split", "(", "'!epics'", ")", "self", ".", "confstr", "=", "splitedparts", "[", "0", "]", "try", ":", "self", ".", "confstr_epics", "=", "splitedparts", "[", "1", "]", ".", "strip", "(", ")", "except", "IndexError", ":", "self", ".", "confstr_epics", "=", "''", "return", "self" ]

[ "Extract", "doc", "snippet", "for", "element", "configuration", ":", "param", "kw", ":", "element", "name", ":", "return", ":", "instance", "itself", "1", "call", "getKwAsDict", "()", "to", "return", "config", "as", "a", "dict", "2", "call", "getKwAsJson", "()", "to", "return", "config", "as", "json", "string", "3", "call", "getKwAsString", "()", "to", "return", "config", "as", "a", "raw", "string" ]

[ "def", "read_data", "(", "header", ",", "fh", "=", "None", ",", "filename", "=", "None", ",", "index_order", "=", "'F'", ")", ":", "if", "index_order", "not", "in", "[", "'F'", ",", "'C'", "]", ":", "raise", "NRRDError", "(", "'Invalid index order'", ")", "# Check that the required fields are in the header", "for", "field", "in", "_NRRD_REQUIRED_FIELDS", ":", "if", "field", "not", "in", "header", ":", "raise", "NRRDError", "(", "'Header is missing required field: \"%s\".'", "%", "field", ")", "if", "header", "[", "'dimension'", "]", "!=", "len", "(", "header", "[", "'sizes'", "]", ")", ":", "raise", "NRRDError", "(", "'Number of elements in sizes does not match dimension. Dimension: %i, len(sizes): %i'", "%", "(", "header", "[", "'dimension'", "]", ",", "len", "(", "header", "[", "'sizes'", "]", ")", ")", ")", "# Determine the data type from the header", "dtype", "=", "_determine_datatype", "(", "header", ")", "# Determine the byte skip, line skip and the data file", "# These all can be written with or without the space according to the NRRD spec, so we check them both", "line_skip", "=", "header", ".", "get", "(", "'lineskip'", ",", "header", ".", "get", "(", "'line skip'", ",", "0", ")", ")", "byte_skip", "=", "header", ".", "get", "(", "'byteskip'", ",", "header", ".", "get", "(", "'byte skip'", ",", "0", ")", ")", "data_filename", "=", "header", ".", "get", "(", "'datafile'", ",", "header", ".", "get", "(", "'data file'", ",", "None", ")", ")", "# If the data file is separate from the header file, then open the data file to read from that instead", "if", "data_filename", "is", "not", "None", ":", "# If the pathname is relative, then append the current directory from the filename", "if", "not", "os", ".", "path", ".", "isabs", "(", "data_filename", ")", ":", "if", "filename", "is", "None", ":", "raise", "NRRDError", "(", "'Filename parameter must be specified when a relative data file path is given'", ")", "data_filename", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "filename", ")", ",", "data_filename", ")", "# Override the fh parameter with the data filename", "# Note that this is opened without a \"with\" block, thus it must be closed manually in all circumstances", "fh", "=", "open", "(", "data_filename", ",", "'rb'", ")", "# Get the total number of data points by multiplying the size of each dimension together", "total_data_points", "=", "header", "[", "'sizes'", "]", ".", "prod", "(", ")", "# Skip the number of lines requested when line_skip >= 0", "# Irrespective of the NRRD file having attached/detached header", "# Lines are skipped before getting to the beginning of the data", "if", "line_skip", ">=", "0", ":", "for", "_", "in", "range", "(", "line_skip", ")", ":", "fh", ".", "readline", "(", ")", "else", ":", "# Must close the file because if the file was opened above from detached filename, there is no \"with\" block to", "# close it for us", "fh", ".", "close", "(", ")", "raise", "NRRDError", "(", "'Invalid lineskip, allowed values are greater than or equal to 0'", ")", "# Skip the requested number of bytes or seek backward, and then parse the data using NumPy", "if", "byte_skip", "<", "-", "1", ":", "# Must close the file because if the file was opened above from detached filename, there is no \"with\" block to", "# close it for us", "fh", ".", "close", "(", ")", "raise", "NRRDError", "(", "'Invalid byteskip, allowed values are greater than or equal to -1'", ")", "elif", "byte_skip", ">=", "0", ":", "fh", ".", "seek", "(", "byte_skip", ",", "os", ".", "SEEK_CUR", ")", "elif", "byte_skip", "==", "-", "1", "and", "header", "[", "'encoding'", "]", "not", "in", "[", "'gzip'", ",", "'gz'", ",", "'bzip2'", ",", "'bz2'", "]", ":", "fh", ".", "seek", "(", "-", "dtype", ".", "itemsize", "*", "total_data_points", ",", "os", ".", "SEEK_END", ")", "else", ":", "# The only case left should be: byte_skip == -1 and header['encoding'] == 'gzip'", "byte_skip", "=", "-", "dtype", ".", "itemsize", "*", "total_data_points", "# If a compression encoding is used, then byte skip AFTER decompressing", "if", "header", "[", "'encoding'", "]", "==", "'raw'", ":", "data", "=", "np", ".", "fromfile", "(", "fh", ",", "dtype", ")", "elif", "header", "[", "'encoding'", "]", "in", "[", "'ASCII'", ",", "'ascii'", ",", "'text'", ",", "'txt'", "]", ":", "data", "=", "np", ".", "fromfile", "(", "fh", ",", "dtype", ",", "sep", "=", "' '", ")", "else", ":", "# Handle compressed data now", "# Construct the decompression object based on encoding", "if", "header", "[", "'encoding'", "]", "in", "[", "'gzip'", ",", "'gz'", "]", ":", "decompobj", "=", "zlib", ".", "decompressobj", "(", "zlib", ".", "MAX_WBITS", "|", "16", ")", "elif", "header", "[", "'encoding'", "]", "in", "[", "'bzip2'", ",", "'bz2'", "]", ":", "decompobj", "=", "bz2", ".", "BZ2Decompressor", "(", ")", "else", ":", "# Must close the file because if the file was opened above from detached filename, there is no \"with\" block", "# to close it for us", "fh", ".", "close", "(", ")", "raise", "NRRDError", "(", "'Unsupported encoding: \"%s\"'", "%", "header", "[", "'encoding'", "]", ")", "# Loop through the file and read a chunk at a time (see _READ_CHUNKSIZE why it is read in chunks)", "decompressed_data", "=", "bytearray", "(", ")", "# Read all of the remaining data from the file", "# Obtain the length of the compressed data since we will be using it repeatedly, more efficient", "compressed_data", "=", "fh", ".", "read", "(", ")", "compressed_data_len", "=", "len", "(", "compressed_data", ")", "start_index", "=", "0", "# Loop through data and decompress it chunk by chunk", "while", "start_index", "<", "compressed_data_len", ":", "# Calculate the end index = start index plus chunk size", "# Set to the string length to read the remaining chunk at the end", "end_index", "=", "min", "(", "start_index", "+", "_READ_CHUNKSIZE", ",", "compressed_data_len", ")", "# Decompress and append data", "decompressed_data", "+=", "decompobj", ".", "decompress", "(", "compressed_data", "[", "start_index", ":", "end_index", "]", ")", "# Update start index", "start_index", "=", "end_index", "# Delete the compressed data since we do not need it anymore", "# This could potentially be using a lot of memory", "del", "compressed_data", "# Byte skip is applied AFTER the decompression. Skip first x bytes of the decompressed data and parse it using", "# NumPy", "data", "=", "np", ".", "frombuffer", "(", "decompressed_data", "[", "byte_skip", ":", "]", ",", "dtype", ")", "# Close the file, even if opened using \"with\" block, closing it manually does not hurt", "fh", ".", "close", "(", ")", "if", "total_data_points", "!=", "data", ".", "size", ":", "raise", "NRRDError", "(", "'Size of the data does not equal the product of all the dimensions: {0}-{1}={2}'", ".", "format", "(", "total_data_points", ",", "data", ".", "size", ",", "total_data_points", "-", "data", ".", "size", ")", ")", "# In the NRRD header, the fields are specified in Fortran order, i.e, the first index is the one that changes", "# fastest and last index changes slowest. This needs to be taken into consideration since numpy uses C-order", "# indexing.", "# The array shape from NRRD (x,y,z) needs to be reversed as numpy expects (z,y,x).", "data", "=", "np", ".", "reshape", "(", "data", ",", "tuple", "(", "header", "[", "'sizes'", "]", "[", ":", ":", "-", "1", "]", ")", ")", "# Transpose data to enable Fortran indexing if requested.", "if", "index_order", "==", "'F'", ":", "data", "=", "data", ".", "T", "return", "data" ]

[ "Read", "data", "from", "file", "into", ":", "class", ":", "numpy", ".", "ndarray" ]