Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Simple", "stamp", "command", "." ]

[ "def", "ExecStamp", "(", "self", ",", "path", ")", ":", "open", "(", "path", ",", "'w'", ")", ".", "close", "(", ")" ]

[ "Mark", "up", "some", "plain", "text", "given", "a", "context", "of", "symbols", "to", "look", "for", ".", "Each", "context", "dictionary", "maps", "object", "names", "to", "anchor", "names", "." ]

[ "def", "markup", "(", "self", ",", "text", ",", "escape", "=", "None", ",", "funcs", "=", "{", "}", ",", "classes", "=", "{", "}", ",", "methods", "=", "{", "}", ")", ":", "escape", "=", "escape", "or", "self", ".", "escape", "results", "=", "[", "]", "here", "=", "0", "# XXX Note that this regular expression does not allow for the", "# hyperlinking of arbitrary strings being used as method", "# names. Only methods with names consisting of word characters", "# and '.'s are hyperlinked.", "pattern", "=", "re", ".", "compile", "(", "r'\\b((http|ftp)://\\S+[\\w/]|'", "r'RFC[- ]?(\\d+)|'", "r'PEP[- ]?(\\d+)|'", "r'(self\\.)?((?:\\w|\\.)+))\\b'", ")", "while", "1", ":", "match", "=", "pattern", ".", "search", "(", "text", ",", "here", ")", "if", "not", "match", ":", "break", "start", ",", "end", "=", "match", ".", "span", "(", ")", "results", ".", "append", "(", "escape", "(", "text", "[", "here", ":", "start", "]", ")", ")", "all", ",", "scheme", ",", "rfc", ",", "pep", ",", "selfdot", ",", "name", "=", "match", ".", "groups", "(", ")", "if", "scheme", ":", "url", "=", "escape", "(", "all", ")", ".", "replace", "(", "'\"'", ",", "'&quot;'", ")", "results", ".", "append", "(", "'<a href=\"%s\">%s</a>'", "%", "(", "url", ",", "url", ")", ")", "elif", "rfc", ":", "url", "=", "'http://www.rfc-editor.org/rfc/rfc%d.txt'", "%", "int", "(", "rfc", ")", "results", ".", "append", "(", "'<a href=\"%s\">%s</a>'", "%", "(", "url", ",", "escape", "(", "all", ")", ")", ")", "elif", "pep", ":", "url", "=", "'http://www.python.org/dev/peps/pep-%04d/'", "%", "int", "(", "pep", ")", "results", ".", "append", "(", "'<a href=\"%s\">%s</a>'", "%", "(", "url", ",", "escape", "(", "all", ")", ")", ")", "elif", "text", "[", "end", ":", "end", "+", "1", "]", "==", "'('", ":", "results", ".", "append", "(", "self", ".", "namelink", "(", "name", ",", "methods", ",", "funcs", ",", "classes", ")", ")", "elif", "selfdot", ":", "results", ".", "append", "(", "'self.<strong>%s</strong>'", "%", "name", ")", "else", ":", "results", ".", "append", "(", "self", ".", "namelink", "(", "name", ",", "classes", ")", ")", "here", "=", "end", "results", ".", "append", "(", "escape", "(", "text", "[", "here", ":", "]", ")", ")", "return", "''", ".", "join", "(", "results", ")" ]

[ "getTestSuite", "(", "item", "litConfig", "cache", ")", "-", ">", "(", "suite", "relative_path", ")" ]

[ "def", "getTestSuite", "(", "item", ",", "litConfig", ",", "cache", ")", ":", "def", "search1", "(", "path", ")", ":", "# Check for a site config or a lit config.", "cfgpath", "=", "dirContainsTestSuite", "(", "path", ",", "litConfig", ")", "# If we didn't find a config file, keep looking.", "if", "not", "cfgpath", ":", "parent", ",", "base", "=", "os", ".", "path", ".", "split", "(", "path", ")", "if", "parent", "==", "path", ":", "return", "(", "None", ",", "(", ")", ")", "ts", ",", "relative", "=", "search", "(", "parent", ")", "return", "(", "ts", ",", "relative", "+", "(", "base", ",", ")", ")", "# We found a test suite, create a new config for it and load it.", "if", "litConfig", ".", "debug", ":", "litConfig", ".", "note", "(", "'loading suite config %r'", "%", "cfgpath", ")", "cfg", "=", "TestingConfig", ".", "fromdefaults", "(", "litConfig", ")", "cfg", ".", "load_from_path", "(", "cfgpath", ",", "litConfig", ")", "source_root", "=", "os", ".", "path", ".", "realpath", "(", "cfg", ".", "test_source_root", "or", "path", ")", "exec_root", "=", "os", ".", "path", ".", "realpath", "(", "cfg", ".", "test_exec_root", "or", "path", ")", "return", "Test", ".", "TestSuite", "(", "cfg", ".", "name", ",", "source_root", ",", "exec_root", ",", "cfg", ")", ",", "(", ")", "def", "search", "(", "path", ")", ":", "# Check for an already instantiated test suite.", "res", "=", "cache", ".", "get", "(", "path", ")", "if", "res", "is", "None", ":", "cache", "[", "path", "]", "=", "res", "=", "search1", "(", "path", ")", "return", "res", "# Canonicalize the path.", "item", "=", "os", ".", "path", ".", "realpath", "(", "item", ")", "# Skip files and virtual components.", "components", "=", "[", "]", "while", "not", "os", ".", "path", ".", "isdir", "(", "item", ")", ":", "parent", ",", "base", "=", "os", ".", "path", ".", "split", "(", "item", ")", "if", "parent", "==", "item", ":", "return", "(", "None", ",", "(", ")", ")", "components", ".", "append", "(", "base", ")", "item", "=", "parent", "components", ".", "reverse", "(", ")", "ts", ",", "relative", "=", "search", "(", "item", ")", "return", "ts", ",", "tuple", "(", "relative", "+", "tuple", "(", "components", ")", ")" ]

[ "Resets", "the", "current", "progress", "to", "the", "start", "point" ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "progress", "=", "self", ".", "_get_progress", "(", "self", ".", "start", ")", "return", "self" ]

