Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "For", "each", "point", "in", "querypts", "(", "which", "may", "be", "a", "single", "point", ")", "it", "returns", "the", "num_neighbors", "nearest", "points", "in", "the", "index", "built", "by", "calling", "build_index", "." ]

[ "def", "nn_index", "(", "self", ",", "qpts", ",", "num_neighbors", "=", "1", ",", "*", "*", "kwargs", ")", ":", "if", "self", ".", "__curindex", "is", "None", ":", "raise", "FLANNException", "(", "'build_index(...) method not called first or current index deleted.'", ")", "if", "qpts", ".", "dtype", ".", "type", "not", "in", "allowed_types", ":", "raise", "FLANNException", "(", "'Cannot handle type: %s'", "%", "qpts", ".", "dtype", ")", "if", "self", ".", "__curindex_type", "!=", "qpts", ".", "dtype", ".", "type", ":", "raise", "FLANNException", "(", "'Index and query must have the same type'", ")", "qpts", "=", "ensure_2d_array", "(", "qpts", ",", "default_flags", ")", "npts", ",", "dim", "=", "self", ".", "__curindex_data", ".", "shape", "if", "qpts", ".", "size", "==", "dim", ":", "qpts", ".", "reshape", "(", "1", ",", "dim", ")", "nqpts", "=", "qpts", ".", "shape", "[", "0", "]", "assert", "qpts", ".", "shape", "[", "1", "]", "==", "dim", ",", "'data and query must have the same dims'", "assert", "npts", ">=", "num_neighbors", ",", "'more neighbors than there are points'", "result", "=", "np", ".", "empty", "(", "(", "nqpts", ",", "num_neighbors", ")", ",", "dtype", "=", "index_type", ")", "if", "self", ".", "__curindex_type", "==", "np", ".", "float64", ":", "dists", "=", "np", ".", "empty", "(", "(", "nqpts", ",", "num_neighbors", ")", ",", "dtype", "=", "np", ".", "float64", ")", "else", ":", "dists", "=", "np", ".", "empty", "(", "(", "nqpts", ",", "num_neighbors", ")", ",", "dtype", "=", "np", ".", "float32", ")", "self", ".", "__flann_parameters", ".", "update", "(", "kwargs", ")", "flann", ".", "find_nearest_neighbors_index", "[", "self", ".", "__curindex_type", "]", "(", "self", ".", "__curindex", ",", "qpts", ",", "nqpts", ",", "result", ",", "dists", ",", "num_neighbors", ",", "pointer", "(", "self", ".", "__flann_parameters", ")", ")", "if", "num_neighbors", "==", "1", ":", "return", "(", "result", ".", "reshape", "(", "nqpts", ")", ",", "dists", ".", "reshape", "(", "nqpts", ")", ")", "else", ":", "return", "(", "result", ",", "dists", ")" ]

[ "Sets", "the", "selected", "start", "X", "." ]

[ "def", "start_x", "(", "self", ",", "value", ":", "float", ")", "->", "None", ":", "self", ".", "fit_function_options", ".", "start_x", "=", "value" ]

[ "Return", "a", "collections", ".", "Sized", "collections", ".", "Container", "of", "paths", "to", "be", "excluded", "for", "single_version_externally_managed", "installations", "." ]

[ "def", "get_exclusions", "(", "self", ")", ":", "all_packages", "=", "(", "pkg", "for", "ns_pkg", "in", "self", ".", "_get_SVEM_NSPs", "(", ")", "for", "pkg", "in", "self", ".", "_all_packages", "(", "ns_pkg", ")", ")", "excl_specs", "=", "product", "(", "all_packages", ",", "self", ".", "_gen_exclusion_paths", "(", ")", ")", "return", "set", "(", "starmap", "(", "self", ".", "_exclude_pkg_path", ",", "excl_specs", ")", ")" ]

[ "Copies", "the", "|source|", "Info", ".", "plist", "to", "the", "destination", "directory", "|dest|", "." ]

[ "def", "ExecCopyInfoPlist", "(", "self", ",", "source", ",", "dest", ")", ":", "# Read the source Info.plist into memory.", "fd", "=", "open", "(", "source", ",", "'r'", ")", "lines", "=", "fd", ".", "read", "(", ")", "fd", ".", "close", "(", ")", "# Go through all the environment variables and replace them as variables in", "# the file.", "for", "key", "in", "os", ".", "environ", ":", "if", "key", ".", "startswith", "(", "'_'", ")", ":", "continue", "evar", "=", "'${%s}'", "%", "key", "lines", "=", "string", ".", "replace", "(", "lines", ",", "evar", ",", "os", ".", "environ", "[", "key", "]", ")", "# Write out the file with variables replaced.", "fd", "=", "open", "(", "dest", ",", "'w'", ")", "fd", ".", "write", "(", "lines", ")", "fd", ".", "close", "(", ")", "# Now write out PkgInfo file now that the Info.plist file has been", "# \"compiled\".", "self", ".", "_WritePkgInfo", "(", "dest", ")" ]

[ "Sets", "the", "given", "keyword", "-", "arguments", "as", "attributes", "of", "the", "current", "HTML", "element" ]

[ "def", "ATTR", "(", "*", "*", "kwargs", ")", ":", "THIS", "(", ")", "(", "*", "*", "kwargs", ")" ]

[ "See", ":", "ref", ":", "module", "-", "visualfeedback", "-", "samplevisibilitygoal" ]

[ "def", "SampleVisibilityGoal", "(", "self", ",", "numsamples", "=", "None", ")", ":", "cmd", "=", "'SampleVisibilityGoal '", "if", "numsamples", "is", "not", "None", ":", "cmd", "+=", "'numsamples %d '", "%", "numsamples", "res", "=", "self", ".", "prob", ".", "SendCommand", "(", "cmd", ")", "if", "res", "is", "None", ":", "raise", "PlanningError", "(", ")", "samples", "=", "[", "float", "(", "s", ")", "for", "s", "in", "res", ".", "split", "(", ")", "]", "returnedsamples", "=", "int", "(", "samples", "[", "0", "]", ")", "return", "numpy", ".", "reshape", "(", "numpy", ".", "array", "(", "samples", "[", "1", ":", "]", ",", "float", ")", ",", "(", "returnedsamples", ",", "(", "len", "(", "samples", ")", "-", "1", ")", "/", "returnedsamples", ")", ")" ]

[ "Find", "the", "container", "traits", "type", "of", "a", "declaration", "." ]

[ "def", "find_container_traits", "(", "cls_or_string", ")", ":", "if", "utils", ".", "is_str", "(", "cls_or_string", ")", ":", "if", "not", "templates", ".", "is_instantiation", "(", "cls_or_string", ")", ":", "return", "None", "name", "=", "templates", ".", "name", "(", "cls_or_string", ")", "if", "name", ".", "startswith", "(", "'std::'", ")", ":", "name", "=", "name", "[", "len", "(", "'std::'", ")", ":", "]", "if", "name", ".", "startswith", "(", "'std::tr1::'", ")", ":", "name", "=", "name", "[", "len", "(", "'std::tr1::'", ")", ":", "]", "for", "cls_traits", "in", "all_container_traits", ":", "if", "cls_traits", ".", "name", "(", ")", "==", "name", ":", "return", "cls_traits", "else", ":", "if", "isinstance", "(", "cls_or_string", ",", "class_declaration", ".", "class_types", ")", ":", "# Look in the cache.", "if", "cls_or_string", ".", "cache", ".", "container_traits", "is", "not", "None", ":", "return", "cls_or_string", ".", "cache", ".", "container_traits", "# Look for a container traits", "for", "cls_traits", "in", "all_container_traits", ":", "if", "cls_traits", ".", "is_my_case", "(", "cls_or_string", ")", ":", "# Store in the cache", "if", "isinstance", "(", "cls_or_string", ",", "class_declaration", ".", "class_types", ")", ":", "cls_or_string", ".", "cache", ".", "container_traits", "=", "cls_traits", "return", "cls_traits" ]

[ "Main", "executable", ".", "Parse", "the", "command", "line", "and", "invoke", "the", "command", "." ]

[ "def", "main", "(", ")", ":", "cmdline", "=", "command_line", ".", "CommandLine", "(", ")", "# The below two commands are currently unstable so have been disabled", "# commands.compare2.CreateCommand(cmdline)", "# commands.maskmaker.CreateCommand(cmdline)", "commands", ".", "measure", ".", "CreateCommand", "(", "cmdline", ")", "commands", ".", "scrape", ".", "CreateCommand", "(", "cmdline", ")", "cmdline", ".", "ParseCommandLine", "(", ")", "return", "0" ]

[ "Checks", "the", "use", "of", "CHECK", "and", "EXPECT", "macros", "." ]

[ "def", "CheckCheck", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "# Decide the set of replacement macros that should be suggested", "lines", "=", "clean_lines", ".", "elided", "check_macro", "=", "None", "start_pos", "=", "-", "1", "for", "macro", "in", "_CHECK_MACROS", ":", "i", "=", "lines", "[", "linenum", "]", ".", "find", "(", "macro", ")", "if", "i", ">=", "0", ":", "check_macro", "=", "macro", "# Find opening parenthesis. Do a regular expression match here", "# to make sure that we are matching the expected CHECK macro, as", "# opposed to some other macro that happens to contain the CHECK", "# substring.", "matched", "=", "Match", "(", "r'^(.*\\b'", "+", "check_macro", "+", "r'\\s*)\\('", ",", "lines", "[", "linenum", "]", ")", "if", "not", "matched", ":", "continue", "start_pos", "=", "len", "(", "matched", ".", "group", "(", "1", ")", ")", "break", "if", "not", "check_macro", "or", "start_pos", "<", "0", ":", "# Don't waste time here if line doesn't contain 'CHECK' or 'EXPECT'", "return", "# Find end of the boolean expression by matching parentheses", "(", "last_line", ",", "end_line", ",", "end_pos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "start_pos", ")", "if", "end_pos", "<", "0", ":", "return", "if", "linenum", "==", "end_line", ":", "expression", "=", "lines", "[", "linenum", "]", "[", "start_pos", "+", "1", ":", "end_pos", "-", "1", "]", "else", ":", "expression", "=", "lines", "[", "linenum", "]", "[", "start_pos", "+", "1", ":", "]", "for", "i", "in", "xrange", "(", "linenum", "+", "1", ",", "end_line", ")", ":", "expression", "+=", "lines", "[", "i", "]", "expression", "+=", "last_line", "[", "0", ":", "end_pos", "-", "1", "]", "# Parse expression so that we can take parentheses into account.", "# This avoids false positives for inputs like \"CHECK((a < 4) == b)\",", "# which is not replaceable by CHECK_LE.", "lhs", "=", "''", "rhs", "=", "''", "operator", "=", "None", "while", "expression", ":", "matched", "=", "Match", "(", "r'^\\s*(<<|<<=|>>|>>=|->\\*|->|&&|\\|\\||'", "r'==|!=|>=|>|<=|<|\\()(.*)$'", ",", "expression", ")", "if", "matched", ":", "token", "=", "matched", ".", "group", "(", "1", ")", "if", "token", "==", "'('", ":", "# Parenthesized operand", "expression", "=", "matched", ".", "group", "(", "2", ")", "(", "end", ",", "_", ")", "=", "FindEndOfExpressionInLine", "(", "expression", ",", "0", ",", "1", ",", "'('", ",", "')'", ")", "if", "end", "<", "0", ":", "return", "# Unmatched parenthesis", "lhs", "+=", "'('", "+", "expression", "[", "0", ":", "end", "]", "expression", "=", "expression", "[", "end", ":", "]", "elif", "token", "in", "(", "'&&'", ",", "'||'", ")", ":", "# Logical and/or operators. This means the expression", "# contains more than one term, for example:", "# CHECK(42 < a && a < b);", "#", "# These are not replaceable with CHECK_LE, so bail out early.", "return", "elif", "token", "in", "(", "'<<'", ",", "'<<='", ",", "'>>'", ",", "'>>='", ",", "'->*'", ",", "'->'", ")", ":", "# Non-relational operator", "lhs", "+=", "token", "expression", "=", "matched", ".", "group", "(", "2", ")", "else", ":", "# Relational operator", "operator", "=", "token", "rhs", "=", "matched", ".", "group", "(", "2", ")", "break", "else", ":", "# Unparenthesized operand. Instead of appending to lhs one character", "# at a time, we do another regular expression match to consume several", "# characters at once if possible. Trivial benchmark shows that this", "# is more efficient when the operands are longer than a single", "# character, which is generally the case.", "matched", "=", "Match", "(", "r'^([^-=!<>()&|]+)(.*)$'", ",", "expression", ")", "if", "not", "matched", ":", "matched", "=", "Match", "(", "r'^(\\s*\\S)(.*)$'", ",", "expression", ")", "if", "not", "matched", ":", "break", "lhs", "+=", "matched", ".", "group", "(", "1", ")", "expression", "=", "matched", ".", "group", "(", "2", ")", "# Only apply checks if we got all parts of the boolean expression", "if", "not", "(", "lhs", "and", "operator", "and", "rhs", ")", ":", "return", "# Check that rhs do not contain logical operators. We already know", "# that lhs is fine since the loop above parses out && and ||.", "if", "rhs", ".", "find", "(", "'&&'", ")", ">", "-", "1", "or", "rhs", ".", "find", "(", "'||'", ")", ">", "-", "1", ":", "return", "# At least one of the operands must be a constant literal. This is", "# to avoid suggesting replacements for unprintable things like", "# CHECK(variable != iterator)", "#", "# The following pattern matches decimal, hex integers, strings, and", "# characters (in that order).", "lhs", "=", "lhs", ".", "strip", "(", ")", "rhs", "=", "rhs", ".", "strip", "(", ")", "match_constant", "=", "r'^([-+]?(\\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|\".*\"|\\'.*\\')$'", "if", "Match", "(", "match_constant", ",", "lhs", ")", "or", "Match", "(", "match_constant", ",", "rhs", ")", ":", "# Note: since we know both lhs and rhs, we can provide a more", "# descriptive error message like:", "# Consider using CHECK_EQ(x, 42) instead of CHECK(x == 42)", "# Instead of:", "# Consider using CHECK_EQ instead of CHECK(a == b)", "#", "# We are still keeping the less descriptive message because if lhs", "# or rhs gets long, the error message might become unreadable.", "error", "(", "filename", ",", "linenum", ",", "'readability/check'", ",", "2", ",", "'Consider using %s instead of %s(a %s b)'", "%", "(", "_CHECK_REPLACEMENT", "[", "check_macro", "]", "[", "operator", "]", ",", "check_macro", ",", "operator", ")", ")" ]

[ "Convert", "a", "3vec", "rotation", "array", "to", "a", "rotation", "matrix", "." ]

