Datasets:

sia-precision-education

/

pile_cpp

like 1

[ "Returns", "a", "dictionary", "of", "BaseDimension", ":", "exponent", "pairs", "describing", "the", "dimension", "of", "this", "unit", "." ]

[ "def", "iter_base_dimensions", "(", "self", ")", ":", "yield", "(", "self", ".", "dimension", ",", "1", ")" ]

[ "Very", "fast", "hashing", "scheme", "but", "not", "persistent", "(", "replace", "/", "implement", "in", "subclasses", "and", "see", ":", "py", ":", "meth", ":", "waflib", ".", "Task", ".", "Task", ".", "uid", ")" ]

[ "def", "__hash__", "(", "self", ")", ":", "return", "id", "(", "self", ")" ]

[ "Returns", "the", "entry", "at", "a", "given", "index", "of", "the", "table", "None", "if", "there", "is", "none", ".", "Raises", "an", "exception", "if", "the", "index", "is", "out", "of", "bounds", "." ]

[ "def", "entryAt", "(", "self", ",", "index", ")", ":", "if", "index", "<", "self", ".", "size", "(", ")", ":", "return", "self", ".", "_entries", ".", "get", "(", "index", ",", "None", ")", "raise", "self", ".", "IndexError", "(", "\"index out of bounds: %s\"", "%", "index", ")" ]

[ "Add", "parser", "options", "for", "this", "plugin", "." ]

[ "def", "add_subcommand", "(", "self", ",", "subparsers", ")", ":", "raise", "NotImplementedError", "(", ")" ]

[ "Returns", "unique", "values", "in", "a", "column", "if", "dummy_na", "is", "False", "nan", "s", "are", "also", "dropped", "." ]

[ "def", "_get_unique", "(", "column", ",", "dummy_na", ")", ":", "if", "isinstance", "(", "column", ",", "cudf", ".", "core", ".", "column", ".", "CategoricalColumn", ")", ":", "unique", "=", "column", ".", "categories", "else", ":", "unique", "=", "column", ".", "unique", "(", ")", "if", "not", "dummy_na", ":", "if", "np", ".", "issubdtype", "(", "unique", ".", "dtype", ",", "np", ".", "floating", ")", ":", "unique", "=", "unique", ".", "nans_to_nulls", "(", ")", "unique", "=", "unique", ".", "dropna", "(", ")", "return", "unique" ]

[ "This", "returns", "a", "human", "-", "readable", "string", "that", "represents", "the", "state", "of", "the", "object", "." ]

[ "def", "__str__", "(", "self", ")", ":", "#ss = [(n, ' %d: re.compile(\"%s\")' %", "# (n, repr(s.pattern))) for n, s in self._searches]", "ss", "=", "list", "(", ")", "for", "n", ",", "s", "in", "self", ".", "_searches", ":", "ss", ".", "append", "(", "(", "n", ",", "' %d: re.compile(%r)'", "%", "(", "n", ",", "s", ".", "pattern", ")", ")", ")", "ss", ".", "append", "(", "(", "-", "1", ",", "'searcher_re:'", ")", ")", "if", "self", ".", "eof_index", ">=", "0", ":", "ss", ".", "append", "(", "(", "self", ".", "eof_index", ",", "' %d: EOF'", "%", "self", ".", "eof_index", ")", ")", "if", "self", ".", "timeout_index", ">=", "0", ":", "ss", ".", "append", "(", "(", "self", ".", "timeout_index", ",", "' %d: TIMEOUT'", "%", "self", ".", "timeout_index", ")", ")", "ss", ".", "sort", "(", ")", "ss", "=", "list", "(", "zip", "(", "*", "ss", ")", ")", "[", "1", "]", "return", "'\\n'", ".", "join", "(", "ss", ")" ]

[ "Create", "a", "new", "xmlXPathObjectPtr", "of", "type", "LocationSet", "and", "initialize", "it", "with", "the", "single", "range", "made", "of", "the", "two", "nodes" ]

[ "def", "xpointerNewLocationSetNodes", "(", "self", ",", "end", ")", ":", "if", "end", "is", "None", ":", "end__o", "=", "None", "else", ":", "end__o", "=", "end", ".", "_o", "ret", "=", "libxml2mod", ".", "xmlXPtrNewLocationSetNodes", "(", "self", ".", "_o", ",", "end__o", ")", "if", "ret", "is", "None", ":", "raise", "treeError", "(", "'xmlXPtrNewLocationSetNodes() failed'", ")", "return", "xpathObjectRet", "(", "ret", ")" ]

[ "Helper", "function", "that", "sets", "a", "memory", "limit", "on", "the", "current", "process", "then", "calls", "|function|", "on", "|args|", "and", "writes", "the", "results", "to", "|queue|", "." ]

[ "def", "_MultiprocessingWrapper", "(", "queue", ",", "memory_share", ",", "function", ",", "args", ")", ":", "try", ":", "if", "memory_share", ":", "_LimitMemory", "(", "memory_share", ")", "queue", ".", "put", "(", "function", "(", "*", "args", ")", ")", "except", "Exception", ":", "queue", ".", "put", "(", "None", ")" ]

[ "Update", "and", "fetch", "the", "acquisition", "parameters", ".", ":", "param", "params", ":", "The", "acquisition", "parameters", ".", ":", "type", "params", ":", "dict", ":", "returns", ":", "The", "current", "acquisition", "parameters" ]

[ "def", "acquisition_params", "(", "self", ",", "*", "*", "params", ")", ":", "pass" ]

[ "Check", "whether", "the", "character", "is", "part", "of", "Mongolian", "UCS", "Block" ]

[ "def", "uCSIsMongolian", "(", "code", ")", ":", "ret", "=", "libxml2mod", ".", "xmlUCSIsMongolian", "(", "code", ")", "return", "ret" ]

[ "Does", "google", "-", "lint", "on", "a", "single", "file", "." ]

[ "def", "ProcessFile", "(", "filename", ",", "vlevel", ",", "extra_check_functions", "=", "[", "]", ")", ":", "_SetVerboseLevel", "(", "vlevel", ")", "try", ":", "# Support the UNIX convention of using \"-\" for stdin. Note that", "# we are not opening the file with universal newline support", "# (which codecs doesn't support anyway), so the resulting lines do", "# contain trailing '\\r' characters if we are reading a file that", "# has CRLF endings.", "# If after the split a trailing '\\r' is present, it is removed", "# below. If it is not expected to be present (i.e. os.linesep !=", "# '\\r\\n' as in Windows), a warning is issued below if this file", "# is processed.", "if", "filename", "==", "'-'", ":", "lines", "=", "codecs", ".", "StreamReaderWriter", "(", "sys", ".", "stdin", ",", "codecs", ".", "getreader", "(", "'utf8'", ")", ",", "codecs", ".", "getwriter", "(", "'utf8'", ")", ",", "'replace'", ")", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "else", ":", "lines", "=", "codecs", ".", "open", "(", "filename", ",", "'r'", ",", "'utf8'", ",", "'replace'", ")", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "carriage_return_found", "=", "False", "# Remove trailing '\\r'.", "for", "linenum", "in", "range", "(", "len", "(", "lines", ")", ")", ":", "if", "lines", "[", "linenum", "]", ".", "endswith", "(", "'\\r'", ")", ":", "lines", "[", "linenum", "]", "=", "lines", "[", "linenum", "]", ".", "rstrip", "(", "'\\r'", ")", "carriage_return_found", "=", "True", "except", "IOError", ":", "sys", ".", "stderr", ".", "write", "(", "\"Skipping input '%s': Can't open for reading\\n\"", "%", "filename", ")", "return", "# Note, if no dot is found, this will give the entire filename as the ext.", "file_extension", "=", "filename", "[", "filename", ".", "rfind", "(", "'.'", ")", "+", "1", ":", "]", "# When reading from stdin, the extension is unknown, so no cpplint tests", "# should rely on the extension.", "if", "filename", "!=", "'-'", "and", "file_extension", "not", "in", "_valid_extensions", ":", "sys", ".", "stderr", ".", "write", "(", "'Ignoring %s; not a valid file name '", "'(%s)\\n'", "%", "(", "filename", ",", "', '", ".", "join", "(", "_valid_extensions", ")", ")", ")", "else", ":", "ProcessFileData", "(", "filename", ",", "file_extension", ",", "lines", ",", "Error", ",", "extra_check_functions", ")", "if", "carriage_return_found", "and", "os", ".", "linesep", "!=", "'\\r\\n'", ":", "# Use 0 for linenum since outputting only one error for potentially", "# several lines.", "Error", "(", "filename", ",", "0", ",", "'whitespace/newline'", ",", "1", ",", "'One or more unexpected \\\\r (^M) found;'", "'better to use only a \\\\n'", ")", "sys", ".", "stderr", ".", "write", "(", "'Done processing %s\\n'", "%", "filename", ")" ]

[ "Print", "failure", "state", "and", "return", "if", "ignore_fun", "matches", "content", "." ]

[ "def", "content_bailout", "(", "content", ",", "ignore_fun", ")", ":", "bug", "=", "(", "ignore_fun", "(", "content", ")", "or", "''", ")", ".", "strip", "(", ")", "if", "bug", ":", "raise", "FailException", "(", "FAILURE_HEADER_TEMPLATE", "%", "dict", "(", "configs", "=", "''", ",", "source_key", "=", "''", ",", "suppression", "=", "bug", ")", ")" ]

[ "Validate", "the", "entry", "fields", "in", "the", "user", "interface", "." ]

[ "def", "numericInput", "(", "self", ",", "numx", ",", "numy", ",", "numz", ")", ":", "self", ".", "point", "=", "App", ".", "Vector", "(", "numx", ",", "numy", ",", "numz", ")", "if", "not", "self", ".", "node", ":", "self", ".", "node", ".", "append", "(", "self", ".", "point", ")", "if", "self", ".", "ghost", ":", "self", ".", "ghost", ".", "on", "(", ")", "_msg", "(", "translate", "(", "\"draft\"", ",", "\"Pick end point of mirror line\"", ")", ")", "else", ":", "last", "=", "self", ".", "node", "[", "-", "1", "]", "if", "self", ".", "ui", ".", "isCopy", ".", "isChecked", "(", ")", ":", "self", ".", "mirror", "(", "last", ",", "self", ".", "point", ",", "True", ")", "else", ":", "self", ".", "mirror", "(", "last", ",", "self", ".", "point", ")", "self", ".", "finish", "(", ")" ]

[ "Called", "when", "the", "netlist", "document", "has", "been", "fully", "parsed" ]

[ "def", "endDocument", "(", "self", ")", ":", "# When the document is complete, the library parts must be linked to", "# the components as they are seperate in the tree so as not to", "# duplicate library part information for every component", "for", "c", "in", "self", ".", "components", ":", "for", "p", "in", "self", ".", "libparts", ":", "if", "p", ".", "getLibName", "(", ")", "==", "c", ".", "getLibName", "(", ")", ":", "if", "p", ".", "getPartName", "(", ")", "==", "c", ".", "getPartName", "(", ")", ":", "c", ".", "setLibPart", "(", "p", ")", "break", "else", ":", "aliases", "=", "p", ".", "getAliases", "(", ")", "if", "aliases", "and", "self", ".", "aliasMatch", "(", "c", ".", "getPartName", "(", ")", ",", "aliases", ")", ":", "c", ".", "setLibPart", "(", "p", ")", "break", "if", "not", "c", ".", "getLibPart", "(", ")", ":", "print", "(", "'missing libpart for ref:'", ",", "c", ".", "getRef", "(", ")", ",", "c", ".", "getPartName", "(", ")", ",", "c", ".", "getLibName", "(", ")", ")" ]

[ "Update", "logic", "of", "game", ".", "Updates", "the", "snake", "and", "checks", "for", "scoring", "/", "win", "condition", "." ]

[ "def", "update", "(", "self", ")", ":", "if", "not", "self", ".", "death", ":", "self", ".", "update_direction", "(", ")", "self", ".", "update_snake", "(", ")", "self", ".", "check_death", "(", ")", "self", ".", "check_apple", "(", ")", "if", "pyxel", ".", "btn", "(", "pyxel", ".", "KEY_Q", ")", ":", "pyxel", ".", "quit", "(", ")", "if", "pyxel", ".", "btnp", "(", "pyxel", ".", "KEY_R", ")", ":", "self", ".", "reset", "(", ")" ]

[ "Yield", "distributions", "accessible", "on", "a", "sys", ".", "path", "directory" ]

[ "def", "find_on_path", "(", "importer", ",", "path_item", ",", "only", "=", "False", ")", ":", "path_item", "=", "_normalize_cached", "(", "path_item", ")", "if", "_is_unpacked_egg", "(", "path_item", ")", ":", "yield", "Distribution", ".", "from_filename", "(", "path_item", ",", "metadata", "=", "PathMetadata", "(", "path_item", ",", "os", ".", "path", ".", "join", "(", "path_item", ",", "'EGG-INFO'", ")", ")", ")", "return", "entries", "=", "(", "os", ".", "path", ".", "join", "(", "path_item", ",", "child", ")", "for", "child", "in", "safe_listdir", "(", "path_item", ")", ")", "# for performance, before sorting by version,", "# screen entries for only those that will yield", "# distributions", "filtered", "=", "(", "entry", "for", "entry", "in", "entries", "if", "dist_factory", "(", "path_item", ",", "entry", ",", "only", ")", ")", "# scan for .egg and .egg-info in directory", "path_item_entries", "=", "_by_version_descending", "(", "filtered", ")", "for", "entry", "in", "path_item_entries", ":", "fullpath", "=", "os", ".", "path", ".", "join", "(", "path_item", ",", "entry", ")", "factory", "=", "dist_factory", "(", "path_item", ",", "entry", ",", "only", ")", "for", "dist", "in", "factory", "(", "fullpath", ")", ":", "yield", "dist" ]

[ "Return", "environment", "dict", "." ]

[ "def", "return_env", "(", "self", ",", "exists", "=", "True", ")", ":", "env", "=", "dict", "(", "include", "=", "self", ".", "_build_paths", "(", "'include'", ",", "[", "self", ".", "VCIncludes", ",", "self", ".", "OSIncludes", ",", "self", ".", "UCRTIncludes", ",", "self", ".", "NetFxSDKIncludes", "]", ",", "exists", ")", ",", "lib", "=", "self", ".", "_build_paths", "(", "'lib'", ",", "[", "self", ".", "VCLibraries", ",", "self", ".", "OSLibraries", ",", "self", ".", "FxTools", ",", "self", ".", "UCRTLibraries", ",", "self", ".", "NetFxSDKLibraries", "]", ",", "exists", ")", ",", "libpath", "=", "self", ".", "_build_paths", "(", "'libpath'", ",", "[", "self", ".", "VCLibraries", ",", "self", ".", "FxTools", ",", "self", ".", "VCStoreRefs", ",", "self", ".", "OSLibpath", "]", ",", "exists", ")", ",", "path", "=", "self", ".", "_build_paths", "(", "'path'", ",", "[", "self", ".", "VCTools", ",", "self", ".", "VSTools", ",", "self", ".", "VsTDb", ",", "self", ".", "SdkTools", ",", "self", ".", "SdkSetup", ",", "self", ".", "FxTools", ",", "self", ".", "MSBuild", ",", "self", ".", "HTMLHelpWorkshop", ",", "self", ".", "FSharp", "]", ",", "exists", ")", ",", ")", "if", "self", ".", "vs_ver", ">=", "14", "and", "isfile", "(", "self", ".", "VCRuntimeRedist", ")", ":", "env", "[", "'py_vcruntime_redist'", "]", "=", "self", ".", "VCRuntimeRedist", "return", "env" ]