[ "__init__", "(", "self", "int", "iconType", "=", "TBI_DEFAULT_TYPE", ")", "-", ">", "TaskBarIcon" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_windows_", ".", "TaskBarIcon_swiginit", "(", "self", ",", "_windows_", ".", "new_TaskBarIcon", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "self", ".", "_setOORInfo", "(", "self", ")", "TaskBarIcon", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "TaskBarIcon", ")" ]

[ "Return", "a", "hash", "object", "for", "the", "current", "state", "." ]

[ "def", "_current", "(", "self", ")", ":", "h", "=", "self", ".", "outer", ".", "copy", "(", ")", "h", ".", "update", "(", "self", ".", "inner", ".", "digest", "(", ")", ")", "return", "h" ]

[ "Pop", "a", "nonterminal", ".", "(", "Internal", ")" ]

[ "def", "pop", "(", "self", ")", ":", "popdfa", ",", "popstate", ",", "popnode", "=", "self", ".", "stack", ".", "pop", "(", ")", "newnode", "=", "self", ".", "convert", "(", "self", ".", "grammar", ",", "popnode", ")", "if", "newnode", "is", "not", "None", ":", "if", "self", ".", "stack", ":", "dfa", ",", "state", ",", "node", "=", "self", ".", "stack", "[", "-", "1", "]", "node", "[", "-", "1", "]", ".", "append", "(", "newnode", ")", "else", ":", "self", ".", "rootnode", "=", "newnode", "self", ".", "rootnode", ".", "used_names", "=", "self", ".", "used_names" ]

[ "r", "GetTypeName", "(", "FieldDefn", "self", ")", "-", ">", "char", "const", "*" ]

[ "def", "GetTypeName", "(", "self", ",", "*", "args", ")", ":", "return", "_ogr", ".", "FieldDefn_GetTypeName", "(", "self", ",", "*", "args", ")" ]

[ "Convert", "tools", "to", "a", "form", "expected", "by", "Visual", "Studio", "." ]

[ "def", "_ConvertToolsToExpectedForm", "(", "tools", ")", ":", "tool_list", "=", "[", "]", "for", "tool", ",", "settings", "in", "tools", ".", "iteritems", "(", ")", ":", "# Collapse settings with lists.", "settings_fixed", "=", "{", "}", "for", "setting", ",", "value", "in", "settings", ".", "iteritems", "(", ")", ":", "if", "type", "(", "value", ")", "==", "list", ":", "if", "(", "(", "tool", "==", "'VCLinkerTool'", "and", "setting", "==", "'AdditionalDependencies'", ")", "or", "setting", "==", "'AdditionalOptions'", ")", ":", "settings_fixed", "[", "setting", "]", "=", "' '", ".", "join", "(", "value", ")", "else", ":", "settings_fixed", "[", "setting", "]", "=", "';'", ".", "join", "(", "value", ")", "else", ":", "settings_fixed", "[", "setting", "]", "=", "value", "# Add in this tool.", "tool_list", ".", "append", "(", "MSVSProject", ".", "Tool", "(", "tool", ",", "settings_fixed", ")", ")", "return", "tool_list" ]

[ "Creates", "an", "Argument", "." ]

[ "def", "CreateArg", "(", "arg_string", ")", ":", "arg_parts", "=", "arg_string", ".", "split", "(", ")", "if", "len", "(", "arg_parts", ")", "==", "1", "and", "arg_parts", "[", "0", "]", "==", "'void'", ":", "return", "None", "# Is this a pointer argument?", "elif", "arg_string", ".", "find", "(", "'*'", ")", ">=", "0", ":", "if", "arg_parts", "[", "0", "]", "==", "'NonImmediate'", ":", "return", "NonImmediatePointerArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "1", ":", "-", "1", "]", ")", ")", "else", ":", "return", "PointerArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "# Is this a resource argument? Must come after pointer check.", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLidBind'", ")", ":", "return", "ResourceIdBindArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLidZero'", ")", ":", "return", "ResourceIdZeroArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLid'", ")", ":", "return", "ResourceIdArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLenum'", ")", "and", "len", "(", "arg_parts", "[", "0", "]", ")", ">", "6", ":", "return", "EnumArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLboolean'", ")", "and", "len", "(", "arg_parts", "[", "0", "]", ")", ">", "9", ":", "return", "ValidatedBoolArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLboolean'", ")", ":", "return", "BoolArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLintUniformLocation'", ")", ":", "return", "UniformLocationArgument", "(", "arg_parts", "[", "-", "1", "]", ")", "elif", "(", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLint'", ")", "and", "len", "(", "arg_parts", "[", "0", "]", ")", ">", "5", "and", "not", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLintptr'", ")", ")", ":", "return", "IntArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "elif", "(", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLsizeiNotNegative'", ")", "or", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLintptrNotNegative'", ")", ")", ":", "return", "SizeNotNegativeArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ",", "arg_parts", "[", "0", "]", "[", "0", ":", "-", "11", "]", ")", "elif", "arg_parts", "[", "0", "]", ".", "startswith", "(", "'GLsize'", ")", ":", "return", "SizeArgument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")", "else", ":", "return", "Argument", "(", "arg_parts", "[", "-", "1", "]", ",", "\" \"", ".", "join", "(", "arg_parts", "[", "0", ":", "-", "1", "]", ")", ")" ]

[ "Read", "header", "lines", "." ]

[ "def", "readheaders", "(", "self", ")", ":", "# XXX The implementation overrides the readheaders() method of", "# rfc822.Message. The base class design isn't amenable to", "# customized behavior here so the method here is a copy of the", "# base class code with a few small changes.", "self", ".", "dict", "=", "{", "}", "self", ".", "unixfrom", "=", "''", "self", ".", "headers", "=", "hlist", "=", "[", "]", "self", ".", "status", "=", "''", "headerseen", "=", "\"\"", "firstline", "=", "1", "startofline", "=", "unread", "=", "tell", "=", "None", "if", "hasattr", "(", "self", ".", "fp", ",", "'unread'", ")", ":", "unread", "=", "self", ".", "fp", ".", "unread", "elif", "self", ".", "seekable", ":", "tell", "=", "self", ".", "fp", ".", "tell", "while", "True", ":", "if", "tell", ":", "try", ":", "startofline", "=", "tell", "(", ")", "except", "IOError", ":", "startofline", "=", "tell", "=", "None", "self", ".", "seekable", "=", "0", "line", "=", "self", ".", "fp", ".", "readline", "(", "_MAXLINE", "+", "1", ")", "if", "len", "(", "line", ")", ">", "_MAXLINE", ":", "raise", "LineTooLong", "(", "\"header line\"", ")", "if", "not", "line", ":", "self", ".", "status", "=", "'EOF in headers'", "break", "# Skip unix From name time lines", "if", "firstline", "and", "line", ".", "startswith", "(", "'From '", ")", ":", "self", ".", "unixfrom", "=", "self", ".", "unixfrom", "+", "line", "continue", "firstline", "=", "0", "if", "headerseen", "and", "line", "[", "0", "]", "in", "' \\t'", ":", "# XXX Not sure if continuation lines are handled properly", "# for http and/or for repeating headers", "# It's a continuation line.", "hlist", ".", "append", "(", "line", ")", "self", ".", "addcontinue", "(", "headerseen", ",", "line", ".", "strip", "(", ")", ")", "continue", "elif", "self", ".", "iscomment", "(", "line", ")", ":", "# It's a comment. Ignore it.", "continue", "elif", "self", ".", "islast", "(", "line", ")", ":", "# Note! No pushback here! The delimiter line gets eaten.", "break", "headerseen", "=", "self", ".", "isheader", "(", "line", ")", "if", "headerseen", ":", "# It's a legal header line, save it.", "hlist", ".", "append", "(", "line", ")", "self", ".", "addheader", "(", "headerseen", ",", "line", "[", "len", "(", "headerseen", ")", "+", "1", ":", "]", ".", "strip", "(", ")", ")", "continue", "else", ":", "# It's not a header line; throw it back and stop here.", "if", "not", "self", ".", "dict", ":", "self", ".", "status", "=", "'No headers'", "else", ":", "self", ".", "status", "=", "'Non-header line where header expected'", "# Try to undo the read.", "if", "unread", ":", "unread", "(", "line", ")", "elif", "tell", ":", "self", ".", "fp", ".", "seek", "(", "startofline", ")", "else", ":", "self", ".", "status", "=", "self", ".", "status", "+", "'; bad seek'", "break" ]

[ "Parse", "an", "ExecSpace", "line", "-", ">", "(", "#nodes", "#cores", "#threads", "/", "core", ")", "." ]

[ "def", "kkt_parse_exespace", "(", "ln", ")", ":", "v", "=", "kkt_parse_exespace_re", "(", "ln", ")", "if", "len", "(", "v", ")", "==", "0", ":", "return", "(", ")", "if", "len", "(", "v", ")", "!=", "3", ":", "print", "'Parse error; ln = '", "+", "ln", "return", "(", ")", "return", "tuple", "(", "[", "int", "(", "i", ")", "for", "i", "in", "v", "]", ")" ]

[ "请求查询客户通知响应" ]

[ "def", "onRspQryNotice", "(", "self", ",", "NoticeField", ",", "RspInfoField", ",", "requestId", ",", "final", ")", ":", "pass" ]

[ "construct", "(", "tuple", ":", "(", "long", "long", "long", "long", ")", "|", "(", "long", "long", "long", "long", "long", ")", "Construct", "a", "qNEW", "object", "from", "a", "4", "-", "or", "5", "-", "tuple", "of", "numbers", "." ]

[ "def", "construct", "(", "tuple", ")", ":", "obj", "=", "qNEWobj", "(", ")", "if", "len", "(", "tuple", ")", "not", "in", "[", "4", ",", "5", "]", ":", "raise", "error", ",", "'argument for construct() wrong length'", "for", "i", "in", "range", "(", "len", "(", "tuple", ")", ")", ":", "field", "=", "obj", ".", "keydata", "[", "i", "]", "setattr", "(", "obj", ",", "field", ",", "tuple", "[", "i", "]", ")", "return", "obj" ]

[ "Check", "if", "file", "is", "in", "free", "format", "Fortran", "." ]

[ "def", "is_free_format", "(", "file", ")", ":", "# f90 allows both fixed and free format, assuming fixed unless", "# signs of free format are detected.", "result", "=", "0", "with", "open", "(", "file", ",", "'r'", ")", "as", "f", ":", "line", "=", "f", ".", "readline", "(", ")", "n", "=", "15", "# the number of non-comment lines to scan for hints", "if", "_has_f_header", "(", "line", ")", ":", "n", "=", "0", "elif", "_has_f90_header", "(", "line", ")", ":", "n", "=", "0", "result", "=", "1", "while", "n", ">", "0", "and", "line", ":", "if", "line", "[", "0", "]", "!=", "'!'", "and", "line", ".", "strip", "(", ")", ":", "n", "-=", "1", "if", "(", "line", "[", "0", "]", "!=", "'\\t'", "and", "_free_f90_start", "(", "line", "[", ":", "5", "]", ")", ")", "or", "line", "[", "-", "2", ":", "-", "1", "]", "==", "'&'", ":", "result", "=", "1", "break", "line", "=", "f", ".", "readline", "(", ")", "return", "result" ]

[ "Returns", "the", "current", "highlighting", "mode", "." ]

[ "def", "GetMode", "(", "self", ")", ":", "return", "self", ".", "_owner", ".", "GetListCtrl", "(", ")", ".", "GetAGWWindowStyleFlag", "(", ")", "&", "ULC_MASK_TYPE" ]

[ "Returns", "predicted", "scores", "for", "given", "features", "." ]

[ "def", "predict_scores", "(", "self", ",", "x", "=", "None", ",", "input_fn", "=", "None", ",", "batch_size", "=", "None", ",", "as_iterable", "=", "True", ")", ":", "key", "=", "prediction_key", ".", "PredictionKey", ".", "SCORES", "preds", "=", "super", "(", "DNNLinearCombinedRegressor", ",", "self", ")", ".", "predict", "(", "x", "=", "x", ",", "input_fn", "=", "input_fn", ",", "batch_size", "=", "batch_size", ",", "outputs", "=", "[", "key", "]", ",", "as_iterable", "=", "as_iterable", ")", "if", "as_iterable", ":", "return", "(", "pred", "[", "key", "]", "for", "pred", "in", "preds", ")", "return", "preds", "[", "key", "]" ]

[ "Unpersists", "graph", "from", "file", "as", "default", "graph", "." ]

[ "def", "load_graph", "(", "filename", ")", ":", "with", "tf", ".", "gfile", ".", "GFile", "(", "filename", ",", "'rb'", ")", "as", "f", ":", "graph_def", "=", "tf", ".", "GraphDef", "(", ")", "graph_def", ".", "ParseFromString", "(", "f", ".", "read", "(", ")", ")", "tf", ".", "import_graph_def", "(", "graph_def", ",", "name", "=", "''", ")" ]

[ ":", "type", "target", ":", "integer", ":", "type", "mountain_arr", ":", "MountainArray", ":", "rtype", ":", "integer" ]

[ "def", "findInMountainArray", "(", "self", ",", "target", ",", "mountain_arr", ")", ":", "def", "binarySearch", "(", "A", ",", "left", ",", "right", ",", "check", ")", ":", "while", "left", "<=", "right", ":", "mid", "=", "left", "+", "(", "right", "-", "left", ")", "//", "2", "if", "check", "(", "mid", ")", ":", "right", "=", "mid", "-", "1", "else", ":", "left", "=", "mid", "+", "1", "return", "left", "peak", "=", "binarySearch", "(", "mountain_arr", ",", "0", ",", "mountain_arr", ".", "length", "(", ")", "-", "1", ",", "lambda", "x", ":", "mountain_arr", ".", "get", "(", "x", ")", ">=", "mountain_arr", ".", "get", "(", "x", "+", "1", ")", ")", "left", "=", "binarySearch", "(", "mountain_arr", ",", "0", ",", "peak", ",", "lambda", "x", ":", "mountain_arr", ".", "get", "(", "x", ")", ">=", "target", ")", "if", "left", "<=", "peak", "and", "mountain_arr", ".", "get", "(", "left", ")", "==", "target", ":", "return", "left", "right", "=", "binarySearch", "(", "mountain_arr", ",", "peak", ",", "mountain_arr", ".", "length", "(", ")", "-", "1", ",", "lambda", "x", ":", "mountain_arr", ".", "get", "(", "x", ")", "<=", "target", ")", "if", "right", "<=", "mountain_arr", ".", "length", "(", ")", "-", "1", "and", "mountain_arr", ".", "get", "(", "right", ")", "==", "target", ":", "return", "right", "return", "-", "1" ]

[ "Format", "this", "node", "for", "dot", "." ]

[ "def", "format", "(", "self", ")", ":", "# TODO: Take indent as a parameter to make output marginally nicer.", "result", "=", "''", "if", "self", ".", "_children", ":", "result", "+=", "' subgraph cluster_{0} {{\\n'", ".", "format", "(", "self", ".", "_nodename", ")", "result", "+=", "' label = \"{0}\"\\n'", ".", "format", "(", "self", ".", "_label", ")", "for", "child", "in", "self", ".", "_children", ":", "result", "+=", "child", ".", "format", "(", ")", "result", "+=", "' }\\n'", "else", ":", "properties", "=", "'label=\"{0}\"'", ".", "format", "(", "self", ".", "_label", ")", "if", "self", ".", "_properties", ":", "properties", "+=", "', '", "+", "self", ".", "_properties", "if", "self", ".", "_style", ":", "properties", "+=", "', style=\"{0}\"'", ".", "format", "(", "self", ".", "_style", ")", "result", "+=", "' {0} [{1}]\\n'", ".", "format", "(", "self", ".", "_nodename", ",", "properties", ")", "return", "result" ]

[]

[ "def", "area", "(", "self", ")", ":", "return", "self", ".", "width", "*", "self", ".", "height" ]

[ "GetTraceData", "(", "SBTrace", "self", "SBError", "error", "void", "*", "buf", "size_t", "offset", "lldb", "::", "tid_t", "thread_id", ")", "-", ">", "size_t" ]

[ "def", "GetTraceData", "(", "self", ",", "error", ",", "buf", ",", "offset", ",", "thread_id", ")", ":", "return", "_lldb", ".", "SBTrace_GetTraceData", "(", "self", ",", "error", ",", "buf", ",", "offset", ",", "thread_id", ")" ]

[ "Hides", "or", "shows", "the", "normalisation", "options", "depending", "on", "if", "TF", "Asymmetry", "fitting", "mode", "is", "on", "or", "off", "." ]

[ "def", "set_tf_asymmetry_mode", "(", "self", ",", "tf_asymmetry_on", ":", "bool", ")", "->", "None", ":", "if", "tf_asymmetry_on", ":", "self", ".", "show_normalisation_options", "(", ")", "else", ":", "self", ".", "hide_normalisation_options", "(", ")" ]

[ "Assert", "x", "has", "a", "rank", "that", "satisfies", "a", "given", "condition", "." ]

[ "def", "_assert_rank_condition", "(", "x", ",", "rank", ",", "static_condition", ",", "dynamic_condition", ",", "data", ",", "summarize", ")", ":", "assert_type", "(", "rank", ",", "dtypes", ".", "int32", ")", "# Attempt to statically defined rank.", "rank_static", "=", "tensor_util", ".", "constant_value", "(", "rank", ")", "if", "rank_static", "is", "not", "None", ":", "if", "rank_static", ".", "ndim", "!=", "0", ":", "raise", "ValueError", "(", "'Rank must be a scalar.'", ")", "x_rank_static", "=", "x", ".", "get_shape", "(", ")", ".", "ndims", "if", "x_rank_static", "is", "not", "None", ":", "if", "not", "static_condition", "(", "x_rank_static", ",", "rank_static", ")", ":", "raise", "ValueError", "(", "'Static rank condition failed'", ",", "x_rank_static", ",", "rank_static", ")", "return", "control_flow_ops", ".", "no_op", "(", "name", "=", "'static_checks_determined_all_ok'", ")", "condition", "=", "dynamic_condition", "(", "array_ops", ".", "rank", "(", "x", ")", ",", "rank", ")", "# Add the condition that `rank` must have rank zero. Prevents the bug where", "# someone does assert_rank(x, [n]), rather than assert_rank(x, n).", "if", "rank_static", "is", "None", ":", "this_data", "=", "[", "'Rank must be a scalar. Received rank: '", ",", "rank", "]", "rank_check", "=", "assert_rank", "(", "rank", ",", "0", ",", "data", "=", "this_data", ")", "condition", "=", "control_flow_ops", ".", "with_dependencies", "(", "[", "rank_check", "]", ",", "condition", ")", "return", "control_flow_ops", ".", "Assert", "(", "condition", ",", "data", ",", "summarize", "=", "summarize", ")" ]

[ "Try", "to", "do", "check", "if", "a", "structure", "is", "always", "considered", "valid", "(", "i", ".", "e", ".", "there", "s", "no", "rules", "to", "its", "acceptance", ")", "." ]

[ "def", "isStructAlwaysValid", "(", "self", ",", "structname", ")", ":", "# A conventions object is required for this call.", "if", "not", "self", ".", "conventions", ":", "raise", "RuntimeError", "(", "\"To use isStructAlwaysValid, be sure your options include a Conventions object.\"", ")", "if", "self", ".", "conventions", ".", "type_always_valid", "(", "structname", ")", ":", "return", "True", "category", "=", "self", ".", "getTypeCategory", "(", "structname", ")", "if", "self", ".", "conventions", ".", "category_requires_validation", "(", "category", ")", ":", "return", "False", "info", "=", "self", ".", "registry", ".", "typedict", ".", "get", "(", "structname", ")", "assert", "(", "info", "is", "not", "None", ")", "members", "=", "info", ".", "getMembers", "(", ")", "for", "member", "in", "members", ":", "member_name", "=", "getElemName", "(", "member", ")", "if", "member_name", "in", "(", "self", ".", "conventions", ".", "structtype_member_name", ",", "self", ".", "conventions", ".", "nextpointer_member_name", ")", ":", "return", "False", "if", "member", ".", "get", "(", "'noautovalidity'", ")", ":", "return", "False", "member_type", "=", "getElemType", "(", "member", ")", "if", "member_type", "in", "(", "'void'", ",", "'char'", ")", "or", "self", ".", "paramIsArray", "(", "member", ")", "or", "self", ".", "paramIsPointer", "(", "member", ")", ":", "return", "False", "if", "self", ".", "conventions", ".", "type_always_valid", "(", "member_type", ")", ":", "continue", "member_category", "=", "self", ".", "getTypeCategory", "(", "member_type", ")", "if", "self", ".", "conventions", ".", "category_requires_validation", "(", "member_category", ")", ":", "return", "False", "if", "member_category", "in", "(", "'struct'", ",", "'union'", ")", ":", "if", "self", ".", "isStructAlwaysValid", "(", "member_type", ")", "is", "False", ":", "return", "False", "return", "True" ]

[ "Add", "the", "synthetically", "generated", "text", "image", "instance", "and", "other", "metadata", "to", "the", "dataset", "." ]

[ "def", "add_res_to_db", "(", "imgname", ",", "res", ",", "db", ")", ":", "ninstance", "=", "len", "(", "res", ")", "for", "i", "in", "xrange", "(", "ninstance", ")", ":", "print", "colorize", "(", "Color", ".", "GREEN", ",", "'added into the db %s '", "%", "res", "[", "i", "]", "[", "'txt'", "]", ")", "dname", "=", "\"%s_%d\"", "%", "(", "imgname", ",", "i", ")", "db", "[", "'data'", "]", ".", "create_dataset", "(", "dname", ",", "data", "=", "res", "[", "i", "]", "[", "'img'", "]", ")", "db", "[", "'data'", "]", "[", "dname", "]", ".", "attrs", "[", "'charBB'", "]", "=", "res", "[", "i", "]", "[", "'charBB'", "]", "db", "[", "'data'", "]", "[", "dname", "]", ".", "attrs", "[", "'wordBB'", "]", "=", "res", "[", "i", "]", "[", "'wordBB'", "]", "print", "'type of res[i][\\'txt\\'] '", ",", "type", "(", "res", "[", "i", "]", "[", "'txt'", "]", ")", "#db['data'][dname].attrs['txt'] = res[i]['txt']", "db", "[", "'data'", "]", "[", "dname", "]", ".", "attrs", ".", "create", "(", "'txt'", ",", "res", "[", "i", "]", "[", "'txt'", "]", ",", "dtype", "=", "h5py", ".", "special_dtype", "(", "vlen", "=", "unicode", ")", ")", "print", "'type of db '", ",", "type", "(", "db", "[", "'data'", "]", "[", "dname", "]", ".", "attrs", "[", "'txt'", "]", ")", "print", "colorize", "(", "Color", ".", "GREEN", ",", "'successfully added'", ")", "print", "res", "[", "i", "]", "[", "'txt'", "]", "print", "res", "[", "i", "]", "[", "'img'", "]", ".", "shape", "print", "'charBB'", ",", "res", "[", "i", "]", "[", "'charBB'", "]", ".", "shape", "print", "'charBB'", ",", "res", "[", "i", "]", "[", "'charBB'", "]", "print", "'wordBB'", ",", "res", "[", "i", "]", "[", "'wordBB'", "]", ".", "shape", "print", "'wordBB'", ",", "res", "[", "i", "]", "[", "'wordBB'", "]", "'''\n img = Image.fromarray(res[i]['img'])\n hsv_img=np.array(rgb2hsv(img))\n print 'hsv_img_shape',hsv_img.shape\n print 'hsv_img',hsv_img\n H=hsv_img[:,:,2]\n print 'H_channel',H.shape,H\n #img = Image.fromarray(db['data'][dname][:])\n '''" ]

[ "Closes", "Skype", "application", "." ]

[ "def", "Shutdown", "(", "self", ")", ":", "self", ".", "_Skype", ".", "_API", ".", "Shutdown", "(", ")" ]

[ "Check", "if", "current", "position", "is", "inside", "template", "argument", "list", "." ]

[ "def", "InTemplateArgumentList", "(", "self", ",", "clean_lines", ",", "linenum", ",", "pos", ")", ":", "while", "linenum", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "# Find the earliest character that might indicate a template argument", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "match", "=", "Match", "(", "r'^[^{};=\\[\\]\\.<>]*(.)'", ",", "line", "[", "pos", ":", "]", ")", "if", "not", "match", ":", "linenum", "+=", "1", "pos", "=", "0", "continue", "token", "=", "match", ".", "group", "(", "1", ")", "pos", "+=", "len", "(", "match", ".", "group", "(", "0", ")", ")", "# These things do not look like template argument list:", "# class Suspect {", "# class Suspect x; }", "if", "token", "in", "(", "'{'", ",", "'}'", ",", "';'", ")", ":", "return", "False", "# These things look like template argument list:", "# template <class Suspect>", "# template <class Suspect = default_value>", "# template <class Suspect[]>", "# template <class Suspect...>", "if", "token", "in", "(", "'>'", ",", "'='", ",", "'['", ",", "']'", ",", "'.'", ")", ":", "return", "True", "# Check if token is an unmatched '<'.", "# If not, move on to the next character.", "if", "token", "!=", "'<'", ":", "pos", "+=", "1", "if", "pos", ">=", "len", "(", "line", ")", ":", "linenum", "+=", "1", "pos", "=", "0", "continue", "# We can't be sure if we just find a single '<', and need to", "# find the matching '>'.", "(", "_", ",", "end_line", ",", "end_pos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", "-", "1", ")", "if", "end_pos", "<", "0", ":", "# Not sure if template argument list or syntax error in file", "return", "False", "linenum", "=", "end_line", "pos", "=", "end_pos", "return", "False" ]

[ "GetFilterIndex", "(", "self", ")", "-", ">", "int" ]

[ "def", "GetFilterIndex", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "GenericDirCtrl_GetFilterIndex", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "validate", "against", "an", "existing", "storable" ]

[ "def", "validate", "(", "self", ",", "other", ")", ":", "if", "other", "is", "None", ":", "return", "return", "True" ]

[ "SetPaperSize", "(", "self", "Size", "size", ")" ]

[ "def", "SetPaperSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PageSetupDialogData_SetPaperSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Get", "all", "the", "message", "s", "header", "fields", "and", "values", "." ]

[ "def", "items", "(", "self", ")", ":", "return", "[", "(", "k", ",", "self", ".", "policy", ".", "header_fetch_parse", "(", "k", ",", "v", ")", ")", "for", "k", ",", "v", "in", "self", ".", "_headers", "]" ]

[ "Load", "the", "search", "pattern", "from", "registry" ]

[ "def", "GetFindString", "(", "self", ")", ":", "return", "wx", ".", "ConfigBase_Get", "(", ")", ".", "Read", "(", "FIND_MATCHPATTERN", ",", "\"\"", ")" ]

[ "Get", "the", "compression", "method", "to", "use", "for", "writing", "." ]

[ "def", "_get_compression", "(", "self", ")", ":", "return", "self", ".", "_compression" ]

[ "Extract", "the", "list", "of", "modified", "paths", "from", "the", "patch", "file", "." ]

[ "def", "extract_paths", "(", "file", ")", ":", "paths", "=", "[", "]", "fp", "=", "open", "(", "file", ")", "for", "line", "in", "fp", ":", "if", "line", "[", ":", "4", "]", "!=", "'+++ '", ":", "continue", "match", "=", "re", ".", "match", "(", "'^([^\\t]+)'", ",", "line", "[", "4", ":", "]", ")", "if", "not", "match", ":", "continue", "paths", ".", "append", "(", "match", ".", "group", "(", "1", ")", ".", "strip", "(", ")", ")", "return", "paths" ]

[ "Report", "an", "error", "to", "the", "handler", "(", "if", "registered", ")", "." ]

[ "def", "_MaybeReportError", "(", "self", ",", "err", ")", ":", "if", "self", ".", "_error_handler", ":", "self", ".", "_error_handler", ".", "HandleError", "(", "err", ")" ]

[ "Perform", "pre", "-", "order", "traversal", "without", "recursive", "function", "calls", "." ]

[ "def", "pre_order", "(", "self", ",", "func", "=", "(", "lambda", "x", ":", "x", ".", "id", ")", ")", ":", "# Do a preorder traversal, caching the result. To avoid having to do", "# recursion, we'll store the previous index we've visited in a vector.", "n", "=", "self", ".", "count", "curNode", "=", "[", "None", "]", "*", "(", "2", "*", "n", ")", "lvisited", "=", "set", "(", ")", "rvisited", "=", "set", "(", ")", "curNode", "[", "0", "]", "=", "self", "k", "=", "0", "preorder", "=", "[", "]", "while", "k", ">=", "0", ":", "nd", "=", "curNode", "[", "k", "]", "ndid", "=", "nd", ".", "id", "if", "nd", ".", "is_leaf", "(", ")", ":", "preorder", ".", "append", "(", "func", "(", "nd", ")", ")", "k", "=", "k", "-", "1", "else", ":", "if", "ndid", "not", "in", "lvisited", ":", "curNode", "[", "k", "+", "1", "]", "=", "nd", ".", "left", "lvisited", ".", "add", "(", "ndid", ")", "k", "=", "k", "+", "1", "elif", "ndid", "not", "in", "rvisited", ":", "curNode", "[", "k", "+", "1", "]", "=", "nd", ".", "right", "rvisited", ".", "add", "(", "ndid", ")", "k", "=", "k", "+", "1", "# If we've visited the left and right of this non-leaf", "# node already, go up in the tree.", "else", ":", "k", "=", "k", "-", "1", "return", "preorder" ]

[ "Get", "a", "file", "descriptor", "for", "select", "()", "if", "available" ]

[ "def", "fileno", "(", "self", ")", ":", "return", "None" ]

[ "Define", "node", "label", "based", "on", "layer", "type", "." ]

[ "def", "get_layer_label", "(", "layer", ",", "rankdir", ")", ":", "if", "rankdir", "in", "(", "'TB'", ",", "'BT'", ")", ":", "# If graph orientation is vertical, horizontal space is free and", "# vertical space is not; separate words with spaces", "separator", "=", "' '", "else", ":", "# If graph orientation is horizontal, vertical space is free and", "# horizontal space is not; separate words with newlines", "separator", "=", "'\\\\n'", "if", "layer", ".", "type", "==", "'Convolution'", "or", "layer", ".", "type", "==", "'Deconvolution'", ":", "# Outer double quotes needed or else colon characters don't parse", "# properly", "node_label", "=", "'\"%s%s(%s)%skernel size: %d%sstride: %d%spad: %d\"'", "%", "(", "layer", ".", "name", ",", "separator", ",", "layer", ".", "type", ",", "separator", ",", "layer", ".", "convolution_param", ".", "kernel_size", "[", "0", "]", "if", "len", "(", "layer", ".", "convolution_param", ".", "kernel_size", ".", "_values", ")", "else", "1", ",", "separator", ",", "layer", ".", "convolution_param", ".", "stride", "[", "0", "]", "if", "len", "(", "layer", ".", "convolution_param", ".", "stride", ".", "_values", ")", "else", "1", ",", "separator", ",", "layer", ".", "convolution_param", ".", "pad", "[", "0", "]", "if", "len", "(", "layer", ".", "convolution_param", ".", "pad", ".", "_values", ")", "else", "0", ")", "elif", "layer", ".", "type", "==", "'Pooling'", ":", "pooling_types_dict", "=", "get_pooling_types_dict", "(", ")", "node_label", "=", "'\"%s%s(%s %s)%skernel size: %d%sstride: %d%spad: %d\"'", "%", "(", "layer", ".", "name", ",", "separator", ",", "pooling_types_dict", "[", "layer", ".", "pooling_param", ".", "pool", "]", ",", "layer", ".", "type", ",", "separator", ",", "layer", ".", "pooling_param", ".", "kernel_size", ",", "separator", ",", "layer", ".", "pooling_param", ".", "stride", ",", "separator", ",", "layer", ".", "pooling_param", ".", "pad", ")", "else", ":", "node_label", "=", "'\"%s%s(%s)\"'", "%", "(", "layer", ".", "name", ",", "separator", ",", "layer", ".", "type", ")", "return", "node_label" ]

[ "Set", "if", "query_item", "will", "be", "enabled", "for", "the", "build", "." ]

[ "def", "set_build_var", "(", "environ_cp", ",", "var_name", ",", "query_item", ",", "option_name", ",", "enabled_by_default", ",", "bazel_config_name", "=", "None", ")", ":", "var", "=", "str", "(", "int", "(", "get_var", "(", "environ_cp", ",", "var_name", ",", "query_item", ",", "enabled_by_default", ")", ")", ")", "environ_cp", "[", "var_name", "]", "=", "var", "if", "var", "==", "'1'", ":", "write_to_bazelrc", "(", "'build:%s --define %s=true'", "%", "(", "bazel_config_name", ",", "option_name", ")", ")", "write_to_bazelrc", "(", "'build --config=%s'", "%", "bazel_config_name", ")", "elif", "bazel_config_name", "is", "not", "None", ":", "# TODO(mikecase): Migrate all users of configure.py to use --config Bazel", "# options and not to set build configs through environment variables.", "write_to_bazelrc", "(", "'build:%s --define %s=true'", "%", "(", "bazel_config_name", ",", "option_name", ")", ")" ]

[ "Compute", "ground", "truth", "facility", "location", "score", "." ]

[ "def", "compute_gt_cluster_score", "(", "pairwise_distances", ",", "labels", ")", ":", "unique_class_ids", "=", "array_ops", ".", "unique", "(", "labels", ")", "[", "0", "]", "num_classes", "=", "array_ops", ".", "size", "(", "unique_class_ids", ")", "iteration", "=", "array_ops", ".", "constant", "(", "0", ")", "gt_cluster_score", "=", "array_ops", ".", "constant", "(", "0.0", ",", "dtype", "=", "dtypes", ".", "float32", ")", "def", "func_cond", "(", "iteration", ",", "gt_cluster_score", ")", ":", "del", "gt_cluster_score", "# Unused argument.", "return", "iteration", "<", "num_classes", "def", "func_body", "(", "iteration", ",", "gt_cluster_score", ")", ":", "\"\"\"Per each cluster, compute the average travel distance.\"\"\"", "mask", "=", "math_ops", ".", "equal", "(", "labels", ",", "unique_class_ids", "[", "iteration", "]", ")", "this_cluster_ids", "=", "array_ops", ".", "where", "(", "mask", ")", "pairwise_distances_subset", "=", "array_ops", ".", "transpose", "(", "array_ops", ".", "gather", "(", "array_ops", ".", "transpose", "(", "array_ops", ".", "gather", "(", "pairwise_distances", ",", "this_cluster_ids", ")", ")", ",", "this_cluster_ids", ")", ")", "this_cluster_score", "=", "-", "1.0", "*", "math_ops", ".", "reduce_min", "(", "math_ops", ".", "reduce_sum", "(", "pairwise_distances_subset", ",", "axis", "=", "0", ")", ")", "return", "iteration", "+", "1", ",", "gt_cluster_score", "+", "this_cluster_score", "_", ",", "gt_cluster_score", "=", "control_flow_ops", ".", "while_loop", "(", "func_cond", ",", "func_body", ",", "[", "iteration", ",", "gt_cluster_score", "]", ")", "return", "gt_cluster_score" ]

[ "Retrieve", "the", "alignment", "of", "the", "record", "." ]

[ "def", "get_align", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_Type_getAlignOf", "(", "self", ")" ]

[ "Builds", "range", "pairs", "from", "the", "given", "values", "of", "the", "number", "of", "entries", "in", "the", "dataset", "and", "number", "of", "partitions", "required", ".", "Each", "range", "contains", "the", "same", "amount", "of", "entries", "except", "for", "those", "cases", "where", "the", "number", "of", "entries", "is", "not", "a", "multiple", "of", "the", "partitions", "." ]

[ "def", "get_balanced_ranges", "(", "nentries", ",", "npartitions", ")", ":", "partition_size", "=", "nentries", "//", "npartitions", "i", "=", "0", "# Iterator", "ranges", "=", "[", "]", "remainder", "=", "nentries", "%", "npartitions", "rangeid", "=", "0", "# Keep track of the current range id", "while", "i", "<", "nentries", ":", "# Start value of current range", "start", "=", "i", "end", "=", "i", "=", "start", "+", "partition_size", "if", "remainder", ":", "# If the modulo value is not", "# exhausted, add '1' to the end", "# of the current range", "end", "=", "i", "=", "end", "+", "1", "remainder", "-=", "1", "ranges", ".", "append", "(", "EmptySourceRange", "(", "rangeid", ",", "start", ",", "end", ")", ")", "rangeid", "+=", "1", "return", "ranges" ]

[ "Initializes", "the", "gcc", "toolset", "for", "the", "given", "version", ".", "If", "necessary", "command", "may", "be", "used", "to", "specify", "where", "the", "compiler", "is", "located", ".", "The", "parameter", "options", "is", "a", "space", "-", "delimited", "list", "of", "options", "each", "one", "specified", "as", "<option", "-", "name", ">", "option", "-", "value", ".", "Valid", "option", "names", "are", ":", "cxxflags", "linkflags", "and", "linker", "-", "type", ".", "Accepted", "linker", "-", "type", "values", "are", "gnu", "darwin", "osf", "hpux", "or", "sun", "and", "the", "default", "value", "will", "be", "selected", "based", "on", "the", "current", "OS", ".", "Example", ":", "using", "gcc", ":", "3", ".", "4", ":", ":", "<cxxflags", ">", "foo", "<linkflags", ">", "bar", "<linker", "-", "type", ">", "sun", ";" ]

[ "def", "init", "(", "version", "=", "None", ",", "command", "=", "None", ",", "options", "=", "None", ")", ":", "options", "=", "to_seq", "(", "options", ")", "command", "=", "to_seq", "(", "command", ")", "# Information about the gcc command...", "# The command.", "command", "=", "to_seq", "(", "common", ".", "get_invocation_command", "(", "'gcc'", ",", "'g++'", ",", "command", ")", ")", "# The root directory of the tool install.", "root", "=", "feature", ".", "get_values", "(", "'<root>'", ",", "options", ")", "root", "=", "root", "[", "0", "]", "if", "root", "else", "''", "# The bin directory where to find the command to execute.", "bin", "=", "None", "# The flavor of compiler.", "flavor", "=", "feature", ".", "get_values", "(", "'<flavor>'", ",", "options", ")", "flavor", "=", "flavor", "[", "0", "]", "if", "flavor", "else", "''", "# Autodetect the root and bin dir if not given.", "if", "command", ":", "if", "not", "bin", ":", "bin", "=", "common", ".", "get_absolute_tool_path", "(", "command", "[", "-", "1", "]", ")", "if", "not", "root", ":", "root", "=", "os", ".", "path", ".", "dirname", "(", "bin", ")", "# Autodetect the version and flavor if not given.", "if", "command", ":", "machine_info", "=", "subprocess", ".", "Popen", "(", "command", "+", "[", "'-dumpmachine'", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", ".", "communicate", "(", ")", "[", "0", "]", "machine", "=", "__machine_match", ".", "search", "(", "machine_info", ")", ".", "group", "(", "1", ")", "version_info", "=", "subprocess", ".", "Popen", "(", "command", "+", "[", "'-dumpversion'", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", ".", "communicate", "(", ")", "[", "0", "]", "version", "=", "__version_match", ".", "search", "(", "version_info", ")", ".", "group", "(", "1", ")", "if", "not", "flavor", "and", "machine", ".", "find", "(", "'mingw'", ")", "!=", "-", "1", ":", "flavor", "=", "'mingw'", "condition", "=", "None", "if", "flavor", ":", "condition", "=", "common", ".", "check_init_parameters", "(", "'gcc'", ",", "None", ",", "(", "'version'", ",", "version", ")", ",", "(", "'flavor'", ",", "flavor", ")", ")", "else", ":", "condition", "=", "common", ".", "check_init_parameters", "(", "'gcc'", ",", "None", ",", "(", "'version'", ",", "version", ")", ")", "if", "command", ":", "command", "=", "command", "[", "0", "]", "common", ".", "handle_options", "(", "'gcc'", ",", "condition", ",", "command", ",", "options", ")", "linker", "=", "feature", ".", "get_values", "(", "'<linker-type>'", ",", "options", ")", "if", "not", "linker", ":", "if", "os_name", "(", ")", "==", "'OSF'", ":", "linker", "=", "'osf'", "elif", "os_name", "(", ")", "==", "'HPUX'", ":", "linker", "=", "'hpux'", "else", ":", "linker", "=", "'gnu'", "init_link_flags", "(", "'gcc'", ",", "linker", ",", "condition", ")", "# If gcc is installed in non-standard location, we'd need to add", "# LD_LIBRARY_PATH when running programs created with it (for unit-test/run", "# rules).", "if", "command", ":", "# On multilib 64-bit boxes, there are both 32-bit and 64-bit libraries", "# and all must be added to LD_LIBRARY_PATH. The linker will pick the", "# right ones. Note that we don't provide a clean way to build 32-bit", "# binary with 64-bit compiler, but user can always pass -m32 manually.", "lib_path", "=", "[", "os", ".", "path", ".", "join", "(", "root", ",", "'bin'", ")", ",", "os", ".", "path", ".", "join", "(", "root", ",", "'lib'", ")", ",", "os", ".", "path", ".", "join", "(", "root", ",", "'lib32'", ")", ",", "os", ".", "path", ".", "join", "(", "root", ",", "'lib64'", ")", "]", "if", "debug", "(", ")", ":", "print", "'notice: using gcc libraries ::'", ",", "condition", ",", "'::'", ",", "lib_path", "toolset", ".", "flags", "(", "'gcc.link'", ",", "'RUN_PATH'", ",", "condition", ",", "lib_path", ")", "# If it's not a system gcc install we should adjust the various programs as", "# needed to prefer using the install specific versions. This is essential", "# for correct use of MinGW and for cross-compiling.", "# - The archive builder.", "archiver", "=", "common", ".", "get_invocation_command", "(", "'gcc'", ",", "'ar'", ",", "feature", ".", "get_values", "(", "'<archiver>'", ",", "options", ")", ",", "[", "bin", "]", ",", "path_last", "=", "True", ")", "toolset", ".", "flags", "(", "'gcc.archive'", ",", "'.AR'", ",", "condition", ",", "[", "archiver", "]", ")", "if", "debug", "(", ")", ":", "print", "'notice: using gcc archiver ::'", ",", "condition", ",", "'::'", ",", "archiver", "# - Ranlib", "ranlib", "=", "common", ".", "get_invocation_command", "(", "'gcc'", ",", "'ranlib'", ",", "feature", ".", "get_values", "(", "'<ranlib>'", ",", "options", ")", ",", "[", "bin", "]", ",", "path_last", "=", "True", ")", "toolset", ".", "flags", "(", "'gcc.archive'", ",", "'.RANLIB'", ",", "condition", ",", "[", "ranlib", "]", ")", "if", "debug", "(", ")", ":", "print", "'notice: using gcc archiver ::'", ",", "condition", ",", "'::'", ",", "ranlib", "# - The resource compiler.", "rc_command", "=", "common", ".", "get_invocation_command_nodefault", "(", "'gcc'", ",", "'windres'", ",", "feature", ".", "get_values", "(", "'<rc>'", ",", "options", ")", ",", "[", "bin", "]", ",", "path_last", "=", "True", ")", "rc_type", "=", "feature", ".", "get_values", "(", "'<rc-type>'", ",", "options", ")", "if", "not", "rc_type", ":", "rc_type", "=", "'windres'", "if", "not", "rc_command", ":", "# If we can't find an RC compiler we fallback to a null RC compiler that", "# creates empty object files. This allows the same Jamfiles to work", "# across the board. The null RC uses the assembler to create the empty", "# objects, so configure that.", "rc_command", "=", "common", ".", "get_invocation_command", "(", "'gcc'", ",", "'as'", ",", "[", "]", ",", "[", "bin", "]", ",", "path_last", "=", "True", ")", "rc_type", "=", "'null'", "rc", ".", "configure", "(", "[", "rc_command", "]", ",", "condition", ",", "[", "'<rc-type>'", "+", "rc_type", "]", ")" ]

[ "Returns", "the", "number", "of", "lines", "represented", "." ]

[ "def", "NumLines", "(", "self", ")", ":", "return", "self", ".", "num_lines" ]

[ "Instruments", "class", "files", "from", "input", "jar", "." ]

[ "def", "_InstrumentClassFiles", "(", "instrument_cmd", ",", "input_path", ",", "output_path", ",", "temp_dir", ",", "affected_source_files", "=", "None", ")", ":", "affected_classes", "=", "None", "unaffected_members", "=", "None", "if", "affected_source_files", ":", "affected_classes", ",", "unaffected_members", "=", "_GetAffectedClasses", "(", "input_path", ",", "affected_source_files", ")", "# Extract affected class files.", "with", "zipfile", ".", "ZipFile", "(", "input_path", ")", "as", "f", ":", "f", ".", "extractall", "(", "temp_dir", ",", "affected_classes", ")", "instrumented_dir", "=", "os", ".", "path", ".", "join", "(", "temp_dir", ",", "'instrumented'", ")", "# Instrument extracted class files.", "instrument_cmd", ".", "extend", "(", "[", "temp_dir", ",", "'--dest'", ",", "instrumented_dir", "]", ")", "build_utils", ".", "CheckOutput", "(", "instrument_cmd", ")", "if", "affected_source_files", "and", "unaffected_members", ":", "# Extract unaffected members to instrumented_dir.", "with", "zipfile", ".", "ZipFile", "(", "input_path", ")", "as", "f", ":", "f", ".", "extractall", "(", "instrumented_dir", ",", "unaffected_members", ")", "# Zip all files to output_path", "build_utils", ".", "ZipDir", "(", "output_path", ",", "instrumented_dir", ")" ]

[ "Returns", "the", "class", "name", "and", "config", "for", "a", "serialized", "keras", "object", "." ]

[ "def", "_class_and_config_for_serialized_keras_object", "(", "config", ",", "module_objects", "=", "None", ",", "custom_objects", "=", "None", ",", "printable_module_name", "=", "'object'", ")", ":", "if", "(", "not", "isinstance", "(", "config", ",", "dict", ")", "or", "'class_name'", "not", "in", "config", "or", "'config'", "not", "in", "config", ")", ":", "raise", "ValueError", "(", "'Improper config format: '", "+", "str", "(", "config", ")", ")", "class_name", "=", "config", "[", "'class_name'", "]", "cls", "=", "_get_registered_object", "(", "class_name", ",", "custom_objects", "=", "custom_objects", ",", "module_objects", "=", "module_objects", ")", "if", "cls", "is", "None", ":", "raise", "ValueError", "(", "'Unknown '", "+", "printable_module_name", "+", "': '", "+", "class_name", ")", "cls_config", "=", "config", "[", "'config'", "]", "deserialized_objects", "=", "{", "}", "for", "key", ",", "item", "in", "cls_config", ".", "items", "(", ")", ":", "if", "isinstance", "(", "item", ",", "dict", ")", "and", "'__passive_serialization__'", "in", "item", ":", "deserialized_objects", "[", "key", "]", "=", "_deserialize_keras_object", "(", "item", ",", "module_objects", "=", "module_objects", ",", "custom_objects", "=", "custom_objects", ",", "printable_module_name", "=", "'config_item'", ")", "elif", "(", "isinstance", "(", "item", ",", "six", ".", "string_types", ")", "and", "tf_inspect", ".", "isfunction", "(", "_get_registered_object", "(", "item", ",", "custom_objects", ")", ")", ")", ":", "# Handle custom functions here. When saving functions, we only save the", "# function's name as a string. If we find a matching string in the custom", "# objects during deserialization, we convert the string back to the", "# original function.", "# Note that a potential issue is that a string field could have a naming", "# conflict with a custom function name, but this should be a rare case.", "# This issue does not occur if a string field has a naming conflict with", "# a custom object, since the config of an object will always be a dict.", "deserialized_objects", "[", "key", "]", "=", "_get_registered_object", "(", "item", ",", "custom_objects", ")", "for", "key", ",", "item", "in", "deserialized_objects", ".", "items", "(", ")", ":", "cls_config", "[", "key", "]", "=", "deserialized_objects", "[", "key", "]", "return", "(", "cls", ",", "cls_config", ")" ]

[ "Checks", "if", "a", "given", "target", "is", "an", "undeclared", "parameter", "." ]

[ "def", "parameter_is_undeclared", "(", "self", ",", "target", ")", ":", "if", "not", "self", ".", "_param_def_block", ":", "return", "False", "return", "target", "in", "self", ".", "_param_def_block", "[", "-", "1", "]" ]

[ "sets", "style", "and", "color", "of", "the", "theme", "Args", ":", "style", ":", "(", "light", ")", "color", ":", "RGB", "tuple" ]

[ "def", "set", "(", "self", ",", "style", "=", "\"light\"", ",", "color", "=", "(", "0", ",", "0", ",", "1", ")", ")", ":", "if", "not", "have_mpl", ":", "raise", "MissingDependencyError", "(", "\"matplotlib\"", ")", "optionsStyle", "=", "[", "\"light\"", ",", "\"system\"", "]", "if", "style", "not", "in", "optionsStyle", ":", "raise", "ValueError", "(", "\"possible style options: \"", "+", "str", "(", "optionsStyle", ")", ")", "if", "len", "(", "color", ")", "!=", "3", ":", "raise", "ValueError", "(", "\"(r,g,b) tuple required\"", ")", "if", "style", "==", "\"system\"", ":", "self", ".", "__rcParams", "=", "mpl", ".", "rcParams", "raise", "ValueError", "(", "\"not implemented, yet\"", ")", "if", "style", "==", "\"light\"", ":", "self", ".", "__defaultColor", "=", "(", "0", ",", "0", ",", "0", ")", "self", ".", "__defaultWidth", "=", "1", "self", ".", "__backgroundColor", "=", "(", "1", ",", "1", ",", "1", ")", "self", ".", "__plotColor", "=", "Theme", ".", "RGBA2RGB", "(", "color", ",", "0.6", ",", "self", ".", "__backgroundColor", ")", "self", ".", "__plotWidth", "=", "3", "self", ".", "__faceColor", "=", "(", "color", "[", "0", "]", ",", "color", "[", "1", "]", ",", "color", "[", "2", "]", ",", "0.2", ")", "self", ".", "__faceColorGray", "=", "\"lightgray\"", "self", ".", "__edgeColor", "=", "(", "color", "[", "0", "]", ",", "color", "[", "1", "]", ",", "color", "[", "2", "]", ",", "0.6", ")", "self", ".", "__edgeColorGray", "=", "(", "0", ",", "0", ",", "0", ")", "self", ".", "__edgeWidth", "=", "1", "self", ".", "__gridColor", "=", "\"lightgray\"", "self", ".", "__fontColor", "=", "(", "0", ",", "0", ",", "0", ")", "self", ".", "__fontSize", "=", "10", "self", ".", "__color", "=", "color", "self", ".", "__style", "=", "style" ]

[ "Called", "for", "strings", "and", "template", "data", "to", "normlize", "it", "to", "unicode", "." ]

[ "def", "_normalize_newlines", "(", "self", ",", "value", ")", ":", "return", "newline_re", ".", "sub", "(", "self", ".", "newline_sequence", ",", "value", ")" ]

[ "The", "parser", "is", "responsible", "for", "turning", "tokens", "into", "Real", "TextObjects" ]

[ "def", "__init__", "(", "self", ",", "parent_to", ",", "text", ",", "indent", ")", ":", "self", ".", "_indent", "=", "indent", "self", ".", "_parent_to", "=", "parent_to", "self", ".", "_text", "=", "text" ]

[ "FIR", "lowpass", "filter", "length", "estimator", "." ]

[ "def", "lporder", "(", "freq1", ",", "freq2", ",", "delta_p", ",", "delta_s", ")", ":", "df", "=", "abs", "(", "freq2", "-", "freq1", ")", "ddp", "=", "math", ".", "log10", "(", "delta_p", ")", "dds", "=", "math", ".", "log10", "(", "delta_s", ")", "a1", "=", "5.309e-3", "a2", "=", "7.114e-2", "a3", "=", "-", "4.761e-1", "a4", "=", "-", "2.66e-3", "a5", "=", "-", "5.941e-1", "a6", "=", "-", "4.278e-1", "b1", "=", "11.01217", "b2", "=", "0.5124401", "t1", "=", "a1", "*", "ddp", "*", "ddp", "t2", "=", "a2", "*", "ddp", "t3", "=", "a4", "*", "ddp", "*", "ddp", "t4", "=", "a5", "*", "ddp", "dinf", "=", "(", "(", "t1", "+", "t2", "+", "a3", ")", "*", "dds", ")", "+", "(", "t3", "+", "t4", "+", "a6", ")", "ff", "=", "b1", "+", "b2", "*", "(", "ddp", "-", "dds", ")", "n", "=", "dinf", "/", "df", "-", "ff", "*", "df", "+", "1", "return", "n" ]

[ "!", "Write", "given", "text", "to", "buffer", "." ]

[ "def", "write", "(", "self", ",", "text", ",", "editable", "=", "False", ")", ":", "GObject", ".", "idle_add", "(", "self", ".", "_write", ",", "text", ",", "editable", ")" ]

[ "SetDataFormat", "(", "self", "wxDataFormat", "format", ")" ]

[ "def", "SetDataFormat", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewEvent_SetDataFormat", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Read", "and", "return", "a", "line", "from", "the", "stream", "." ]

[ "def", "readline", "(", "self", ",", "limit", "=", "-", "1", ")", ":", "if", "not", "self", ".", "_universal", "and", "limit", "<", "0", ":", "# Shortcut common case - newline found in buffer.", "i", "=", "self", ".", "_readbuffer", ".", "find", "(", "'\\n'", ",", "self", ".", "_offset", ")", "+", "1", "if", "i", ">", "0", ":", "line", "=", "self", ".", "_readbuffer", "[", "self", ".", "_offset", ":", "i", "]", "self", ".", "_offset", "=", "i", "return", "line", "if", "not", "self", ".", "_universal", ":", "return", "io", ".", "BufferedIOBase", ".", "readline", "(", "self", ",", "limit", ")", "line", "=", "''", "while", "limit", "<", "0", "or", "len", "(", "line", ")", "<", "limit", ":", "readahead", "=", "self", ".", "peek", "(", "2", ")", "if", "readahead", "==", "''", ":", "return", "line", "#", "# Search for universal newlines or line chunks.", "#", "# The pattern returns either a line chunk or a newline, but not", "# both. Combined with peek(2), we are assured that the sequence", "# '\\r\\n' is always retrieved completely and never split into", "# separate newlines - '\\r', '\\n' due to coincidental readaheads.", "#", "match", "=", "self", ".", "PATTERN", ".", "search", "(", "readahead", ")", "newline", "=", "match", ".", "group", "(", "'newline'", ")", "if", "newline", "is", "not", "None", ":", "if", "self", ".", "newlines", "is", "None", ":", "self", ".", "newlines", "=", "[", "]", "if", "newline", "not", "in", "self", ".", "newlines", ":", "self", ".", "newlines", ".", "append", "(", "newline", ")", "self", ".", "_offset", "+=", "len", "(", "newline", ")", "return", "line", "+", "'\\n'", "chunk", "=", "match", ".", "group", "(", "'chunk'", ")", "if", "limit", ">=", "0", ":", "chunk", "=", "chunk", "[", ":", "limit", "-", "len", "(", "line", ")", "]", "self", ".", "_offset", "+=", "len", "(", "chunk", ")", "line", "+=", "chunk", "return", "line" ]

[ "Filters", "a", "sequence", "of", "objects", "by", "applying", "a", "test", "to", "the", "specified", "attribute", "of", "each", "object", "and", "only", "selecting", "the", "objects", "with", "the", "test", "succeeding", "." ]

[ "def", "do_selectattr", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "select_or_reject", "(", "args", ",", "kwargs", ",", "lambda", "x", ":", "x", ",", "True", ")" ]

[ "Computes", "the", "element", "wise", "maximum", "of", "two", "tensors", "." ]

[ "def", "tensor_max", "(", "t1", ",", "t2", ",", "out_format", ",", "dtype", "=", "None", ")", ":", "return", "_compute_bin_elt_wise_op", "(", "_cm", ".", "max", ",", "t1", ",", "t2", ",", "out_format", ",", "dtype", ")" ]

[ "Merge", "all", "replacement", "files", "in", "a", "directory", "into", "a", "single", "file" ]

[ "def", "merge_replacement_files", "(", "tmpdir", ",", "mergefile", ")", ":", "# The fixes suggested by clang-tidy >= 4.0.0 are given under", "# the top level key 'Diagnostics' in the output yaml files", "mergekey", "=", "\"Diagnostics\"", "merged", "=", "[", "]", "for", "replacefile", "in", "glob", ".", "iglob", "(", "os", ".", "path", ".", "join", "(", "tmpdir", ",", "'*.yaml'", ")", ")", ":", "content", "=", "yaml", ".", "safe_load", "(", "open", "(", "replacefile", ",", "'r'", ")", ")", "if", "not", "content", ":", "continue", "# Skip empty files.", "merged", ".", "extend", "(", "content", ".", "get", "(", "mergekey", ",", "[", "]", ")", ")", "if", "merged", ":", "# MainSourceFile: The key is required by the definition inside", "# include/clang/Tooling/ReplacementsYaml.h, but the value", "# is actually never used inside clang-apply-replacements,", "# so we set it to '' here.", "output", "=", "{", "'MainSourceFile'", ":", "''", ",", "mergekey", ":", "merged", "}", "with", "open", "(", "mergefile", ",", "'w'", ")", "as", "out", ":", "yaml", ".", "safe_dump", "(", "output", ",", "out", ")", "else", ":", "# Empty the file:", "open", "(", "mergefile", ",", "'w'", ")", ".", "close", "(", ")" ]

[ "Returns", "boolean", "which", "tells", "if", "given", "label", "is", "COCO", "label", "." ]

[ "def", "is_coco_label", "(", "label", ")", ":", "return", "label", "in", "COCO_CLASSES_SET" ]

[ "For", "definition", "and", "repetition", "levels" ]

[ "def", "read_data", "(", "fobj", ",", "coding", ",", "count", ",", "bit_width", ")", ":", "out", "=", "np", ".", "empty", "(", "count", ",", "dtype", "=", "np", ".", "int32", ")", "o", "=", "encoding", ".", "Numpy32", "(", "out", ")", "if", "coding", "==", "parquet_thrift", ".", "Encoding", ".", "RLE", ":", "while", "o", ".", "loc", "<", "count", ":", "encoding", ".", "read_rle_bit_packed_hybrid", "(", "fobj", ",", "bit_width", ",", "o", "=", "o", ")", "else", ":", "raise", "NotImplementedError", "(", "'Encoding %s'", "%", "coding", ")", "return", "out" ]

[ "Ask", "for", "a", "filename", "to", "save", "as" ]

[ "def", "asksaveasfilename", "(", "*", "*", "options", ")", ":", "return", "SaveAs", "(", "*", "*", "options", ")", ".", "show", "(", ")" ]

[ "Returns", "the", "number", "of", "elements", "." ]

[ "def", "__len__", "(", "self", ")", ":", "return", "len", "(", "self", ".", "GetData", "(", ")", ")" ]

[ "Takes", "a", "dense", "numpy", "array", "or", "a", "sparse", "matrix", "or", "a", "function", "and", "makes", "an", "operator", "performing", "matrix", "*", "blockvector", "products", "." ]

[ "def", "_makeOperator", "(", "operatorInput", ",", "expectedShape", ")", ":", "if", "operatorInput", "is", "None", ":", "def", "ident", "(", "x", ")", ":", "return", "x", "operator", "=", "LinearOperator", "(", "expectedShape", ",", "ident", ",", "matmat", "=", "ident", ")", "else", ":", "operator", "=", "aslinearoperator", "(", "operatorInput", ")", "if", "operator", ".", "shape", "!=", "expectedShape", ":", "raise", "ValueError", "(", "'operator has invalid shape'", ")", "return", "operator" ]

[ "Execute", "one", "step", "of", "the", "coroutine", "until", "the", "next", "yield", "or", "freeze", "." ]

[ "def", "step", "(", "self", ")", ":", "if", "self", ".", "done", ":", "raise", "CoroutineDone", "(", ")", "if", "self", ".", "frozen", ":", "raise", "CoroutineFrozen", "(", ")", "self", ".", "__started", "=", "True", "self", ".", "__coro", ".", "parent", "=", "greenlet", ".", "getcurrent", "(", ")", "prev", "=", "Coroutine", ".", "__current", "try", ":", "Coroutine", ".", "__current", "=", "self", "self", ".", "__coro", ".", "switch", "(", ")", "except", "Terminate", ":", "assert", "not", "self", ".", "__coro", "self", ".", "__done_set", "(", ")", "except", "Exception", "as", "e", ":", "self", ".", "__done_set", "(", "e", ")", "self", ".", "__traceback", "=", "e", ".", "__traceback__", ".", "tb_next", "raise", "else", ":", "if", "not", "self", ".", "__coro", ":", "self", ".", "__done_set", "(", ")", "finally", ":", "Coroutine", ".", "__current", "=", "prev" ]

[ "Returns", "the", "single", "namespace", "bound", "to", "this", "name", "." ]

[ "def", "get_namespace", "(", "self", ")", ":", "if", "len", "(", "self", ".", "__namespaces", ")", "!=", "1", ":", "raise", "ValueError", ",", "\"name is bound to multiple namespaces\"", "return", "self", ".", "__namespaces", "[", "0", "]" ]

[ "Add", "dist", "if", "we", "can_add", "()", "it", "and", "it", "has", "not", "already", "been", "added" ]

[ "def", "add", "(", "self", ",", "dist", ")", ":", "if", "self", ".", "can_add", "(", "dist", ")", "and", "dist", ".", "has_version", "(", ")", ":", "dists", "=", "self", ".", "_distmap", ".", "setdefault", "(", "dist", ".", "key", ",", "[", "]", ")", "if", "dist", "not", "in", "dists", ":", "dists", ".", "append", "(", "dist", ")", "dists", ".", "sort", "(", "key", "=", "operator", ".", "attrgetter", "(", "'hashcmp'", ")", ",", "reverse", "=", "True", ")" ]

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

[ "def", "Voicemail", "(", "self", ",", "Id", ")", ":", "o", "=", "IVoicemail", "(", "Id", ",", "self", ")", "o", ".", "Type", "return", "o" ]

[ "Causes", "the", "PreProcessor", "object", "to", "stop", "processing", "#import", "#include", "and", "#include_next", "lines", "." ]

[ "def", "stop_handling_includes", "(", "self", ",", "t", "=", "None", ")", ":", "d", "=", "self", ".", "dispatch_table", "d", "[", "'import'", "]", "=", "self", ".", "do_nothing", "d", "[", "'include'", "]", "=", "self", ".", "do_nothing", "d", "[", "'include_next'", "]", "=", "self", ".", "do_nothing", "d", "[", "'define'", "]", "=", "self", ".", "do_nothing", "d", "[", "'undef'", "]", "=", "self", ".", "do_nothing" ]

[ "SetRGB", "(", "self", "int", "x", "int", "y", "byte", "r", "byte", "g", "byte", "b", ")" ]

[ "def", "SetRGB", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "Image_SetRGB", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parse", "a", "sectioned", "setup", "file", "." ]

[ "def", "_read", "(", "self", ",", "fp", ",", "fpname", ")", ":", "cursect", "=", "None", "# None, or a dictionary", "optname", "=", "None", "lineno", "=", "0", "e", "=", "None", "# None, or an exception", "while", "True", ":", "line", "=", "fp", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "lineno", "=", "lineno", "+", "1", "# comment or blank line?", "if", "line", ".", "strip", "(", ")", "==", "''", "or", "line", "[", "0", "]", "in", "'#;'", ":", "continue", "if", "line", ".", "split", "(", "None", ",", "1", ")", "[", "0", "]", ".", "lower", "(", ")", "==", "'rem'", "and", "line", "[", "0", "]", "in", "\"rR\"", ":", "# no leading whitespace", "continue", "# continuation line?", "if", "line", "[", "0", "]", ".", "isspace", "(", ")", "and", "cursect", "is", "not", "None", "and", "optname", ":", "value", "=", "line", ".", "strip", "(", ")", "if", "value", ":", "cursect", "[", "optname", "]", ".", "append", "(", "value", ")", "# a section header or option header?", "else", ":", "# is it a section header?", "mo", "=", "self", ".", "SECTCRE", ".", "match", "(", "line", ")", "if", "mo", ":", "sectname", "=", "mo", ".", "group", "(", "'header'", ")", "if", "sectname", "in", "self", ".", "_sections", ":", "cursect", "=", "self", ".", "_sections", "[", "sectname", "]", "elif", "sectname", "==", "DEFAULTSECT", ":", "cursect", "=", "self", ".", "_defaults", "else", ":", "cursect", "=", "self", ".", "_dict", "(", ")", "cursect", "[", "'__name__'", "]", "=", "sectname", "self", ".", "_sections", "[", "sectname", "]", "=", "cursect", "# So sections can't start with a continuation line", "optname", "=", "None", "# no section header in the file?", "elif", "cursect", "is", "None", ":", "raise", "MissingSectionHeaderError", "(", "fpname", ",", "lineno", ",", "line", ")", "# an option line?", "else", ":", "mo", "=", "self", ".", "_optcre", ".", "match", "(", "line", ")", "if", "mo", ":", "optname", ",", "vi", ",", "optval", "=", "mo", ".", "group", "(", "'option'", ",", "'vi'", ",", "'value'", ")", "optname", "=", "self", ".", "optionxform", "(", "optname", ".", "rstrip", "(", ")", ")", "# This check is fine because the OPTCRE cannot", "# match if it would set optval to None", "if", "optval", "is", "not", "None", ":", "if", "vi", "in", "(", "'='", ",", "':'", ")", "and", "';'", "in", "optval", ":", "# ';' is a comment delimiter only if it follows", "# a spacing character", "pos", "=", "optval", ".", "find", "(", "';'", ")", "if", "pos", "!=", "-", "1", "and", "optval", "[", "pos", "-", "1", "]", ".", "isspace", "(", ")", ":", "optval", "=", "optval", "[", ":", "pos", "]", "optval", "=", "optval", ".", "strip", "(", ")", "# allow empty values", "if", "optval", "==", "'\"\"'", ":", "optval", "=", "''", "cursect", "[", "optname", "]", "=", "[", "optval", "]", "else", ":", "# valueless option handling", "cursect", "[", "optname", "]", "=", "optval", "else", ":", "# a non-fatal parsing error occurred. set up the", "# exception but keep going. the exception will be", "# raised at the end of the file and will contain a", "# list of all bogus lines", "if", "not", "e", ":", "e", "=", "ParsingError", "(", "fpname", ")", "e", ".", "append", "(", "lineno", ",", "repr", "(", "line", ")", ")", "# if any parsing errors occurred, raise an exception", "if", "e", ":", "raise", "e", "# join the multi-line values collected while reading", "all_sections", "=", "[", "self", ".", "_defaults", "]", "all_sections", ".", "extend", "(", "self", ".", "_sections", ".", "values", "(", ")", ")", "for", "options", "in", "all_sections", ":", "for", "name", ",", "val", "in", "options", ".", "items", "(", ")", ":", "if", "isinstance", "(", "val", ",", "list", ")", ":", "options", "[", "name", "]", "=", "'\\n'", ".", "join", "(", "val", ")" ]

[ "Mark", "this", "as", "present", "in", "the", "parent", "." ]

[ "def", "SetInParent", "(", "self", ")", ":", "raise", "NotImplementedError" ]

[ "Only", "get", "the", "attachment", "position", "at", "the", "_edge_", "of", "the", "shape", "ignoring", "branching", "mode", ".", "This", "is", "used", "e", ".", "g", ".", "to", "indicate", "the", "edge", "of", "interest", "not", "the", "point", "on", "the", "attachment", "branch", "." ]

[ "def", "GetAttachmentPositionEdge", "(", "self", ",", "attachment", ",", "nth", "=", "0", ",", "no_arcs", "=", "1", ",", "line", "=", "None", ")", ":", "oldMode", "=", "self", ".", "_attachmentMode", "# Calculate as if to edge, not branch", "if", "self", ".", "_attachmentMode", "==", "ATTACHMENT_MODE_BRANCHING", ":", "self", ".", "_attachmentMode", "=", "ATTACHMENT_MODE_EDGE", "res", "=", "self", ".", "GetAttachmentPosition", "(", "attachment", ",", "nth", ",", "no_arcs", ",", "line", ")", "self", ".", "_attachmentMode", "=", "oldMode", "return", "res" ]

[ "The", "filtered", "global", "position", "(", "e", ".", "g", ".", "fused", "GPS", "and", "accelerometers", ")", ".", "The", "position", "is", "in", "GPS", "-", "frame", "(", "right", "-", "handed", "Z", "-", "up", ")", ".", "It", "is", "designed", "as", "scaled", "integer", "message", "since", "the", "resolution", "of", "float", "is", "not", "sufficient", "." ]

[ "def", "global_position_int_send", "(", "self", ",", "time_boot_ms", ",", "lat", ",", "lon", ",", "alt", ",", "relative_alt", ",", "vx", ",", "vy", ",", "vz", ",", "hdg", ")", ":", "return", "self", ".", "send", "(", "self", ".", "global_position_int_encode", "(", "time_boot_ms", ",", "lat", ",", "lon", ",", "alt", ",", "relative_alt", ",", "vx", ",", "vy", ",", "vz", ",", "hdg", ")", ")" ]

[ "return", "train", "and", "val", "iterators", "for", "mnist" ]

[ "def", "mnist_iterator", "(", "batch_size", ",", "input_shape", ")", ":", "# download data", "get_data", ".", "GetMNIST_ubyte", "(", ")", "flat", "=", "False", "if", "len", "(", "input_shape", ")", "==", "3", "else", "True", "train_dataiter", "=", "mx", ".", "io", ".", "MNISTIter", "(", "image", "=", "\"data/train-images-idx3-ubyte\"", ",", "label", "=", "\"data/train-labels-idx1-ubyte\"", ",", "input_shape", "=", "input_shape", ",", "batch_size", "=", "batch_size", ",", "shuffle", "=", "True", ",", "flat", "=", "flat", ")", "val_dataiter", "=", "mx", ".", "io", ".", "MNISTIter", "(", "image", "=", "\"data/t10k-images-idx3-ubyte\"", ",", "label", "=", "\"data/t10k-labels-idx1-ubyte\"", ",", "input_shape", "=", "input_shape", ",", "batch_size", "=", "batch_size", ",", "flat", "=", "flat", ")", "return", "(", "train_dataiter", ",", "val_dataiter", ")" ]

[ "Truncate", "file", "to", "size", "bytes", "." ]

[ "def", "truncate", "(", "self", ",", "pos", "=", "None", ")", ":", "self", ".", "_unsupported", "(", "\"truncate\"", ")" ]

[ "Load", "location", "from", "element", "/", "dict" ]

[ "def", "_load_location", "(", "location", ",", "element", ")", ":", "location", ".", "file", "=", "element", ".", "get", "(", "'file'", ")", "line", "=", "element", ".", "get", "(", "'line'", ")", "if", "line", "is", "None", ":", "line", "=", "element", ".", "get", "(", "'linenr'", ")", "if", "line", "is", "None", ":", "line", "=", "'0'", "location", ".", "linenr", "=", "int", "(", "line", ")", "location", ".", "column", "=", "int", "(", "element", ".", "get", "(", "'column'", ",", "'0'", ")", ")" ]

[ "Echo", "some", "comments", "and", "invoke", "both", "versions", "of", "toy" ]

[ "def", "writeTimingCall", "(", "self", ",", "filename", ",", "numFuncs", ",", "funcsCalled", ",", "totalCalls", ")", ":", "rootname", "=", "filename", "if", "'.'", "in", "filename", ":", "rootname", "=", "filename", "[", ":", "filename", ".", "rfind", "(", "'.'", ")", "]", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"%s: Calls %d of %d functions, %d total\\\" >> %s\\n\"", "%", "(", "filename", ",", "funcsCalled", ",", "numFuncs", ",", "totalCalls", ",", "self", ".", "timeFile", ")", ")", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"\\\" >> %s\\n\"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"With MCJIT\\\" >> %s\\n\"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"/usr/bin/time -f \\\"Command %C\\\\n\\\\tuser time: %U s\\\\n\\\\tsytem time: %S s\\\\n\\\\tmax set: %M kb\\\"\"", ")", "self", ".", "shfile", ".", "write", "(", "\" -o %s -a \"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"./toy-mcjit < %s > %s-mcjit.out 2> %s-mcjit.err\\n\"", "%", "(", "filename", ",", "rootname", ",", "rootname", ")", ")", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"\\\" >> %s\\n\"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"With JIT\\\" >> %s\\n\"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"/usr/bin/time -f \\\"Command %C\\\\n\\\\tuser time: %U s\\\\n\\\\tsytem time: %S s\\\\n\\\\tmax set: %M kb\\\"\"", ")", "self", ".", "shfile", ".", "write", "(", "\" -o %s -a \"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"./toy-jit < %s > %s-jit.out 2> %s-jit.err\\n\"", "%", "(", "filename", ",", "rootname", ",", "rootname", ")", ")", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"\\\" >> %s\\n\"", "%", "self", ".", "timeFile", ")", "self", ".", "shfile", ".", "write", "(", "\"echo \\\"\\\" >> %s\\n\"", "%", "self", ".", "timeFile", ")" ]

[ "Retrieve", "the", "compressed", "histogram", "events", "associated", "with", "a", "run", "and", "tag", "." ]

[ "def", "CompressedHistograms", "(", "self", ",", "run", ",", "tag", ")", ":", "accumulator", "=", "self", ".", "_GetAccumulator", "(", "run", ")", "return", "accumulator", ".", "CompressedHistograms", "(", "tag", ")" ]

[ "Check", "whether", "the", "provided", "array", "or", "dtype", "is", "of", "a", "complex", "dtype", "." ]

[ "def", "is_complex_dtype", "(", "arr_or_dtype", ")", "->", "bool", ":", "return", "_is_dtype_type", "(", "arr_or_dtype", ",", "classes", "(", "np", ".", "complexfloating", ")", ")" ]

[ "GET", "the", "given", "url", ".", "Serialize", "the", "result", "at", "clean", "path", "version", "of", "url", "." ]

[ "def", "GetAndSave", "(", "self", ",", "url", ",", "save_suffix", ",", "unzip", "=", "False", ")", ":", "self", ".", "connection", ".", "request", "(", "'GET'", ",", "'/data/'", "+", "url", ",", "headers", "=", "{", "'content-type'", ":", "'text/plain'", "}", ")", "response", "=", "self", ".", "connection", ".", "getresponse", "(", ")", "file_name", "=", "Clean", "(", "url", ")", "+", "save_suffix", "destination", "=", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "file_name", ")", "if", "response", ".", "status", "!=", "200", ":", "raise", "IOError", "(", "url", ")", "if", "unzip", ":", "s", "=", "StringIO", ".", "StringIO", "(", "response", ".", "read", "(", ")", ")", "content", "=", "gzip", ".", "GzipFile", "(", "fileobj", "=", "s", ")", ".", "read", "(", ")", "else", ":", "content", "=", "response", ".", "read", "(", ")", "with", "open", "(", "destination", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "content", ")", "return", "content" ]

[ "Init", "Pre", "-", "message", "hooks" ]

[ "def", "initPreMessageHooks", "(", "self", ",", "c", ")", ":", "# Pre-message hooks for async input ports", "c", ".", "pre_message_hooks", "=", "[", "(", "instance", ",", "type", ",", "sync", ",", "priority", ",", "role", ",", "max_num", ")", "for", "(", "instance", ",", "type", ",", "sync", ",", "priority", ",", "full", ",", "role", ",", "max_num", ")", "in", "c", ".", "input_ports", "if", "role", "!=", "\"Cmd\"", "and", "sync", "==", "\"async\"", "]", "# Pre-message hooks for typed async input ports", "c", ".", "pre_message_hooks_typed", "=", "[", "(", "instance", ",", "type", ",", "sync", ",", "priority", ",", "full", ",", "role", ",", "max_num", ")", "for", "(", "instance", ",", "type", ",", "sync", ",", "priority", ",", "full", ",", "role", ",", "max_num", ",", ")", "in", "c", ".", "typed_input_ports", "if", "role", "!=", "\"Cmd\"", "and", "sync", "==", "\"async\"", "]", "# Pre-message hooks for serial async input ports", "c", ".", "pre_message_hooks_serial", "=", "c", ".", "serial_input_ports" ]

[ "Compute", "the", "moving", "average", "of", "a", "variable", "." ]

[ "def", "assign_moving_average", "(", "variable", ",", "value", ",", "decay", ",", "zero_debias", "=", "True", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"AssignMovingAvg\"", ",", "[", "variable", ",", "value", ",", "decay", "]", ")", "as", "scope", ":", "decay", "=", "ops", ".", "convert_to_tensor", "(", "1.0", "-", "decay", ",", "name", "=", "\"decay\"", ")", "if", "decay", ".", "dtype", "!=", "variable", ".", "dtype", ".", "base_dtype", ":", "decay", "=", "math_ops", ".", "cast", "(", "decay", ",", "variable", ".", "dtype", ".", "base_dtype", ")", "def", "update_fn", "(", "v", ",", "value", ")", ":", "return", "state_ops", ".", "assign_sub", "(", "v", ",", "(", "v", "-", "value", ")", "*", "decay", ",", "name", "=", "scope", ")", "def", "update", "(", "strategy", ",", "v", ",", "value", ")", ":", "if", "zero_debias", ":", "return", "_zero_debias", "(", "strategy", ",", "v", ",", "value", ",", "decay", ")", "else", ":", "return", "_update", "(", "strategy", ",", "v", ",", "update_fn", ",", "args", "=", "(", "value", ",", ")", ")", "replica_context", "=", "distribution_strategy_context", ".", "get_replica_context", "(", ")", "if", "replica_context", ":", "# In a replica context, we update variable using the mean of value across", "# replicas.", "def", "merge_fn", "(", "strategy", ",", "v", ",", "value", ")", ":", "value", "=", "strategy", ".", "extended", ".", "reduce_to", "(", "ds_reduce_util", ".", "ReduceOp", ".", "MEAN", ",", "value", ",", "v", ")", "return", "update", "(", "strategy", ",", "v", ",", "value", ")", "return", "replica_context", ".", "merge_call", "(", "merge_fn", ",", "args", "=", "(", "variable", ",", "value", ")", ")", "else", ":", "strategy", "=", "distribution_strategy_context", ".", "get_cross_replica_context", "(", ")", "return", "update", "(", "strategy", ",", "variable", ",", "value", ")" ]

[ "Creates", "an", "address", "from", "just", "the", "20", "-", "byte", "binary", "hash", "of", "a", "public", "key", "." ]

[ "def", "createFromPublicKeyHash160", "(", "self", ",", "pubkeyHash160", ",", "netbyte", "=", "ADDRBYTE", ")", ":", "self", ".", "__init__", "(", ")", "self", ".", "addrStr20", "=", "pubkeyHash160", "self", ".", "isInitialized", "=", "True", "return", "self" ]

[ "SetOperatingSystemId", "(", "self", "int", "n", ")" ]

[ "def", "SetOperatingSystemId", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "PlatformInformation_SetOperatingSystemId", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "SetAttr", "(", "self", "GridCellAttr", "attr", "int", "row", "int", "col", ")" ]

[ "def", "SetAttr", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "GridTableBase_SetAttr", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Make", "a", "cache", "key", "from", "optionally", "typed", "positional", "and", "keyword", "arguments" ]

[ "def", "_make_key", "(", "args", ",", "kwds", ",", "typed", ",", "kwd_mark", "=", "(", "object", "(", ")", ",", ")", ",", "fasttypes", "=", "{", "int", ",", "str", "}", ",", "tuple", "=", "tuple", ",", "type", "=", "type", ",", "len", "=", "len", ")", ":", "# All of code below relies on kwds preserving the order input by the user.", "# Formerly, we sorted() the kwds before looping. The new way is *much*", "# faster; however, it means that f(x=1, y=2) will now be treated as a", "# distinct call from f(y=2, x=1) which will be cached separately.", "key", "=", "args", "if", "kwds", ":", "key", "+=", "kwd_mark", "for", "item", "in", "kwds", ".", "items", "(", ")", ":", "key", "+=", "item", "if", "typed", ":", "key", "+=", "tuple", "(", "type", "(", "v", ")", "for", "v", "in", "args", ")", "if", "kwds", ":", "key", "+=", "tuple", "(", "type", "(", "v", ")", "for", "v", "in", "kwds", ".", "values", "(", ")", ")", "elif", "len", "(", "key", ")", "==", "1", "and", "type", "(", "key", "[", "0", "]", ")", "in", "fasttypes", ":", "return", "key", "[", "0", "]", "return", "_HashedSeq", "(", "key", ")" ]

[ "Return", "True", "if", "one", "or", "many", "bits", "are", "all", "set", "to", "value", "." ]

[ "def", "all", "(", "self", ",", "value", ",", "pos", "=", "None", ")", ":", "value", "=", "bool", "(", "value", ")", "length", "=", "self", ".", "len", "if", "pos", "is", "None", ":", "pos", "=", "xrange", "(", "self", ".", "len", ")", "for", "p", "in", "pos", ":", "if", "p", "<", "0", ":", "p", "+=", "length", "if", "not", "0", "<=", "p", "<", "length", ":", "raise", "IndexError", "(", "\"Bit position {0} out of range.\"", ".", "format", "(", "p", ")", ")", "if", "not", "self", ".", "_datastore", ".", "getbit", "(", "p", ")", "is", "value", ":", "return", "False", "return", "True" ]

[ "Normalize", "an", "encoding", "name", "." ]

[ "def", "normalize_encoding", "(", "encoding", ")", ":", "# Make sure we have an 8-bit string, because .translate() works", "# differently for Unicode strings.", "if", "hasattr", "(", "__builtin__", ",", "\"unicode\"", ")", "and", "isinstance", "(", "encoding", ",", "unicode", ")", ":", "# Note that .encode('latin-1') does *not* use the codec", "# registry, so this call doesn't recurse. (See unicodeobject.c", "# PyUnicode_AsEncodedString() for details)", "encoding", "=", "encoding", ".", "encode", "(", "'latin-1'", ")", "return", "'_'", ".", "join", "(", "encoding", ".", "translate", "(", "_norm_encoding_map", ")", ".", "split", "(", ")", ")" ]

[ "Pop", "the", "next", "method", "from", "our", "call", "queue", "." ]

[ "def", "_PopNextMethod", "(", "self", ")", ":", "try", ":", "return", "self", ".", "_call_queue", ".", "popleft", "(", ")", "except", "IndexError", ":", "raise", "UnexpectedMethodCallError", "(", "self", ",", "None", ")" ]

[ "Dump", "profile", "and", "stop", "profiler", ".", "Use", "this", "to", "save", "profile", "in", "advance", "in", "case", "your", "program", "cannot", "exit", "normally", "." ]

[ "def", "dump_profile", "(", ")", ":", "warnings", ".", "warn", "(", "'profiler.dump_profile() is deprecated. '", "'Please use profiler.dump() instead'", ")", "dump", "(", "True", ")" ]

[ "Retrieves", "bottleneck", "values", "for", "training", "images", "after", "distortions", "." ]

[ "def", "get_random_distorted_bottlenecks", "(", "sess", ",", "image_lists", ",", "how_many", ",", "category", ",", "image_dir", ",", "input_jpeg_tensor", ",", "distorted_image", ",", "resized_input_tensor", ",", "bottleneck_tensor", ")", ":", "class_count", "=", "len", "(", "image_lists", ".", "keys", "(", ")", ")", "bottlenecks", "=", "[", "]", "ground_truths", "=", "[", "]", "for", "unused_i", "in", "range", "(", "how_many", ")", ":", "label_index", "=", "random", ".", "randrange", "(", "class_count", ")", "label_name", "=", "list", "(", "image_lists", ".", "keys", "(", ")", ")", "[", "label_index", "]", "image_index", "=", "random", ".", "randrange", "(", "65536", ")", "image_path", "=", "get_image_path", "(", "image_lists", ",", "label_name", ",", "image_index", ",", "image_dir", ",", "category", ")", "if", "not", "gfile", ".", "Exists", "(", "image_path", ")", ":", "tf", ".", "logging", ".", "fatal", "(", "'File does not exist %s'", ",", "image_path", ")", "jpeg_data", "=", "gfile", ".", "FastGFile", "(", "image_path", ",", "'rb'", ")", ".", "read", "(", ")", "# Note that we materialize the distorted_image_data as a numpy array before", "# sending running inference on the image. This involves 2 memory copies and", "# might be optimized in other implementations.", "distorted_image_data", "=", "sess", ".", "run", "(", "distorted_image", ",", "{", "input_jpeg_tensor", ":", "jpeg_data", "}", ")", "bottleneck", "=", "run_bottleneck_on_image", "(", "sess", ",", "distorted_image_data", ",", "resized_input_tensor", ",", "bottleneck_tensor", ")", "ground_truth", "=", "np", ".", "zeros", "(", "class_count", ",", "dtype", "=", "np", ".", "float32", ")", "ground_truth", "[", "label_index", "]", "=", "1.0", "bottlenecks", ".", "append", "(", "bottleneck", ")", "ground_truths", ".", "append", "(", "ground_truth", ")", "return", "bottlenecks", ",", "ground_truths" ]

[ "Creates", "a", "template", "object", "from", "a", "module", ".", "This", "is", "used", "by", "the", "module", "loader", "to", "create", "a", "template", "object", "." ]

[ "def", "from_module_dict", "(", "cls", ",", "environment", ",", "module_dict", ",", "globals", ")", ":", "return", "cls", ".", "_from_namespace", "(", "environment", ",", "module_dict", ",", "globals", ")" ]

[ "IsStrictlyBetween", "(", "self", "DateTime", "t1", "DateTime", "t2", ")", "-", ">", "bool" ]

[ "def", "IsStrictlyBetween", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "DateTime_IsStrictlyBetween", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Adds", "quantile", "summary", "to", "its", "stream", "in", "resource", "." ]

[ "def", "add_summary", "(", "self", ",", "stamp_token", ",", "column", ",", "example_weights", ")", ":", "summary", "=", "self", ".", "_make_summary", "(", "column", ",", "example_weights", ")", "return", "gen_quantile_ops", ".", "quantile_accumulator_add_summaries", "(", "quantile_accumulator_handles", "=", "[", "self", ".", "resource_handle", "]", ",", "stamp_token", "=", "stamp_token", ",", "summaries", "=", "[", "summary", "]", ")" ]

[ "Get", "a", "Python", "class", "for", "a", "CLSID" ]

[ "def", "GetClassForCLSID", "(", "clsid", ")", ":", "# first, take a short-cut - we may already have generated support ready-to-roll.", "clsid", "=", "str", "(", "clsid", ")", "if", "CLSIDToClass", ".", "HasClass", "(", "clsid", ")", ":", "return", "CLSIDToClass", ".", "GetClass", "(", "clsid", ")", "mod", "=", "GetModuleForCLSID", "(", "clsid", ")", "if", "mod", "is", "None", ":", "return", "None", "try", ":", "return", "CLSIDToClass", ".", "GetClass", "(", "clsid", ")", "except", "KeyError", ":", "return", "None" ]

[ "Creates", "a", "message", "service", "stub", "class", "." ]

[ "def", "__init__", "(", "cls", ",", "name", ",", "bases", ",", "dictionary", ")", ":", "super", "(", "GeneratedServiceStubType", ",", "cls", ")", ".", "__init__", "(", "name", ",", "bases", ",", "dictionary", ")", "# Don't do anything if this class doesn't have a descriptor. This happens", "# when a service stub is subclassed.", "if", "GeneratedServiceStubType", ".", "_DESCRIPTOR_KEY", "not", "in", "dictionary", ":", "return", "descriptor", "=", "dictionary", "[", "GeneratedServiceStubType", ".", "_DESCRIPTOR_KEY", "]", "service_stub_builder", "=", "_ServiceStubBuilder", "(", "descriptor", ")", "service_stub_builder", ".", "BuildServiceStub", "(", "cls", ")" ]

[ "Builds", "a", "dict", "mapping", "fully", "-", "qualified", "target", "names", "to", "their", "target", "dicts", "." ]

[ "def", "BuildTargetsDict", "(", "data", ")", ":", "targets", "=", "{", "}", "for", "build_file", "in", "data", "[", "'target_build_files'", "]", ":", "for", "target", "in", "data", "[", "build_file", "]", ".", "get", "(", "'targets'", ",", "[", "]", ")", ":", "target_name", "=", "gyp", ".", "common", ".", "QualifiedTarget", "(", "build_file", ",", "target", "[", "'target_name'", "]", ",", "target", "[", "'toolset'", "]", ")", "if", "target_name", "in", "targets", ":", "raise", "GypError", "(", "'Duplicate target definitions for '", "+", "target_name", ")", "targets", "[", "target_name", "]", "=", "target", "return", "targets" ]

[ "Converts", "a", "4", "-", "dimensional", "array", "to", "blob", "proto", ".", "If", "diff", "is", "given", "also", "convert", "the", "diff", ".", "You", "need", "to", "make", "sure", "that", "arr", "and", "diff", "have", "the", "same", "shape", "and", "this", "function", "does", "not", "do", "sanity", "check", "." ]

[ "def", "array_to_blobproto", "(", "arr", ",", "diff", "=", "None", ")", ":", "if", "arr", ".", "ndim", "!=", "4", ":", "raise", "ValueError", "(", "'Incorrect array shape.'", ")", "blob", "=", "caffe_pb2", ".", "BlobProto", "(", ")", "blob", ".", "num", ",", "blob", ".", "channels", ",", "blob", ".", "height", ",", "blob", ".", "width", "=", "arr", ".", "shape", "blob", ".", "data", ".", "extend", "(", "arr", ".", "astype", "(", "float", ")", ".", "flat", ")", "if", "diff", "is", "not", "None", ":", "blob", ".", "diff", ".", "extend", "(", "diff", ".", "astype", "(", "float", ")", ".", "flat", ")", "return", "blob" ]

[ "Get", "PE", "DllCharacteristics", "bits", ".", "Returns", "a", "tuple", "(", "arch", "bits", ")", "where", "arch", "is", "i386", ":", "x86", "-", "64", "or", "i386", "and", "bits", "is", "the", "DllCharacteristics", "value", "." ]

[ "def", "get_PE_dll_characteristics", "(", "executable", ")", ":", "p", "=", "subprocess", ".", "Popen", "(", "[", "OBJDUMP_CMD", ",", "'-x'", ",", "executable", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "stdin", "=", "subprocess", ".", "PIPE", ")", "(", "stdout", ",", "stderr", ")", "=", "p", ".", "communicate", "(", ")", "if", "p", ".", "returncode", ":", "raise", "IOError", "(", "'Error opening file'", ")", "arch", "=", "''", "bits", "=", "0", "for", "line", "in", "stdout", ".", "split", "(", "'\\n'", ")", ":", "tokens", "=", "line", ".", "split", "(", ")", "if", "len", "(", "tokens", ")", ">=", "2", "and", "tokens", "[", "0", "]", "==", "'architecture:'", ":", "arch", "=", "tokens", "[", "1", "]", ".", "rstrip", "(", "','", ")", "if", "len", "(", "tokens", ")", ">=", "2", "and", "tokens", "[", "0", "]", "==", "'DllCharacteristics'", ":", "bits", "=", "int", "(", "tokens", "[", "1", "]", ",", "16", ")", "return", "(", "arch", ",", "bits", ")" ]

[ "Return", "the", "Charset", "instance", "associated", "with", "the", "message", "s", "payload", "." ]

[ "def", "get_charset", "(", "self", ")", ":", "return", "self", ".", "_charset" ]