[ "def", "r_as_matrix", "(", "rotation", ":", "np", ".", "array", ")", ":", "rmat", "=", "np", ".", "zeros", "(", "shape", "=", "(", "3", ",", "3", ")", ")", "cv2", ".", "Rodrigues", "(", "rotation", ",", "rmat", ")", "return", "rmat" ]

[ "Retrieve", "the", "URL", "associated", "to", "the", ":", "class", ":", "HyperLinkCtrl", "." ]

[ "def", "GetURL", "(", "self", ")", ":", "return", "self", ".", "_URL" ]

[ "GetVirtualAttributes", "(", "self", "RichTextObject", "obj", ")", "-", ">", "RichTextAttr" ]

[ "def", "GetVirtualAttributes", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextDrawingContext_GetVirtualAttributes", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Loads", "trainer", "states", "(", "e", ".", "g", ".", "optimizer", "momentum", ")", "from", "a", "file", "." ]

[ "def", "load_states", "(", "self", ",", "fname", ")", ":", "if", "not", "self", ".", "_kv_initialized", ":", "self", ".", "_init_kvstore", "(", ")", "if", "self", ".", "_params_to_init", ":", "self", ".", "_init_params", "(", ")", "if", "self", ".", "_update_on_kvstore", ":", "self", ".", "_kvstore", ".", "load_optimizer_states", "(", "fname", ")", "self", ".", "_optimizer", "=", "self", ".", "_kvstore", ".", "_updater", ".", "optimizer", "else", ":", "with", "open", "(", "fname", ",", "'rb'", ")", "as", "f", ":", "states", "=", "f", ".", "read", "(", ")", "for", "updater", "in", "self", ".", "_updaters", ":", "updater", ".", "set_states", "(", "states", ")", "updater", ".", "optimizer", "=", "self", ".", "_updaters", "[", "0", "]", ".", "optimizer", "self", ".", "_optimizer", "=", "self", ".", "_updaters", "[", "0", "]", ".", "optimizer", "param_dict", "=", "{", "i", ":", "param", "for", "i", ",", "param", "in", "enumerate", "(", "self", ".", "_params", ")", "}", "self", ".", "_optimizer", ".", "param_dict", "=", "param_dict" ]

[ "GetDisabledBitmap", "(", "self", ")", "-", ">", "Bitmap" ]

[ "def", "GetDisabledBitmap", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ToolBarToolBase_GetDisabledBitmap", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Save", "the", "cookie", "jar", "after", "authentication", "." ]

[ "def", "_Authenticate", "(", "self", ")", ":", "super", "(", "HttpRpcServer", ",", "self", ")", ".", "_Authenticate", "(", ")", "if", "self", ".", "save_cookies", ":", "StatusUpdate", "(", "\"Saving authentication cookies to %s\"", "%", "self", ".", "cookie_file", ")", "self", ".", "cookie_jar", ".", "save", "(", ")" ]

[ "Replaces", "argument", "placeholders", "with", "their", "values", "." ]

[ "def", "_ReplaceArgumentPlaceholders", "(", "self", ",", "dom", ")", ":", "placeholders", "=", "{", "'packageName'", ":", "self", ".", "_merger_dom", ".", "getElementsByTagName", "(", "self", ".", "_MANIFEST", ")", ".", "item", "(", "0", ")", ".", "getAttribute", "(", "self", ".", "_PACKAGE", ")", ",", "}", "for", "element", "in", "dom", ".", "getElementsByTagName", "(", "'*'", ")", ":", "for", "i", "in", "range", "(", "element", ".", "attributes", ".", "length", ")", ":", "attr", "=", "element", ".", "attributes", ".", "item", "(", "i", ")", "attr", ".", "value", "=", "self", ".", "_ReplaceArgumentHelper", "(", "placeholders", ",", "attr", ".", "value", ")" ]

[ "Convert", "an", ".", "egg", "-", "info", "directory", "into", "a", ".", "dist", "-", "info", "directory" ]

[ "def", "egg2dist", "(", "self", ",", "egginfo_path", ",", "distinfo_path", ")", ":", "def", "adios", "(", "p", ")", ":", "\"\"\"Appropriately delete directory, file or link.\"\"\"", "if", "os", ".", "path", ".", "exists", "(", "p", ")", "and", "not", "os", ".", "path", ".", "islink", "(", "p", ")", "and", "os", ".", "path", ".", "isdir", "(", "p", ")", ":", "shutil", ".", "rmtree", "(", "p", ")", "elif", "os", ".", "path", ".", "exists", "(", "p", ")", ":", "os", ".", "unlink", "(", "p", ")", "adios", "(", "distinfo_path", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "egginfo_path", ")", ":", "# There is no egg-info. This is probably because the egg-info", "# file/directory is not named matching the distribution name used", "# to name the archive file. Check for this case and report", "# accordingly.", "import", "glob", "pat", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "egginfo_path", ")", ",", "'*.egg-info'", ")", "possible", "=", "glob", ".", "glob", "(", "pat", ")", "err", "=", "\"Egg metadata expected at %s but not found\"", "%", "(", "egginfo_path", ",", ")", "if", "possible", ":", "alt", "=", "os", ".", "path", ".", "basename", "(", "possible", "[", "0", "]", ")", "err", "+=", "\" (%s found - possible misnamed archive file?)\"", "%", "(", "alt", ",", ")", "raise", "ValueError", "(", "err", ")", "if", "os", ".", "path", ".", "isfile", "(", "egginfo_path", ")", ":", "# .egg-info is a single file", "pkginfo_path", "=", "egginfo_path", "pkg_info", "=", "pkginfo_to_metadata", "(", "egginfo_path", ",", "egginfo_path", ")", "os", ".", "mkdir", "(", "distinfo_path", ")", "else", ":", "# .egg-info is a directory", "pkginfo_path", "=", "os", ".", "path", ".", "join", "(", "egginfo_path", ",", "'PKG-INFO'", ")", "pkg_info", "=", "pkginfo_to_metadata", "(", "egginfo_path", ",", "pkginfo_path", ")", "# ignore common egg metadata that is useless to wheel", "shutil", ".", "copytree", "(", "egginfo_path", ",", "distinfo_path", ",", "ignore", "=", "lambda", "x", ",", "y", ":", "{", "'PKG-INFO'", ",", "'requires.txt'", ",", "'SOURCES.txt'", ",", "'not-zip-safe'", "}", ")", "# delete dependency_links if it is only whitespace", "dependency_links_path", "=", "os", ".", "path", ".", "join", "(", "distinfo_path", ",", "'dependency_links.txt'", ")", "with", "open", "(", "dependency_links_path", ",", "'r'", ")", "as", "dependency_links_file", ":", "dependency_links", "=", "dependency_links_file", ".", "read", "(", ")", ".", "strip", "(", ")", "if", "not", "dependency_links", ":", "adios", "(", "dependency_links_path", ")", "write_pkg_info", "(", "os", ".", "path", ".", "join", "(", "distinfo_path", ",", "'METADATA'", ")", ",", "pkg_info", ")", "for", "license_path", "in", "self", ".", "license_paths", ":", "filename", "=", "os", ".", "path", ".", "basename", "(", "license_path", ")", "shutil", ".", "copy", "(", "license_path", ",", "os", ".", "path", ".", "join", "(", "distinfo_path", ",", "filename", ")", ")", "adios", "(", "egginfo_path", ")" ]

[ "Elementwise", "sum", "of", "arrays" ]

[ "def", "add_n", "(", "attrs", ",", "inputs", ",", "proto_obj", ")", ":", "return", "'add_n'", ",", "attrs", ",", "inputs" ]

[ "Return", "the", "integer", "value", "of", "this", "counter", "." ]

[ "def", "Value", "(", "self", ")", ":", "return", "self", ".", "data", ".", "IntAt", "(", "self", ".", "value_offset", ")" ]

[ "Saves", "vocabulary", "processor", "into", "given", "file", "." ]

[ "def", "save", "(", "self", ",", "filename", ")", ":", "with", "gfile", ".", "Open", "(", "filename", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "pickle", ".", "dumps", "(", "self", ")", ")" ]

[ "GetPaperRectPixels", "(", "self", ")", "-", ">", "Rect" ]