[ "SetBackgroundMode", "(", "self", "int", "mode", ")" ]

[ "def", "SetBackgroundMode", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "DC_SetBackgroundMode", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "self", "modulo", "other", "." ]

[ "def", "__mod__", "(", "self", ",", "other", ")", ":", "other", "=", "as_dimension", "(", "other", ")", "if", "self", ".", "_value", "is", "None", "or", "other", ".", "value", "is", "None", ":", "return", "Dimension", "(", "None", ")", "else", ":", "return", "Dimension", "(", "self", ".", "_value", "%", "other", ".", "value", ")" ]

[ "Return", "nodes", "appropriate", "for", "use", "with", "dominator" ]

[ "def", "getRoot", "(", "self", ")", ":", "return", "self", ".", "entry" ]

[ "Generates", "a", "key", "pair", "and", "config", "file", "for", "SSH", "using", "the", "GN", "SDK", "." ]

[ "def", "ProvisionSSH", "(", ")", ":", "returncode", ",", "out", ",", "err", "=", "common", ".", "RunGnSdkFunction", "(", "'fuchsia-common.sh'", ",", "'check-fuchsia-ssh-config'", ")", "if", "returncode", "!=", "0", ":", "logging", ".", "error", "(", "'Command exited with error code %d'", "%", "(", "returncode", ")", ")", "logging", ".", "error", "(", "'Stdout: %s'", "%", "out", ")", "logging", ".", "error", "(", "'Stderr: %s'", "%", "err", ")", "raise", "Exception", "(", "'Failed to provision ssh keys'", ")" ]

[ "Serve", "a", "POST", "request", "." ]

[ "def", "do_POST", "(", "self", ")", ":", "try", ":", "length", "=", "self", ".", "headers", ".", "getheader", "(", "'content-length'", ")", "or", "\"0\"", "try", ":", "length", "=", "int", "(", "length", ")", "except", ":", "length", "=", "0", "content", "=", "self", ".", "rfile", ".", "read", "(", "length", ")", "fields", "=", "parse_query", "(", "content", ")", "f", "=", "self", ".", "send_head", "(", "fields", ")", "if", "f", ":", "self", ".", "copyfile", "(", "f", ",", "self", ".", "wfile", ")", "f", ".", "close", "(", ")", "except", "Exception", ",", "e", ":", "self", ".", "handle_exception", "(", "e", ")" ]

[ "Gets", "a", "differential", "ADC", "reading", "from", "channels", "chP", "and", "chN", "in", "mV", ".", "\\", "The", "sample", "rate", "for", "this", "mode", "(", "single", "-", "shot", ")", "can", "be", "used", "to", "lower", "the", "noise", "\\", "(", "low", "sps", ")", "or", "to", "lower", "the", "power", "consumption", "(", "high", "sps", ")", "by", "duty", "cycling", "\\", "see", "data", "sheet", "page", "14", "for", "more", "info", ".", "\\", "The", "pga", "must", "be", "given", "in", "mV", "see", "page", "13", "for", "the", "supported", "values", "." ]

[ "def", "readADCDifferential", "(", "self", ",", "chP", "=", "0", ",", "chN", "=", "1", ",", "pga", "=", "6144", ",", "sps", "=", "250", ")", ":", "# Disable comparator, Non-latching, Alert/Rdy active low", "# traditional comparator, single-shot mode", "config", "=", "self", ".", "__ADS1015_REG_CONFIG_CQUE_NONE", "|", "self", ".", "__ADS1015_REG_CONFIG_CLAT_NONLAT", "|", "self", ".", "__ADS1015_REG_CONFIG_CPOL_ACTVLOW", "|", "self", ".", "__ADS1015_REG_CONFIG_CMODE_TRAD", "|", "self", ".", "__ADS1015_REG_CONFIG_MODE_SINGLE", "# Set channels", "if", "(", "(", "chP", "==", "0", ")", "&", "(", "chN", "==", "1", ")", ")", ":", "config", "|=", "self", ".", "__ADS1015_REG_CONFIG_MUX_DIFF_0_1", "elif", "(", "(", "chP", "==", "0", ")", "&", "(", "chN", "==", "3", ")", ")", ":", "config", "|=", "self", ".", "__ADS1015_REG_CONFIG_MUX_DIFF_0_3", "elif", "(", "(", "chP", "==", "2", ")", "&", "(", "chN", "==", "3", ")", ")", ":", "config", "|=", "self", ".", "__ADS1015_REG_CONFIG_MUX_DIFF_2_3", "elif", "(", "(", "chP", "==", "1", ")", "&", "(", "chN", "==", "3", ")", ")", ":", "config", "|=", "self", ".", "__ADS1015_REG_CONFIG_MUX_DIFF_1_3", "else", ":", "if", "(", "self", ".", "debug", ")", ":", "print", "\"ADS1x15: Invalid channels specified: %d, %d\"", "%", "(", "chP", ",", "chN", ")", "return", "-", "1", "# Set sample per seconds, defaults to 250sps", "# If sps is in the dictionary (defined in init()) it returns the value of the constant", "# othewise it returns the value for 250sps. This saves a lot of if/elif/else code!", "if", "(", "self", ".", "ic", "==", "self", ".", "__IC_ADS1015", ")", ":", "config", "|=", "self", ".", "spsADS1015", ".", "setdefault", "(", "sps", ",", "self", ".", "__ADS1015_REG_CONFIG_DR_1600SPS", ")", "else", ":", "if", "(", "(", "sps", "not", "in", "self", ".", "spsADS1115", ")", "&", "self", ".", "debug", ")", ":", "print", "\"ADS1x15: Invalid pga specified: %d, using 6144mV\"", "%", "sps", "config", "|=", "self", ".", "spsADS1115", ".", "setdefault", "(", "sps", ",", "self", ".", "__ADS1115_REG_CONFIG_DR_250SPS", ")", "# Set PGA/voltage range, defaults to +-6.144V", "if", "(", "(", "pga", "not", "in", "self", ".", "pgaADS1x15", ")", "&", "self", ".", "debug", ")", ":", "print", "\"ADS1x15: Invalid pga specified: %d, using 6144mV\"", "%", "sps", "config", "|=", "self", ".", "pgaADS1x15", ".", "setdefault", "(", "pga", ",", "self", ".", "__ADS1015_REG_CONFIG_PGA_6_144V", ")", "self", ".", "pga", "=", "pga", "# Set 'start single-conversion' bit", "config", "|=", "self", ".", "__ADS1015_REG_CONFIG_OS_SINGLE", "# Write config register to the ADC", "bytes", "=", "[", "(", "config", ">>", "8", ")", "&", "0xFF", ",", "config", "&", "0xFF", "]", "self", ".", "i2c", ".", "writeList", "(", "self", ".", "__ADS1015_REG_POINTER_CONFIG", ",", "bytes", ")", "# Wait for the ADC conversion to complete", "# The minimum delay depends on the sps: delay >= 1/sps", "# We add 0.1ms to be sure", "delay", "=", "1.0", "/", "sps", "+", "0.0001", "time", ".", "sleep", "(", "delay", ")", "# Read the conversion results", "result", "=", "self", ".", "i2c", ".", "readList", "(", "self", ".", "__ADS1015_REG_POINTER_CONVERT", ",", "2", ")", "if", "(", "self", ".", "ic", "==", "self", ".", "__IC_ADS1015", ")", ":", "# Shift right 4 bits for the 12-bit ADS1015 and convert to mV", "return", "(", "(", "(", "result", "[", "0", "]", "<<", "8", ")", "|", "(", "result", "[", "1", "]", "&", "0xFF", ")", ")", ">>", "4", ")", "*", "pga", "/", "2048.0", "else", ":", "# Return a mV value for the ADS1115", "# (Take signed values into account as well)", "val", "=", "(", "result", "[", "0", "]", "<<", "8", ")", "|", "(", "result", "[", "1", "]", ")", "if", "val", ">", "0x7FFF", ":", "return", "(", "val", "-", "0xFFFF", ")", "*", "pga", "/", "32768.0", "else", ":", "return", "(", "(", "result", "[", "0", "]", "<<", "8", ")", "|", "(", "result", "[", "1", "]", ")", ")", "*", "pga", "/", "32768.0" ]

[ "Decodes", "data", "encoded", "with", "the", "encode_data", "function", "." ]

[ "def", "decode_data", "(", "data", ")", ":", "return", "pickle", ".", "loads", "(", "base64", ".", "b64decode", "(", "data", ")", ")" ]

[ "Solve", "eigenvalue", "problem", "for", "a", "real", "symmetric", "tridiagonal", "matrix", "." ]

[ "def", "eigvalsh_tridiagonal", "(", "d", ",", "e", ",", "select", "=", "'a'", ",", "select_range", "=", "None", ",", "check_finite", "=", "True", ",", "tol", "=", "0.", ",", "lapack_driver", "=", "'auto'", ")", ":", "return", "eigh_tridiagonal", "(", "d", ",", "e", ",", "eigvals_only", "=", "True", ",", "select", "=", "select", ",", "select_range", "=", "select_range", ",", "check_finite", "=", "check_finite", ",", "tol", "=", "tol", ",", "lapack_driver", "=", "lapack_driver", ")" ]

[ "Return", "true", "if", "header_name", "is", "an", "HTTP", "/", "1", ".", "1", "Hop", "-", "by", "-", "Hop", "header" ]

[ "def", "is_hop_by_hop", "(", "header_name", ")", ":", "return", "_hoppish", "(", "header_name", ".", "lower", "(", ")", ")" ]

[ "Get", "the", "latency", "of", "submissions", ":", "latency" ]

[ "def", "do_latency", "(", "self", ",", "arg", ")", ":", "if", "self", ".", "listener", ":", "if", "data", ":=", "self", ".", "listener", ".", "get_submission_latencies", "(", ")", ":", "_", ",", "_", ",", "latencies", "=", "list", "(", "zip", "(", "*", "data", ")", ")", "latencies", "=", "np", ".", "array", "(", "latencies", "[", "-", "10", ":", "]", ")", "if", "latencies", ".", "size", ":", "print", "(", "\"Rough delay between submit to action request received (10 most recent)\"", ")", "print", "(", "f\"avg: {latencies.mean()} seconds\"", ")", "return", "print", "(", "\"No requests received yet.\"", ")", "return", "print", "(", "\"No listener found.\"", ")" ]

[ "Return", "complete", "path", "for", "path", ".", "Prepends", "baseurl", "if", "necessary", "." ]

[ "def", "_fullpath", "(", "self", ",", "path", ")", ":", "splitpath", "=", "path", ".", "split", "(", "self", ".", "_baseurl", ",", "2", ")", "if", "len", "(", "splitpath", ")", "==", "1", ":", "result", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_baseurl", ",", "path", ")", "else", ":", "result", "=", "path", "# path contains baseurl already", "return", "result" ]

[ "This", "event", "is", "caused", "by", "a", "change", "in", "the", "SMS", "message", "status", "." ]

[ "def", "SmsMessageStatusChanged", "(", "self", ",", "Message", ",", "Status", ")", ":" ]

[ "Extract", "a", "sentence", "-", "level", "grammar", "on", "demand", "(", "or", "return", "cached", ")", "Threadsafe", "wrt", "extractor", "but", "NOT", "decoder", ".", "Acquire", "ctx_name", "lock", "before", "calling", "." ]

[ "def", "grammar", "(", "self", ",", "sentence", ",", "ctx_name", "=", "None", ")", ":", "self", ".", "extractor_lock", ".", "acquire", "(", ")", "self", ".", "lazy_ctx", "(", "ctx_name", ")", "grammar_dict", "=", "self", ".", "grammar_dict", "[", "ctx_name", "]", "grammar_file", "=", "grammar_dict", ".", "get", "(", "sentence", ",", "None", ")", "# Cache hit", "if", "grammar_file", ":", "logger", ".", "info", "(", "'({}) Grammar cache hit: {}'", ".", "format", "(", "ctx_name", ",", "grammar_file", ")", ")", "self", ".", "extractor_lock", ".", "release", "(", ")", "return", "grammar_file", "# Extract and cache", "(", "fid", ",", "grammar_file", ")", "=", "tempfile", ".", "mkstemp", "(", "dir", "=", "self", ".", "decoders", "[", "ctx_name", "]", ".", "tmp", ",", "prefix", "=", "'grammar.'", ",", "suffix", "=", "'.gz'", ")", "os", ".", "close", "(", "fid", ")", "self", ".", "extractor", ".", "grammar", "(", "sentence", ",", "grammar_file", ",", "ctx_name", ")", "grammar_files", "=", "self", ".", "grammar_files", "[", "ctx_name", "]", "if", "len", "(", "grammar_files", ")", "==", "self", ".", "cache_size", ":", "rm_sent", "=", "grammar_files", ".", "popleft", "(", ")", "# If not already removed by learn method", "if", "rm_sent", "in", "grammar_dict", ":", "rm_grammar", "=", "grammar_dict", ".", "pop", "(", "rm_sent", ")", "os", ".", "remove", "(", "rm_grammar", ")", "grammar_files", ".", "append", "(", "sentence", ")", "grammar_dict", "[", "sentence", "]", "=", "grammar_file", "self", ".", "extractor_lock", ".", "release", "(", ")", "return", "grammar_file" ]

[ "Entry", "point", "for", "the", "script", "." ]

[ "def", "generate_expansions", "(", ")", ":", "args", "=", "parse_args", "(", ")", "expansions", "=", "{", "}", "expansions", ".", "update", "(", "generate_version_expansions", "(", "args", ")", ")", "expansions", ".", "update", "(", "generate_scons_cache_expansions", "(", ")", ")", "with", "open", "(", "args", ".", "out", ",", "\"w\"", ")", "as", "out", ":", "print", "(", "\"saving compile expansions to {0}: ({1})\"", ".", "format", "(", "args", ".", "out", ",", "expansions", ")", ")", "yaml", ".", "safe_dump", "(", "expansions", ",", "out", ",", "default_flow_style", "=", "False", ")" ]

[ "check", "if", "we", "should", "skip", "this", "build", "because", "we", "do", "not", "support", "the", "board", "in", "this", "release" ]

[ "def", "skip_board_waf", "(", "self", ",", "board", ")", ":", "try", ":", "out", "=", "self", ".", "run_program", "(", "'waf'", ",", "[", "'./waf'", ",", "'configure'", ",", "'--board=BOARDTEST'", "]", ",", "False", ")", "lines", "=", "out", ".", "split", "(", "'\\n'", ")", "needles", "=", "[", "\"BOARDTEST' (choose from\"", ",", "\"BOARDTEST': choices are\"", "]", "for", "line", "in", "lines", ":", "for", "needle", "in", "needles", ":", "idx", "=", "line", ".", "find", "(", "needle", ")", "if", "idx", "!=", "-", "1", ":", "break", "if", "idx", "!=", "-", "1", ":", "line", "=", "line", "[", "idx", "+", "len", "(", "needle", ")", ":", "-", "1", "]", "line", "=", "line", ".", "replace", "(", "\"'\"", ",", "\"\"", ")", "line", "=", "line", ".", "replace", "(", "\" \"", ",", "\"\"", ")", "boards", "=", "line", ".", "split", "(", "\",\"", ")", "return", "board", "not", "in", "boards", "except", "IOError", "as", "e", ":", "if", "e", ".", "errno", "!=", "2", ":", "raise", "self", ".", "progress", "(", "\"Skipping unsupported board %s\"", "%", "(", "board", ",", ")", ")", "return", "True" ]

[ "Calculate", "a", "Sobel", "filter", "." ]

[ "def", "sobel", "(", "input", ",", "axis", "=", "-", "1", ",", "output", "=", "None", ",", "mode", "=", "\"reflect\"", ",", "cval", "=", "0.0", ")", ":", "input", "=", "numpy", ".", "asarray", "(", "input", ")", "axis", "=", "_ni_support", ".", "_check_axis", "(", "axis", ",", "input", ".", "ndim", ")", "output", ",", "return_value", "=", "_ni_support", ".", "_get_output", "(", "output", ",", "input", ")", "correlate1d", "(", "input", ",", "[", "-", "1", ",", "0", ",", "1", "]", ",", "axis", ",", "output", ",", "mode", ",", "cval", ",", "0", ")", "axes", "=", "[", "ii", "for", "ii", "in", "range", "(", "input", ".", "ndim", ")", "if", "ii", "!=", "axis", "]", "for", "ii", "in", "axes", ":", "correlate1d", "(", "output", ",", "[", "1", ",", "2", ",", "1", "]", ",", "ii", ",", "output", ",", "mode", ",", "cval", ",", "0", ")", "return", "return_value" ]

[ "Make", "a", "protobuf", "EnumDescriptor", "given", "an", "EnumDescriptorProto", "protobuf", "." ]

[ "def", "_ConvertEnumDescriptor", "(", "self", ",", "enum_proto", ",", "package", "=", "None", ",", "file_desc", "=", "None", ",", "containing_type", "=", "None", ",", "scope", "=", "None", ",", "top_level", "=", "False", ")", ":", "if", "package", ":", "enum_name", "=", "'.'", ".", "join", "(", "(", "package", ",", "enum_proto", ".", "name", ")", ")", "else", ":", "enum_name", "=", "enum_proto", ".", "name", "if", "file_desc", "is", "None", ":", "file_name", "=", "None", "else", ":", "file_name", "=", "file_desc", ".", "name", "values", "=", "[", "self", ".", "_MakeEnumValueDescriptor", "(", "value", ",", "index", ")", "for", "index", ",", "value", "in", "enumerate", "(", "enum_proto", ".", "value", ")", "]", "desc", "=", "descriptor", ".", "EnumDescriptor", "(", "name", "=", "enum_proto", ".", "name", ",", "full_name", "=", "enum_name", ",", "filename", "=", "file_name", ",", "file", "=", "file_desc", ",", "values", "=", "values", ",", "containing_type", "=", "containing_type", ",", "options", "=", "_OptionsOrNone", "(", "enum_proto", ")", ",", "# pylint: disable=protected-access", "create_key", "=", "descriptor", ".", "_internal_create_key", ")", "scope", "[", "'.%s'", "%", "enum_name", "]", "=", "desc", "self", ".", "_CheckConflictRegister", "(", "desc", ",", "desc", ".", "full_name", ",", "desc", ".", "file", ".", "name", ")", "self", ".", "_enum_descriptors", "[", "enum_name", "]", "=", "desc", "# Add top level enum values.", "if", "top_level", ":", "for", "value", "in", "values", ":", "full_name", "=", "_NormalizeFullyQualifiedName", "(", "'.'", ".", "join", "(", "(", "package", ",", "value", ".", "name", ")", ")", ")", "self", ".", "_CheckConflictRegister", "(", "value", ",", "full_name", ",", "file_name", ")", "self", ".", "_top_enum_values", "[", "full_name", "]", "=", "value", "return", "desc" ]

[ "Keep", "the", "current", "angle", "." ]

[ "def", "setAngle", "(", "self", ",", "delta", "=", "None", ")", ":", "if", "delta", ":", "self", ".", "mask", "=", "delta", "elif", "isinstance", "(", "self", ".", "mask", ",", "App", ".", "Vector", ")", ":", "self", ".", "mask", "=", "None", "elif", "self", ".", "trackLine", ":", "if", "self", ".", "trackLine", ".", "Visible", ":", "self", ".", "mask", "=", "self", ".", "trackLine", ".", "p2", "(", ")", ".", "sub", "(", "self", ".", "trackLine", ".", "p1", "(", ")", ")" ]

[ "Returns", "Specified", "Keywords", "List" ]

[ "def", "GetKeywords", "(", "self", ")", ":", "return", "[", "SECTION_KW", ",", "KEYWORDS", ",", "PARAM_KW", ",", "PREPROC_KW", ",", "PASCAL_KW", "]" ]

[ "Returns", "true", "if", "running", "on", "windows", "whether", "in", "cygwin", "or", "not", "." ]

[ "def", "on_windows", "(", ")", ":", "if", "bjam", ".", "variable", "(", "\"NT\"", ")", ":", "return", "True", "elif", "bjam", ".", "variable", "(", "\"UNIX\"", ")", ":", "uname", "=", "bjam", ".", "variable", "(", "\"JAMUNAME\"", ")", "if", "uname", "and", "uname", "[", "0", "]", ".", "startswith", "(", "\"CYGWIN\"", ")", ":", "return", "True", "return", "False" ]

[ "Skip", "function", "for", "unknown", "wire", "types", ".", "Raises", "an", "exception", "." ]

[ "def", "_RaiseInvalidWireType", "(", "buffer", ",", "pos", ",", "end", ")", ":", "raise", "_DecodeError", "(", "'Tag had invalid wire type.'", ")" ]

[ "Read", "prepare", "and", "assemble", "the", "list", "of", "source", "files", "." ]

[ "def", "PrepareSources", "(", "source_files", ",", "native_type", ",", "emit_js", ")", ":", "macro_file", "=", "None", "macro_files", "=", "filter", "(", "IsMacroFile", ",", "source_files", ")", "assert", "len", "(", "macro_files", ")", "in", "[", "0", ",", "1", "]", "if", "macro_files", ":", "source_files", ".", "remove", "(", "macro_files", "[", "0", "]", ")", "macro_file", "=", "macro_files", "[", "0", "]", "message_template_file", "=", "None", "message_template_files", "=", "filter", "(", "IsMessageTemplateFile", ",", "source_files", ")", "assert", "len", "(", "message_template_files", ")", "in", "[", "0", ",", "1", "]", "if", "message_template_files", ":", "source_files", ".", "remove", "(", "message_template_files", "[", "0", "]", ")", "message_template_file", "=", "message_template_files", "[", "0", "]", "filters", "=", "None", "if", "native_type", "in", "(", "\"EXTRAS\"", ",", "\"EXPERIMENTAL_EXTRAS\"", ")", ":", "filters", "=", "BuildExtraFilterChain", "(", ")", "else", ":", "filters", "=", "BuildFilterChain", "(", "macro_file", ",", "message_template_file", ")", "# Sort 'debugger' sources first.", "source_files", "=", "sorted", "(", "source_files", ",", "lambda", "l", ",", "r", ":", "IsDebuggerFile", "(", "r", ")", "-", "IsDebuggerFile", "(", "l", ")", ")", "source_files_and_contents", "=", "[", "(", "f", ",", "ReadFile", "(", "f", ")", ")", "for", "f", "in", "source_files", "]", "# Have a single not-quite-empty source file if there are none present;", "# otherwise you get errors trying to compile an empty C++ array.", "# It cannot be empty (or whitespace, which gets trimmed to empty), as", "# the deserialization code assumes each file is nonempty.", "if", "not", "source_files_and_contents", ":", "source_files_and_contents", "=", "[", "(", "\"dummy.js\"", ",", "\"(function() {})\"", ")", "]", "result", "=", "Sources", "(", ")", "for", "(", "source", ",", "contents", ")", "in", "source_files_and_contents", ":", "try", ":", "lines", "=", "filters", "(", "contents", ")", "except", "Error", "as", "e", ":", "raise", "Error", "(", "\"In file %s:\\n%s\"", "%", "(", "source", ",", "str", "(", "e", ")", ")", ")", "result", ".", "modules", ".", "append", "(", "lines", ")", "is_debugger", "=", "IsDebuggerFile", "(", "source", ")", "result", ".", "is_debugger_id", ".", "append", "(", "is_debugger", ")", "name", "=", "os", ".", "path", ".", "basename", "(", "source", ")", "[", ":", "-", "3", "]", "result", ".", "names", ".", "append", "(", "name", ")", "return", "result" ]

[ "Generate", "the", "definitions", "for", "generic", "argument", "or", "reply", "field", "lookup", "methods", "." ]

[ "def", "gen_field_list_entry_lookup_methods", "(", "self", ",", "field_list", ")", ":", "# type: (ast.FieldListBase) -> None", "field_list_info", "=", "generic_field_list_types", ".", "get_field_list_info", "(", "field_list", ")", "defn", "=", "field_list_info", ".", "get_has_field_method", "(", ")", ".", "get_definition", "(", ")", "with", "self", ".", "_block", "(", "'%s {'", "%", "(", "defn", ",", ")", ",", "'}'", ")", ":", "self", ".", "_writer", ".", "write_line", "(", "'return _genericFields.find(fieldName.toString()) != _genericFields.end();'", ")", "self", ".", "_writer", ".", "write_empty_line", "(", ")", "defn", "=", "field_list_info", ".", "get_should_forward_method", "(", ")", ".", "get_definition", "(", ")", "with", "self", ".", "_block", "(", "'%s {'", "%", "(", "defn", ",", ")", ",", "'}'", ")", ":", "self", ".", "_writer", ".", "write_line", "(", "'auto it = _genericFields.find(fieldName.toString());'", ")", "self", ".", "_writer", ".", "write_line", "(", "'return (it == _genericFields.end() || it->second);'", ")", "self", ".", "_writer", ".", "write_empty_line", "(", ")" ]

[ "Add", "ldflags", "at", "the", "end", "of", "current", "ldflags", "." ]

[ "def", "add_ldflags", "(", "self", ",", "flags", ")", ":", "collections", ".", "deque", "(", "map", "(", "self", ".", "__ldflags", ".", "add", ",", "flags", ")", ")", "return", "self" ]

[ "SetColumnText", "(", "self", "int", "column", "String", "text", ")" ]