[ "def", "GetPaperRectPixels", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "Printout_GetPaperRectPixels", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Perform", "error", "checking", "on", "the", "loaded", "hit", "tree" ]

[ "def", "check", "(", "self", ")", ":", "for", "err", "in", "Parser", ".", "checkDuplicates", "(", "self", ".", "root", ")", ":", "self", ".", "error", "(", "*", "err", ")" ]

[ "Put", "away", "popup", "and", "cancel", "frame" ]

[ "def", "hidePopupMenu", "(", "self", ",", "event", "=", "None", ")", ":", "self", ".", "popupMenu", ".", "hide", "(", ")", "self", ".", "cancelFrame", ".", "hide", "(", ")" ]

[ "Check", "that", "arg", ".", "dtype", "==", "self", ".", "dtype", "." ]

[ "def", "_check_input_dtype", "(", "self", ",", "arg", ")", ":", "if", "arg", ".", "dtype", "!=", "self", ".", "dtype", ":", "raise", "TypeError", "(", "\"Expected argument to have dtype %s. Found: %s in tensor %s\"", "%", "(", "self", ".", "dtype", ",", "arg", ".", "dtype", ",", "arg", ")", ")" ]

[ "Return", "the", "period", "numbers", "(", "starting", "from", "1", ")", "that", "contribute", "to", "the", "respective", "foil", "states" ]

[ "def", "_get_foil_periods", "(", "self", ")", ":", "if", "self", ".", "_nperiods", "==", "2", ":", "foil_out_periods", "=", "(", "2", ",", ")", "foil_thin_periods", "=", "(", "1", ",", ")", "foil_thick_periods", "=", "None", "elif", "self", ".", "_nperiods", "==", "3", ":", "foil_out_periods", "=", "(", "3", ",", ")", "foil_thin_periods", "=", "(", "2", ",", ")", "foil_thick_periods", "=", "(", "1", ",", ")", "elif", "self", ".", "_nperiods", "==", "6", ":", "if", "self", ".", "_spectra_type", "==", "BACKWARD", ":", "foil_out_periods", "=", "(", "5", ",", "6", ")", "foil_thin_periods", "=", "(", "3", ",", "4", ")", "foil_thick_periods", "=", "(", "1", ",", "2", ")", "else", ":", "foil_out_periods", "=", "(", "4", ",", "5", ",", "6", ")", "foil_thin_periods", "=", "(", "1", ",", "2", ",", "3", ")", "foil_thick_periods", "=", "(", "1", ",", "2", ")", "else", ":", "pass", "return", "foil_out_periods", ",", "foil_thin_periods", ",", "foil_thick_periods" ]

[ "Cleanup", "the", "last", "global", "error", "registered", ".", "For", "parsing", "error", "this", "does", "not", "change", "the", "well", "-", "formedness", "result", "." ]

[ "def", "resetLastError", "(", ")", ":", "libxml2mod", ".", "xmlResetLastError", "(", ")" ]

[ "Build", "a", "filename", "-", ">", "pct", "coverage", "." ]

[ "def", "compute_filecoverage", "(", "self", ")", ":", "result", "=", "dict", "(", ")", "for", "filename", ",", "fns", "in", "self", ".", "point_symbol_info", ".", "items", "(", ")", ":", "file_points", "=", "[", "]", "for", "fn", ",", "points", "in", "fns", ".", "items", "(", ")", ":", "file_points", ".", "extend", "(", "points", ".", "keys", "(", ")", ")", "covered_points", "=", "self", ".", "covered_points", "&", "set", "(", "file_points", ")", "result", "[", "filename", "]", "=", "int", "(", "math", ".", "ceil", "(", "len", "(", "covered_points", ")", "*", "100", "/", "len", "(", "file_points", ")", ")", ")", "return", "result" ]

[ "IsHorizontal", "(", "self", ")", "-", ">", "bool" ]

[ "def", "IsHorizontal", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiDockInfo_IsHorizontal", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "the", "number", "of", "selected", "items", "in", ":", "class", ":", "UltimateListCtrl", "." ]

[ "def", "GetSelectedItemCount", "(", "self", ")", ":", "# deal with the quick case first", "if", "self", ".", "IsSingleSel", "(", ")", ":", "return", "(", "self", ".", "HasCurrent", "(", ")", "and", "[", "self", ".", "IsHighlighted", "(", "self", ".", "_current", ")", "]", "or", "[", "False", "]", ")", "[", "0", "]", "# virtual controls remmebers all its selections itself", "if", "self", ".", "IsVirtual", "(", ")", ":", "return", "self", ".", "_selStore", ".", "GetSelectedCount", "(", ")", "# TODO: we probably should maintain the number of items selected even for", "# non virtual controls as enumerating all lines is really slow...", "countSel", "=", "0", "count", "=", "self", ".", "GetItemCount", "(", ")", "for", "line", "in", "xrange", "(", "count", ")", ":", "if", "self", ".", "GetLine", "(", "line", ")", ".", "IsHighlighted", "(", ")", ":", "countSel", "+=", "1", "return", "countSel" ]

[ "Remove", "current", "key", "bindings", ".", "Iterate", "over", "window", "instances", "defined", "in", "parent", "and", "remove", "the", "keybindings", "." ]

[ "def", "deactivate_current_config", "(", "self", ")", ":", "# Before a config is saved, some cleanup of current", "# config must be done - remove the previous keybindings.", "win_instances", "=", "self", ".", "parent", ".", "instance_dict", ".", "keys", "(", ")", "for", "instance", "in", "win_instances", ":", "instance", ".", "RemoveKeybindings", "(", ")" ]

[ "A", "local", "state", "of", "the", "delivery", "." ]

[ "def", "local_state", "(", "self", ")", "->", "DispositionType", ":", "return", "DispositionType", ".", "get", "(", "pn_delivery_local_state", "(", "self", ".", "_impl", ")", ")" ]

[ "Run", "batch", "all", "-", "reduce", "for", "sparse", "values", "." ]

[ "def", "_do_batch_all_reduce_sparse", "(", "self", ",", "reduce_op", ",", "sparse_values", ")", ":", "logging", ".", "log_first_n", "(", "logging", ".", "WARN", ",", "\"Efficient allreduce is not supported for %d IndexedSlices\"", "%", "len", "(", "sparse_values", ")", ",", "10", ")", "# Use `sparse_values` as destinations to do all-reduces. It is effectively", "# an allgather under the hood but not an efficient one.", "return", "self", ".", "_simple_cross_replica_ops", ".", "batch_reduce", "(", "reduce_op", ",", "zip", "(", "sparse_values", ",", "sparse_values", ")", ")" ]

[ "Transmit", "one", "packet", "with", "slight", "AWGN", "and", "large", "frequency", "offset", ".", "Check", "packet", "is", "received", "and", "no", "bit", "errors", "have", "occurred", "." ]

[ "def", "test_004_tx1packet_large_fO", "(", "self", ")", ":", "fft_len", "=", "64", "len_tag_key", "=", "'frame_len'", "n_bytes", "=", "21", "test_data", "=", "list", "(", "[", "random", ".", "randint", "(", "0", ",", "255", ")", "for", "x", "in", "range", "(", "n_bytes", ")", "]", ")", "#test_data = tuple([255 for x in range(n_bytes)])", "# 1.0/fft_len is one sub-carrier", "frequency_offset", "=", "1.0", "/", "fft_len", "*", "2.5", "channel", "=", "channels", ".", "channel_model", "(", "0.00001", ",", "frequency_offset", ")", "# Tx", "tx_fg", "=", "ofdm_tx_fg", "(", "test_data", ",", "len_tag_key", ")", "tx_fg", ".", "run", "(", ")", "tx_samples", "=", "tx_fg", ".", "get_tx_samples", "(", ")", "# Rx", "rx_fg", "=", "ofdm_rx_fg", "(", "tx_samples", ",", "len_tag_key", ",", "channel", ",", "prepend_zeros", "=", "100", ")", "rx_fg", ".", "run", "(", ")", "rx_data", "=", "rx_fg", ".", "get_rx_bytes", "(", ")", "self", ".", "assertEqual", "(", "test_data", ",", "rx_data", ")" ]

[ "Writes", "the", "defclass", "that", "defines", "the", "message", "type" ]

[ "def", "write_defclass", "(", "s", ",", "spec", ")", ":", "cl", "=", "message_class", "(", "spec", ")", "new_cl", "=", "new_message_class", "(", "spec", ")", "suffix", "=", "'srv'", "if", "spec", ".", "component_type", "==", "'service'", "else", "'msg'", "s", ".", "write", "(", "'(cl:defclass %s (roslisp-msg-protocol:ros-message)'", "%", "cl", ")", "with", "Indent", "(", "s", ")", ":", "s", ".", "write", "(", "'('", ")", "with", "Indent", "(", "s", ",", "inc", "=", "1", ",", "indent_first", "=", "False", ")", ":", "for", "field", "in", "spec", ".", "parsed_fields", "(", ")", ":", "write_slot_definition", "(", "s", ",", "field", ")", "s", ".", "write", "(", "')'", ",", "indent", "=", "False", ")", "s", ".", "write", "(", "')'", ")", "s", ".", "newline", "(", ")", "s", ".", "write", "(", "'(cl:defclass %s (%s)'", "%", "(", "new_cl", ",", "cl", ")", ")", "with", "Indent", "(", "s", ")", ":", "s", ".", "write", "(", "'())'", ")", "s", ".", "newline", "(", ")", "s", ".", "write", "(", "'(cl:defmethod cl:initialize-instance :after ((m %s) cl:&rest args)'", "%", "cl", ")", "with", "Indent", "(", "s", ")", ":", "s", ".", "write", "(", "'(cl:declare (cl:ignorable args))'", ")", "s", ".", "write", "(", "'(cl:unless (cl:typep m \\'%s)'", "%", "new_cl", ")", "with", "Indent", "(", "s", ")", ":", "s", ".", "write", "(", "'(roslisp-msg-protocol:msg-deprecation-warning \"using old message class name %s-%s:%s is deprecated: use %s-%s:%s instead.\")))'", "%", "(", "spec", ".", "package", ",", "suffix", ",", "cl", ",", "spec", ".", "package", ",", "suffix", ",", "new_cl", ")", ")" ]

[ "Test", "if", "this", "is", "a", "declaration", "kind", "." ]

[ "def", "is_declaration", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_isDeclaration", "(", "self", ")" ]

[ "Generate", "shell", "code", "to", "reset", "environment", "variables", "by", "unrolling", "modifications", "based", "on", "all", "workspaces", "in", "CMAKE_PREFIX_PATH", ".", "This", "does", "not", "cover", "modifications", "performed", "by", "environment", "hooks", "." ]

[ "def", "rollback_env_variables", "(", "environ", ",", "env_var_subfolders", ")", ":", "lines", "=", "[", "]", "unmodified_environ", "=", "copy", ".", "copy", "(", "environ", ")", "for", "key", "in", "sorted", "(", "env_var_subfolders", ".", "keys", "(", ")", ")", ":", "subfolders", "=", "env_var_subfolders", "[", "key", "]", "if", "not", "isinstance", "(", "subfolders", ",", "list", ")", ":", "subfolders", "=", "[", "subfolders", "]", "for", "subfolder", "in", "subfolders", ":", "value", "=", "_rollback_env_variable", "(", "unmodified_environ", ",", "key", ",", "subfolder", ")", "if", "value", "is", "not", "None", ":", "environ", "[", "key", "]", "=", "value", "lines", ".", "append", "(", "assignment", "(", "key", ",", "value", ")", ")", "if", "lines", ":", "lines", ".", "insert", "(", "0", ",", "comment", "(", "'reset environment variables by unrolling modifications based on all workspaces in CMAKE_PREFIX_PATH'", ")", ")", "return", "lines" ]

[ "Wrapper", "around", "GeNNModel", ".", "push_connectivity_to_device" ]

[ "def", "push_connectivity_to_device", "(", "self", ")", ":", "self", ".", "_model", ".", "push_connectivity_to_device", "(", "self", ".", "name", ")" ]

[ "Bring", "the", "number", "of", "pool", "processes", "up", "to", "the", "specified", "number", "for", "use", "after", "reaping", "workers", "which", "have", "exited", "." ]

[ "def", "_repopulate_pool", "(", "self", ")", ":", "from", "multiprocessing", ".", "util", "import", "debug", "for", "i", "in", "range", "(", "self", ".", "_processes", "-", "len", "(", "self", ".", "_pool", ")", ")", ":", "w", "=", "self", ".", "Process", "(", "target", "=", "tbb_process_pool_worker3", ",", "args", "=", "(", "self", ".", "_inqueue", ",", "self", ".", "_outqueue", ",", "self", ".", "_initializer", ",", "self", ".", "_initargs", ",", "self", ".", "_maxtasksperchild", ",", "self", ".", "_wrap_exception", ")", ")", "self", ".", "_pool", ".", "append", "(", "w", ")", "w", ".", "name", "=", "w", ".", "name", ".", "replace", "(", "'Process'", ",", "'PoolWorker'", ")", "w", ".", "daemon", "=", "True", "w", ".", "start", "(", ")", "debug", "(", "'added worker'", ")" ]

[ "Automatically", "find", "/", "download", "setuptools", "and", "make", "it", "available", "on", "sys", ".", "path" ]

[ "def", "use_setuptools", "(", "version", "=", "DEFAULT_VERSION", ",", "download_base", "=", "DEFAULT_URL", ",", "to_dir", "=", "os", ".", "curdir", ",", "download_delay", "=", "15", ")", ":", "was_imported", "=", "'pkg_resources'", "in", "sys", ".", "modules", "or", "'setuptools'", "in", "sys", ".", "modules", "def", "do_download", "(", ")", ":", "egg", "=", "download_setuptools", "(", "version", ",", "download_base", ",", "to_dir", ",", "download_delay", ")", "sys", ".", "path", ".", "insert", "(", "0", ",", "egg", ")", "import", "setuptools", "setuptools", ".", "bootstrap_install_from", "=", "egg", "try", ":", "import", "pkg_resources", "except", "ImportError", ":", "return", "do_download", "(", ")", "try", ":", "pkg_resources", ".", "require", "(", "\"setuptools>=\"", "+", "version", ")", "return", "except", "pkg_resources", ".", "VersionConflict", ",", "e", ":", "if", "was_imported", ":", "print", ">>", "sys", ".", "stderr", ",", "(", "\"The required version of setuptools (>=%s) is not available, and\\n\"", "\"can't be installed while this script is running. Please install\\n\"", "\" a more recent version first, using 'easy_install -U setuptools'.\"", "\"\\n\\n(Currently using %r)\"", ")", "%", "(", "version", ",", "e", ".", "args", "[", "0", "]", ")", "sys", ".", "exit", "(", "2", ")", "except", "pkg_resources", ".", "DistributionNotFound", ":", "pass", "del", "pkg_resources", ",", "sys", ".", "modules", "[", "'pkg_resources'", "]", "# reload ok", "return", "do_download", "(", ")" ]

[ "Returns", "the", "number", "of", "preferences", "widgets" ]

[ "def", "count", "(", "self", ")", ":", "return", "len", "(", "self", ".", "_widgets", ")" ]

[ "Return", "a", "SourceLocation", "representing", "the", "last", "character", "within", "a", "source", "range", "." ]

[ "def", "end", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_getRangeEnd", "(", "self", ")" ]

[ "__getitem__", "(", "self", "size_t", "index", ")", "-", ">", "RichTextObject" ]

[ "def", "__getitem__", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextObjectList___getitem__", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "list", "of", "the", "row", "axis", "labels", "." ]

[ "def", "axes", "(", "self", ")", ":", "return", "[", "self", ".", "index", "]" ]

[ "Applies", "the", "given", "include", "rules", "returning", "the", "new", "rules", "." ]

[ "def", "_ApplyRules", "(", "self", ",", "existing_rules", ",", "includes", ",", "specific_includes", ",", "cur_dir_norm", ")", ":", "rules", "=", "copy", ".", "deepcopy", "(", "existing_rules", ")", "# First apply the implicit \"allow\" rule for the current directory.", "base_dir_norm", "=", "NormalizePath", "(", "self", ".", "base_directory", ")", "if", "not", "cur_dir_norm", ".", "startswith", "(", "base_dir_norm", ")", ":", "raise", "Exception", "(", "'Internal error: base directory is not at the beginning for\\n'", "' %s and base dir\\n'", "' %s'", "%", "(", "cur_dir_norm", ",", "base_dir_norm", ")", ")", "relative_dir", "=", "posixpath", ".", "relpath", "(", "cur_dir_norm", ",", "base_dir_norm", ")", "# Make the help string a little more meaningful.", "source", "=", "relative_dir", "or", "'top level'", "rules", ".", "AddRule", "(", "'+'", "+", "relative_dir", ",", "relative_dir", ",", "'Default rule for '", "+", "source", ")", "def", "ApplyOneRule", "(", "rule_str", ",", "dependee_regexp", "=", "None", ")", ":", "\"\"\"Deduces a sensible description for the rule being added, and\n adds the rule with its description to |rules|.\n\n If we are ignoring temporary rules, this function does nothing\n for rules beginning with the Rule.TEMP_ALLOW character.\n \"\"\"", "if", "self", ".", "_ignore_temp_rules", "and", "rule_str", ".", "startswith", "(", "Rule", ".", "TEMP_ALLOW", ")", ":", "return", "rule_block_name", "=", "'include_rules'", "if", "dependee_regexp", ":", "rule_block_name", "=", "'specific_include_rules'", "if", "relative_dir", ":", "rule_description", "=", "relative_dir", "+", "\"'s %s\"", "%", "rule_block_name", "else", ":", "rule_description", "=", "'the top level %s'", "%", "rule_block_name", "rules", ".", "AddRule", "(", "rule_str", ",", "relative_dir", ",", "rule_description", ",", "dependee_regexp", ")", "# Apply the additional explicit rules.", "for", "rule_str", "in", "includes", ":", "ApplyOneRule", "(", "rule_str", ")", "# Finally, apply the specific rules.", "if", "self", ".", "_ignore_specific_rules", ":", "return", "rules", "for", "regexp", ",", "specific_rules", "in", "specific_includes", ".", "iteritems", "(", ")", ":", "for", "rule_str", "in", "specific_rules", ":", "ApplyOneRule", "(", "rule_str", ",", "regexp", ")", "return", "rules" ]

[ "Updates", "the", "global", "list", "of", "line", "error", "-", "suppressions", "." ]

[ "def", "ParseNolintSuppressions", "(", "filename", ",", "raw_line", ",", "linenum", ",", "error", ")", ":", "matched", "=", "Search", "(", "r'\\bNOLINT(NEXTLINE)?\\b(\\([^)]+\\))?'", ",", "raw_line", ")", "if", "matched", ":", "if", "matched", ".", "group", "(", "1", ")", ":", "suppressed_line", "=", "linenum", "+", "1", "else", ":", "suppressed_line", "=", "linenum", "category", "=", "matched", ".", "group", "(", "2", ")", "if", "category", "in", "(", "None", ",", "'(*)'", ")", ":", "# => \"suppress all\"", "_error_suppressions", ".", "setdefault", "(", "None", ",", "set", "(", ")", ")", ".", "add", "(", "suppressed_line", ")", "else", ":", "if", "category", ".", "startswith", "(", "'('", ")", "and", "category", ".", "endswith", "(", "')'", ")", ":", "category", "=", "category", "[", "1", ":", "-", "1", "]", "if", "category", "in", "_ERROR_CATEGORIES", ":", "_error_suppressions", ".", "setdefault", "(", "category", ",", "set", "(", ")", ")", ".", "add", "(", "suppressed_line", ")", "elif", "category", "not", "in", "_LEGACY_ERROR_CATEGORIES", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/nolint'", ",", "5", ",", "'Unknown NOLINT error category: %s'", "%", "category", ")" ]

[ "Function", "definition", "proto", "." ]

[ "def", "definition", "(", "self", ")", ":", "self", ".", "_create_definition_if_needed", "(", ")", "return", "self", ".", "_definition" ]

[ "SetCaretWidth", "(", "self", "int", "pixelWidth", ")" ]

[ "def", "SetCaretWidth", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetCaretWidth", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "When", "being", "redirected", "we", "may", "want", "to", "strip", "authentication", "from", "the", "request", "to", "avoid", "leaking", "credentials", ".", "This", "method", "intelligently", "removes", "and", "reapplies", "authentication", "where", "possible", "to", "avoid", "credential", "loss", "." ]

[ "def", "rebuild_auth", "(", "self", ",", "prepared_request", ",", "response", ")", ":", "headers", "=", "prepared_request", ".", "headers", "url", "=", "prepared_request", ".", "url", "if", "'Authorization'", "in", "headers", ":", "# If we get redirected to a new host, we should strip out any", "# authentication headers.", "original_parsed", "=", "urlparse", "(", "response", ".", "request", ".", "url", ")", "redirect_parsed", "=", "urlparse", "(", "url", ")", "if", "(", "original_parsed", ".", "hostname", "!=", "redirect_parsed", ".", "hostname", ")", ":", "del", "headers", "[", "'Authorization'", "]", "# .netrc might have more auth for us on our new host.", "new_auth", "=", "get_netrc_auth", "(", "url", ")", "if", "self", ".", "trust_env", "else", "None", "if", "new_auth", "is", "not", "None", ":", "prepared_request", ".", "prepare_auth", "(", "new_auth", ")", "return" ]

[ "Returns", "x", "+", "y", "element", "-", "wise", "." ]

[ "def", "_tensor_add_tensor", "(", "x", ",", "y", ")", ":", "return", "F", ".", "add", "(", "x", ",", "y", ")" ]

[ "Set", "communication", "parameters", "on", "opened", "port", "." ]

[ "def", "_reconfigure_port", "(", "self", ")", ":", "if", "not", "self", ".", "_port_handle", ":", "raise", "SerialException", "(", "\"Can only operate on a valid port handle\"", ")", "# Set Windows timeout values", "# timeouts is a tuple with the following items:", "# (ReadIntervalTimeout,ReadTotalTimeoutMultiplier,", "# ReadTotalTimeoutConstant,WriteTotalTimeoutMultiplier,", "# WriteTotalTimeoutConstant)", "timeouts", "=", "win32", ".", "COMMTIMEOUTS", "(", ")", "if", "self", ".", "_timeout", "is", "None", ":", "pass", "# default of all zeros is OK", "elif", "self", ".", "_timeout", "==", "0", ":", "timeouts", ".", "ReadIntervalTimeout", "=", "win32", ".", "MAXDWORD", "else", ":", "timeouts", ".", "ReadTotalTimeoutConstant", "=", "max", "(", "int", "(", "self", ".", "_timeout", "*", "1000", ")", ",", "1", ")", "if", "self", ".", "_timeout", "!=", "0", "and", "self", ".", "_inter_byte_timeout", "is", "not", "None", ":", "timeouts", ".", "ReadIntervalTimeout", "=", "max", "(", "int", "(", "self", ".", "_inter_byte_timeout", "*", "1000", ")", ",", "1", ")", "if", "self", ".", "_write_timeout", "is", "None", ":", "pass", "elif", "self", ".", "_write_timeout", "==", "0", ":", "timeouts", ".", "WriteTotalTimeoutConstant", "=", "win32", ".", "MAXDWORD", "else", ":", "timeouts", ".", "WriteTotalTimeoutConstant", "=", "max", "(", "int", "(", "self", ".", "_write_timeout", "*", "1000", ")", ",", "1", ")", "win32", ".", "SetCommTimeouts", "(", "self", ".", "_port_handle", ",", "ctypes", ".", "byref", "(", "timeouts", ")", ")", "win32", ".", "SetCommMask", "(", "self", ".", "_port_handle", ",", "win32", ".", "EV_ERR", ")", "# Setup the connection info.", "# Get state and modify it:", "comDCB", "=", "win32", ".", "DCB", "(", ")", "win32", ".", "GetCommState", "(", "self", ".", "_port_handle", ",", "ctypes", ".", "byref", "(", "comDCB", ")", ")", "comDCB", ".", "BaudRate", "=", "self", ".", "_baudrate", "if", "self", ".", "_bytesize", "==", "serial", ".", "FIVEBITS", ":", "comDCB", ".", "ByteSize", "=", "5", "elif", "self", ".", "_bytesize", "==", "serial", ".", "SIXBITS", ":", "comDCB", ".", "ByteSize", "=", "6", "elif", "self", ".", "_bytesize", "==", "serial", ".", "SEVENBITS", ":", "comDCB", ".", "ByteSize", "=", "7", "elif", "self", ".", "_bytesize", "==", "serial", ".", "EIGHTBITS", ":", "comDCB", ".", "ByteSize", "=", "8", "else", ":", "raise", "ValueError", "(", "\"Unsupported number of data bits: {!r}\"", ".", "format", "(", "self", ".", "_bytesize", ")", ")", "if", "self", ".", "_parity", "==", "serial", ".", "PARITY_NONE", ":", "comDCB", ".", "Parity", "=", "win32", ".", "NOPARITY", "comDCB", ".", "fParity", "=", "0", "# Disable Parity Check", "elif", "self", ".", "_parity", "==", "serial", ".", "PARITY_EVEN", ":", "comDCB", ".", "Parity", "=", "win32", ".", "EVENPARITY", "comDCB", ".", "fParity", "=", "1", "# Enable Parity Check", "elif", "self", ".", "_parity", "==", "serial", ".", "PARITY_ODD", ":", "comDCB", ".", "Parity", "=", "win32", ".", "ODDPARITY", "comDCB", ".", "fParity", "=", "1", "# Enable Parity Check", "elif", "self", ".", "_parity", "==", "serial", ".", "PARITY_MARK", ":", "comDCB", ".", "Parity", "=", "win32", ".", "MARKPARITY", "comDCB", ".", "fParity", "=", "1", "# Enable Parity Check", "elif", "self", ".", "_parity", "==", "serial", ".", "PARITY_SPACE", ":", "comDCB", ".", "Parity", "=", "win32", ".", "SPACEPARITY", "comDCB", ".", "fParity", "=", "1", "# Enable Parity Check", "else", ":", "raise", "ValueError", "(", "\"Unsupported parity mode: {!r}\"", ".", "format", "(", "self", ".", "_parity", ")", ")", "if", "self", ".", "_stopbits", "==", "serial", ".", "STOPBITS_ONE", ":", "comDCB", ".", "StopBits", "=", "win32", ".", "ONESTOPBIT", "elif", "self", ".", "_stopbits", "==", "serial", ".", "STOPBITS_ONE_POINT_FIVE", ":", "comDCB", ".", "StopBits", "=", "win32", ".", "ONE5STOPBITS", "elif", "self", ".", "_stopbits", "==", "serial", ".", "STOPBITS_TWO", ":", "comDCB", ".", "StopBits", "=", "win32", ".", "TWOSTOPBITS", "else", ":", "raise", "ValueError", "(", "\"Unsupported number of stop bits: {!r}\"", ".", "format", "(", "self", ".", "_stopbits", ")", ")", "comDCB", ".", "fBinary", "=", "1", "# Enable Binary Transmission", "# Char. w/ Parity-Err are replaced with 0xff (if fErrorChar is set to TRUE)", "if", "self", ".", "_rs485_mode", "is", "None", ":", "if", "self", ".", "_rtscts", ":", "comDCB", ".", "fRtsControl", "=", "win32", ".", "RTS_CONTROL_HANDSHAKE", "else", ":", "comDCB", ".", "fRtsControl", "=", "win32", ".", "RTS_CONTROL_ENABLE", "if", "self", ".", "_rts_state", "else", "win32", ".", "RTS_CONTROL_DISABLE", "comDCB", ".", "fOutxCtsFlow", "=", "self", ".", "_rtscts", "else", ":", "# checks for unsupported settings", "# XXX verify if platform really does not have a setting for those", "if", "not", "self", ".", "_rs485_mode", ".", "rts_level_for_tx", ":", "raise", "ValueError", "(", "'Unsupported value for RS485Settings.rts_level_for_tx: {!r}'", ".", "format", "(", "self", ".", "_rs485_mode", ".", "rts_level_for_tx", ",", ")", ")", "if", "self", ".", "_rs485_mode", ".", "rts_level_for_rx", ":", "raise", "ValueError", "(", "'Unsupported value for RS485Settings.rts_level_for_rx: {!r}'", ".", "format", "(", "self", ".", "_rs485_mode", ".", "rts_level_for_rx", ",", ")", ")", "if", "self", ".", "_rs485_mode", ".", "delay_before_tx", "is", "not", "None", ":", "raise", "ValueError", "(", "'Unsupported value for RS485Settings.delay_before_tx: {!r}'", ".", "format", "(", "self", ".", "_rs485_mode", ".", "delay_before_tx", ",", ")", ")", "if", "self", ".", "_rs485_mode", ".", "delay_before_rx", "is", "not", "None", ":", "raise", "ValueError", "(", "'Unsupported value for RS485Settings.delay_before_rx: {!r}'", ".", "format", "(", "self", ".", "_rs485_mode", ".", "delay_before_rx", ",", ")", ")", "if", "self", ".", "_rs485_mode", ".", "loopback", ":", "raise", "ValueError", "(", "'Unsupported value for RS485Settings.loopback: {!r}'", ".", "format", "(", "self", ".", "_rs485_mode", ".", "loopback", ",", ")", ")", "comDCB", ".", "fRtsControl", "=", "win32", ".", "RTS_CONTROL_TOGGLE", "comDCB", ".", "fOutxCtsFlow", "=", "0", "if", "self", ".", "_dsrdtr", ":", "comDCB", ".", "fDtrControl", "=", "win32", ".", "DTR_CONTROL_HANDSHAKE", "else", ":", "comDCB", ".", "fDtrControl", "=", "win32", ".", "DTR_CONTROL_ENABLE", "if", "self", ".", "_dtr_state", "else", "win32", ".", "DTR_CONTROL_DISABLE", "comDCB", ".", "fOutxDsrFlow", "=", "self", ".", "_dsrdtr", "comDCB", ".", "fOutX", "=", "self", ".", "_xonxoff", "comDCB", ".", "fInX", "=", "self", ".", "_xonxoff", "comDCB", ".", "fNull", "=", "0", "comDCB", ".", "fErrorChar", "=", "0", "comDCB", ".", "fAbortOnError", "=", "0", "comDCB", ".", "XonChar", "=", "serial", ".", "XON", "comDCB", ".", "XoffChar", "=", "serial", ".", "XOFF", "if", "not", "win32", ".", "SetCommState", "(", "self", ".", "_port_handle", ",", "ctypes", ".", "byref", "(", "comDCB", ")", ")", ":", "raise", "SerialException", "(", "'Cannot configure port, something went wrong. '", "'Original message: {!r}'", ".", "format", "(", "ctypes", ".", "WinError", "(", ")", ")", ")" ]

[ "Untar", "the", "file", "(", "with", "path", "filename", ")", "to", "the", "destination", "location", ".", "All", "files", "are", "written", "based", "on", "system", "defaults", "and", "umask", "(", "i", ".", "e", ".", "permissions", "are", "not", "preserved", ")", "except", "that", "regular", "file", "members", "with", "any", "execute", "permissions", "(", "user", "group", "or", "world", ")", "have", "chmod", "+", "x", "applied", "after", "being", "written", ".", "Note", "that", "for", "windows", "any", "execute", "changes", "using", "os", ".", "chmod", "are", "no", "-", "ops", "per", "the", "python", "docs", "." ]

[ "def", "untar_file", "(", "filename", ",", "location", ")", ":", "# type: (str, str) -> None", "ensure_dir", "(", "location", ")", "if", "filename", ".", "lower", "(", ")", ".", "endswith", "(", "'.gz'", ")", "or", "filename", ".", "lower", "(", ")", ".", "endswith", "(", "'.tgz'", ")", ":", "mode", "=", "'r:gz'", "elif", "filename", ".", "lower", "(", ")", ".", "endswith", "(", "BZ2_EXTENSIONS", ")", ":", "mode", "=", "'r:bz2'", "elif", "filename", ".", "lower", "(", ")", ".", "endswith", "(", "XZ_EXTENSIONS", ")", ":", "mode", "=", "'r:xz'", "elif", "filename", ".", "lower", "(", ")", ".", "endswith", "(", "'.tar'", ")", ":", "mode", "=", "'r'", "else", ":", "logger", ".", "warning", "(", "'Cannot determine compression type for file %s'", ",", "filename", ",", ")", "mode", "=", "'r:*'", "tar", "=", "tarfile", ".", "open", "(", "filename", ",", "mode", ")", "try", ":", "leading", "=", "has_leading_dir", "(", "[", "member", ".", "name", "for", "member", "in", "tar", ".", "getmembers", "(", ")", "]", ")", "for", "member", "in", "tar", ".", "getmembers", "(", ")", ":", "fn", "=", "member", ".", "name", "if", "leading", ":", "fn", "=", "split_leading_dir", "(", "fn", ")", "[", "1", "]", "path", "=", "os", ".", "path", ".", "join", "(", "location", ",", "fn", ")", "if", "not", "is_within_directory", "(", "location", ",", "path", ")", ":", "message", "=", "(", "'The tar file ({}) has a file ({}) trying to install '", "'outside target directory ({})'", ")", "raise", "InstallationError", "(", "message", ".", "format", "(", "filename", ",", "path", ",", "location", ")", ")", "if", "member", ".", "isdir", "(", ")", ":", "ensure_dir", "(", "path", ")", "elif", "member", ".", "issym", "(", ")", ":", "try", ":", "# https://github.com/python/typeshed/issues/2673", "tar", ".", "_extract_member", "(", "member", ",", "path", ")", "# type: ignore", "except", "Exception", "as", "exc", ":", "# Some corrupt tar files seem to produce this", "# (specifically bad symlinks)", "logger", ".", "warning", "(", "'In the tar file %s the member %s is invalid: %s'", ",", "filename", ",", "member", ".", "name", ",", "exc", ",", ")", "continue", "else", ":", "try", ":", "fp", "=", "tar", ".", "extractfile", "(", "member", ")", "except", "(", "KeyError", ",", "AttributeError", ")", "as", "exc", ":", "# Some corrupt tar files seem to produce this", "# (specifically bad symlinks)", "logger", ".", "warning", "(", "'In the tar file %s the member %s is invalid: %s'", ",", "filename", ",", "member", ".", "name", ",", "exc", ",", ")", "continue", "ensure_dir", "(", "os", ".", "path", ".", "dirname", "(", "path", ")", ")", "assert", "fp", "is", "not", "None", "with", "open", "(", "path", ",", "'wb'", ")", "as", "destfp", ":", "shutil", ".", "copyfileobj", "(", "fp", ",", "destfp", ")", "fp", ".", "close", "(", ")", "# Update the timestamp (useful for cython compiled files)", "tar", ".", "utime", "(", "member", ",", "path", ")", "# member have any execute permissions for user/group/world?", "if", "member", ".", "mode", "&", "0o111", ":", "set_extracted_file_to_default_mode_plus_executable", "(", "path", ")", "finally", ":", "tar", ".", "close", "(", ")" ]

[ "Returns", "a", "path", "canonicalized", "for", "alphabetical", "comparison", "." ]

[ "def", "CanonicalizeAlphabeticalOrder", "(", "self", ",", "header_path", ")", ":", "return", "header_path", ".", "replace", "(", "'-inl.h'", ",", "'.h'", ")", ".", "replace", "(", "'-'", ",", "'_'", ")", ".", "lower", "(", ")" ]

[ "Return", "an", "import", "statement", "in", "the", "form", ":", "from", "package", "import", "name_leafs" ]

[ "def", "FromImport", "(", "package_name", ",", "name_leafs", ")", ":", "# XXX: May not handle dotted imports properly (eg, package_name='foo.bar')", "#assert package_name == '.' or '.' not in package_name, \"FromImport has \"\\", "# \"not been tested with dotted package names -- use at your own \"\\", "# \"peril!\"", "for", "leaf", "in", "name_leafs", ":", "# Pull the leaves out of their old tree", "leaf", ".", "remove", "(", ")", "children", "=", "[", "Leaf", "(", "token", ".", "NAME", ",", "u\"from\"", ")", ",", "Leaf", "(", "token", ".", "NAME", ",", "package_name", ",", "prefix", "=", "u\" \"", ")", ",", "Leaf", "(", "token", ".", "NAME", ",", "u\"import\"", ",", "prefix", "=", "u\" \"", ")", ",", "Node", "(", "syms", ".", "import_as_names", ",", "name_leafs", ")", "]", "imp", "=", "Node", "(", "syms", ".", "import_from", ",", "children", ")", "return", "imp" ]

[ "Computes", "and", "constructs", "when", "necessary", "the", "list", "of", "java", "source", "directories", "." ]

[ "def", "_CreateJavaSourceDir", "(", "entry_output_dir", ",", "java_sources_file", ")", ":", "java_dirs", "=", "[", "]", "if", "java_sources_file", ":", "java_files", "=", "_RebasePath", "(", "build_utils", ".", "ReadSourcesList", "(", "java_sources_file", ")", ")", "java_dirs", "=", "_ComputeJavaSourceDirs", "(", "java_files", ")", "found_java_files", "=", "build_utils", ".", "FindInDirectories", "(", "java_dirs", ",", "'*.java'", ")", "unwanted_java_files", "=", "set", "(", "found_java_files", ")", "-", "set", "(", "java_files", ")", "missing_java_files", "=", "set", "(", "java_files", ")", "-", "set", "(", "found_java_files", ")", "if", "unwanted_java_files", ":", "logging", ".", "debug", "(", "'Target requires .java symlinks: %s'", ",", "entry_output_dir", ")", "symlink_dir", "=", "os", ".", "path", ".", "join", "(", "entry_output_dir", ",", "_JAVA_SUBDIR", ")", "_CreateSymlinkTree", "(", "entry_output_dir", ",", "symlink_dir", ",", "java_files", ",", "java_dirs", ")", "java_dirs", "=", "[", "symlink_dir", "]", "if", "missing_java_files", ":", "logging", ".", "warning", "(", "'Some java files were not found: %s'", ",", "missing_java_files", ")", "return", "java_dirs" ]

[ "EndFontSize", "(", "self", ")", "-", ">", "bool" ]

[ "def", "EndFontSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextBuffer_EndFontSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Resolve", "a", "dyld", "path", "." ]

[ "def", "Resolve", "(", "path", ",", "exe_path", ",", "loader_path", ",", "rpaths", ")", ":", "path", "=", "path", ".", "replace", "(", "'@loader_path'", ",", "loader_path", ")", "path", "=", "path", ".", "replace", "(", "'@executable_path'", ",", "exe_path", ")", "if", "path", ".", "find", "(", "'@rpath'", ")", "!=", "-", "1", ":", "for", "rpath", "in", "rpaths", ":", "new_path", "=", "path", ".", "replace", "(", "'@rpath'", ",", "rpath", ")", "if", "os", ".", "access", "(", "new_path", ",", "os", ".", "X_OK", ")", ":", "return", "new_path", "return", "''", "return", "path" ]

[ "SizerItemWindow", "(", "Window", "window", "int", "proportion", "=", "0", "int", "flag", "=", "0", "int", "border", "=", "0", "PyObject", "userData", "=", "None", ")", "-", ">", "SizerItem" ]

[ "def", "SizerItemWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_core_", ".", "new_SizerItemWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "GetValueForKey", "(", "SBStructuredData", "self", "char", "const", "*", "key", ")", "-", ">", "SBStructuredData" ]

[ "def", "GetValueForKey", "(", "self", ",", "key", ")", ":", "return", "_lldb", ".", "SBStructuredData_GetValueForKey", "(", "self", ",", "key", ")" ]

[ "Create", "counters", "for", "bug", "statistics", "." ]

[ "def", "create_counters", "(", ")", ":", "def", "predicate", "(", "bug", ")", ":", "bug_category", "=", "bug", "[", "'bug_category'", "]", "bug_type", "=", "bug", "[", "'bug_type'", "]", "current_category", "=", "predicate", ".", "categories", ".", "get", "(", "bug_category", ",", "dict", "(", ")", ")", "current_type", "=", "current_category", ".", "get", "(", "bug_type", ",", "{", "'bug_type'", ":", "bug_type", ",", "'bug_type_class'", ":", "category_type_name", "(", "bug", ")", ",", "'bug_count'", ":", "0", "}", ")", "current_type", ".", "update", "(", "{", "'bug_count'", ":", "current_type", "[", "'bug_count'", "]", "+", "1", "}", ")", "current_category", ".", "update", "(", "{", "bug_type", ":", "current_type", "}", ")", "predicate", ".", "categories", ".", "update", "(", "{", "bug_category", ":", "current_category", "}", ")", "predicate", ".", "total", "+=", "1", "predicate", ".", "total", "=", "0", "predicate", ".", "categories", "=", "dict", "(", ")", "return", "predicate" ]

[ "Create", "a", "TranslationUnit", "instance", "from", "a", "saved", "AST", "file", "." ]

[ "def", "from_ast_file", "(", "cls", ",", "filename", ",", "index", "=", "None", ")", ":", "if", "index", "is", "None", ":", "index", "=", "Index", ".", "create", "(", ")", "ptr", "=", "conf", ".", "lib", ".", "clang_createTranslationUnit", "(", "index", ",", "filename", ")", "if", "not", "ptr", ":", "raise", "TranslationUnitLoadError", "(", "filename", ")", "return", "cls", "(", "ptr", "=", "ptr", ",", "index", "=", "index", ")" ]

[ "Reset", "the", "state", "of", "this", "mock", "to", "record", "mode", "with", "an", "empty", "queue", "." ]

[ "def", "_Reset", "(", "self", ")", ":", "# Maintain a list of method calls we are expecting", "self", ".", "_expected_calls_queue", "=", "collections", ".", "deque", "(", ")", "# Make sure we are in setup mode, not replay mode", "self", ".", "_replay_mode", "=", "False" ]

[ "Returns", "logger", "used", "by", "multiprocessing" ]

[ "def", "get_logger", "(", ")", ":", "global", "_logger", "import", "logging", "logging", ".", "_acquireLock", "(", ")", "try", ":", "if", "not", "_logger", ":", "_logger", "=", "logging", ".", "getLogger", "(", "LOGGER_NAME", ")", "_logger", ".", "propagate", "=", "0", "# XXX multiprocessing should cleanup before logging", "if", "hasattr", "(", "atexit", ",", "'unregister'", ")", ":", "atexit", ".", "unregister", "(", "_exit_function", ")", "atexit", ".", "register", "(", "_exit_function", ")", "else", ":", "atexit", ".", "_exithandlers", ".", "remove", "(", "(", "_exit_function", ",", "(", ")", ",", "{", "}", ")", ")", "atexit", ".", "_exithandlers", ".", "append", "(", "(", "_exit_function", ",", "(", ")", ",", "{", "}", ")", ")", "finally", ":", "logging", ".", "_releaseLock", "(", ")", "return", "_logger" ]

[ "Set", "an", "environment", "variable", "which", "will", "enable", "or", "disable", "the", "use", "of", "FP16", "precision", "in", "TensorRT", "Note", ":", "The", "mode", "FP16", "force", "the", "whole", "TRT", "node", "to", "be", "executed", "in", "FP16", ":", "param", "status", ":", "Boolean", "True", "if", "TensorRT", "should", "run", "in", "FP16", "False", "for", "FP32" ]

[ "def", "set_use_fp16", "(", "status", ")", ":", "os", ".", "environ", "[", "\"MXNET_TENSORRT_USE_FP16\"", "]", "=", "str", "(", "int", "(", "status", ")", ")" ]

[ "Adds", "a", "Batch", "Normalization", "layer", "from", "http", ":", "//", "arxiv", ".", "org", "/", "abs", "/", "1502", ".", "03167", "." ]

[ "def", "batch_norm", "(", "inputs", ",", "decay", "=", "0.999", ",", "center", "=", "True", ",", "scale", "=", "False", ",", "epsilon", "=", "0.001", ",", "activation_fn", "=", "None", ",", "param_initializers", "=", "None", ",", "param_regularizers", "=", "None", ",", "updates_collections", "=", "ops", ".", "GraphKeys", ".", "UPDATE_OPS", ",", "is_training", "=", "True", ",", "reuse", "=", "None", ",", "variables_collections", "=", "None", ",", "outputs_collections", "=", "None", ",", "trainable", "=", "True", ",", "batch_weights", "=", "None", ",", "fused", "=", "None", ",", "data_format", "=", "DATA_FORMAT_NHWC", ",", "zero_debias_moving_mean", "=", "False", ",", "scope", "=", "None", ",", "renorm", "=", "False", ",", "renorm_clipping", "=", "None", ",", "renorm_decay", "=", "0.99", ",", "adjustment", "=", "None", ")", ":", "if", "fused", "is", "None", ":", "fused", "=", "True", "# Only use _fused_batch_norm if all of the following three", "# conditions are true:", "# (1) fused is set True;", "# (2) it is possible to use (currently it doesn't support batch weights,", "# renorm, and the case when rank is neither 2 nor 4);", "# (3) it is used with zero_debias_moving_mean, or an input shape of rank 2,", "# or non-default updates_collections (not implemented in", "# normalization_layers.BatchNormalization yet); otherwise use the fused", "# implementation in normalization_layers.BatchNormalization.", "inputs", "=", "ops", ".", "convert_to_tensor", "(", "inputs", ")", "rank", "=", "inputs", ".", "get_shape", "(", ")", ".", "ndims", "possible_to_fuse", "=", "(", "batch_weights", "is", "None", "and", "not", "renorm", "and", "rank", "in", "[", "2", ",", "4", "]", "and", "adjustment", "is", "None", ")", "if", "fused", "and", "possible_to_fuse", "and", "(", "zero_debias_moving_mean", "or", "rank", "==", "2", "or", "updates_collections", "is", "not", "ops", ".", "GraphKeys", ".", "UPDATE_OPS", ")", ":", "return", "_fused_batch_norm", "(", "inputs", ",", "decay", "=", "decay", ",", "center", "=", "center", ",", "scale", "=", "scale", ",", "epsilon", "=", "epsilon", ",", "activation_fn", "=", "activation_fn", ",", "param_initializers", "=", "param_initializers", ",", "updates_collections", "=", "updates_collections", ",", "is_training", "=", "is_training", ",", "reuse", "=", "reuse", ",", "variables_collections", "=", "variables_collections", ",", "outputs_collections", "=", "outputs_collections", ",", "trainable", "=", "trainable", ",", "data_format", "=", "data_format", ",", "zero_debias_moving_mean", "=", "zero_debias_moving_mean", ",", "scope", "=", "scope", ")", "if", "data_format", "not", "in", "(", "DATA_FORMAT_NCHW", ",", "DATA_FORMAT_NHWC", ")", ":", "raise", "ValueError", "(", "'data_format has to be either NCHW or NHWC.'", ")", "layer_variable_getter", "=", "_build_variable_getter", "(", ")", "with", "variable_scope", ".", "variable_scope", "(", "scope", ",", "'BatchNorm'", ",", "[", "inputs", "]", ",", "reuse", "=", "reuse", ",", "custom_getter", "=", "layer_variable_getter", ")", "as", "sc", ":", "inputs", "=", "ops", ".", "convert_to_tensor", "(", "inputs", ")", "# Determine whether we can use the core layer class.", "if", "(", "batch_weights", "is", "None", "and", "updates_collections", "is", "ops", ".", "GraphKeys", ".", "UPDATE_OPS", "and", "not", "zero_debias_moving_mean", ")", ":", "# Use the core layer class.", "axis", "=", "1", "if", "data_format", "==", "DATA_FORMAT_NCHW", "else", "-", "1", "if", "not", "param_initializers", ":", "param_initializers", "=", "{", "}", "beta_initializer", "=", "param_initializers", ".", "get", "(", "'beta'", ",", "init_ops", ".", "zeros_initializer", "(", ")", ")", "gamma_initializer", "=", "param_initializers", ".", "get", "(", "'gamma'", ",", "init_ops", ".", "ones_initializer", "(", ")", ")", "moving_mean_initializer", "=", "param_initializers", ".", "get", "(", "'moving_mean'", ",", "init_ops", ".", "zeros_initializer", "(", ")", ")", "moving_variance_initializer", "=", "param_initializers", ".", "get", "(", "'moving_variance'", ",", "init_ops", ".", "ones_initializer", "(", ")", ")", "if", "not", "param_regularizers", ":", "param_regularizers", "=", "{", "}", "beta_regularizer", "=", "param_regularizers", ".", "get", "(", "'beta'", ")", "gamma_regularizer", "=", "param_regularizers", ".", "get", "(", "'gamma'", ")", "layer", "=", "normalization_layers", ".", "BatchNormalization", "(", "axis", "=", "axis", ",", "momentum", "=", "decay", ",", "epsilon", "=", "epsilon", ",", "center", "=", "center", ",", "scale", "=", "scale", ",", "beta_initializer", "=", "beta_initializer", ",", "gamma_initializer", "=", "gamma_initializer", ",", "moving_mean_initializer", "=", "moving_mean_initializer", ",", "moving_variance_initializer", "=", "moving_variance_initializer", ",", "beta_regularizer", "=", "beta_regularizer", ",", "gamma_regularizer", "=", "gamma_regularizer", ",", "trainable", "=", "trainable", ",", "renorm", "=", "renorm", ",", "renorm_clipping", "=", "renorm_clipping", ",", "renorm_momentum", "=", "renorm_decay", ",", "adjustment", "=", "adjustment", ",", "name", "=", "sc", ".", "name", ",", "_scope", "=", "sc", ",", "_reuse", "=", "reuse", ",", "fused", "=", "fused", ")", "outputs", "=", "layer", ".", "apply", "(", "inputs", ",", "training", "=", "is_training", ")", "# Add variables to collections.", "_add_variable_to_collections", "(", "layer", ".", "moving_mean", ",", "variables_collections", ",", "'moving_mean'", ")", "_add_variable_to_collections", "(", "layer", ".", "moving_variance", ",", "variables_collections", ",", "'moving_variance'", ")", "if", "layer", ".", "beta", "is", "not", "None", ":", "_add_variable_to_collections", "(", "layer", ".", "beta", ",", "variables_collections", ",", "'beta'", ")", "if", "layer", ".", "gamma", "is", "not", "None", ":", "_add_variable_to_collections", "(", "layer", ".", "gamma", ",", "variables_collections", ",", "'gamma'", ")", "if", "activation_fn", "is", "not", "None", ":", "outputs", "=", "activation_fn", "(", "outputs", ")", "return", "utils", ".", "collect_named_outputs", "(", "outputs_collections", ",", "sc", ".", "name", ",", "outputs", ")", "# Not supported by layer class: batch_weights argument,", "# and custom updates_collections. In that case, use the legacy BN", "# implementation.", "# Custom updates collections are not supported because the update logic", "# is different in this case, in particular w.r.t. \"forced updates\" and", "# update op reuse.", "if", "renorm", ":", "raise", "ValueError", "(", "'renorm is not supported with batch_weights, '", "'updates_collections or zero_debias_moving_mean'", ")", "inputs_shape", "=", "inputs", ".", "get_shape", "(", ")", "inputs_rank", "=", "inputs_shape", ".", "ndims", "if", "inputs_rank", "is", "None", ":", "raise", "ValueError", "(", "'Inputs %s has undefined rank.'", "%", "inputs", ".", "name", ")", "dtype", "=", "inputs", ".", "dtype", ".", "base_dtype", "if", "batch_weights", "is", "not", "None", ":", "batch_weights", "=", "ops", ".", "convert_to_tensor", "(", "batch_weights", ")", "inputs_shape", "[", "0", ":", "1", "]", ".", "assert_is_compatible_with", "(", "batch_weights", ".", "get_shape", "(", ")", ")", "# Reshape batch weight values so they broadcast across inputs.", "nshape", "=", "[", "-", "1", "]", "+", "[", "1", "for", "_", "in", "range", "(", "inputs_rank", "-", "1", ")", "]", "batch_weights", "=", "array_ops", ".", "reshape", "(", "batch_weights", ",", "nshape", ")", "if", "data_format", "==", "DATA_FORMAT_NCHW", ":", "moments_axes", "=", "[", "0", "]", "+", "list", "(", "range", "(", "2", ",", "inputs_rank", ")", ")", "params_shape", "=", "inputs_shape", "[", "1", ":", "2", "]", "# For NCHW format, rather than relying on implicit broadcasting, we", "# explicitly reshape the params to params_shape_broadcast when computing", "# the moments and the batch normalization.", "params_shape_broadcast", "=", "list", "(", "[", "1", ",", "inputs_shape", "[", "1", "]", ".", "value", "]", "+", "[", "1", "for", "_", "in", "range", "(", "2", ",", "inputs_rank", ")", "]", ")", "else", ":", "moments_axes", "=", "list", "(", "range", "(", "inputs_rank", "-", "1", ")", ")", "params_shape", "=", "inputs_shape", "[", "-", "1", ":", "]", "params_shape_broadcast", "=", "None", "if", "not", "params_shape", ".", "is_fully_defined", "(", ")", ":", "raise", "ValueError", "(", "'Inputs %s has undefined channels dimension %s.'", "%", "(", "inputs", ".", "name", ",", "params_shape", ")", ")", "# Allocate parameters for the beta and gamma of the normalization.", "beta", ",", "gamma", "=", "None", ",", "None", "if", "not", "param_initializers", ":", "param_initializers", "=", "{", "}", "if", "center", ":", "beta_collections", "=", "utils", ".", "get_variable_collections", "(", "variables_collections", ",", "'beta'", ")", "beta_initializer", "=", "param_initializers", ".", "get", "(", "'beta'", ",", "init_ops", ".", "zeros_initializer", "(", ")", ")", "beta", "=", "variables", ".", "model_variable", "(", "'beta'", ",", "shape", "=", "params_shape", ",", "dtype", "=", "dtype", ",", "initializer", "=", "beta_initializer", ",", "collections", "=", "beta_collections", ",", "trainable", "=", "trainable", ")", "if", "scale", ":", "gamma_collections", "=", "utils", ".", "get_variable_collections", "(", "variables_collections", ",", "'gamma'", ")", "gamma_initializer", "=", "param_initializers", ".", "get", "(", "'gamma'", ",", "init_ops", ".", "ones_initializer", "(", ")", ")", "gamma", "=", "variables", ".", "model_variable", "(", "'gamma'", ",", "shape", "=", "params_shape", ",", "dtype", "=", "dtype", ",", "initializer", "=", "gamma_initializer", ",", "collections", "=", "gamma_collections", ",", "trainable", "=", "trainable", ")", "# Create moving_mean and moving_variance variables and add them to the", "# appropriate collections. We disable variable partitioning while creating", "# them, because assign_moving_average is not yet supported for partitioned", "# variables (this needs to be handled carefully, as it may break", "# the checkpoint backward compatibility).", "with", "variable_scope", ".", "variable_scope", "(", "variable_scope", ".", "get_variable_scope", "(", ")", ")", "as", "local_scope", ":", "local_scope", ".", "set_partitioner", "(", "None", ")", "moving_mean_collections", "=", "utils", ".", "get_variable_collections", "(", "variables_collections", ",", "'moving_mean'", ")", "moving_mean_initializer", "=", "param_initializers", ".", "get", "(", "'moving_mean'", ",", "init_ops", ".", "zeros_initializer", "(", ")", ")", "moving_mean", "=", "variables", ".", "model_variable", "(", "'moving_mean'", ",", "shape", "=", "params_shape", ",", "dtype", "=", "dtype", ",", "initializer", "=", "moving_mean_initializer", ",", "trainable", "=", "False", ",", "collections", "=", "moving_mean_collections", ")", "moving_variance_collections", "=", "utils", ".", "get_variable_collections", "(", "variables_collections", ",", "'moving_variance'", ")", "moving_variance_initializer", "=", "param_initializers", ".", "get", "(", "'moving_variance'", ",", "init_ops", ".", "ones_initializer", "(", ")", ")", "moving_variance", "=", "variables", ".", "model_variable", "(", "'moving_variance'", ",", "shape", "=", "params_shape", ",", "dtype", "=", "dtype", ",", "initializer", "=", "moving_variance_initializer", ",", "trainable", "=", "False", ",", "collections", "=", "moving_variance_collections", ")", "# If `is_training` doesn't have a constant value, because it is a `Tensor`,", "# a `Variable` or `Placeholder` then is_training_value will be None and", "# `needs_moments` will be true.", "is_training_value", "=", "utils", ".", "constant_value", "(", "is_training", ")", "need_moments", "=", "is_training_value", "is", "None", "or", "is_training_value", "if", "need_moments", ":", "# Calculate the moments based on the individual batch.", "if", "batch_weights", "is", "None", ":", "if", "data_format", "==", "DATA_FORMAT_NCHW", ":", "mean", ",", "variance", "=", "nn", ".", "moments", "(", "inputs", ",", "moments_axes", ",", "keep_dims", "=", "True", ")", "mean", "=", "array_ops", ".", "reshape", "(", "mean", ",", "[", "-", "1", "]", ")", "variance", "=", "array_ops", ".", "reshape", "(", "variance", ",", "[", "-", "1", "]", ")", "else", ":", "mean", ",", "variance", "=", "nn", ".", "moments", "(", "inputs", ",", "moments_axes", ")", "else", ":", "if", "data_format", "==", "DATA_FORMAT_NCHW", ":", "mean", ",", "variance", "=", "nn", ".", "weighted_moments", "(", "inputs", ",", "moments_axes", ",", "batch_weights", ",", "keep_dims", "=", "True", ")", "mean", "=", "array_ops", ".", "reshape", "(", "mean", ",", "[", "-", "1", "]", ")", "variance", "=", "array_ops", ".", "reshape", "(", "variance", ",", "[", "-", "1", "]", ")", "else", ":", "mean", ",", "variance", "=", "nn", ".", "weighted_moments", "(", "inputs", ",", "moments_axes", ",", "batch_weights", ")", "moving_vars_fn", "=", "lambda", ":", "(", "moving_mean", ",", "moving_variance", ")", "if", "updates_collections", "is", "None", ":", "def", "_force_updates", "(", ")", ":", "\"\"\"Internal function forces updates moving_vars if is_training.\"\"\"", "update_moving_mean", "=", "moving_averages", ".", "assign_moving_average", "(", "moving_mean", ",", "mean", ",", "decay", ",", "zero_debias", "=", "zero_debias_moving_mean", ")", "update_moving_variance", "=", "moving_averages", ".", "assign_moving_average", "(", "moving_variance", ",", "variance", ",", "decay", ",", "zero_debias", "=", "False", ")", "with", "ops", ".", "control_dependencies", "(", "[", "update_moving_mean", ",", "update_moving_variance", "]", ")", ":", "return", "array_ops", ".", "identity", "(", "mean", ")", ",", "array_ops", ".", "identity", "(", "variance", ")", "mean", ",", "variance", "=", "utils", ".", "smart_cond", "(", "is_training", ",", "_force_updates", ",", "moving_vars_fn", ")", "else", ":", "def", "_delay_updates", "(", ")", ":", "\"\"\"Internal function that delay updates moving_vars if is_training.\"\"\"", "update_moving_mean", "=", "moving_averages", ".", "assign_moving_average", "(", "moving_mean", ",", "mean", ",", "decay", ",", "zero_debias", "=", "zero_debias_moving_mean", ")", "update_moving_variance", "=", "moving_averages", ".", "assign_moving_average", "(", "moving_variance", ",", "variance", ",", "decay", ",", "zero_debias", "=", "False", ")", "return", "update_moving_mean", ",", "update_moving_variance", "update_mean", ",", "update_variance", "=", "utils", ".", "smart_cond", "(", "is_training", ",", "_delay_updates", ",", "moving_vars_fn", ")", "ops", ".", "add_to_collections", "(", "updates_collections", ",", "update_mean", ")", "ops", ".", "add_to_collections", "(", "updates_collections", ",", "update_variance", ")", "# Use computed moments during training and moving_vars otherwise.", "vars_fn", "=", "lambda", ":", "(", "mean", ",", "variance", ")", "mean", ",", "variance", "=", "utils", ".", "smart_cond", "(", "is_training", ",", "vars_fn", ",", "moving_vars_fn", ")", "else", ":", "mean", ",", "variance", "=", "moving_mean", ",", "moving_variance", "if", "data_format", "==", "DATA_FORMAT_NCHW", ":", "mean", "=", "array_ops", ".", "reshape", "(", "mean", ",", "params_shape_broadcast", ")", "variance", "=", "array_ops", ".", "reshape", "(", "variance", ",", "params_shape_broadcast", ")", "if", "beta", "is", "not", "None", ":", "beta", "=", "array_ops", ".", "reshape", "(", "beta", ",", "params_shape_broadcast", ")", "if", "gamma", "is", "not", "None", ":", "gamma", "=", "array_ops", ".", "reshape", "(", "gamma", ",", "params_shape_broadcast", ")", "# Compute batch_normalization.", "outputs", "=", "nn", ".", "batch_normalization", "(", "inputs", ",", "mean", ",", "variance", ",", "beta", ",", "gamma", ",", "epsilon", ")", "outputs", ".", "set_shape", "(", "inputs_shape", ")", "if", "activation_fn", "is", "not", "None", ":", "outputs", "=", "activation_fn", "(", "outputs", ")", "return", "utils", ".", "collect_named_outputs", "(", "outputs_collections", ",", "sc", ".", "name", ",", "outputs", ")" ]

[ "Create", "the", "metadata", "." ]

[ "def", "__init__", "(", "self", ",", "sparse", ",", "map_op", ",", "rank", ")", ":", "self", ".", "_sparse", "=", "sparse", "self", ".", "_map_op", "=", "map_op", "self", ".", "_rank", "=", "tensor_shape", ".", "Dimension", "(", "rank", ")" ]

[ "Return", "disk", "usage", "statistics", "about", "the", "given", "path", "as", "a", "namedtuple", "including", "total", "used", "and", "free", "space", "expressed", "in", "bytes", "plus", "the", "percentage", "usage", "." ]

[ "def", "disk_usage", "(", "path", ")", ":", "return", "_psplatform", ".", "get_disk_usage", "(", "path", ")" ]

[ "Sets", "the", "function", "with", "custom", "code", "for", "pointLabel", "drawing", "********", "more", "info", "needed", "***************" ]

[ "def", "SetPointLabelFunc", "(", "self", ",", "func", ")", ":", "self", ".", "_pointLabelFunc", "=", "func" ]

[ "Constructs", "a", ":", "class", ":", "Request", "<Request", ">", "prepares", "it", "and", "sends", "it", ".", "Returns", ":", "class", ":", "Response", "<Response", ">", "object", "." ]

[ "def", "request", "(", "self", ",", "method", ",", "url", ",", "params", "=", "None", ",", "data", "=", "None", ",", "headers", "=", "None", ",", "cookies", "=", "None", ",", "files", "=", "None", ",", "auth", "=", "None", ",", "timeout", "=", "None", ",", "allow_redirects", "=", "True", ",", "proxies", "=", "None", ",", "hooks", "=", "None", ",", "stream", "=", "None", ",", "verify", "=", "None", ",", "cert", "=", "None", ",", "json", "=", "None", ")", ":", "# Create the Request.", "req", "=", "Request", "(", "method", "=", "method", ".", "upper", "(", ")", ",", "url", "=", "url", ",", "headers", "=", "headers", ",", "files", "=", "files", ",", "data", "=", "data", "or", "{", "}", ",", "json", "=", "json", ",", "params", "=", "params", "or", "{", "}", ",", "auth", "=", "auth", ",", "cookies", "=", "cookies", ",", "hooks", "=", "hooks", ",", ")", "prep", "=", "self", ".", "prepare_request", "(", "req", ")", "proxies", "=", "proxies", "or", "{", "}", "settings", "=", "self", ".", "merge_environment_settings", "(", "prep", ".", "url", ",", "proxies", ",", "stream", ",", "verify", ",", "cert", ")", "# Send the request.", "send_kwargs", "=", "{", "'timeout'", ":", "timeout", ",", "'allow_redirects'", ":", "allow_redirects", ",", "}", "send_kwargs", ".", "update", "(", "settings", ")", "resp", "=", "self", ".", "send", "(", "prep", ",", "*", "*", "send_kwargs", ")", "return", "resp" ]

[ "Selects", "or", "checks", "a", "radio", "or", "check", "item", "." ]

[ "def", "Select", "(", "self", ",", "select", "=", "True", ")", ":", "self", ".", "_selected", "=", "select" ]

[ "Get", "the", "transitive", "inputs", "of", "given", "node", "according", "to", "partition", "graphs", "." ]

[ "def", "transitive_inputs", "(", "self", ",", "node_name", ",", "include_control", "=", "True", ",", "include_reversed_ref", "=", "False", ",", "device_name", "=", "None", ",", ")", ":", "if", "not", "self", ".", "_debug_graphs", ":", "raise", "LookupError", "(", "\"Node inputs are not loaded from partition graphs yet.\"", ")", "device_name", "=", "self", ".", "_infer_device_name", "(", "device_name", ",", "node_name", ")", "input_lists", "=", "[", "self", ".", "_debug_graphs", "[", "device_name", "]", ".", "node_inputs", "]", "if", "include_control", ":", "input_lists", ".", "append", "(", "self", ".", "_debug_graphs", "[", "device_name", "]", ".", "node_ctrl_inputs", ")", "if", "include_reversed_ref", ":", "input_lists", ".", "append", "(", "self", ".", "_debug_graphs", "[", "device_name", "]", ".", "node_reversed_ref_inputs", ")", "tracer", "=", "debug_graphs", ".", "DFSGraphTracer", "(", "input_lists", ",", "skip_node_names", "=", "self", ".", "_get_merge_node_names", "(", "device_name", ")", ")", "tracer", ".", "trace", "(", "node_name", ")", "return", "tracer", ".", "inputs", "(", ")" ]

[ "Returns", "the", "full", "(", "dummies", "included", ")", "geometry", "in", "Bohr", "as", "a", "N", "X", "3", "array", "." ]

[ "def", "full_geometry", "(", "self", ",", "np_out", "=", "False", ")", ":", "geom", "=", "np", ".", "asarray", "(", "[", "self", ".", "full_atoms", "[", "at", "]", ".", "compute", "(", ")", "for", "at", "in", "range", "(", "self", ".", "nallatom", "(", ")", ")", "]", ")", "geom", "*=", "self", ".", "input_units_to_au", "(", ")", "if", "np_out", ":", "return", "geom", "else", ":", "return", "geom", ".", "tolist", "(", ")" ]

[ "Find", "the", "wrapper", "for", "the", "array", "with", "the", "highest", "priority", "." ]

[ "def", "get_array_prepare", "(", "*", "args", ")", ":", "wrappers", "=", "sorted", "(", "(", "getattr", "(", "x", ",", "'__array_priority__'", ",", "0", ")", ",", "-", "i", ",", "x", ".", "__array_prepare__", ")", "for", "i", ",", "x", "in", "enumerate", "(", "args", ")", "if", "hasattr", "(", "x", ",", "'__array_prepare__'", ")", ")", "if", "wrappers", ":", "return", "wrappers", "[", "-", "1", "]", "[", "-", "1", "]", "return", "None" ]

[ "SetOwner", "(", "self", "DataViewModel", "owner", ")" ]

[ "def", "SetOwner", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewModelNotifier_SetOwner", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "EnableTop", "(", "self", "size_t", "pos", "bool", "enable", ")" ]

[ "def", "EnableTop", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "MenuBar_EnableTop", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Convert", "an", "8bit", "part", "of", "a", "MIME", "mail", "message", "to", "quoted", "-", "printable", "." ]

[ "def", "mimify_part", "(", "ifile", ",", "ofile", ",", "is_mime", ")", ":", "has_cte", "=", "is_qp", "=", "is_base64", "=", "0", "multipart", "=", "None", "must_quote_body", "=", "must_quote_header", "=", "has_iso_chars", "=", "0", "header", "=", "[", "]", "header_end", "=", "''", "message", "=", "[", "]", "message_end", "=", "''", "# read header", "hfile", "=", "HeaderFile", "(", "ifile", ")", "while", "1", ":", "line", "=", "hfile", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "if", "not", "must_quote_header", "and", "iso_char", ".", "search", "(", "line", ")", ":", "must_quote_header", "=", "1", "if", "mv", ".", "match", "(", "line", ")", ":", "is_mime", "=", "1", "if", "cte", ".", "match", "(", "line", ")", ":", "has_cte", "=", "1", "if", "qp", ".", "match", "(", "line", ")", ":", "is_qp", "=", "1", "elif", "base64_re", ".", "match", "(", "line", ")", ":", "is_base64", "=", "1", "mp_res", "=", "mp", ".", "match", "(", "line", ")", "if", "mp_res", ":", "multipart", "=", "'--'", "+", "mp_res", ".", "group", "(", "1", ")", "if", "he", ".", "match", "(", "line", ")", ":", "header_end", "=", "line", "break", "header", ".", "append", "(", "line", ")", "# read body", "while", "1", ":", "line", "=", "ifile", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "if", "multipart", ":", "if", "line", "==", "multipart", "+", "'--\\n'", ":", "message_end", "=", "line", "break", "if", "line", "==", "multipart", "+", "'\\n'", ":", "message_end", "=", "line", "break", "if", "is_base64", ":", "message", ".", "append", "(", "line", ")", "continue", "if", "is_qp", ":", "while", "line", "[", "-", "2", ":", "]", "==", "'=\\n'", ":", "line", "=", "line", "[", ":", "-", "2", "]", "newline", "=", "ifile", ".", "readline", "(", ")", "if", "newline", "[", ":", "len", "(", "QUOTE", ")", "]", "==", "QUOTE", ":", "newline", "=", "newline", "[", "len", "(", "QUOTE", ")", ":", "]", "line", "=", "line", "+", "newline", "line", "=", "mime_decode", "(", "line", ")", "message", ".", "append", "(", "line", ")", "if", "not", "has_iso_chars", ":", "if", "iso_char", ".", "search", "(", "line", ")", ":", "has_iso_chars", "=", "must_quote_body", "=", "1", "if", "not", "must_quote_body", ":", "if", "len", "(", "line", ")", ">", "MAXLEN", ":", "must_quote_body", "=", "1", "# convert and output header and body", "for", "line", "in", "header", ":", "if", "must_quote_header", ":", "line", "=", "mime_encode_header", "(", "line", ")", "chrset_res", "=", "chrset", ".", "match", "(", "line", ")", "if", "chrset_res", ":", "if", "has_iso_chars", ":", "# change us-ascii into iso-8859-1", "if", "chrset_res", ".", "group", "(", "2", ")", ".", "lower", "(", ")", "==", "'us-ascii'", ":", "line", "=", "'%s%s%s'", "%", "(", "chrset_res", ".", "group", "(", "1", ")", ",", "CHARSET", ",", "chrset_res", ".", "group", "(", "3", ")", ")", "else", ":", "# change iso-8859-* into us-ascii", "line", "=", "'%sus-ascii%s'", "%", "chrset_res", ".", "group", "(", "1", ",", "3", ")", "if", "has_cte", "and", "cte", ".", "match", "(", "line", ")", ":", "line", "=", "'Content-Transfer-Encoding: '", "if", "is_base64", ":", "line", "=", "line", "+", "'base64\\n'", "elif", "must_quote_body", ":", "line", "=", "line", "+", "'quoted-printable\\n'", "else", ":", "line", "=", "line", "+", "'7bit\\n'", "ofile", ".", "write", "(", "line", ")", "if", "(", "must_quote_header", "or", "must_quote_body", ")", "and", "not", "is_mime", ":", "ofile", ".", "write", "(", "'Mime-Version: 1.0\\n'", ")", "ofile", ".", "write", "(", "'Content-Type: text/plain; '", ")", "if", "has_iso_chars", ":", "ofile", ".", "write", "(", "'charset=\"%s\"\\n'", "%", "CHARSET", ")", "else", ":", "ofile", ".", "write", "(", "'charset=\"us-ascii\"\\n'", ")", "if", "must_quote_body", "and", "not", "has_cte", ":", "ofile", ".", "write", "(", "'Content-Transfer-Encoding: quoted-printable\\n'", ")", "ofile", ".", "write", "(", "header_end", ")", "for", "line", "in", "message", ":", "if", "must_quote_body", ":", "line", "=", "mime_encode", "(", "line", ",", "0", ")", "ofile", ".", "write", "(", "line", ")", "ofile", ".", "write", "(", "message_end", ")", "line", "=", "message_end", "while", "multipart", ":", "if", "line", "==", "multipart", "+", "'--\\n'", ":", "# read bit after the end of the last part", "while", "1", ":", "line", "=", "ifile", ".", "readline", "(", ")", "if", "not", "line", ":", "return", "if", "must_quote_body", ":", "line", "=", "mime_encode", "(", "line", ",", "0", ")", "ofile", ".", "write", "(", "line", ")", "if", "line", "==", "multipart", "+", "'\\n'", ":", "nifile", "=", "File", "(", "ifile", ",", "multipart", ")", "mimify_part", "(", "nifile", ",", "ofile", ",", "1", ")", "line", "=", "nifile", ".", "peek", "if", "not", "line", ":", "# premature end of file", "break", "ofile", ".", "write", "(", "line", ")", "continue", "# unexpectedly no multipart separator--copy rest of file", "while", "1", ":", "line", "=", "ifile", ".", "readline", "(", ")", "if", "not", "line", ":", "return", "if", "must_quote_body", ":", "line", "=", "mime_encode", "(", "line", ",", "0", ")", "ofile", ".", "write", "(", "line", ")" ]

[ "Overrriden", "from", "TypeHandler", "." ]

[ "def", "WriteImmediateServiceUnitTest", "(", "self", ",", "func", ",", "file", ")", ":", "valid_test", "=", "\"\"\"\nTEST_F(%(test_name)s, %(name)sValidArgs) {\n EXPECT_CALL(\n *gl_,\n %(gl_func_name)s(1, Pointee(kService%(upper_resource_name)sId)))\n .Times(1);\n cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();\n SpecializedSetup<cmds::%(name)s, 0>(true);\n cmd.Init(1, &client_%(resource_name)s_id_);\n EXPECT_EQ(error::kNoError,\n ExecuteImmediateCmd(cmd, sizeof(client_%(resource_name)s_id_)));\n EXPECT_EQ(GL_NO_ERROR, GetGLError());\n EXPECT_TRUE(\n Get%(upper_resource_name)s(client_%(resource_name)s_id_) == NULL);\n}\n\"\"\"", "self", ".", "WriteValidUnitTest", "(", "func", ",", "file", ",", "valid_test", ",", "{", "'resource_name'", ":", "func", ".", "GetInfo", "(", "'resource_type'", ")", ".", "lower", "(", ")", ",", "'upper_resource_name'", ":", "func", ".", "GetInfo", "(", "'resource_type'", ")", ",", "}", ")", "invalid_test", "=", "\"\"\"\nTEST_F(%(test_name)s, %(name)sInvalidArgs) {\n cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();\n SpecializedSetup<cmds::%(name)s, 0>(false);\n GLuint temp = kInvalidClientId;\n cmd.Init(1, &temp);\n EXPECT_EQ(error::kNoError,\n ExecuteImmediateCmd(cmd, sizeof(temp)));\n}\n\"\"\"", "self", ".", "WriteValidUnitTest", "(", "func", ",", "file", ",", "invalid_test", ")" ]

[ "Try", "to", "cast", "val", "as", "a", "Boolean", "." ]

[ "def", "cast", "(", "self", ",", "val", ")", ":", "if", "isinstance", "(", "val", ",", "bool", ")", ":", "return", "BoolVal", "(", "val", ",", "self", ".", "ctx", ")", "if", "z3_debug", "(", ")", ":", "if", "not", "is_expr", "(", "val", ")", ":", "msg", "=", "\"True, False or Z3 Boolean expression expected. Received %s of type %s\"", "_z3_assert", "(", "is_expr", "(", "val", ")", ",", "msg", "%", "(", "val", ",", "type", "(", "val", ")", ")", ")", "if", "not", "self", ".", "eq", "(", "val", ".", "sort", "(", ")", ")", ":", "_z3_assert", "(", "self", ".", "eq", "(", "val", ".", "sort", "(", ")", ")", ",", "\"Value cannot be converted into a Z3 Boolean value\"", ")", "return", "val" ]

[ "The", "non", "-", "zero", "values", "in", "the", "represented", "dense", "tensor", "." ]

[ "def", "values", "(", "self", ")", ":", "return", "self", ".", "_values" ]

[ "Returns", "true", "if", "at", "least", "one", "leaf", "in", "the", "tree", "has", "real", "dtype", "." ]

[ "def", "tree_leaf_isreal", "(", "pars", ":", "PyTree", ")", "->", "bool", ":", "return", "any", "(", "jax", ".", "tree_leaves", "(", "jax", ".", "tree_map", "(", "is_real", ",", "pars", ")", ")", ")" ]

[ "R", "Takes", "a", "snapshot", "of", "the", "current", "state", "of", "the", "MPCD", "system" ]

[ "def", "take_snapshot", "(", "self", ",", "particles", "=", "True", ")", ":", "return", "snapshot", "(", "self", ".", "data", ".", "takeSnapshot", "(", "particles", ")", ")" ]

[ "Returns", "a", "combination", "geometry", "and", "attribute", "record", "for", "the", "supplied", "record", "index", "." ]

[ "def", "shapeRecord", "(", "self", ",", "i", "=", "0", ")", ":", "i", "=", "self", ".", "__restrictIndex", "(", "i", ")", "return", "_ShapeRecord", "(", "shape", "=", "self", ".", "shape", "(", "i", ")", ",", "record", "=", "self", ".", "record", "(", "i", ")", ")" ]

[ "Return", "a", "string", "description", "of", "the", "model", "including", "a", "description", "of", "the", "training", "data", "training", "statistics", "and", "model", "hyper", "-", "parameters", "." ]

[ "def", "__repr__", "(", "self", ")", ":", "(", "sections", ",", "section_titles", ")", "=", "self", ".", "_get_summary_struct", "(", ")", "return", "_toolkit_repr_print", "(", "self", ",", "sections", ",", "section_titles", ",", "width", "=", "30", ")" ]

[ "Numerator", "of", "the", "TransferFunction", "system", "." ]

[ "def", "num", "(", "self", ")", ":", "return", "self", ".", "_num" ]

[ "Return", "immutable", "credentials", "." ]

[ "def", "get_frozen_credentials", "(", "self", ")", ":", "self", ".", "_refresh", "(", ")", "return", "self", ".", "_frozen_credentials" ]

[ "returns", "the", "default", "width", "value", "of", "the", "theme" ]

[ "def", "getDefaultWidth", "(", "self", ")", ":", "return", "self", ".", "__defaultWidth" ]

[ "Thread", "runner", "for", "reading", "lines", "of", "from", "a", "subprocess", "into", "a", "buffer", "." ]

[ "def", "_reader", "(", "self", ",", "name", ",", "stream", ",", "outbuf", ")", ":", "while", "True", ":", "s", "=", "stream", ".", "readline", "(", ")", "if", "not", "s", ":", "break", "s", "=", "s", ".", "decode", "(", "'utf-8'", ")", ".", "rstrip", "(", ")", "outbuf", ".", "append", "(", "s", ")", "logger", ".", "debug", "(", "'%s: %s'", "%", "(", "name", ",", "s", ")", ")", "stream", ".", "close", "(", ")" ]

[ "WebPDecodeBGR", "(", "uint8_t", "data", ")", "-", ">", "(", "rgb", "width", "height", ")" ]

[ "def", "WebPDecodeBGR", "(", "*", "args", ")", ":", "return", "_libwebp", ".", "WebPDecodeBGR", "(", "*", "args", ")" ]

[ "Evaluates", "the", "model", "at", "the", "given", "checkpoint", "path", "." ]

[ "def", "evaluate_once", "(", "master", ",", "checkpoint_path", ",", "logdir", ",", "num_evals", "=", "1", ",", "initial_op", "=", "None", ",", "initial_op_feed_dict", "=", "None", ",", "eval_op", "=", "None", ",", "eval_op_feed_dict", "=", "None", ",", "final_op", "=", "None", ",", "final_op_feed_dict", "=", "None", ",", "summary_op", "=", "_USE_DEFAULT", ",", "summary_op_feed_dict", "=", "None", ",", "variables_to_restore", "=", "None", ",", "session_config", "=", "None", ")", ":", "if", "summary_op", "==", "_USE_DEFAULT", ":", "summary_op", "=", "summary", ".", "merge_all", "(", ")", "hooks", "=", "[", "evaluation", ".", "StopAfterNEvalsHook", "(", "num_evals", ")", ",", "]", "if", "summary_op", "is", "not", "None", ":", "hooks", ".", "append", "(", "evaluation", ".", "SummaryAtEndHook", "(", "log_dir", "=", "logdir", ",", "summary_op", "=", "summary_op", ",", "feed_dict", "=", "summary_op_feed_dict", ")", ")", "saver", "=", "None", "if", "variables_to_restore", "is", "not", "None", ":", "saver", "=", "tf_saver", ".", "Saver", "(", "variables_to_restore", ")", "return", "evaluation", ".", "evaluate_once", "(", "checkpoint_path", ",", "master", "=", "master", ",", "scaffold", "=", "monitored_session", ".", "Scaffold", "(", "init_op", "=", "initial_op", ",", "init_feed_dict", "=", "initial_op_feed_dict", ",", "saver", "=", "saver", ")", ",", "eval_ops", "=", "eval_op", ",", "feed_dict", "=", "eval_op_feed_dict", ",", "final_ops", "=", "final_op", ",", "final_ops_feed_dict", "=", "final_op_feed_dict", ",", "hooks", "=", "hooks", ",", "config", "=", "session_config", ")" ]

[ "Returns", "a", "decoder", "for", "a", "MessageSet", "item", "." ]

[ "def", "MessageSetItemDecoder", "(", "descriptor", ")", ":", "type_id_tag_bytes", "=", "encoder", ".", "TagBytes", "(", "2", ",", "wire_format", ".", "WIRETYPE_VARINT", ")", "message_tag_bytes", "=", "encoder", ".", "TagBytes", "(", "3", ",", "wire_format", ".", "WIRETYPE_LENGTH_DELIMITED", ")", "item_end_tag_bytes", "=", "encoder", ".", "TagBytes", "(", "1", ",", "wire_format", ".", "WIRETYPE_END_GROUP", ")", "local_ReadTag", "=", "ReadTag", "local_DecodeVarint", "=", "_DecodeVarint", "local_SkipField", "=", "SkipField", "def", "DecodeItem", "(", "buffer", ",", "pos", ",", "end", ",", "message", ",", "field_dict", ")", ":", "message_set_item_start", "=", "pos", "type_id", "=", "-", "1", "message_start", "=", "-", "1", "message_end", "=", "-", "1", "# Technically, type_id and message can appear in any order, so we need", "# a little loop here.", "while", "1", ":", "(", "tag_bytes", ",", "pos", ")", "=", "local_ReadTag", "(", "buffer", ",", "pos", ")", "if", "tag_bytes", "==", "type_id_tag_bytes", ":", "(", "type_id", ",", "pos", ")", "=", "local_DecodeVarint", "(", "buffer", ",", "pos", ")", "elif", "tag_bytes", "==", "message_tag_bytes", ":", "(", "size", ",", "message_start", ")", "=", "local_DecodeVarint", "(", "buffer", ",", "pos", ")", "pos", "=", "message_end", "=", "message_start", "+", "size", "elif", "tag_bytes", "==", "item_end_tag_bytes", ":", "break", "else", ":", "pos", "=", "SkipField", "(", "buffer", ",", "pos", ",", "end", ",", "tag_bytes", ")", "if", "pos", "==", "-", "1", ":", "raise", "_DecodeError", "(", "'Missing group end tag.'", ")", "if", "pos", ">", "end", ":", "raise", "_DecodeError", "(", "'Truncated message.'", ")", "if", "type_id", "==", "-", "1", ":", "raise", "_DecodeError", "(", "'MessageSet item missing type_id.'", ")", "if", "message_start", "==", "-", "1", ":", "raise", "_DecodeError", "(", "'MessageSet item missing message.'", ")", "extension", "=", "message", ".", "Extensions", ".", "_FindExtensionByNumber", "(", "type_id", ")", "if", "extension", "is", "not", "None", ":", "value", "=", "field_dict", ".", "get", "(", "extension", ")", "if", "value", "is", "None", ":", "value", "=", "field_dict", ".", "setdefault", "(", "extension", ",", "extension", ".", "message_type", ".", "_concrete_class", "(", ")", ")", "if", "value", ".", "_InternalParse", "(", "buffer", ",", "message_start", ",", "message_end", ")", "!=", "message_end", ":", "# The only reason _InternalParse would return early is if it encountered", "# an end-group tag.", "raise", "_DecodeError", "(", "'Unexpected end-group tag.'", ")", "else", ":", "if", "not", "message", ".", "_unknown_fields", ":", "message", ".", "_unknown_fields", "=", "[", "]", "message", ".", "_unknown_fields", ".", "append", "(", "(", "MESSAGE_SET_ITEM_TAG", ",", "buffer", "[", "message_set_item_start", ":", "pos", "]", ")", ")", "return", "pos", "return", "DecodeItem" ]

[ "Boolean", "indicating", "if", "Tensor", "input", "/", "outputs", "are", "Cholesky", "factorized", "." ]

[ "def", "cholesky_input_output_matrices", "(", "self", ")", ":", "return", "self", ".", "_cholesky_input_output_matrices" ]

[ "Removes", "common", "suffixes", "from", "a", "resource", "ID", "." ]

[ "def", "GetBaseResourceId", "(", "resource_id", ")", ":", "suffixes", "=", "[", "'_TOP_LEFT'", ",", "'_TOP'", ",", "'_TOP_RIGHT'", ",", "'_LEFT'", ",", "'_CENTER'", ",", "'_RIGHT'", ",", "'_BOTTOM_LEFT'", ",", "'_BOTTOM'", ",", "'_BOTTOM_RIGHT'", ",", "'_TL'", ",", "'_T'", ",", "'_TR'", ",", "'_L'", ",", "'_M'", ",", "'_R'", ",", "'_BL'", ",", "'_B'", ",", "'_BR'", "]", "# Note: This does not check _HOVER, _PRESSED, _HOT, etc. as those are never", "# used in macros.", "for", "suffix", "in", "suffixes", ":", "if", "resource_id", ".", "endswith", "(", "suffix", ")", ":", "resource_id", "=", "resource_id", "[", ":", "-", "len", "(", "suffix", ")", "]", "return", "resource_id" ]

[ "raise", "a", "ClusterError", "when", "called", "." ]

[ "def", "_missing_raise", "(", ")", ":", "raise", "ClusterError", "(", "\"One of the clusters is empty. \"", "\"Re-run kmeans with a different initialization.\"", ")" ]

[ "D", ".", "pop", "(", "k", "[", "d", "]", ")", "-", ">", "v", "remove", "specified", "key", "and", "return", "the", "corresponding", "value", ".", "If", "key", "is", "not", "found", "d", "is", "returned", "if", "given", "otherwise", "KeyError", "is", "raised", "." ]

[ "def", "pop", "(", "self", ",", "key", ",", "default", "=", "__marker", ")", ":", "try", ":", "value", "=", "self", "[", "key", "]", "except", "KeyError", ":", "if", "default", "is", "self", ".", "__marker", ":", "raise", "return", "default", "else", ":", "del", "self", "[", "key", "]", "return", "value" ]

[ "Map", "MXNet", "s", "ceil", "operator", "attributes", "to", "onnx", "s", "Ceil", "operator", "and", "return", "the", "created", "node", "." ]

[ "def", "convert_ceil", "(", "node", ",", "*", "*", "kwargs", ")", ":", "return", "create_basic_op_node", "(", "'Ceil'", ",", "node", ",", "kwargs", ")" ]

[ "Preprocess", "source", "by", "generating", "all", "data", "needed", "by", "CTU", "analysis", "." ]

[ "def", "ctu_collect_phase", "(", "opts", ")", ":", "def", "generate_ast", "(", "triple_arch", ")", ":", "\"\"\" Generates ASTs for the current compilation command. \"\"\"", "args", "=", "opts", "[", "'direct_args'", "]", "+", "opts", "[", "'flags'", "]", "ast_joined_path", "=", "os", ".", "path", ".", "join", "(", "opts", "[", "'ctu'", "]", ".", "dir", ",", "triple_arch", ",", "'ast'", ",", "os", ".", "path", ".", "realpath", "(", "opts", "[", "'file'", "]", ")", "[", "1", ":", "]", "+", "'.ast'", ")", "ast_path", "=", "os", ".", "path", ".", "abspath", "(", "ast_joined_path", ")", "ast_dir", "=", "os", ".", "path", ".", "dirname", "(", "ast_path", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "ast_dir", ")", ":", "try", ":", "os", ".", "makedirs", "(", "ast_dir", ")", "except", "OSError", ":", "# In case an other process already created it.", "pass", "ast_command", "=", "[", "opts", "[", "'clang'", "]", ",", "'-emit-ast'", "]", "ast_command", ".", "extend", "(", "args", ")", "ast_command", ".", "append", "(", "'-w'", ")", "ast_command", ".", "append", "(", "opts", "[", "'file'", "]", ")", "ast_command", ".", "append", "(", "'-o'", ")", "ast_command", ".", "append", "(", "ast_path", ")", "logging", ".", "debug", "(", "\"Generating AST using '%s'\"", ",", "ast_command", ")", "run_command", "(", "ast_command", ",", "cwd", "=", "opts", "[", "'directory'", "]", ")", "def", "map_extdefs", "(", "triple_arch", ")", ":", "\"\"\" Generate external definition map file for the current source. \"\"\"", "args", "=", "opts", "[", "'direct_args'", "]", "+", "opts", "[", "'flags'", "]", "extdefmap_command", "=", "[", "opts", "[", "'ctu'", "]", ".", "extdef_map_cmd", "]", "extdefmap_command", ".", "append", "(", "opts", "[", "'file'", "]", ")", "extdefmap_command", ".", "append", "(", "'--'", ")", "extdefmap_command", ".", "extend", "(", "args", ")", "logging", ".", "debug", "(", "\"Generating external definition map using '%s'\"", ",", "extdefmap_command", ")", "extdef_src_list", "=", "run_command", "(", "extdefmap_command", ",", "cwd", "=", "opts", "[", "'directory'", "]", ")", "extdef_ast_list", "=", "extdef_map_list_src_to_ast", "(", "extdef_src_list", ")", "extern_defs_map_folder", "=", "os", ".", "path", ".", "join", "(", "opts", "[", "'ctu'", "]", ".", "dir", ",", "triple_arch", ",", "CTU_TEMP_DEFMAP_FOLDER", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "extern_defs_map_folder", ")", ":", "try", ":", "os", ".", "makedirs", "(", "extern_defs_map_folder", ")", "except", "OSError", ":", "# In case an other process already created it.", "pass", "if", "extdef_ast_list", ":", "with", "tempfile", ".", "NamedTemporaryFile", "(", "mode", "=", "'w'", ",", "dir", "=", "extern_defs_map_folder", ",", "delete", "=", "False", ")", "as", "out_file", ":", "out_file", ".", "write", "(", "\"\\n\"", ".", "join", "(", "extdef_ast_list", ")", "+", "\"\\n\"", ")", "cwd", "=", "opts", "[", "'directory'", "]", "cmd", "=", "[", "opts", "[", "'clang'", "]", ",", "'--analyze'", "]", "+", "opts", "[", "'direct_args'", "]", "+", "opts", "[", "'flags'", "]", "+", "[", "opts", "[", "'file'", "]", "]", "triple_arch", "=", "get_triple_arch", "(", "cmd", ",", "cwd", ")", "generate_ast", "(", "triple_arch", ")", "map_extdefs", "(", "triple_arch", ")" ]

[ "Evaluates", "a", "spec", "and", "returns", "the", "environment", "." ]

[ "def", "eval_spec", "(", "spec", ",", "environment", "=", "None", ")", ":", "specs_lib", ".", "check_keywords", "(", "spec", ")", "bindings", "=", "{", "}", "if", "environment", ":", "bindings", ".", "update", "(", "environment", ")", "exec_", "(", "spec", ",", "vars", "(", "specs_ops", ")", ",", "bindings", ")", "# pylint: disable=exec-used", "return", "bindings" ]

[ "scene", "event", "handler" ]

[ "def", "action", "(", "self", ",", "arg", ")", ":", "if", "arg", "[", "\"Type\"", "]", "==", "\"SoKeyboardEvent\"", ":", "if", "arg", "[", "\"Key\"", "]", "==", "\"ESCAPE\"", ":", "self", ".", "reject", "(", ")", "elif", "arg", "[", "\"Type\"", "]", "==", "\"SoLocation2Event\"", ":", "# mouse movement detection", "self", ".", "point", ",", "ctrlPoint", ",", "info", "=", "gui_tool_utils", ".", "getPoint", "(", "self", ".", "sourceCmd", ",", "arg", ",", "noTracker", "=", "True", ")", "if", "not", "self", ".", "pointPicked", ":", "self", ".", "setPoint", "(", "self", ".", "point", ")", "elif", "arg", "[", "\"Type\"", "]", "==", "\"SoMouseButtonEvent\"", ":", "if", "(", "arg", "[", "\"State\"", "]", "==", "\"DOWN\"", ")", "and", "(", "arg", "[", "\"Button\"", "]", "==", "\"BUTTON1\"", ")", ":", "self", ".", "setPoint", "(", "self", ".", "point", ")", "self", ".", "pointPicked", "=", "True" ]

[ "Open", "|path|", "for", "writing", "creating", "directories", "if", "necessary", "." ]

[ "def", "OpenOutput", "(", "path", ",", "mode", "=", "'w'", ")", ":", "gyp", ".", "common", ".", "EnsureDirExists", "(", "path", ")", "return", "open", "(", "path", ",", "mode", ")" ]

[ "Returns", "an", "encoder", "for", "a", "group", "field", "." ]

[ "def", "GroupEncoder", "(", "field_number", ",", "is_repeated", ",", "is_packed", ")", ":", "start_tag", "=", "TagBytes", "(", "field_number", ",", "wire_format", ".", "WIRETYPE_START_GROUP", ")", "end_tag", "=", "TagBytes", "(", "field_number", ",", "wire_format", ".", "WIRETYPE_END_GROUP", ")", "assert", "not", "is_packed", "if", "is_repeated", ":", "def", "EncodeRepeatedField", "(", "write", ",", "value", ")", ":", "for", "element", "in", "value", ":", "write", "(", "start_tag", ")", "element", ".", "_InternalSerialize", "(", "write", ")", "write", "(", "end_tag", ")", "return", "EncodeRepeatedField", "else", ":", "def", "EncodeField", "(", "write", ",", "value", ")", ":", "write", "(", "start_tag", ")", "value", ".", "_InternalSerialize", "(", "write", ")", "return", "write", "(", "end_tag", ")", "return", "EncodeField" ]

[ "jump_statement", ":", "GOTO", "ID", "SEMI" ]

[ "def", "p_jump_statement_1", "(", "t", ")", ":", "pass" ]