[ "def", "SetColumnText", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "TreeListCtrl_SetColumnText", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Determines", "if", "the", "given", "filename", "has", "a", "suffix", "that", "identifies", "it", "as", "a", "test", "." ]

[ "def", "_IsTestFilename", "(", "filename", ")", ":", "if", "(", "filename", ".", "endswith", "(", "'_test.cc'", ")", "or", "filename", ".", "endswith", "(", "'_unittest.cc'", ")", "or", "filename", ".", "endswith", "(", "'_regtest.cc'", ")", ")", ":", "return", "True", "else", ":", "return", "False" ]

[ "Return", "a", "point", "snapped", "to", "extension", "or", "parallel", "line", "." ]

[ "def", "snapToExtensions", "(", "self", ",", "point", ",", "last", ",", "constrain", ",", "eline", ")", ":", "tsnap", "=", "self", ".", "snapToHold", "(", "point", ")", "if", "tsnap", ":", "if", "self", ".", "tracker", "and", "not", "self", ".", "selectMode", ":", "self", ".", "tracker", ".", "setCoords", "(", "tsnap", "[", "2", "]", ")", "self", ".", "tracker", ".", "setMarker", "(", "self", ".", "mk", "[", "tsnap", "[", "1", "]", "]", ")", "self", ".", "tracker", ".", "on", "(", ")", "if", "self", ".", "extLine", ":", "self", ".", "extLine", ".", "p1", "(", "tsnap", "[", "0", "]", ")", "self", ".", "extLine", ".", "p2", "(", "tsnap", "[", "2", "]", ")", "self", ".", "extLine", ".", "color", ".", "rgb", "=", "Gui", ".", "draftToolBar", ".", "getDefaultColor", "(", "\"line\"", ")", "self", ".", "extLine", ".", "on", "(", ")", "self", ".", "setCursor", "(", "tsnap", "[", "1", "]", ")", "return", "tsnap", "[", "2", "]", ",", "eline", "if", "self", ".", "isEnabled", "(", "\"Extension\"", ")", ":", "tsnap", "=", "self", ".", "snapToExtOrtho", "(", "last", ",", "constrain", ",", "eline", ")", "if", "tsnap", ":", "if", "(", "tsnap", "[", "0", "]", ".", "sub", "(", "point", ")", ")", ".", "Length", "<", "self", ".", "radius", ":", "if", "self", ".", "tracker", "and", "not", "self", ".", "selectMode", ":", "self", ".", "tracker", ".", "setCoords", "(", "tsnap", "[", "2", "]", ")", "self", ".", "tracker", ".", "setMarker", "(", "self", ".", "mk", "[", "tsnap", "[", "1", "]", "]", ")", "self", ".", "tracker", ".", "on", "(", ")", "if", "self", ".", "extLine", ":", "self", ".", "extLine", ".", "p2", "(", "tsnap", "[", "2", "]", ")", "self", ".", "extLine", ".", "color", ".", "rgb", "=", "Gui", ".", "draftToolBar", ".", "getDefaultColor", "(", "\"line\"", ")", "self", ".", "extLine", ".", "on", "(", ")", "self", ".", "setCursor", "(", "tsnap", "[", "1", "]", ")", "return", "tsnap", "[", "2", "]", ",", "eline", "else", ":", "tsnap", "=", "self", ".", "snapToExtPerpendicular", "(", "last", ")", "if", "tsnap", ":", "if", "(", "tsnap", "[", "0", "]", ".", "sub", "(", "point", ")", ")", ".", "Length", "<", "self", ".", "radius", ":", "if", "self", ".", "tracker", "and", "not", "self", ".", "selectMode", ":", "self", ".", "tracker", ".", "setCoords", "(", "tsnap", "[", "2", "]", ")", "self", ".", "tracker", ".", "setMarker", "(", "self", ".", "mk", "[", "tsnap", "[", "1", "]", "]", ")", "self", ".", "tracker", ".", "on", "(", ")", "if", "self", ".", "extLine", ":", "self", ".", "extLine", ".", "p2", "(", "tsnap", "[", "2", "]", ")", "self", ".", "extLine", ".", "color", ".", "rgb", "=", "Gui", ".", "draftToolBar", ".", "getDefaultColor", "(", "\"line\"", ")", "self", ".", "extLine", ".", "on", "(", ")", "self", ".", "setCursor", "(", "tsnap", "[", "1", "]", ")", "return", "tsnap", "[", "2", "]", ",", "eline", "for", "o", "in", "self", ".", "lastObj", ":", "if", "(", "self", ".", "isEnabled", "(", "'Extension'", ")", "or", "self", ".", "isEnabled", "(", "'Parallel'", ")", ")", ":", "ob", "=", "App", ".", "ActiveDocument", ".", "getObject", "(", "o", ")", "if", "not", "ob", ":", "continue", "if", "not", "ob", ".", "isDerivedFrom", "(", "\"Part::Feature\"", ")", ":", "continue", "edges", "=", "ob", ".", "Shape", ".", "Edges", "if", "Draft", ".", "getType", "(", "ob", ")", "==", "\"Wall\"", ":", "for", "so", "in", "[", "ob", "]", "+", "ob", ".", "Additions", ":", "if", "Draft", ".", "getType", "(", "so", ")", "==", "\"Wall\"", ":", "if", "so", ".", "Base", ":", "edges", ".", "extend", "(", "so", ".", "Base", ".", "Shape", ".", "Edges", ")", "edges", ".", "reverse", "(", ")", "if", "(", "not", "self", ".", "maxEdges", ")", "or", "(", "len", "(", "edges", ")", "<=", "self", ".", "maxEdges", ")", ":", "for", "e", "in", "edges", ":", "if", "DraftGeomUtils", ".", "geomType", "(", "e", ")", "!=", "\"Line\"", ":", "continue", "np", "=", "self", ".", "getPerpendicular", "(", "e", ",", "point", ")", "if", "(", "np", ".", "sub", "(", "point", ")", ")", ".", "Length", "<", "self", ".", "radius", ":", "if", "self", ".", "isEnabled", "(", "'Extension'", ")", ":", "if", "DraftGeomUtils", ".", "isPtOnEdge", "(", "np", ",", "e", ")", ":", "continue", "if", "np", "!=", "e", ".", "Vertexes", "[", "0", "]", ".", "Point", ":", "p0", "=", "e", ".", "Vertexes", "[", "0", "]", ".", "Point", "if", "self", ".", "tracker", "and", "not", "self", ".", "selectMode", ":", "self", ".", "tracker", ".", "setCoords", "(", "np", ")", "self", ".", "tracker", ".", "setMarker", "(", "self", ".", "mk", "[", "'extension'", "]", ")", "self", ".", "tracker", ".", "on", "(", ")", "if", "self", ".", "extLine", ":", "if", "self", ".", "snapStyle", ":", "dv", "=", "np", ".", "sub", "(", "p0", ")", "self", ".", "extLine", ".", "p1", "(", "p0", ".", "add", "(", "dv", ".", "multiply", "(", "0.5", ")", ")", ")", "else", ":", "self", ".", "extLine", ".", "p1", "(", "p0", ")", "self", ".", "extLine", ".", "p2", "(", "np", ")", "self", ".", "extLine", ".", "color", ".", "rgb", "=", "Gui", ".", "draftToolBar", ".", "getDefaultColor", "(", "\"line\"", ")", "self", ".", "extLine", ".", "on", "(", ")", "self", ".", "setCursor", "(", "'extension'", ")", "ne", "=", "Part", ".", "LineSegment", "(", "p0", ",", "np", ")", ".", "toShape", "(", ")", "# storing extension line for intersection calculations later", "if", "len", "(", "self", ".", "lastExtensions", ")", "==", "0", ":", "self", ".", "lastExtensions", ".", "append", "(", "ne", ")", "elif", "len", "(", "self", ".", "lastExtensions", ")", "==", "1", ":", "if", "not", "DraftGeomUtils", ".", "areColinear", "(", "ne", ",", "self", ".", "lastExtensions", "[", "0", "]", ")", ":", "self", ".", "lastExtensions", ".", "append", "(", "self", ".", "lastExtensions", "[", "0", "]", ")", "self", ".", "lastExtensions", "[", "0", "]", "=", "ne", "else", ":", "if", "(", "not", "DraftGeomUtils", ".", "areColinear", "(", "ne", ",", "self", ".", "lastExtensions", "[", "0", "]", ")", ")", "and", "(", "not", "DraftGeomUtils", ".", "areColinear", "(", "ne", ",", "self", ".", "lastExtensions", "[", "1", "]", ")", ")", ":", "self", ".", "lastExtensions", "[", "1", "]", "=", "self", ".", "lastExtensions", "[", "0", "]", "self", ".", "lastExtensions", "[", "0", "]", "=", "ne", "return", "np", ",", "ne", "elif", "self", ".", "isEnabled", "(", "'Parallel'", ")", ":", "if", "last", ":", "ve", "=", "DraftGeomUtils", ".", "vec", "(", "e", ")", "if", "not", "DraftVecUtils", ".", "isNull", "(", "ve", ")", ":", "de", "=", "Part", ".", "LineSegment", "(", "last", ",", "last", ".", "add", "(", "ve", ")", ")", ".", "toShape", "(", ")", "np", "=", "self", ".", "getPerpendicular", "(", "de", ",", "point", ")", "if", "(", "np", ".", "sub", "(", "point", ")", ")", ".", "Length", "<", "self", ".", "radius", ":", "if", "self", ".", "tracker", "and", "not", "self", ".", "selectMode", ":", "self", ".", "tracker", ".", "setCoords", "(", "np", ")", "self", ".", "tracker", ".", "setMarker", "(", "self", ".", "mk", "[", "'parallel'", "]", ")", "self", ".", "tracker", ".", "on", "(", ")", "self", ".", "setCursor", "(", "'parallel'", ")", "return", "np", ",", "de", "return", "point", ",", "eline" ]

[ "An", "iterator", "over", "the", "given", "futures", "that", "yields", "each", "as", "it", "completes", "." ]

[ "def", "as_completed", "(", "fs", ",", "timeout", "=", "None", ")", ":", "if", "timeout", "is", "not", "None", ":", "end_time", "=", "timeout", "+", "time", ".", "monotonic", "(", ")", "fs", "=", "set", "(", "fs", ")", "total_futures", "=", "len", "(", "fs", ")", "with", "_AcquireFutures", "(", "fs", ")", ":", "finished", "=", "set", "(", "f", "for", "f", "in", "fs", "if", "f", ".", "_state", "in", "[", "CANCELLED_AND_NOTIFIED", ",", "FINISHED", "]", ")", "pending", "=", "fs", "-", "finished", "waiter", "=", "_create_and_install_waiters", "(", "fs", ",", "_AS_COMPLETED", ")", "finished", "=", "list", "(", "finished", ")", "try", ":", "yield", "from", "_yield_finished_futures", "(", "finished", ",", "waiter", ",", "ref_collect", "=", "(", "fs", ",", ")", ")", "while", "pending", ":", "if", "timeout", "is", "None", ":", "wait_timeout", "=", "None", "else", ":", "wait_timeout", "=", "end_time", "-", "time", ".", "monotonic", "(", ")", "if", "wait_timeout", "<", "0", ":", "raise", "TimeoutError", "(", "'%d (of %d) futures unfinished'", "%", "(", "len", "(", "pending", ")", ",", "total_futures", ")", ")", "waiter", ".", "event", ".", "wait", "(", "wait_timeout", ")", "with", "waiter", ".", "lock", ":", "finished", "=", "waiter", ".", "finished_futures", "waiter", ".", "finished_futures", "=", "[", "]", "waiter", ".", "event", ".", "clear", "(", ")", "# reverse to keep finishing order", "finished", ".", "reverse", "(", ")", "yield", "from", "_yield_finished_futures", "(", "finished", ",", "waiter", ",", "ref_collect", "=", "(", "fs", ",", "pending", ")", ")", "finally", ":", "# Remove waiter from unfinished futures", "for", "f", "in", "fs", ":", "with", "f", ".", "_condition", ":", "f", ".", "_waiters", ".", "remove", "(", "waiter", ")" ]

[ "Sum", "the", "weights", "of", "true_positives", "." ]

[ "def", "true_positives", "(", "labels", ",", "predictions", ",", "weights", "=", "None", ",", "metrics_collections", "=", "None", ",", "updates_collections", "=", "None", ",", "name", "=", "None", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "name", ",", "'true_positives'", ",", "(", "predictions", ",", "labels", ",", "weights", ")", ")", ":", "predictions", ",", "labels", ",", "weights", "=", "_remove_squeezable_dimensions", "(", "predictions", "=", "math_ops", ".", "cast", "(", "predictions", ",", "dtype", "=", "dtypes", ".", "bool", ")", ",", "labels", "=", "math_ops", ".", "cast", "(", "labels", ",", "dtype", "=", "dtypes", ".", "bool", ")", ",", "weights", "=", "weights", ")", "is_true_positive", "=", "math_ops", ".", "logical_and", "(", "math_ops", ".", "equal", "(", "labels", ",", "True", ")", ",", "math_ops", ".", "equal", "(", "predictions", ",", "True", ")", ")", "return", "_count_condition", "(", "is_true_positive", ",", "weights", ",", "metrics_collections", ",", "updates_collections", ")" ]

[ "Collapses", "strings", "and", "chars", "on", "a", "line", "to", "simple", "or", "blocks", "." ]

[ "def", "_CollapseStrings", "(", "elided", ")", ":", "if", "not", "_RE_PATTERN_INCLUDE", ".", "match", "(", "elided", ")", ":", "# Remove escaped characters first to make quote/single quote collapsing", "# basic. Things that look like escaped characters shouldn't occur", "# outside of strings and chars.", "elided", "=", "_RE_PATTERN_CLEANSE_LINE_ESCAPES", ".", "sub", "(", "''", ",", "elided", ")", "elided", "=", "_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES", ".", "sub", "(", "\"''\"", ",", "elided", ")", "elided", "=", "_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES", ".", "sub", "(", "'\"\"'", ",", "elided", ")", "return", "elided" ]

[ "Remove", "all", "elements", "of", "another", "set", "from", "this", "set", "." ]

[ "def", "__isub__", "(", "self", ",", "other", ")", ":", "self", ".", "_binary_sanity_check", "(", "other", ")", "self", ".", "difference_update", "(", "other", ")", "return", "self" ]

[ "Move", "chart", "to", "right", "." ]

[ "def", "_on_key_right", "(", "self", ")", "->", "None", ":", "self", ".", "_right_ix", "+=", "1", "self", ".", "_right_ix", "=", "min", "(", "self", ".", "_right_ix", ",", "self", ".", "_manager", ".", "get_count", "(", ")", ")", "self", ".", "_update_x_range", "(", ")", "self", ".", "_cursor", ".", "move_right", "(", ")", "self", ".", "_cursor", ".", "update_info", "(", ")" ]

[ "Arguments", "are", "as", "described", "in", "the", "attribute", "description", "above", "." ]

[ "def", "__init__", "(", "self", ",", "name", ",", "index", ",", "number", ",", "type", "=", "None", ",", "options", "=", "None", ")", ":", "super", "(", "EnumValueDescriptor", ",", "self", ")", ".", "__init__", "(", "options", ",", "'EnumValueOptions'", ")", "self", ".", "name", "=", "name", "self", ".", "index", "=", "index", "self", ".", "number", "=", "number", "self", ".", "type", "=", "type" ]

[ "Run", "bakeoff", "F1", "test", "for", "NA12878" ]

[ "def", "_test_bakeoff", "(", "self", ",", "region", ",", "graph", ",", "skip_indexing", ",", "mapper", "=", "'map'", ",", "tag_ext", "=", "''", ",", "misc_opts", "=", "None", ",", "genotype", "=", "False", ")", ":", "assert", "not", "tag_ext", "or", "tag_ext", ".", "startswith", "(", "'-'", ")", "tag", "=", "'{}-{}{}'", ".", "format", "(", "region", ",", "graph", ",", "tag_ext", ")", "chrom", ",", "offset", "=", "self", ".", "_bakeoff_coords", "(", "region", ")", "if", "skip_indexing", ":", "xg_path", "=", "None", "gcsa_path", "=", "self", ".", "_input", "(", "'{}-{}.gcsa'", ".", "format", "(", "graph", ",", "region", ")", ")", "else", ":", "xg_path", "=", "None", "gcsa_path", "=", "None", "extra_opts", "=", "'--vcf_offsets {}'", ".", "format", "(", "offset", ")", "if", "misc_opts", ":", "extra_opts", "+=", "' {}'", ".", "format", "(", "misc_opts", ")", "# these are the options these tests were trained on. specify here instead of relying", "# on them being baked into toil-vg", "extra_opts", "+=", "' --min_mapq 15 --filter_opts \\' -r 0.9 -fu -m 1 -q 15 -D 999\\''", "self", ".", "_toil_vg_run", "(", "'NA12878'", ",", "chrom", ",", "self", ".", "_input", "(", "'{}-{}.vg'", ".", "format", "(", "graph", ",", "region", ")", ")", ",", "xg_path", ",", "gcsa_path", ",", "self", ".", "_input", "(", "'platinum_NA12878_{}.fq.gz'", ".", "format", "(", "region", ")", ")", ",", "self", ".", "_input", "(", "'platinum_NA12878_{}.vcf.gz'", ".", "format", "(", "region", ")", ")", ",", "self", ".", "_input", "(", "'chr{}.fa.gz'", ".", "format", "(", "chrom", ")", ")", ",", "True", ",", "mapper", ",", "extra_opts", ",", "genotype", ",", "tag", ")", "if", "self", ".", "verify", ":", "self", ".", "_verify_f1", "(", "'NA12878'", ",", "tag", ")" ]

[ "Given", "a", "FunctionPageInfo", "object", "Return", "the", "page", "as", "an", "md", "string", "." ]

[ "def", "_build_function_page", "(", "page_info", ")", ":", "parts", "=", "[", "'# %s\\n\\n'", "%", "page_info", ".", "full_name", "]", "if", "len", "(", "page_info", ".", "aliases", ")", ">", "1", ":", "parts", ".", "append", "(", "'### Aliases:\\n\\n'", ")", "parts", ".", "extend", "(", "'* `%s`\\n'", "%", "name", "for", "name", "in", "page_info", ".", "aliases", ")", "parts", ".", "append", "(", "'\\n'", ")", "if", "page_info", ".", "signature", "is", "not", "None", ":", "parts", ".", "append", "(", "_build_signature", "(", "page_info", ")", ")", "if", "page_info", ".", "defined_in", ":", "parts", ".", "append", "(", "'\\n\\n'", ")", "parts", ".", "append", "(", "str", "(", "page_info", ".", "defined_in", ")", ")", "parts", ".", "append", "(", "page_info", ".", "guides", ")", "parts", ".", "append", "(", "page_info", ".", "doc", ".", "docstring", ")", "parts", ".", "append", "(", "_build_function_details", "(", "page_info", ".", "doc", ".", "function_details", ")", ")", "parts", ".", "append", "(", "_build_compatibility", "(", "page_info", ".", "doc", ".", "compatibility", ")", ")", "return", "''", ".", "join", "(", "parts", ")" ]

[ "Deletes", "the", "item", "at", "the", "specified", "position", "." ]

[ "def", "__delitem__", "(", "self", ",", "key", ")", ":", "del", "self", ".", "_values", "[", "key", "]", "self", ".", "_message_listener", ".", "Modified", "(", ")" ]

[ "Determine", "how", "alternative", "communities", "are", "considered", "for", "moving", "a", "node", "for", "*", "optimising", "*", "a", "partition", "." ]

[ "def", "consider_comms", "(", "self", ")", ":", "return", "_c_leiden", ".", "_Optimiser_get_consider_comms", "(", "self", ".", "_optimiser", ")" ]

[ "Add", "(", "self", "String", "propClass", "String", "propLabel", "String", "propName", "String", "propValue", "PGChoices", "pChoices", "=", "None", ")", "-", ">", "PGProperty" ]

[ "def", "Add", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridPopulator_Add", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "the", "name", "of", "the", "auxiliary", "count", "member", "used", "for", "array", "typed", "." ]

[ "def", "CountName", "(", "name", ")", ":", "return", "'%s_bytes'", "%", "name" ]

[ "Runs", "the", "locomotion", "controller", "example", "." ]

[ "def", "_run_example", "(", "max_time", "=", "_MAX_TIME_SECONDS", ",", "run_on_robot", "=", "False", ",", "use_keyboard", "=", "False", ")", ":", "if", "use_keyboard", ":", "kb", "=", "keyboard_utils", ".", "KeyboardInput", "(", ")", "env", "=", "env_loader", ".", "load", "(", ")", "env", ".", "reset", "(", ")", "# To mitigate jittering from the python", "gc", ".", "collect", "(", ")", "# Wait for the robot to be placed properly.", "if", "run_on_robot", ":", "input", "(", "\"Press Enter to continue when robot is ready.\"", ")", "lin_speed", "=", "np", ".", "array", "(", "[", "0.0", ",", "0.0", ",", "0.0", "]", ")", "ang_speed", "=", "0.0", "controller", "=", "locomotion_controller_setup", ".", "setup_controller", "(", "env", ".", "robot", ",", "FLAGS", ".", "gait", ",", "run_on_robot", ",", "FLAGS", ".", "use_ground_truth_velocity", ")", "controller", ".", "reset", "(", ")", "loop_start_time", "=", "env", ".", "get_time_since_reset", "(", ")", "loop_elapsed_time", "=", "0", "robot_log", "=", "{", "\"timestamps\"", ":", "[", "]", ",", "\"motor_angles\"", ":", "[", "]", ",", "\"motor_velocities\"", ":", "[", "]", ",", "\"base_velocities\"", ":", "[", "]", ",", "\"foot_positions\"", ":", "[", "]", ",", "\"base_rollpitchyaw\"", ":", "[", "]", ",", "\"base_angular_velocities\"", ":", "[", "]", ",", "\"actions\"", ":", "[", "]", "}", "try", ":", "while", "loop_elapsed_time", "<", "max_time", ":", "#if use_keyboard:", "# lin_speed, ang_speed = _update_speed_from_kb(kb, lin_speed, ang_speed)", "#else:", "lin_speed", ",", "ang_speed", "=", "_generate_example_linear_angular_speed", "(", "loop_elapsed_time", ")", "# Needed before every call to get_action().", "_update_controller_params", "(", "controller", ",", "lin_speed", ",", "ang_speed", ")", "controller", ".", "update", "(", ")", "hybrid_action", "=", "controller", ".", "get_action", "(", ")", "# Log the robot data.", "robot_log", "[", "\"timestamps\"", "]", ".", "append", "(", "env", ".", "robot", ".", "GetTimeSinceReset", "(", ")", ")", "robot_log", "[", "\"motor_angles\"", "]", ".", "append", "(", "env", ".", "robot", ".", "motor_angles", ")", "robot_log", "[", "\"motor_velocities\"", "]", ".", "append", "(", "env", ".", "robot", ".", "motor_velocities", ")", "robot_log", "[", "\"base_velocities\"", "]", ".", "append", "(", "controller", ".", "state_estimator", ".", "com_velocity_body_yaw_aligned_frame", ")", "robot_log", "[", "\"foot_positions\"", "]", ".", "append", "(", "env", ".", "robot", ".", "foot_positions", "(", ")", ")", "robot_log", "[", "\"base_rollpitchyaw\"", "]", ".", "append", "(", "env", ".", "robot", ".", "base_roll_pitch_yaw", ")", "robot_log", "[", "\"base_angular_velocities\"", "]", ".", "append", "(", "env", ".", "robot", ".", "base_roll_pitch_yaw_rate", ")", "robot_log", "[", "\"actions\"", "]", ".", "append", "(", "hybrid_action", ")", "env", ".", "step", "(", "hybrid_action", ")", "loop_elapsed_time", "=", "env", ".", "get_time_since_reset", "(", ")", "-", "loop_start_time", "finally", ":", "if", "FLAGS", ".", "run_on_robot", ":", "# Apply zero torques to the robot.", "env", ".", "robot", ".", "apply_action", "(", "[", "0", "]", "*", "env", ".", "robot", ".", "num_motors", ",", "motor_control_mode", "=", "robot_config", ".", "MotorControlMode", ".", "TORQUE", ")", "if", "FLAGS", ".", "log_path", ":", "pickle", ".", "dump", "(", "robot_log", ",", "gfile", ".", "Open", "(", "FLAGS", ".", "log_path", "+", "\"/robot.log\"", ",", "\"wb\"", ")", ")" ]

[ "Jiggles", "the", "objects", "x", "-", "y", "positions", "within", "the", "range", "bmin", "-", "bmax", "and", "randomizes", "orientation", "about", "the", "z", "axis", "until", "the", "objects", "are", "collision", "free", ".", "A", "list", "of", "fixed", "objects", "(", "fixed_objects", ")", "may", "be", "given", "as", "well", "." ]

[ "def", "xy_jiggle", "(", "world", ",", "objects", ",", "fixed_objects", ",", "bmin", ",", "bmax", ",", "iters", ",", "randomize", "=", "True", ",", "verbose", "=", "0", ")", ":", "if", "randomize", ":", "for", "obj", "in", "objects", ":", "xy_randomize", "(", "obj", ",", "bmin", ",", "bmax", ")", "inner_iters", "=", "10", "while", "iters", ">", "0", ":", "numConflicts", "=", "[", "0", "]", "*", "len", "(", "objects", ")", "for", "(", "i", ",", "j", ")", "in", "collide", ".", "self_collision_iter", "(", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "]", ")", ":", "numConflicts", "[", "i", "]", "+=", "1", "numConflicts", "[", "j", "]", "+=", "1", "for", "(", "i", ",", "j", ")", "in", "collide", ".", "group_collision_iter", "(", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "]", ",", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "fixed_objects", "]", ")", ":", "numConflicts", "[", "i", "]", "+=", "1", "amax", "=", "max", "(", "(", "c", ",", "i", ")", "for", "(", "i", ",", "c", ")", "in", "enumerate", "(", "numConflicts", ")", ")", "[", "1", "]", "cmax", "=", "numConflicts", "[", "amax", "]", "if", "cmax", "==", "0", ":", "#conflict free", "return", "if", "verbose", ":", "print", "cmax", ",", "\"conflicts with object\"", ",", "objects", "[", "amax", "]", ".", "getName", "(", ")", "other_geoms", "=", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "[", ":", "amax", "]", "+", "objects", "[", "amax", "+", "1", ":", "]", "+", "fixed_objects", "]", "for", "it", "in", "xrange", "(", "inner_iters", ")", ":", "xy_randomize", "(", "objects", "[", "amax", "]", ",", "bmin", ",", "bmax", ")", "nc", "=", "sum", "(", "[", "1", "for", "p", "in", "collide", ".", "group_collision_iter", "(", "[", "objects", "[", "amax", "]", ".", "geometry", "(", ")", "]", ",", "other_geoms", ")", "]", ")", "if", "nc", "<", "cmax", ":", "break", "iters", "-=", "1", "if", "verbose", ":", "print", "\"Now\"", ",", "nc", ",", "\"conflicts with object\"", ",", "objects", "[", "amax", "]", ".", "getName", "(", ")", "numConflicts", "=", "[", "0", "]", "*", "len", "(", "objects", ")", "for", "(", "i", ",", "j", ")", "in", "collide", ".", "self_collision_iter", "(", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "]", ")", ":", "numConflicts", "[", "i", "]", "+=", "1", "numConflicts", "[", "j", "]", "+=", "1", "for", "(", "i", ",", "j", ")", "in", "collide", ".", "group_collision_iter", "(", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "]", ",", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "fixed_objects", "]", ")", ":", "numConflicts", "[", "i", "]", "+=", "1", "removed", "=", "[", "]", "while", "max", "(", "numConflicts", ")", ">", "0", ":", "amax", "=", "max", "(", "(", "c", ",", "i", ")", "for", "(", "i", ",", "c", ")", "in", "enumerate", "(", "numConflicts", ")", ")", "[", "1", "]", "cmax", "=", "numConflicts", "[", "amax", "]", "if", "verbose", ":", "print", "\"Unable to find conflict-free configuration for object\"", ",", "objects", "[", "amax", "]", ".", "getName", "(", ")", ",", "\"with\"", ",", "cmax", ",", "\"conflicts\"", "removed", ".", "append", "(", "amax", ")", "#revise # of conflicts -- this could be faster, but whatever...", "numConflicts", "=", "[", "0", "]", "*", "len", "(", "objects", ")", "for", "(", "i", ",", "j", ")", "in", "collide", ".", "self_collision_iter", "(", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "]", ")", ":", "if", "i", "in", "removed", "or", "j", "in", "removed", ":", "continue", "numConflicts", "[", "i", "]", "+=", "1", "numConflicts", "[", "j", "]", "+=", "1", "for", "(", "i", ",", "j", ")", "in", "collide", ".", "group_collision_iter", "(", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "objects", "]", ",", "[", "o", ".", "geometry", "(", ")", "for", "o", "in", "fixed_objects", "]", ")", ":", "if", "i", "in", "removed", ":", "continue", "numConflicts", "[", "i", "]", "+=", "1", "return", "removed" ]

[ "Returns", "a", "topology", "object", "." ]

[ "def", "get_connections", "(", "self", ")", ":", "return", "self", ".", "__connections" ]

[ "Forward", "pass", ":", "prepare", "inputs", "and", "run", "the", "net", "forward", "." ]

[ "def", "_Net_forward", "(", "self", ",", "blobs", "=", "None", ",", "start", "=", "None", ",", "end", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "blobs", "is", "None", ":", "blobs", "=", "[", "]", "if", "start", "is", "not", "None", ":", "start_ind", "=", "list", "(", "self", ".", "_layer_names", ")", ".", "index", "(", "start", ")", "else", ":", "start_ind", "=", "0", "if", "end", "is", "not", "None", ":", "end_ind", "=", "list", "(", "self", ".", "_layer_names", ")", ".", "index", "(", "end", ")", "outputs", "=", "set", "(", "[", "end", "]", "+", "blobs", ")", "else", ":", "end_ind", "=", "len", "(", "self", ".", "layers", ")", "-", "1", "outputs", "=", "set", "(", "self", ".", "outputs", "+", "blobs", ")", "if", "kwargs", ":", "if", "set", "(", "kwargs", ".", "keys", "(", ")", ")", "!=", "set", "(", "self", ".", "inputs", ")", ":", "raise", "Exception", "(", "'Input blob arguments do not match net inputs.'", ")", "# Set input according to defined shapes and make arrays single and", "# C-contiguous as Caffe expects.", "for", "in_", ",", "blob", "in", "kwargs", ".", "iteritems", "(", ")", ":", "if", "blob", ".", "shape", "[", "0", "]", "!=", "self", ".", "blobs", "[", "in_", "]", ".", "num", ":", "raise", "Exception", "(", "'Input is not batch sized'", ")", "self", ".", "blobs", "[", "in_", "]", ".", "data", "[", "...", "]", "=", "blob", "self", ".", "_forward", "(", "start_ind", ",", "end_ind", ")", "# Unpack blobs to extract", "return", "{", "out", ":", "self", ".", "blobs", "[", "out", "]", ".", "data", "for", "out", "in", "outputs", "}" ]

[ "Get", "a", "list", "of", "column", "names", "for", "the", "query", ".", "The", "query", "must", "have", "a", "result", "set", "." ]

[ "def", "get_column_names", "(", "self", ",", "last_query_handle", ")", ":", "raise", "NotImplementedError", "(", ")" ]

[ "Record", "defect", "on", "obj", "." ]

[ "def", "register_defect", "(", "self", ",", "obj", ",", "defect", ")", ":", "obj", ".", "defects", ".", "append", "(", "defect", ")" ]

[ "Load", "anns", "with", "the", "specified", "ids", ".", ":", "param", "ids", "(", "int", "array", ")", ":", "integer", "ids", "specifying", "img", ":", "return", ":", "imgs", "(", "object", "array", ")", ":", "loaded", "img", "objects" ]

[ "def", "loadImgs", "(", "self", ",", "ids", "=", "[", "]", ")", ":", "if", "type", "(", "ids", ")", "==", "list", ":", "return", "[", "self", ".", "imgs", "[", "id", "]", "for", "id", "in", "ids", "]", "elif", "type", "(", "ids", ")", "==", "int", ":", "return", "[", "self", ".", "imgs", "[", "ids", "]", "]" ]

[ "Return", "the", "set", "of", "directories", "required", "by", "the", "paths", "in", "the", "container", "in", "no", "particular", "order", ".", "The", "returned", "directories", "are", "relative", "to", "an", "unspecified", "(", "virtual", ")", "root", "directory", "(", "and", "do", "not", "include", "said", "root", "directory", ")", "." ]

[ "def", "required_directories", "(", "self", ")", ":", "return", "set", "(", "k", "for", "k", ",", "v", "in", "self", ".", "_required_directories", ".", "items", "(", ")", "if", "v", ">", "0", ")" ]

[ "Check", "whether", "the", "tool", "exists" ]

[ "def", "exists", "(", "env", ")", ":", "from", "SCons", ".", "Tool", ".", "GettextCommon", "import", "_xgettext_exists", "try", ":", "return", "_xgettext_exists", "(", "env", ")", "except", ":", "return", "False" ]

[ "Initializer", "." ]

[ "def", "__init__", "(", "self", ",", "content", "=", "None", ")", ":", "if", "content", "is", "not", "None", ":", "assert", "isinstance", "(", "content", ",", "BasePattern", ")", ",", "repr", "(", "content", ")", "self", ".", "content", "=", "content" ]

[ "Create", "a", "data", "reader", "for", "CosmoFlow", "." ]

[ "def", "create_cosmoflow_data_reader", "(", "train_path", ",", "val_path", ",", "test_path", ",", "num_responses", ")", ":", "reader_args", "=", "[", "{", "\"role\"", ":", "\"train\"", ",", "\"data_filename\"", ":", "train_path", "}", ",", "{", "\"role\"", ":", "\"validate\"", ",", "\"data_filename\"", ":", "val_path", "}", ",", "{", "\"role\"", ":", "\"test\"", ",", "\"data_filename\"", ":", "test_path", "}", ",", "]", "for", "reader_arg", "in", "reader_args", ":", "reader_arg", "[", "\"data_file_pattern\"", "]", "=", "\"{}/*.hdf5\"", ".", "format", "(", "reader_arg", "[", "\"data_filename\"", "]", ")", "reader_arg", "[", "\"hdf5_key_data\"", "]", "=", "\"full\"", "reader_arg", "[", "\"hdf5_key_responses\"", "]", "=", "\"unitPar\"", "reader_arg", "[", "\"num_responses\"", "]", "=", "num_responses", "reader_arg", ".", "pop", "(", "\"data_filename\"", ")", "readers", "=", "[", "]", "for", "reader_arg", "in", "reader_args", ":", "reader", "=", "lbann", ".", "reader_pb2", ".", "Reader", "(", "name", "=", "\"hdf5\"", ",", "shuffle", "=", "(", "reader_arg", "[", "\"role\"", "]", "!=", "\"test\"", ")", ",", "validation_percent", "=", "0", ",", "absolute_sample_count", "=", "0", ",", "percent_of_data_to_use", "=", "1.0", ",", "disable_labels", "=", "True", ",", "disable_responses", "=", "False", ",", "scaling_factor_int16", "=", "1.0", ",", "*", "*", "reader_arg", ")", "readers", ".", "append", "(", "reader", ")", "return", "lbann", ".", "reader_pb2", ".", "DataReader", "(", "reader", "=", "readers", ")" ]

[ "We", "picked", "a", "thingo!" ]

[ "def", "_OnRPSChoice", "(", "self", ",", "state", ",", "which", ",", "events", ")", ":", "if", "PtWasLocallyNotified", "(", "self", ".", "key", ")", ":", "self", ".", "_round_played", "=", "True", "if", "self", ".", "sceneobject", ".", "isLocallyOwned", "(", ")", ":", "avatar", "=", "PtFindAvatar", "(", "events", ")", "seat", "=", "self", ".", "players", ".", "index", "(", "PtGetClientIDFromAvatarKey", "(", "avatar", ".", "getKey", "(", ")", ")", ")", "self", ".", "SDL", ".", "setIndex", "(", "SDL_CUR_SELECTION", ",", "seat", ",", "which", "+", "1", ")", "# Waiting on moves? You just got one. COUNTDOWN!", "if", "self", ".", "game_state", "==", "GAME_AWAIT_MOVES", ":", "self", ".", "game_state", "=", "GAME_MOVE_COUNTDOWN" ]

[ "Appends", "value", "to", "the", "build", "setting", "for", "key", "which", "is", "treated", "as", "a", "list", "in", "all", "child", "XCBuildConfiguration", "objects", "." ]

[ "def", "AppendBuildSetting", "(", "self", ",", "key", ",", "value", ")", ":", "for", "configuration", "in", "self", ".", "_properties", "[", "'buildConfigurations'", "]", ":", "configuration", ".", "AppendBuildSetting", "(", "key", ",", "value", ")" ]

[ "AddBackSorted", "(", "TIntV", "self", "TInt", "Val", "bool", "const", "&", "Asc", ")", "-", ">", "int" ]

[ "def", "AddBackSorted", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TIntV_AddBackSorted", "(", "self", ",", "*", "args", ")" ]

[ "Return", "a", "list", "of", "lambda", "functions", "expressing", "the", "domain", "bounds", "as", "linear", "constraints", ".", "Used", "by", "COBYLA", "." ]

[ "def", "get_constraint_list", "(", "self", ")", ":", "constraints", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "num_repeats", ")", ":", "# Using start_index, start each domain at the correct index when flattening out points in COBYLA.", "constraints", ".", "extend", "(", "self", ".", "_domain", ".", "get_constraint_list", "(", "start_index", "=", "self", ".", "dim", "*", "i", ")", ")", "return", "constraints" ]

[ "Print", "msg", "to", "stdout", "if", "the", "global", "DEBUG", "(", "taken", "from", "the", "DISTUTILS_DEBUG", "environment", "variable", ")", "flag", "is", "true", "." ]

[ "def", "debug_print", "(", "self", ",", "msg", ")", ":", "from", "distutils", ".", "debug", "import", "DEBUG", "if", "DEBUG", ":", "print", "(", "msg", ")" ]

[ "Write", "the", "header", "for", "an", "array", "using", "the", "2", ".", "0", "format", ".", "The", "2", ".", "0", "format", "allows", "storing", "very", "large", "structured", "arrays", "." ]

[ "def", "write_array_header_2_0", "(", "fp", ",", "d", ")", ":", "_write_array_header", "(", "fp", ",", "d", ",", "(", "2", ",", "0", ")", ")" ]

[ "Returns", "carla", "traffic", "light", "state", "based", "on", "sumo", "traffic", "light", "state", "." ]

[ "def", "get_carla_traffic_light_state", "(", "sumo_tl_state", ")", ":", "if", "sumo_tl_state", "==", "SumoSignalState", ".", "RED", "or", "sumo_tl_state", "==", "SumoSignalState", ".", "RED_YELLOW", ":", "return", "carla", ".", "TrafficLightState", ".", "Red", "elif", "sumo_tl_state", "==", "SumoSignalState", ".", "YELLOW", ":", "return", "carla", ".", "TrafficLightState", ".", "Yellow", "elif", "sumo_tl_state", "==", "SumoSignalState", ".", "GREEN", "or", "sumo_tl_state", "==", "SumoSignalState", ".", "GREEN_WITHOUT_PRIORITY", ":", "return", "carla", ".", "TrafficLightState", ".", "Green", "elif", "sumo_tl_state", "==", "SumoSignalState", ".", "OFF", ":", "return", "carla", ".", "TrafficLightState", ".", "Off", "else", ":", "# SumoSignalState.GREEN_RIGHT_TURN and SumoSignalState.OFF_BLINKING", "return", "carla", ".", "TrafficLightState", ".", "Unknown" ]

[ "Generates", "a", "list", "of", "run", "numbers", "as", "a", "list", "from", "the", "input", ".", "This", "input", "can", "be", "either", "a", "string", "or", "int", "type", "and", "uses", "the", "same", "syntax", "that", "Mantid", "supports", "i", ".", "e", ".", "1", "-", "10", "generates", "1", "2", "3", "...", "9", "10", "inclusive", "and", "commas", "can", "specify", "breaks", "between", "runs", ":", "param", "run_number_string", ":", "The", "string", "or", "int", "to", "convert", "into", "a", "list", "of", "run", "numbers", ":", "return", ":", "A", "list", "of", "run", "numbers", "generated", "from", "the", "string" ]

[ "def", "generate_run_numbers", "(", "run_number_string", ")", ":", "# Check its not a single run", "if", "isinstance", "(", "run_number_string", ",", "int", ")", ":", "# Cast into a list and return", "return", "[", "run_number_string", "]", "elif", "isinstance", "(", "run_number_string", ",", "str", ")", "and", "run_number_string", ".", "isdigit", "(", ")", ":", "# We can let Python handle the conversion in this case", "return", "[", "int", "(", "run_number_string", ")", "]", "# If its a string we must parse it", "run_number_string", "=", "run_number_string", ".", "strip", "(", ")", "run_boundaries", "=", "run_number_string", ".", "replace", "(", "'_'", ",", "'-'", ")", "# Accept either _ or - delimiters", "run_list", "=", "_run_number_generator", "(", "processed_string", "=", "run_boundaries", ")", "return", "run_list" ]

[ "Temperature", "units", "must", "be", "degrees", "C", "." ]

[ "def", "verify_units", "(", "self", ",", "units", ")", ":", "return", "units", "in", "[", "DEGREES_C", ",", "DEGREES_c", "]" ]

[ ":", "type", "points", ":", "List", "[", "List", "[", "int", "]]", ":", "rtype", ":", "int" ]

[ "def", "minTimeToVisitAllPoints", "(", "self", ",", "points", ")", ":", "return", "sum", "(", "max", "(", "abs", "(", "points", "[", "i", "+", "1", "]", "[", "0", "]", "-", "points", "[", "i", "]", "[", "0", "]", ")", ",", "abs", "(", "points", "[", "i", "+", "1", "]", "[", "1", "]", "-", "points", "[", "i", "]", "[", "1", "]", ")", ")", "for", "i", "in", "xrange", "(", "len", "(", "points", ")", "-", "1", ")", ")" ]

[ "PrependIconTextColumn", "(", "self", "PyObject", "label_or_bitmap", "unsigned", "int", "model_column", "int", "mode", "=", "DATAVIEW_CELL_INERT", "int", "width", "=", "-", "1", "int", "align", "=", "ALIGN_NOT", "int", "flags", "=", "DATAVIEW_COL_RESIZABLE", ")", "-", ">", "DataViewColumn" ]

[ "def", "PrependIconTextColumn", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewCtrl_PrependIconTextColumn", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Read", "a", "single", "mime", ".", "types", "-", "format", "file", "." ]

[ "def", "readfp", "(", "self", ",", "fp", ",", "strict", "=", "True", ")", ":", "while", "1", ":", "line", "=", "fp", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "words", "=", "line", ".", "split", "(", ")", "for", "i", "in", "range", "(", "len", "(", "words", ")", ")", ":", "if", "words", "[", "i", "]", "[", "0", "]", "==", "'#'", ":", "del", "words", "[", "i", ":", "]", "break", "if", "not", "words", ":", "continue", "type", ",", "suffixes", "=", "words", "[", "0", "]", ",", "words", "[", "1", ":", "]", "for", "suff", "in", "suffixes", ":", "self", ".", "add_type", "(", "type", ",", "'.'", "+", "suff", ",", "strict", ")" ]

[]

[ "def", "_on_server_send_timeout", "(", "self", ",", "keys", ",", "key_infos_map", ",", "group_id", ")", ":", "same_meta", "=", "lambda", "lhs", ",", "rhs", ":", "(", "lhs", ".", "timestamp", ",", "lhs", ".", "size", ",", "lhs", ".", "user_flags", ")", "==", "(", "rhs", ".", "timestamp", ",", "rhs", ".", "size", ",", "rhs", ".", "user_flags", ")", "num_failed_keys", "=", "0", "for", "key", "in", "keys", ":", "key_infos", "=", "key_infos_map", "[", "str", "(", "key", ")", "]", "filtered_key_infos", "=", "self", ".", "_get_unprocessed_key_infos", "(", "key_infos", ",", "group_id", ")", "if", "len", "(", "filtered_key_infos", ")", ">", "1", ":", "current_meta", "=", "filtered_key_infos", "[", "0", "]", "next_meta", "=", "filtered_key_infos", "[", "1", "]", "if", "same_meta", "(", "current_meta", ",", "next_meta", ")", ":", "self", ".", "buckets", ".", "on_server_send_fail", "(", "key", ",", "key_infos", ",", "next_meta", ".", "group_id", ")", "continue", "num_failed_keys", "+=", "1", "if", "num_failed_keys", ">", "0", ":", "self", ".", "result", "=", "False", "self", ".", "_update_timeouted_keys_stats", "(", "num_failed_keys", ")" ]

[ "Read", "in", "the", "header", "block", "data", ".", "This", "block", "comprises", "4", "fortran", "records", "which", "we", "refer", "to", "as", ":", "header", "table1", "table2", "summary", "." ]

[ "def", "read_header", "(", "self", ")", ":", "# read header record", "header", "=", "self", ".", "get_fortran_record", "(", ")", "# interpret header", "self", ".", "kod", "=", "header", ".", "get_string", "(", "8", ")", "[", "0", "]", "# code identifier", "if", "'SF_00001'", "not", "in", "self", ".", "kod", ":", "self", ".", "ver", "=", "header", ".", "get_string", "(", "5", ")", "[", "0", "]", "# code version identifier", "if", "'2.6.0'", "in", "self", ".", "ver", ":", "self", ".", "loddat", "=", "header", ".", "get_string", "(", "28", ")", "[", "0", "]", "# code version date", "elif", "'5 '", "in", "self", ".", "ver", ":", "self", ".", "loddat", "=", "header", ".", "get_string", "(", "8", ")", "[", "0", "]", "# code version date", "else", ":", "raise", "NotImplementedError", "(", "\"MCNP5/X Version:\"", "+", "self", ".", "ver", ".", "rstrip", "(", ")", "+", "\" not supported\"", ")", "self", ".", "idtm", "=", "header", ".", "get_string", "(", "19", ")", "[", "0", "]", "# current date and time", "self", ".", "probid", "=", "header", ".", "get_string", "(", "19", ")", "[", "0", "]", "# problem id string", "self", ".", "aid", "=", "header", ".", "get_string", "(", "80", ")", "[", "0", "]", "# title card of initial run", "self", ".", "knod", "=", "header", ".", "get_int", "(", ")", "[", "0", "]", "# dump number", "# read table 1 record; various counts and sizes", "tablelengths", "=", "self", ".", "get_fortran_record", "(", ")", "# interpret table lengths", "if", "'2.6.0'", "in", "self", ".", "ver", ":", "self", ".", "np1", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# hist used to gen. src", "self", ".", "nrss", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# #tracks to surf src", "else", ":", "self", ".", "np1", "=", "tablelengths", ".", "get_long", "(", ")", "[", "0", "]", "# hist used to gen. src", "self", ".", "nrss", "=", "tablelengths", ".", "get_long", "(", ")", "[", "0", "]", "# #tracks to surf src", "# values in surf src record", "# 6 for a spherical source", "# 11 otherwise", "self", ".", "ncrd", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "self", ".", "njsw", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# number of surfaces", "self", ".", "niss", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# #histories to surf src", "self", ".", "table1extra", "=", "list", "(", ")", "while", "tablelengths", ".", "num_bytes", ">", "tablelengths", ".", "pos", ":", "self", ".", "table1extra", "+=", "tablelengths", ".", "get_int", "(", ")", "elif", "'SF_00001'", "in", "self", ".", "kod", ":", "header", "=", "self", ".", "get_fortran_record", "(", ")", "self", ".", "ver", "=", "header", ".", "get_string", "(", "12", ")", "[", "0", "]", "# code version identifier", "self", ".", "loddat", "=", "header", ".", "get_string", "(", "9", ")", "[", "0", "]", "# code version date", "self", ".", "idtm", "=", "header", ".", "get_string", "(", "19", ")", "[", "0", "]", "# current date and time", "self", ".", "probid", "=", "header", ".", "get_string", "(", "19", ")", "[", "0", "]", "# problem id string", "self", ".", "aid", "=", "header", ".", "get_string", "(", "80", ")", "[", "0", "]", "# title card of initial run", "self", ".", "knod", "=", "header", ".", "get_int", "(", ")", "[", "0", "]", "# dump number", "# read table 1 record; various counts and sizes", "tablelengths", "=", "self", ".", "get_fortran_record", "(", ")", "# interpret table lengths", "self", ".", "np1", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# hist used to gen.source", "self", ".", "notsure0", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# vals in surf src rec.", "self", ".", "nrss", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# tracks writ. to surf.src", "self", ".", "notsure1", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# number of surfaces", "self", ".", "ncrd", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# histories to surf.src", "self", ".", "njsw", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# number of surfaces", "self", ".", "niss", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# histories to surf.src", "self", ".", "table1extra", "=", "list", "(", ")", "while", "tablelengths", ".", "num_bytes", ">", "tablelengths", ".", "pos", ":", "self", ".", "table1extra", "+=", "tablelengths", ".", "get_int", "(", ")", "if", "self", ".", "np1", "<", "0", ":", "# read table 2 record; more size info", "tablelengths", "=", "self", ".", "get_fortran_record", "(", ")", "self", ".", "niwr", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# #cells in surf.src card", "self", ".", "mipts", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# source particle type", "self", ".", "kjaq", "=", "tablelengths", ".", "get_int", "(", ")", "[", "0", "]", "# macrobody facet flag", "self", ".", "table2extra", "=", "list", "(", ")", "while", "tablelengths", ".", "num_bytes", ">", "tablelengths", ".", "pos", ":", "self", ".", "table2extra", "+=", "tablelengths", ".", "get_int", "(", ")", "else", ":", "pass", "# Since np1 can be negative, preserve the actual np1 value while", "# taking the absolute value so that np1 can be used mathematically", "self", ".", "orignp1", "=", "self", ".", "np1", "self", ".", "np1", "=", "abs", "(", "self", ".", "np1", ")", "# get info for each surface", "self", ".", "surflist", "=", "list", "(", ")", "for", "j", "in", "range", "(", "self", ".", "njsw", ")", ":", "# read next surface info record", "self", ".", "surfaceinfo", "=", "self", ".", "get_fortran_record", "(", ")", "surfinfo", "=", "SourceSurf", "(", ")", "surfinfo", ".", "id", "=", "self", ".", "surfaceinfo", ".", "get_int", "(", ")", "# surface ID", "if", "self", ".", "kjaq", "==", "1", ":", "surfinfo", ".", "facet_id", "=", "self", ".", "surfaceinfo", ".", "get_int", "(", ")", "# facet ID", "else", ":", "surfinfo", ".", "facet_id", "=", "-", "1", "# dummy facet ID", "surfinfo", ".", "type", "=", "self", ".", "surfaceinfo", ".", "get_int", "(", ")", "# surface type", "surfinfo", ".", "num_params", "=", "self", ".", "surfaceinfo", ".", "get_int", "(", ")", "[", "0", "]", "# #surface prm", "surfinfo", ".", "surf_params", "=", "self", ".", "surfaceinfo", ".", "get_double", "(", "surfinfo", ".", "num_params", ")", "self", ".", "surflist", ".", "append", "(", "surfinfo", ")", "# we read any extra records as determined by njsw+niwr...", "# no known case of their actual utility is known currently", "for", "j", "in", "range", "(", "self", ".", "njsw", ",", "self", ".", "njsw", "+", "self", ".", "niwr", ")", ":", "self", ".", "get_fortran_record", "(", ")", "warn", "(", "\"Extra info in header not handled: {0}\"", ".", "format", "(", "j", ")", ",", "RuntimeWarning", ")", "# read summary table record", "summary_info", "=", "self", ".", "get_fortran_record", "(", ")", "self", ".", "summary_table", "=", "summary_info", ".", "get_int", "(", "(", "2", "+", "4", "*", "self", ".", "mipts", ")", "*", "(", "self", ".", "njsw", "+", "self", ".", "niwr", ")", "+", "1", ")", "self", ".", "summary_extra", "=", "list", "(", ")", "while", "summary_info", ".", "num_bytes", ">", "summary_info", ".", "pos", ":", "self", ".", "summary_extra", "+=", "summary_info", ".", "get_int", "(", ")" ]

[ "True", "if", "a", "path", "points", "to", "an", "existing", "file", "system", "object", "." ]

[ "def", "Exists", "(", "self", ",", "file_path", ")", ":", "if", "file_path", "is", "None", ":", "raise", "TypeError", "if", "not", "file_path", ":", "return", "False", "try", ":", "file_path", "=", "self", ".", "ResolvePath", "(", "file_path", ")", "except", "IOError", ":", "return", "False", "if", "file_path", "==", "self", ".", "root", ".", "name", ":", "return", "True", "path_components", "=", "self", ".", "GetPathComponents", "(", "file_path", ")", "current_dir", "=", "self", ".", "root", "for", "component", "in", "path_components", ":", "if", "component", "not", "in", "current_dir", ".", "contents", ":", "return", "False", "current_dir", "=", "current_dir", ".", "contents", "[", "component", "]", "return", "True" ]

[ "Sets", "the", "output", "format", "for", "errors", "." ]

[ "def", "SetOutputFormat", "(", "self", ",", "output_format", ")", ":", "self", ".", "output_format", "=", "output_format" ]

[ "Count", "the", "total", "moves", "in", "a", "game", "range", "." ]

[ "def", "count_moves_in_game_range", "(", "self", ",", "game_begin", ",", "game_end", ")", ":", "rows", "=", "self", ".", "bt_table", ".", "read_rows", "(", "ROWCOUNT_PREFIX", ".", "format", "(", "game_begin", ")", ",", "ROWCOUNT_PREFIX", ".", "format", "(", "game_end", ")", ",", "filter_", "=", "bigtable_row_filters", ".", "ColumnRangeFilter", "(", "METADATA", ",", "MOVE_COUNT", ",", "MOVE_COUNT", ")", ")", "return", "sum", "(", "[", "int", "(", "r", ".", "cell_value", "(", "METADATA", ",", "MOVE_COUNT", ")", ")", "for", "r", "in", "rows", "]", ")" ]

[ "with", "some", "providers", "returned", "parameters", "and", "the", ".", "return_value", "are", "not", "available", "until", "after", "the", "last", "recordset", "has", "been", "read", ".", "In", "that", "case", "you", "must", "coll", "nextset", "()", "until", "it", "returns", "None", "then", "call", "this", "method", "to", "get", "your", "returned", "information", "." ]

[ "def", "get_returned_parameters", "(", "self", ")", ":", "retLst", "=", "(", "[", "]", ")", "# store procedures may return altered parameters, including an added \"return value\" item", "for", "p", "in", "tuple", "(", "self", ".", "cmd", ".", "Parameters", ")", ":", "if", "verbose", ">", "2", ":", "print", "(", "'Returned=Name: %s, Dir.: %s, Type: %s, Size: %s, Value: \"%s\",'", "\" Precision: %s, NumericScale: %s\"", "%", "(", "p", ".", "Name", ",", "adc", ".", "directions", "[", "p", ".", "Direction", "]", ",", "adc", ".", "adTypeNames", ".", "get", "(", "p", ".", "Type", ",", "str", "(", "p", ".", "Type", ")", "+", "\" (unknown type)\"", ")", ",", "p", ".", "Size", ",", "p", ".", "Value", ",", "p", ".", "Precision", ",", "p", ".", "NumericScale", ",", ")", ")", "pyObject", "=", "api", ".", "convert_to_python", "(", "p", ".", "Value", ",", "api", ".", "variantConversions", "[", "p", ".", "Type", "]", ")", "if", "p", ".", "Direction", "==", "adc", ".", "adParamReturnValue", ":", "self", ".", "returnValue", "=", "(", "pyObject", "# also load the undocumented attribute (Vernon's Error!)", ")", "self", ".", "return_value", "=", "pyObject", "else", ":", "retLst", ".", "append", "(", "pyObject", ")", "return", "retLst" ]

[ "Update", "nesting", "state", "with", "current", "line", "." ]

[ "def", "Update", "(", "self", ",", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# Remember top of the previous nesting stack.", "#", "# The stack is always pushed/popped and not modified in place, so", "# we can just do a shallow copy instead of copy.deepcopy. Using", "# deepcopy would slow down cpplint by ~28%.", "if", "self", ".", "stack", ":", "self", ".", "previous_stack_top", "=", "self", ".", "stack", "[", "-", "1", "]", "else", ":", "self", ".", "previous_stack_top", "=", "None", "# Update pp_stack", "self", ".", "UpdatePreprocessor", "(", "line", ")", "# Count parentheses. This is to avoid adding struct arguments to", "# the nesting stack.", "if", "self", ".", "stack", ":", "inner_block", "=", "self", ".", "stack", "[", "-", "1", "]", "depth_change", "=", "line", ".", "count", "(", "'('", ")", "-", "line", ".", "count", "(", "')'", ")", "inner_block", ".", "open_parentheses", "+=", "depth_change", "# Also check if we are starting or ending an inline assembly block.", "if", "inner_block", ".", "inline_asm", "in", "(", "_NO_ASM", ",", "_END_ASM", ")", ":", "if", "(", "depth_change", "!=", "0", "and", "inner_block", ".", "open_parentheses", "==", "1", "and", "_MATCH_ASM", ".", "match", "(", "line", ")", ")", ":", "# Enter assembly block", "inner_block", ".", "inline_asm", "=", "_INSIDE_ASM", "else", ":", "# Not entering assembly block. If previous line was _END_ASM,", "# we will now shift to _NO_ASM state.", "inner_block", ".", "inline_asm", "=", "_NO_ASM", "elif", "(", "inner_block", ".", "inline_asm", "==", "_INSIDE_ASM", "and", "inner_block", ".", "open_parentheses", "==", "0", ")", ":", "# Exit assembly block", "inner_block", ".", "inline_asm", "=", "_END_ASM", "# Consume namespace declaration at the beginning of the line. Do", "# this in a loop so that we catch same line declarations like this:", "# namespace proto2 { namespace bridge { class MessageSet; } }", "while", "True", ":", "# Match start of namespace. The \"\\b\\s*\" below catches namespace", "# declarations even if it weren't followed by a whitespace, this", "# is so that we don't confuse our namespace checker. The", "# missing spaces will be flagged by CheckSpacing.", "namespace_decl_match", "=", "Match", "(", "r'^\\s*namespace\\b\\s*([:\\w]+)?(.*)$'", ",", "line", ")", "if", "not", "namespace_decl_match", ":", "break", "new_namespace", "=", "_NamespaceInfo", "(", "namespace_decl_match", ".", "group", "(", "1", ")", ",", "linenum", ")", "self", ".", "stack", ".", "append", "(", "new_namespace", ")", "line", "=", "namespace_decl_match", ".", "group", "(", "2", ")", "if", "line", ".", "find", "(", "'{'", ")", "!=", "-", "1", ":", "new_namespace", ".", "seen_open_brace", "=", "True", "line", "=", "line", "[", "line", ".", "find", "(", "'{'", ")", "+", "1", ":", "]", "# Look for a class declaration in whatever is left of the line", "# after parsing namespaces. The regexp accounts for decorated classes", "# such as in:", "# class LOCKABLE API Object {", "# };", "class_decl_match", "=", "Match", "(", "r'^(\\s*(?:template\\s*<[\\w\\s<>,:]*>\\s*)?'", "r'(class|struct)\\s+(?:[A-Z_]+\\s+)*(\\w+(?:::\\w+)*))'", "r'(.*)$'", ",", "line", ")", "if", "(", "class_decl_match", "and", "(", "not", "self", ".", "stack", "or", "self", ".", "stack", "[", "-", "1", "]", ".", "open_parentheses", "==", "0", ")", ")", ":", "# We do not want to accept classes that are actually template arguments:", "# template <class Ignore1,", "# class Ignore2 = Default<Args>,", "# template <Args> class Ignore3>", "# void Function() {};", "#", "# To avoid template argument cases, we scan forward and look for", "# an unmatched '>'. If we see one, assume we are inside a", "# template argument list.", "end_declaration", "=", "len", "(", "class_decl_match", ".", "group", "(", "1", ")", ")", "if", "not", "self", ".", "InTemplateArgumentList", "(", "clean_lines", ",", "linenum", ",", "end_declaration", ")", ":", "self", ".", "stack", ".", "append", "(", "_ClassInfo", "(", "class_decl_match", ".", "group", "(", "3", ")", ",", "class_decl_match", ".", "group", "(", "2", ")", ",", "clean_lines", ",", "linenum", ")", ")", "line", "=", "class_decl_match", ".", "group", "(", "4", ")", "# If we have not yet seen the opening brace for the innermost block,", "# run checks here.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "CheckBegin", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "# Update access control if we are inside a class/struct", "if", "self", ".", "stack", "and", "isinstance", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "_ClassInfo", ")", ":", "classinfo", "=", "self", ".", "stack", "[", "-", "1", "]", "access_match", "=", "Match", "(", "r'^(.*)\\b(public|private|protected|signals)(\\s+(?:slots\\s*)?)?'", "r':(?:[^:]|$)'", ",", "line", ")", "if", "access_match", ":", "classinfo", ".", "access", "=", "access_match", ".", "group", "(", "2", ")", "# Check that access keywords are indented +1 space. Skip this", "# check if the keywords are not preceded by whitespaces.", "indent", "=", "access_match", ".", "group", "(", "1", ")", "if", "(", "len", "(", "indent", ")", "!=", "classinfo", ".", "class_indent", "+", "1", "and", "Match", "(", "r'^\\s*$'", ",", "indent", ")", ")", ":", "if", "classinfo", ".", "is_struct", ":", "parent", "=", "'struct '", "+", "classinfo", ".", "name", "else", ":", "parent", "=", "'class '", "+", "classinfo", ".", "name", "slots", "=", "''", "if", "access_match", ".", "group", "(", "3", ")", ":", "slots", "=", "access_match", ".", "group", "(", "3", ")", "error", "(", "filename", ",", "linenum", ",", "'whitespace/indent'", ",", "3", ",", "'%s%s: should be indented +1 space inside %s'", "%", "(", "access_match", ".", "group", "(", "2", ")", ",", "slots", ",", "parent", ")", ")", "# Consume braces or semicolons from what's left of the line", "while", "True", ":", "# Match first brace, semicolon, or closed parenthesis.", "matched", "=", "Match", "(", "r'^[^{;)}]*([{;)}])(.*)$'", ",", "line", ")", "if", "not", "matched", ":", "break", "token", "=", "matched", ".", "group", "(", "1", ")", "if", "token", "==", "'{'", ":", "# If namespace or class hasn't seen a opening brace yet, mark", "# namespace/class head as complete. Push a new block onto the", "# stack otherwise.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "seen_open_brace", "=", "True", "elif", "Match", "(", "r'^extern\\s*\"[^\"]*\"\\s*\\{'", ",", "line", ")", ":", "self", ".", "stack", ".", "append", "(", "_ExternCInfo", "(", "linenum", ")", ")", "else", ":", "self", ".", "stack", ".", "append", "(", "_BlockInfo", "(", "linenum", ",", "True", ")", ")", "if", "_MATCH_ASM", ".", "match", "(", "line", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "inline_asm", "=", "_BLOCK_ASM", "elif", "token", "==", "';'", "or", "token", "==", "')'", ":", "# If we haven't seen an opening brace yet, but we already saw", "# a semicolon, this is probably a forward declaration. Pop", "# the stack for these.", "#", "# Similarly, if we haven't seen an opening brace yet, but we", "# already saw a closing parenthesis, then these are probably", "# function arguments with extra \"class\" or \"struct\" keywords.", "# Also pop these stack for these.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", ".", "pop", "(", ")", "else", ":", "# token == '}'", "# Perform end of block checks and pop the stack.", "if", "self", ".", "stack", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "CheckEnd", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "self", ".", "stack", ".", "pop", "(", ")", "line", "=", "matched", ".", "group", "(", "2", ")" ]

[ "Returns", "true", "if", "the", "given", "line", "is", "blank", "." ]

[ "def", "IsBlankLine", "(", "line", ")", ":", "return", "not", "line", "or", "line", ".", "isspace", "(", ")" ]

[ "write", "records", "to", "file", "path", "with", "objector" ]

[ "def", "write_record", "(", "file_path", ",", "records", ",", "objector", ")", ":", "request", "=", "service_pb2", ".", "WriteLocalSeqFileRequest", "(", ")", "request", ".", "file_path", "=", "file_path", "for", "record", "in", "records", ":", "request", ".", "key", ".", "append", "(", "\"\"", ")", "request", ".", "value", ".", "append", "(", "objector", ".", "serialize", "(", "record", ")", ")", "response", "=", "_service", ".", "request", "(", "request", ",", "\"write_local_seqfile\"", ")", "import", "google", ".", "protobuf", ".", "json_format", "as", "json_format", "res", "=", "json_format", ".", "Parse", "(", "response", ",", "service_pb2", ".", "VoidResponse", "(", ")", ")", "return", "None", ",", "res", ".", "status" ]

[ "Returns", "the", "target", "column", "of", "this", "Estimator", "." ]

[ "def", "_get_target_column", "(", "self", ")", ":", "return", "self", ".", "_target_column" ]

[ "Optional", "method", "which", "writes", "data", "(", "bytes", ")", "to", "a", "file", "path", "(", "a", "str", ")", "." ]

[ "def", "_cache_bytecode", "(", "self", ",", "source_path", ",", "cache_path", ",", "data", ")", ":", "# For backwards compatibility, we delegate to set_data()", "return", "self", ".", "set_data", "(", "cache_path", ",", "data", ")" ]

[ "Check", "for", "printf", "related", "issues", "." ]

[ "def", "CheckPrintf", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# When snprintf is used, the second argument shouldn't be a literal.", "match", "=", "Search", "(", "r'snprintf\\s*\\(([^,]*),\\s*([0-9]*)\\s*,'", ",", "line", ")", "if", "match", "and", "match", ".", "group", "(", "2", ")", "!=", "'0'", ":", "# If 2nd arg is zero, snprintf is used to calculate size.", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "3", ",", "'If you can, use sizeof(%s) instead of %s as the 2nd arg '", "'to snprintf.'", "%", "(", "match", ".", "group", "(", "1", ")", ",", "match", ".", "group", "(", "2", ")", ")", ")", "# Check if some verboten C functions are being used.", "if", "Search", "(", "r'\\bsprintf\\s*\\('", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "5", ",", "'Never use sprintf. Use snprintf instead.'", ")", "match", "=", "Search", "(", "r'\\b(strcpy|strcat)\\s*\\('", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "4", ",", "'Almost always, snprintf is better than %s'", "%", "match", ".", "group", "(", "1", ")", ")" ]

[ "Completion", "function", "for", "both", "frame", "filter", "dictionary", "and", "frame", "filter", "name", "." ]

[ "def", "complete", "(", "self", ",", "text", ",", "word", ")", ":", "if", "text", ".", "count", "(", "\" \"", ")", "==", "0", ":", "return", "_complete_frame_filter_list", "(", "text", ",", "word", ",", "True", ")", "else", ":", "printer_list", "=", "gdb", ".", "frames", ".", "return_list", "(", "text", ".", "split", "(", ")", "[", "0", "]", ".", "rstrip", "(", ")", ")", "return", "_complete_frame_filter_name", "(", "word", ",", "printer_list", ")" ]

[ "Returns", "the", "module", "s", "list", "of", "output", "filters", "as", "a", "list", "." ]

[ "def", "_Filters", "(", ")", ":", "return", "_cpplint_state", ".", "filters" ]

[ "Contact", "DAS", "server", "and", "retrieve", "data", "for", "given", "DAS", "query" ]

[ "def", "get_data", "(", "host", ",", "query", ",", "idx", ",", "limit", ",", "debug", ")", ":", "params", "=", "{", "'input'", ":", "query", ",", "'idx'", ":", "idx", ",", "'limit'", ":", "limit", "}", "path", "=", "'/das/cache'", "pat", "=", "re", ".", "compile", "(", "'http[s]{0,1}://'", ")", "if", "not", "pat", ".", "match", "(", "host", ")", ":", "msg", "=", "'Invalid hostname: %s'", "%", "host", "raise", "Exception", "(", "msg", ")", "url", "=", "host", "+", "path", "headers", "=", "{", "\"Accept\"", ":", "\"application/json\"", "}", "encoded_data", "=", "urllib", ".", "urlencode", "(", "params", ",", "doseq", "=", "True", ")", "url", "+=", "'?%s'", "%", "encoded_data", "req", "=", "urllib2", ".", "Request", "(", "url", "=", "url", ",", "headers", "=", "headers", ")", "if", "debug", ":", "hdlr", "=", "urllib2", ".", "HTTPHandler", "(", "debuglevel", "=", "1", ")", "opener", "=", "urllib2", ".", "build_opener", "(", "hdlr", ")", "else", ":", "opener", "=", "urllib2", ".", "build_opener", "(", ")", "fdesc", "=", "opener", ".", "open", "(", "req", ")", "data", "=", "fdesc", ".", "read", "(", ")", "fdesc", ".", "close", "(", ")", "pat", "=", "re", ".", "compile", "(", "r'^[a-z0-9]{32}'", ")", "if", "data", "and", "isinstance", "(", "data", ",", "str", ")", "and", "pat", ".", "match", "(", "data", ")", "and", "len", "(", "data", ")", "==", "32", ":", "pid", "=", "data", "else", ":", "pid", "=", "None", "count", "=", "5", "# initial waiting time in seconds", "timeout", "=", "30", "# final waiting time in seconds", "while", "pid", ":", "params", ".", "update", "(", "{", "'pid'", ":", "data", "}", ")", "encoded_data", "=", "urllib", ".", "urlencode", "(", "params", ",", "doseq", "=", "True", ")", "url", "=", "host", "+", "path", "+", "'?%s'", "%", "encoded_data", "req", "=", "urllib2", ".", "Request", "(", "url", "=", "url", ",", "headers", "=", "headers", ")", "try", ":", "fdesc", "=", "opener", ".", "open", "(", "req", ")", "data", "=", "fdesc", ".", "read", "(", ")", "fdesc", ".", "close", "(", ")", "except", "urllib2", ".", "HTTPError", "as", "err", ":", "print", "(", "err", ")", "return", "\"\"", "if", "data", "and", "isinstance", "(", "data", ",", "str", ")", "and", "pat", ".", "match", "(", "data", ")", "and", "len", "(", "data", ")", "==", "32", ":", "pid", "=", "data", "else", ":", "pid", "=", "None", "time", ".", "sleep", "(", "count", ")", "if", "count", "<", "timeout", ":", "count", "*=", "2", "else", ":", "count", "=", "timeout", "return", "data" ]

[ "Decodes", "data", "from", "the", "stream", "self", ".", "stream", "and", "returns", "the", "resulting", "object", "." ]

[ "def", "read", "(", "self", ",", "size", "=", "-", "1", ",", "chars", "=", "-", "1", ",", "firstline", "=", "False", ")", ":", "# If we have lines cached, first merge them back into characters", "if", "self", ".", "linebuffer", ":", "self", ".", "charbuffer", "=", "\"\"", ".", "join", "(", "self", ".", "linebuffer", ")", "self", ".", "linebuffer", "=", "None", "# read until we get the required number of characters (if available)", "while", "True", ":", "# can the request can be satisfied from the character buffer?", "if", "chars", "<", "0", ":", "if", "size", "<", "0", ":", "if", "self", ".", "charbuffer", ":", "break", "elif", "len", "(", "self", ".", "charbuffer", ")", ">=", "size", ":", "break", "else", ":", "if", "len", "(", "self", ".", "charbuffer", ")", ">=", "chars", ":", "break", "# we need more data", "if", "size", "<", "0", ":", "newdata", "=", "self", ".", "stream", ".", "read", "(", ")", "else", ":", "newdata", "=", "self", ".", "stream", ".", "read", "(", "size", ")", "# decode bytes (those remaining from the last call included)", "data", "=", "self", ".", "bytebuffer", "+", "newdata", "try", ":", "newchars", ",", "decodedbytes", "=", "self", ".", "decode", "(", "data", ",", "self", ".", "errors", ")", "except", "UnicodeDecodeError", ",", "exc", ":", "if", "firstline", ":", "newchars", ",", "decodedbytes", "=", "self", ".", "decode", "(", "data", "[", ":", "exc", ".", "start", "]", ",", "self", ".", "errors", ")", "lines", "=", "newchars", ".", "splitlines", "(", "True", ")", "if", "len", "(", "lines", ")", "<=", "1", ":", "raise", "else", ":", "raise", "# keep undecoded bytes until the next call", "self", ".", "bytebuffer", "=", "data", "[", "decodedbytes", ":", "]", "# put new characters in the character buffer", "self", ".", "charbuffer", "+=", "newchars", "# there was no data available", "if", "not", "newdata", ":", "break", "if", "chars", "<", "0", ":", "# Return everything we've got", "result", "=", "self", ".", "charbuffer", "self", ".", "charbuffer", "=", "\"\"", "else", ":", "# Return the first chars characters", "result", "=", "self", ".", "charbuffer", "[", ":", "chars", "]", "self", ".", "charbuffer", "=", "self", ".", "charbuffer", "[", "chars", ":", "]", "return", "result" ]

[ "TODO", "." ]

[ "def", "setData", "(", "self", ",", "data", ")", ":", "if", "isinstance", "(", "data", ",", "list", ")", ":", "if", "len", "(", "data", ")", "==", "len", "(", "self", ".", "managers", ")", ":", "self", ".", "tD", ".", "clear", "(", ")", "self", ".", "dataVals", ".", "clear", "(", ")", "self", ".", "dataErrs", ".", "clear", "(", ")", "self", ".", "fop", ".", "setData", "(", "data", ")", "for", "i", ",", "mgr", "in", "enumerate", "(", "self", ".", "managers", ")", ":", "t", "=", "mgr", ".", "tD", "self", ".", "tD", ".", "add", "(", "t", ",", "data", "[", "i", "]", ".", "size", "(", ")", ")", "self", ".", "dataVals", "=", "pg", ".", "cat", "(", "self", ".", "dataVals", ",", "data", "[", "i", "]", "(", "mgr", ".", "dataToken", "(", ")", ")", ")", "if", "mgr", ".", "errIsAbsolute", ":", "self", ".", "dataErrs", "=", "pg", ".", "cat", "(", "self", ".", "dataErrs", ",", "data", "[", "i", "]", "(", "'err'", ")", "/", "data", "[", "i", "]", "(", "mgr", ".", "dataToken", "(", ")", ")", ")", "else", ":", "self", ".", "dataErrs", "=", "pg", ".", "cat", "(", "self", ".", "dataErrs", ",", "data", "[", "i", "]", "(", "'err'", ")", ")", "self", ".", "data", "=", "data", "self", ".", "inv", ".", "setTransData", "(", "self", ".", "tD", ")", "self", ".", "inv", ".", "setTransModel", "(", "self", ".", "tM", ")", "else", ":", "raise", "BaseException", "(", "\"To few datacontainer given\"", ")" ]

[ "Generate", "a", "matplotlib", "errorbar", "figure", "." ]

[ "def", "errorbar", "(", "self", ",", "xerr", "=", "False", ",", "yerr", "=", "False", ",", "label_rotation", "=", "0", ",", "label_alignment", "=", "'center'", ",", "*", "*", "kwargs", ")", ":", "if", "xerr", ":", "kwargs", "[", "'xerr'", "]", "=", "self", ".", "xerr", "if", "yerr", ":", "kwargs", "[", "'yerr'", "]", "=", "self", ".", "yerr", "replacements", "=", "kwargs", ".", "get", "(", "'replacements'", ",", "None", ")", "or", "self", ".", "replacements", "errorbar", "=", "plt", ".", "errorbar", "(", "self", ".", "x", ",", "self", ".", "y", ",", "label", "=", "replace", "(", "self", ".", "label", ",", "replacements", ")", ",", "*", "*", "kwargs", ")", "self", ".", "_prepare_xaxis", "(", "label_rotation", ",", "label_alignment", ")", "return", "errorbar" ]

[ "Dispatches", ":", "class", ":", "stash", "or", ":", "class", ":", "pop", "commands", "generated", "by", "the", "module", "s", "forward", "()", "." ]

[ "def", "dispatch", "(", "self", ",", "input", ",", "handle_stash", ":", "Callable", "[", "[", "str", ",", "Optional", "[", "Tensor", "]", "]", ",", "None", "]", ",", "handle_pop", ":", "Callable", "[", "[", "str", "]", ",", "Optional", "[", "Tensor", "]", "]", ",", ")", ":", "generator", "=", "self", ".", "module", "(", "input", ")", "if", "not", "isinstance", "(", "generator", ",", "Generator", ")", ":", "# The underlying module returned output without any yield.", "output", "=", "generator", "return", "output", "try", ":", "op", "=", "next", "(", "generator", ")", "while", "True", ":", "if", "isinstance", "(", "op", ",", "stash", ")", ":", "handle_stash", "(", "op", ".", "name", ",", "op", ".", "tensor", ")", "op", "=", "next", "(", "generator", ")", "continue", "if", "isinstance", "(", "op", ",", "pop", ")", ":", "tensor", "=", "handle_pop", "(", "op", ".", "name", ")", "op", "=", "generator", ".", "send", "(", "tensor", ")", "continue", "raise", "TypeError", "(", "\"%r is not a command from @skippable\"", "%", "op", ")", "except", "StopIteration", "as", "stop", ":", "output", "=", "stop", ".", "args", "[", "0", "]", "return", "output" ]

[ "Parse", "an", "ELF", "executable", "and", "return", "a", "list", "of", "(", "symbol", "version", ")", "tuples", "for", "dynamic", "imported", "symbols", "." ]

[ "def", "read_symbols", "(", "executable", ",", "imports", "=", "True", ")", ":", "p", "=", "subprocess", ".", "Popen", "(", "[", "READELF_CMD", ",", "'--dyn-syms'", ",", "'-W'", ",", "executable", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "stdin", "=", "subprocess", ".", "PIPE", ")", "(", "stdout", ",", "stderr", ")", "=", "p", ".", "communicate", "(", ")", "if", "p", ".", "returncode", ":", "raise", "IOError", "(", "'Could not read symbols for %s: %s'", "%", "(", "executable", ",", "stderr", ".", "strip", "(", ")", ")", ")", "syms", "=", "[", "]", "for", "line", "in", "stdout", ".", "split", "(", "b'\\n'", ")", ":", "line", "=", "line", ".", "split", "(", ")", "if", "len", "(", "line", ")", ">", "7", "and", "re", ".", "match", "(", "b'[0-9]+:$'", ",", "line", "[", "0", "]", ")", ":", "(", "sym", ",", "_", ",", "version", ")", "=", "line", "[", "7", "]", ".", "partition", "(", "b'@'", ")", "is_import", "=", "line", "[", "6", "]", "==", "b'UND'", "if", "version", ".", "startswith", "(", "b'@'", ")", ":", "version", "=", "version", "[", "1", ":", "]", "if", "is_import", "==", "imports", ":", "syms", ".", "append", "(", "(", "sym", ",", "version", ")", ")", "return", "syms" ]

[ "Remove", "a", "list", "of", "completion", "items", "from", "a", "completion", "context", "." ]

[ "def", "remove_comp_items", "(", "self", ",", "context_word", ",", "comp_items", ")", ":", "if", "context_word", "not", "in", "self", ".", "_comp_dict", ":", "raise", "KeyError", "(", "\"Context word \\\"%s\\\" has not been registered\"", "%", "context_word", ")", "for", "item", "in", "comp_items", ":", "self", ".", "_comp_dict", "[", "context_word", "]", ".", "remove", "(", "item", ")" ]