Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Matrix", "multiplication" ]

[ "def", "mult", "(", "matrix1", ",", "matrix2", ")", ":", "if", "len", "(", "matrix1", "[", "0", "]", ")", "!=", "len", "(", "matrix2", ")", ":", "# Check matrix dimensions", "raise", "ValidationError", "(", "'Matrices must be m*n and n*p to multiply!'", ")", "else", ":", "# Multiply if correct dimensions", "try", ":", "new_matrix", "=", "zero", "(", "len", "(", "matrix1", ")", ",", "len", "(", "matrix2", "[", "0", "]", ")", ")", "for", "i", "in", "range", "(", "len", "(", "matrix1", ")", ")", ":", "for", "j", "in", "range", "(", "len", "(", "matrix2", "[", "0", "]", ")", ")", ":", "for", "k", "in", "range", "(", "len", "(", "matrix2", ")", ")", ":", "new_matrix", "[", "i", "]", "[", "j", "]", "+=", "matrix1", "[", "i", "]", "[", "k", "]", "*", "matrix2", "[", "k", "]", "[", "j", "]", "except", "TypeError", ":", "new_matrix", "=", "zero", "(", "len", "(", "matrix1", ")", ",", "1", ")", "for", "i", "in", "range", "(", "len", "(", "matrix1", ")", ")", ":", "for", "k", "in", "range", "(", "len", "(", "matrix2", ")", ")", ":", "new_matrix", "[", "i", "]", "[", "0", "]", "+=", "matrix1", "[", "i", "]", "[", "k", "]", "*", "matrix2", "[", "k", "]", "return", "new_matrix" ]

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

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

[ "Octave", "is", "quite", "hard", "to", "spot", "and", "it", "looks", "like", "Matlab", "as", "well", "." ]

[ "def", "analyse_text", "(", "text", ")", ":", "return", "0" ]

[ "Returns", "a", "context", "manager", "that", "indents", "all", "strings", "logged", "by", "the", "specified", "amount", "." ]

[ "def", "indent", "(", "self", ",", "level", "=", "1", ")", ":", "return", "LoggerIndent", "(", "self", ",", "level", "+", "self", ".", "logging_indent", ")" ]

[ "Here", "we", "can", "pass", "list", "of", "GPU", "ids", "as", "a", "parameter", "or", "ngpu", "to", "use", "first", "n", "GPU", "s", ".", "gpus", "mut", "be", "a", "list", "or", "None" ]

[ "def", "index_cpu_to_gpus_list", "(", "index", ",", "co", "=", "None", ",", "gpus", "=", "None", ",", "ngpu", "=", "-", "1", ")", ":", "if", "(", "gpus", "is", "None", ")", "and", "(", "ngpu", "==", "-", "1", ")", ":", "# All blank", "gpus", "=", "range", "(", "get_num_gpus", "(", ")", ")", "elif", "(", "gpus", "is", "None", ")", "and", "(", "ngpu", "!=", "-", "1", ")", ":", "# Get number of GPU's only", "gpus", "=", "range", "(", "ngpu", ")", "res", "=", "[", "StandardGpuResources", "(", ")", "for", "_", "in", "gpus", "]", "index_gpu", "=", "index_cpu_to_gpu_multiple_py", "(", "res", ",", "index", ",", "co", ",", "gpus", ")", "return", "index_gpu" ]

[ "Gets", "path", "value", "(", "filesystem", "path", ")", "." ]

[ "def", "getvalue_path", "(", "self", ",", "key", ",", "default_val", "=", "None", ")", ":", "logging", ".", "debug", "(", "\"getvalue_path() - key: %s\"", ",", "key", ")", "val", "=", "self", ".", "_getvalue_raw", "(", "key", ",", "default_val", ")", "if", "not", "val", ":", "return", "val", "if", "self", ".", "_do_sanitize", ":", "val", "=", "self", ".", "_sanitize_path", "(", "val", ")", "logging", ".", "debug", "(", "\"getvalue_path() - key: %s, val: %s\"", ",", "key", ",", "val", ")", "return", "val" ]

[ "Apply", "detector", "efficiency", "corrections", "." ]

[ "def", "_correctByDetectorEfficiency", "(", "self", ",", "mainWS", ")", ":", "correctedWSName", "=", "self", ".", "_names", ".", "withSuffix", "(", "'detector_efficiency_corrected'", ")", "correctedWS", "=", "DetectorEfficiencyCorUser", "(", "InputWorkspace", "=", "mainWS", ",", "OutputWorkspace", "=", "correctedWSName", ",", "EnableLogging", "=", "self", ".", "_subalgLogging", ")", "self", ".", "_cleanup", ".", "cleanup", "(", "mainWS", ")", "return", "correctedWS" ]

[ "Set", "the", "label", "text", "@param", "lbl", ":", "string" ]

[ "def", "SetLabel", "(", "self", ",", "lbl", ")", ":", "self", ".", "_lbl", ".", "SetLabel", "(", "lbl", ")", "self", ".", "_lbl", ".", "Refresh", "(", ")", "self", ".", "Layout", "(", ")" ]

[ "Stop", "the", "server", "." ]

[ "def", "stop", "(", "self", ")", ":", "self", ".", "_stop", "=", "True", "self", ".", "wake_up", "(", ")" ]

[ "Creates", "a", "single", "string", "from", "object", "ids", "." ]

[ "def", "object_list_uid", "(", "object_list", ")", ":", "object_list", "=", "nest", ".", "flatten", "(", "object_list", ")", "return", "', '", ".", "join", "(", "[", "str", "(", "abs", "(", "id", "(", "x", ")", ")", ")", "for", "x", "in", "object_list", "]", ")" ]

[ "Deal", "with", "mouse", "press", "event", ".", "Override", "of", "QTableView", "::", "mousePressEvent", ".", "This", "function", "change", "the", "state", "of", "a", "eventual", "push", "button", "below", "the", "mouse", "pointer", "." ]

[ "def", "mousePressEvent", "(", "self", ",", "event", ")", ":", "li", "=", "self", ".", "logicalIndexAt", "(", "event", ".", "pos", "(", ")", ")", "if", "self", ".", "mouseOnButton", "(", "event", ".", "pos", "(", ")", ",", "li", ")", ":", "self", ".", "buttonPressed", "=", "li", "self", ".", "updateSection", "(", "li", ")", "else", ":", "super", "(", "DrillHeaderView", ",", "self", ")", ".", "mousePressEvent", "(", "event", ")" ]

[ "Call", "method", "for", "oracle", "returns", "best", "response", "against", "a", "set", "of", "policies", "." ]

[ "def", "__call__", "(", "self", ",", "game", ",", "policy", ",", "total_policies", ",", "current_player", ",", "probabilities_of_playing_policies", ",", "*", "*", "oracle_specific_execution_kwargs", ")", ":", "raise", "NotImplementedError", "(", "\"Calling Abstract class method.\"", ")" ]

[ "Associate", "a", "variational", "StochasticTensor", "with", "a", "Distribution", "prior", "." ]

[ "def", "register_prior", "(", "variational", ",", "prior", ")", ":", "if", "not", "isinstance", "(", "variational", ",", "st", ".", "StochasticTensor", ")", ":", "raise", "TypeError", "(", "\"variational must be a StochasticTensor\"", ")", "if", "not", "isinstance", "(", "prior", ",", "distribution", ".", "Distribution", ")", ":", "raise", "TypeError", "(", "\"prior must be a Distribution\"", ")", "ops", ".", "add_to_collection", "(", "VI_PRIORS", ",", "(", "variational", ",", "prior", ")", ")" ]

[ "Update", "this", "OrderedSet", "to", "remove", "items", "from", "another", "set", "then", "add", "items", "from", "the", "other", "set", "that", "were", "not", "present", "in", "this", "set", "." ]

[ "def", "symmetric_difference_update", "(", "self", ",", "other", ")", ":", "items_to_add", "=", "[", "item", "for", "item", "in", "other", "if", "item", "not", "in", "self", "]", "items_to_remove", "=", "set", "(", "other", ")", "self", ".", "_update_items", "(", "[", "item", "for", "item", "in", "self", ".", "items", "if", "item", "not", "in", "items_to_remove", "]", "+", "items_to_add", ")" ]

[ "a", "(", "rgs", ")", "Print", "the", "argument", "list", "of", "the", "current", "function", "." ]

[ "def", "do_args", "(", "self", ",", "arg", ")", ":", "co", "=", "self", ".", "curframe", ".", "f_code", "dict", "=", "self", ".", "curframe_locals", "n", "=", "co", ".", "co_argcount", "+", "co", ".", "co_kwonlyargcount", "if", "co", ".", "co_flags", "&", "inspect", ".", "CO_VARARGS", ":", "n", "=", "n", "+", "1", "if", "co", ".", "co_flags", "&", "inspect", ".", "CO_VARKEYWORDS", ":", "n", "=", "n", "+", "1", "for", "i", "in", "range", "(", "n", ")", ":", "name", "=", "co", ".", "co_varnames", "[", "i", "]", "if", "name", "in", "dict", ":", "self", ".", "message", "(", "'%s = %r'", "%", "(", "name", ",", "dict", "[", "name", "]", ")", ")", "else", ":", "self", ".", "message", "(", "'%s = *** undefined ***'", "%", "(", "name", ",", ")", ")" ]

[ "Initialize", "seed", "values", "for", ":", "func", ":", "id_srand", "(", "any", "appropriately", "random", "numbers", "will", "do", ")", "." ]

[ "def", "id_srandi", "(", "t", ")", ":", "t", "=", "np", ".", "asfortranarray", "(", "t", ")", "_id", ".", "id_srandi", "(", "t", ")" ]

[ "Returns", "the", "image", "size", "inside", "the", ":", "class", ":", "ImageContainerBase", "image", "list", "." ]

[ "def", "GetImageSize", "(", "self", ")", ":", "return", "self", ".", "_nImgSize" ]

[ "Retrieve", "the", "Type", "of", "the", "result", "for", "this", "Cursor", "." ]

[ "def", "result_type", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_result_type'", ")", ":", "self", ".", "_result_type", "=", "conf", ".", "lib", ".", "clang_getResultType", "(", "self", ".", "type", ")", "return", "self", ".", "_result_type" ]

[ "Computes", "a", "safe", "mean", "of", "the", "losses", "." ]

[ "def", "_safe_mean", "(", "losses", ",", "num_present", ")", ":", "total_loss", "=", "math_ops", ".", "reduce_sum", "(", "losses", ")", "return", "_safe_div", "(", "total_loss", ",", "num_present", ")" ]

[ "r", "It", "s", "kind", "of", "difficult", "to", "decide", "if", "something", "might", "be", "a", "keyword", "in", "VimL", "because", "it", "allows", "you", "to", "abbreviate", "them", ".", "In", "fact", "ab", "[", "breviate", "]", "is", "a", "good", "example", ".", ":", "ab", ":", "abbre", "or", ":", "abbreviate", "are", "valid", "ways", "to", "call", "it", "so", "rather", "than", "making", "really", "awful", "regexps", "like", "::" ]

[ "def", "is_in", "(", "self", ",", "w", ",", "mapping", ")", ":", "p", "=", "bisect", "(", "mapping", ",", "(", "w", ",", ")", ")", "if", "p", ">", "0", ":", "if", "mapping", "[", "p", "-", "1", "]", "[", "0", "]", "==", "w", "[", ":", "len", "(", "mapping", "[", "p", "-", "1", "]", "[", "0", "]", ")", "]", "and", "mapping", "[", "p", "-", "1", "]", "[", "1", "]", "[", ":", "len", "(", "w", ")", "]", "==", "w", ":", "return", "True", "if", "p", "<", "len", "(", "mapping", ")", ":", "return", "mapping", "[", "p", "]", "[", "0", "]", "==", "w", "[", ":", "len", "(", "mapping", "[", "p", "]", "[", "0", "]", ")", "]", "and", "mapping", "[", "p", "]", "[", "1", "]", "[", ":", "len", "(", "w", ")", "]", "==", "w", "return", "False" ]

[ "Drives", "the", "leaf_to_root", "method", ".", "The", "reason", "that", "leaf_to_root", "must", "be", "run", "multiple", "times", "is", "because", "we", "need", "to", "reject", "group", "matches", ";", "for", "example", "the", "alternative", "form", "(", "a", "|", "b", "c", ")", "creates", "a", "group", "[", "b", "c", "]", "that", "needs", "to", "be", "matched", ".", "Since", "matching", "multiple", "linear", "patterns", "overcomes", "the", "automaton", "s", "capabilities", "leaf_to_root", "merges", "each", "group", "into", "a", "single", "choice", "based", "on", "characteristic", "ity" ]

[ "def", "get_linear_subpattern", "(", "self", ")", ":", "for", "l", "in", "self", ".", "leaves", "(", ")", ":", "subp", "=", "l", ".", "leaf_to_root", "(", ")", "if", "subp", ":", "return", "subp" ]

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

[ "def", "Show", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "DragImage_Show", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "the", "module", "s", "verbosity", "and", "returns", "the", "previous", "setting", "." ]

[ "def", "_SetVerboseLevel", "(", "level", ")", ":", "return", "_cpplint_state", ".", "SetVerboseLevel", "(", "level", ")" ]

[ "Generate", "function", "declarations", "for", "config", "initializers", "." ]

[ "def", "_gen_config_function_declaration", "(", "self", ",", "spec", ")", ":", "# type: (ast.IDLAST) -> None", "initializer", "=", "spec", ".", "globals", ".", "configs", "and", "spec", ".", "globals", ".", "configs", ".", "initializer", "if", "not", "initializer", ":", "return", "if", "initializer", ".", "register", ":", "self", ".", "_writer", ".", "write_line", "(", "'Status %s(optionenvironment::OptionSection*);'", "%", "(", "initializer", ".", "register", ")", ")", "if", "initializer", ".", "store", ":", "self", ".", "_writer", ".", "write_line", "(", "'Status %s(const optionenvironment::Environment&);'", "%", "(", "initializer", ".", "store", ")", ")", "if", "initializer", ".", "register", "or", "initializer", ".", "store", ":", "self", ".", "write_empty_line", "(", ")" ]

[ "Does", "a", "POST", "to", "the", "reactions", "API", "." ]

[ "def", "react_to_threat_descriptor", "(", "self", ",", "descriptor_id", ",", "reaction", ",", "*", ",", "showURLs", "=", "False", ",", "dryRun", "=", "False", ")", ":", "return", "self", ".", "_postThreatDescriptor", "(", "\"/\"", ".", "join", "(", "(", "self", ".", "_base_url", ",", "str", "(", "descriptor_id", ")", ",", "f\"?access_token={self.api_token}\"", ",", ")", ")", ",", "{", "\"reactions\"", ":", "reaction", "}", ",", "showURLs", "=", "showURLs", ",", "dryRun", "=", "dryRun", ",", ")" ]

[ "Release", "curation", "." ]

[ "def", "release_curate", "(", "obj", ",", "version", ")", ":", "from", ".", "release", "import", "Release", "release", "=", "Release", ".", "from_jira", "(", "version", ",", "jira", "=", "obj", "[", "'jira'", "]", ",", "repo", "=", "obj", "[", "'repo'", "]", ")", "curation", "=", "release", ".", "curate", "(", ")", "click", ".", "echo", "(", "curation", ".", "render", "(", "'console'", ")", ")" ]

[ "Returns", "the", "concatenation", "of", "the", "dimension", "in", "self", "and", "other", "." ]

[ "def", "concatenate", "(", "self", ",", "other", ")", ":", "# TODO(mrry): Handle the case where we concatenate a known shape with a", "# completely unknown shape, so that we can use the partial information.", "other", "=", "as_shape", "(", "other", ")", "if", "self", ".", "_dims", "is", "None", "or", "other", ".", "dims", "is", "None", ":", "return", "unknown_shape", "(", ")", "else", ":", "return", "TensorShape", "(", "self", ".", "_dims", "+", "other", ".", "dims", ")" ]

[ "__init__", "(", "self", ")", "-", ">", "PyApp" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_core_", ".", "PyApp_swiginit", "(", "self", ",", "_core_", ".", "new_PyApp", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "self", ".", "_setOORInfo", "(", "self", ",", "False", ")", "PyApp", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "PyApp", ")", "self", ".", "this", ".", "own", "(", "True", ")" ]

[ "Lists", "the", "checkpoint", "keys", "and", "shapes", "of", "variables", "in", "a", "checkpoint", "." ]

[ "def", "list_variables", "(", "ckpt_dir_or_file", ")", ":", "reader", "=", "load_checkpoint", "(", "ckpt_dir_or_file", ")", "variable_map", "=", "reader", ".", "get_variable_to_shape_map", "(", ")", "names", "=", "sorted", "(", "variable_map", ".", "keys", "(", ")", ")", "result", "=", "[", "]", "for", "name", "in", "names", ":", "result", ".", "append", "(", "(", "name", ",", "variable_map", "[", "name", "]", ")", ")", "return", "result" ]

[ "Perform", "operation", "." ]

[ "def", "__call__", "(", "self", ",", "context", ")", ":", "context", ".", "_mutation_pool", ".", "delete", "(", "self", ".", "entity", ")" ]

[ "Unroll", "an", "RNN", "cell", "across", "time", "steps", "." ]

[ "def", "unroll", "(", "self", ",", "length", ",", "inputs", ",", "begin_state", "=", "None", ",", "layout", "=", "'NTC'", ",", "merge_outputs", "=", "None", ")", ":", "self", ".", "reset", "(", ")", "inputs", ",", "_", "=", "_normalize_sequence", "(", "length", ",", "inputs", ",", "layout", ",", "False", ")", "if", "begin_state", "is", "None", ":", "begin_state", "=", "self", ".", "begin_state", "(", ")", "states", "=", "begin_state", "outputs", "=", "[", "]", "for", "i", "in", "range", "(", "length", ")", ":", "output", ",", "states", "=", "self", "(", "inputs", "[", "i", "]", ",", "states", ")", "outputs", ".", "append", "(", "output", ")", "outputs", ",", "_", "=", "_normalize_sequence", "(", "length", ",", "outputs", ",", "layout", ",", "merge_outputs", ")", "return", "outputs", ",", "states" ]

[ "Translates", "a", "namespace", "name", "or", "function", "name", "into", "something", "more", "suited", "to", "C", "++", "." ]

[ "def", "Classname", "(", "s", ")", ":", "return", "'_'", ".", "join", "(", "[", "x", "[", "0", "]", ".", "upper", "(", ")", "+", "x", "[", "1", ":", "]", "for", "x", "in", "re", ".", "split", "(", "'\\W'", ",", "s", ")", "]", ")" ]

[ "Append", "message", "to", "mailbox", "and", "return", "(", "start", "stop", ")", "offsets", "." ]

[ "def", "_append_message", "(", "self", ",", "message", ")", ":", "self", ".", "_file", ".", "seek", "(", "0", ",", "2", ")", "before", "=", "self", ".", "_file", ".", "tell", "(", ")", "if", "len", "(", "self", ".", "_toc", ")", "==", "0", "and", "not", "self", ".", "_pending", ":", "# This is the first message, and the _pre_mailbox_hook", "# hasn't yet been called. If self._pending is True,", "# messages have been removed, so _pre_mailbox_hook must", "# have been called already.", "self", ".", "_pre_mailbox_hook", "(", "self", ".", "_file", ")", "try", ":", "self", ".", "_pre_message_hook", "(", "self", ".", "_file", ")", "offsets", "=", "self", ".", "_install_message", "(", "message", ")", "self", ".", "_post_message_hook", "(", "self", ".", "_file", ")", "except", "BaseException", ":", "self", ".", "_file", ".", "truncate", "(", "before", ")", "raise", "self", ".", "_file", ".", "flush", "(", ")", "self", ".", "_file_length", "=", "self", ".", "_file", ".", "tell", "(", ")", "# Record current length of mailbox", "return", "offsets" ]

[ "ClearListStyle", "(", "self", "RichTextRange", "range", "int", "flags", "=", "RICHTEXT_SETSTYLE_WITH_UNDO", ")", "-", ">", "bool" ]

[ "def", "ClearListStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_ClearListStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Check", "if", "windows", "match", "." ]

[ "def", "has_samewindow", "(", "self", ",", "other", ")", ":", "return", "np", ".", "all", "(", "self", ".", "window", "==", "other", ".", "window", ")" ]

[ "Compute", "the", "directed", "Hausdorff", "distance", "between", "two", "N", "-", "D", "arrays", "." ]

[ "def", "directed_hausdorff", "(", "u", ",", "v", ",", "seed", "=", "0", ")", ":", "u", "=", "np", ".", "asarray", "(", "u", ",", "dtype", "=", "np", ".", "float64", ",", "order", "=", "'c'", ")", "v", "=", "np", ".", "asarray", "(", "v", ",", "dtype", "=", "np", ".", "float64", ",", "order", "=", "'c'", ")", "result", "=", "_hausdorff", ".", "directed_hausdorff", "(", "u", ",", "v", ",", "seed", ")", "return", "result" ]

[ "Return", "the", "number", "of", "chunks", "the", "column", "consists", "of", "." ]

[ "def", "num_chunks", "(", "self", ")", "->", "int", ":", "return", "1" ]

[ "Do", "it", "all", "in", "one", "call!" ]

[ "def", "run_compile", "(", ")", ":", "import", "tempfile", "i", "=", "sys", ".", "argv", ".", "index", "(", "'-c'", ")", "del", "sys", ".", "argv", "[", "i", "]", "remove_build_dir", "=", "0", "try", ":", "i", "=", "sys", ".", "argv", ".", "index", "(", "'--build-dir'", ")", "except", "ValueError", ":", "i", "=", "None", "if", "i", "is", "not", "None", ":", "build_dir", "=", "sys", ".", "argv", "[", "i", "+", "1", "]", "del", "sys", ".", "argv", "[", "i", "+", "1", "]", "del", "sys", ".", "argv", "[", "i", "]", "else", ":", "remove_build_dir", "=", "1", "build_dir", "=", "tempfile", ".", "mkdtemp", "(", ")", "_reg1", "=", "re", ".", "compile", "(", "r'--link-'", ")", "sysinfo_flags", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "[", "1", ":", "]", "if", "_reg1", ".", "match", "(", "_m", ")", "]", "sys", ".", "argv", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "if", "_m", "not", "in", "sysinfo_flags", "]", "if", "sysinfo_flags", ":", "sysinfo_flags", "=", "[", "f", "[", "7", ":", "]", "for", "f", "in", "sysinfo_flags", "]", "_reg2", "=", "re", ".", "compile", "(", "r'--((no-|)(wrap-functions|lower)|debug-capi|quiet)|-include'", ")", "f2py_flags", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "[", "1", ":", "]", "if", "_reg2", ".", "match", "(", "_m", ")", "]", "sys", ".", "argv", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "if", "_m", "not", "in", "f2py_flags", "]", "f2py_flags2", "=", "[", "]", "fl", "=", "0", "for", "a", "in", "sys", ".", "argv", "[", "1", ":", "]", ":", "if", "a", "in", "[", "'only:'", ",", "'skip:'", "]", ":", "fl", "=", "1", "elif", "a", "==", "':'", ":", "fl", "=", "0", "if", "fl", "or", "a", "==", "':'", ":", "f2py_flags2", ".", "append", "(", "a", ")", "if", "f2py_flags2", "and", "f2py_flags2", "[", "-", "1", "]", "!=", "':'", ":", "f2py_flags2", ".", "append", "(", "':'", ")", "f2py_flags", ".", "extend", "(", "f2py_flags2", ")", "sys", ".", "argv", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "if", "_m", "not", "in", "f2py_flags2", "]", "_reg3", "=", "re", ".", "compile", "(", "r'--((f(90)?compiler(-exec|)|compiler)=|help-compiler)'", ")", "flib_flags", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "[", "1", ":", "]", "if", "_reg3", ".", "match", "(", "_m", ")", "]", "sys", ".", "argv", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "if", "_m", "not", "in", "flib_flags", "]", "_reg4", "=", "re", ".", "compile", "(", "r'--((f(77|90)(flags|exec)|opt|arch)=|(debug|noopt|noarch|help-fcompiler))'", ")", "fc_flags", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "[", "1", ":", "]", "if", "_reg4", ".", "match", "(", "_m", ")", "]", "sys", ".", "argv", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "if", "_m", "not", "in", "fc_flags", "]", "if", "1", ":", "del_list", "=", "[", "]", "for", "s", "in", "flib_flags", ":", "v", "=", "'--fcompiler='", "if", "s", "[", ":", "len", "(", "v", ")", "]", "==", "v", ":", "from", "numpy", ".", "distutils", "import", "fcompiler", "fcompiler", ".", "load_all_fcompiler_classes", "(", ")", "allowed_keys", "=", "list", "(", "fcompiler", ".", "fcompiler_class", ".", "keys", "(", ")", ")", "nv", "=", "ov", "=", "s", "[", "len", "(", "v", ")", ":", "]", ".", "lower", "(", ")", "if", "ov", "not", "in", "allowed_keys", ":", "vmap", "=", "{", "}", "# XXX", "try", ":", "nv", "=", "vmap", "[", "ov", "]", "except", "KeyError", ":", "if", "ov", "not", "in", "vmap", ".", "values", "(", ")", ":", "print", "(", "'Unknown vendor: \"%s\"'", "%", "(", "s", "[", "len", "(", "v", ")", ":", "]", ")", ")", "nv", "=", "ov", "i", "=", "flib_flags", ".", "index", "(", "s", ")", "flib_flags", "[", "i", "]", "=", "'--fcompiler='", "+", "nv", "continue", "for", "s", "in", "del_list", ":", "i", "=", "flib_flags", ".", "index", "(", "s", ")", "del", "flib_flags", "[", "i", "]", "assert", "len", "(", "flib_flags", ")", "<=", "2", ",", "repr", "(", "flib_flags", ")", "_reg5", "=", "re", ".", "compile", "(", "r'--(verbose)'", ")", "setup_flags", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "[", "1", ":", "]", "if", "_reg5", ".", "match", "(", "_m", ")", "]", "sys", ".", "argv", "=", "[", "_m", "for", "_m", "in", "sys", ".", "argv", "if", "_m", "not", "in", "setup_flags", "]", "if", "'--quiet'", "in", "f2py_flags", ":", "setup_flags", ".", "append", "(", "'--quiet'", ")", "modulename", "=", "'untitled'", "sources", "=", "sys", ".", "argv", "[", "1", ":", "]", "for", "optname", "in", "[", "'--include_paths'", ",", "'--include-paths'", ",", "'--f2cmap'", "]", ":", "if", "optname", "in", "sys", ".", "argv", ":", "i", "=", "sys", ".", "argv", ".", "index", "(", "optname", ")", "f2py_flags", ".", "extend", "(", "sys", ".", "argv", "[", "i", ":", "i", "+", "2", "]", ")", "del", "sys", ".", "argv", "[", "i", "+", "1", "]", ",", "sys", ".", "argv", "[", "i", "]", "sources", "=", "sys", ".", "argv", "[", "1", ":", "]", "if", "'-m'", "in", "sys", ".", "argv", ":", "i", "=", "sys", ".", "argv", ".", "index", "(", "'-m'", ")", "modulename", "=", "sys", ".", "argv", "[", "i", "+", "1", "]", "del", "sys", ".", "argv", "[", "i", "+", "1", "]", ",", "sys", ".", "argv", "[", "i", "]", "sources", "=", "sys", ".", "argv", "[", "1", ":", "]", "else", ":", "from", "numpy", ".", "distutils", ".", "command", ".", "build_src", "import", "get_f2py_modulename", "pyf_files", ",", "sources", "=", "filter_files", "(", "''", ",", "'[.]pyf([.]src|)'", ",", "sources", ")", "sources", "=", "pyf_files", "+", "sources", "for", "f", "in", "pyf_files", ":", "modulename", "=", "get_f2py_modulename", "(", "f", ")", "if", "modulename", ":", "break", "extra_objects", ",", "sources", "=", "filter_files", "(", "''", ",", "'[.](o|a|so|dylib)'", ",", "sources", ")", "include_dirs", ",", "sources", "=", "filter_files", "(", "'-I'", ",", "''", ",", "sources", ",", "remove_prefix", "=", "1", ")", "library_dirs", ",", "sources", "=", "filter_files", "(", "'-L'", ",", "''", ",", "sources", ",", "remove_prefix", "=", "1", ")", "libraries", ",", "sources", "=", "filter_files", "(", "'-l'", ",", "''", ",", "sources", ",", "remove_prefix", "=", "1", ")", "undef_macros", ",", "sources", "=", "filter_files", "(", "'-U'", ",", "''", ",", "sources", ",", "remove_prefix", "=", "1", ")", "define_macros", ",", "sources", "=", "filter_files", "(", "'-D'", ",", "''", ",", "sources", ",", "remove_prefix", "=", "1", ")", "for", "i", "in", "range", "(", "len", "(", "define_macros", ")", ")", ":", "name_value", "=", "define_macros", "[", "i", "]", ".", "split", "(", "'='", ",", "1", ")", "if", "len", "(", "name_value", ")", "==", "1", ":", "name_value", ".", "append", "(", "None", ")", "if", "len", "(", "name_value", ")", "==", "2", ":", "define_macros", "[", "i", "]", "=", "tuple", "(", "name_value", ")", "else", ":", "print", "(", "'Invalid use of -D:'", ",", "name_value", ")", "from", "numpy", ".", "distutils", ".", "system_info", "import", "get_info", "num_info", "=", "{", "}", "if", "num_info", ":", "include_dirs", ".", "extend", "(", "num_info", ".", "get", "(", "'include_dirs'", ",", "[", "]", ")", ")", "from", "numpy", ".", "distutils", ".", "core", "import", "setup", ",", "Extension", "ext_args", "=", "{", "'name'", ":", "modulename", ",", "'sources'", ":", "sources", ",", "'include_dirs'", ":", "include_dirs", ",", "'library_dirs'", ":", "library_dirs", ",", "'libraries'", ":", "libraries", ",", "'define_macros'", ":", "define_macros", ",", "'undef_macros'", ":", "undef_macros", ",", "'extra_objects'", ":", "extra_objects", ",", "'f2py_options'", ":", "f2py_flags", ",", "}", "if", "sysinfo_flags", ":", "from", "numpy", ".", "distutils", ".", "misc_util", "import", "dict_append", "for", "n", "in", "sysinfo_flags", ":", "i", "=", "get_info", "(", "n", ")", "if", "not", "i", ":", "outmess", "(", "'No %s resources found in system'", "' (try `f2py --help-link`)\\n'", "%", "(", "repr", "(", "n", ")", ")", ")", "dict_append", "(", "ext_args", ",", "*", "*", "i", ")", "ext", "=", "Extension", "(", "*", "*", "ext_args", ")", "sys", ".", "argv", "=", "[", "sys", ".", "argv", "[", "0", "]", "]", "+", "setup_flags", "sys", ".", "argv", ".", "extend", "(", "[", "'build'", ",", "'--build-temp'", ",", "build_dir", ",", "'--build-base'", ",", "build_dir", ",", "'--build-platlib'", ",", "'.'", ",", "# disable CCompilerOpt", "'--disable-optimization'", "]", ")", "if", "fc_flags", ":", "sys", ".", "argv", ".", "extend", "(", "[", "'config_fc'", "]", "+", "fc_flags", ")", "if", "flib_flags", ":", "sys", ".", "argv", ".", "extend", "(", "[", "'build_ext'", "]", "+", "flib_flags", ")", "setup", "(", "ext_modules", "=", "[", "ext", "]", ")", "if", "remove_build_dir", "and", "os", ".", "path", ".", "exists", "(", "build_dir", ")", ":", "import", "shutil", "outmess", "(", "'Removing build directory %s\\n'", "%", "(", "build_dir", ")", ")", "shutil", ".", "rmtree", "(", "build_dir", ")" ]

[ "optreturns", ":", "RETURNS", "LPAREN", "lparams", "RPAREN" ]

[ "def", "p_optreturns_tsyms", "(", "p", ")", ":", "p", "[", "0", "]", "=", "p", "[", "3", "]" ]

[ "Checks", "that", "all", "classes", "and", "namespaces", "have", "been", "completely", "parsed", ".", "Call", "this", "when", "all", "lines", "in", "a", "file", "have", "been", "processed", ".", "Args", ":", "filename", ":", "The", "name", "of", "the", "current", "file", ".", "error", ":", "The", "function", "to", "call", "with", "any", "errors", "found", "." ]

[ "def", "CheckCompletedBlocks", "(", "self", ",", "filename", ",", "error", ")", ":", "# Note: This test can result in false positives if #ifdef constructs", "# get in the way of brace matching. See the testBuildClass test in", "# cpplint_unittest.py for an example of this.", "for", "obj", "in", "self", ".", "stack", ":", "if", "isinstance", "(", "obj", ",", "_ClassInfo", ")", ":", "error", "(", "filename", ",", "obj", ".", "starting_linenum", ",", "'build/class'", ",", "5", ",", "'Failed to find complete declaration of class %s'", "%", "obj", ".", "name", ")", "elif", "isinstance", "(", "obj", ",", "_NamespaceInfo", ")", ":", "error", "(", "filename", ",", "obj", ".", "starting_linenum", ",", "'build/namespaces'", ",", "5", ",", "'Failed to find complete declaration of namespace %s'", "%", "obj", ".", "name", ")" ]

[ "cancelHistoricalData", "(", "EClientSocketBase", "self", "TickerId", "tickerId", ")" ]

[ "def", "cancelHistoricalData", "(", "self", ",", "tickerId", ")", ":", "return", "_swigibpy", ".", "EClientSocketBase_cancelHistoricalData", "(", "self", ",", "tickerId", ")" ]

[ "Initializes", "PosixStubWriter", "for", "this", "set", "of", "signatures", "and", "module_name", "." ]

[ "def", "__init__", "(", "self", ",", "module_name", ",", "signatures", ")", ":", "self", ".", "signatures", "=", "signatures", "self", ".", "module_name", "=", "module_name" ]

[ "SetTarget", "(", "self", "String", "target", ")" ]

[ "def", "SetTarget", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "HelpEvent_SetTarget", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "the", ":", "class", ":", "UltimateListCtrl", "AGW", "-", "specific", "style", "flag", "." ]

[ "def", "SetAGWWindowStyleFlag", "(", "self", ",", "style", ")", ":", "if", "style", "&", "ULC_HAS_VARIABLE_ROW_HEIGHT", "and", "not", "self", ".", "HasAGWFlag", "(", "ULC_REPORT", ")", ":", "raise", "Exception", "(", "\"ULC_HAS_VARIABLE_ROW_HEIGHT style can be used only in report mode\"", ")", "wasInReportView", "=", "self", ".", "HasAGWFlag", "(", "ULC_REPORT", ")", "self", ".", "_agwStyle", "=", "style", "if", "self", ".", "_mainWin", ":", "inReportView", "=", "(", "style", "&", "ULC_REPORT", ")", "!=", "0", "if", "inReportView", "!=", "wasInReportView", ":", "# we need to notify the main window about this change as it must", "# update its data structures", "self", ".", "_mainWin", ".", "SetReportView", "(", "inReportView", ")", "self", ".", "CreateOrDestroyHeaderWindowAsNeeded", "(", ")", "self", ".", "CreateOrDestroyFooterWindowAsNeeded", "(", ")", "self", ".", "GetSizer", "(", ")", ".", "Layout", "(", ")", "if", "style", "&", "ULC_HAS_VARIABLE_ROW_HEIGHT", ":", "self", ".", "_mainWin", ".", "ResetLineDimensions", "(", ")", "self", ".", "_mainWin", ".", "ResetVisibleLinesRange", "(", ")", "self", ".", "Refresh", "(", ")" ]

[ ":", "type", "grid", ":", "List", "[", "List", "[", "int", "]]", ":", "type", "x", ":", "int", ":", "rtype", ":", "int" ]

[ "def", "minOperations", "(", "self", ",", "grid", ",", "x", ")", ":", "def", "nth_element", "(", "nums", ",", "n", ",", "compare", "=", "lambda", "a", ",", "b", ":", "a", "<", "b", ")", ":", "def", "tri_partition", "(", "nums", ",", "left", ",", "right", ",", "target", ",", "compare", ")", ":", "mid", "=", "left", "while", "mid", "<=", "right", ":", "if", "nums", "[", "mid", "]", "==", "target", ":", "mid", "+=", "1", "elif", "compare", "(", "nums", "[", "mid", "]", ",", "target", ")", ":", "nums", "[", "left", "]", ",", "nums", "[", "mid", "]", "=", "nums", "[", "mid", "]", ",", "nums", "[", "left", "]", "left", "+=", "1", "mid", "+=", "1", "else", ":", "nums", "[", "mid", "]", ",", "nums", "[", "right", "]", "=", "nums", "[", "right", "]", ",", "nums", "[", "mid", "]", "right", "-=", "1", "return", "left", ",", "right", "left", ",", "right", "=", "0", ",", "len", "(", "nums", ")", "-", "1", "while", "left", "<=", "right", ":", "pivot_idx", "=", "random", ".", "randint", "(", "left", ",", "right", ")", "pivot_left", ",", "pivot_right", "=", "tri_partition", "(", "nums", ",", "left", ",", "right", ",", "nums", "[", "pivot_idx", "]", ",", "compare", ")", "if", "pivot_left", "<=", "n", "<=", "pivot_right", ":", "return", "elif", "pivot_left", ">", "n", ":", "right", "=", "pivot_left", "-", "1", "else", ":", "# pivot_right < n.", "left", "=", "pivot_right", "+", "1", "nums", "=", "[", "v", "for", "row", "in", "grid", "for", "v", "in", "row", "]", "if", "len", "(", "set", "(", "v", "%", "x", "for", "v", "in", "nums", ")", ")", ">", "1", ":", "return", "-", "1", "nth_element", "(", "nums", ",", "len", "(", "nums", ")", "//", "2", ")", "median", "=", "nums", "[", "len", "(", "nums", ")", "//", "2", "]", "return", "sum", "(", "abs", "(", "v", "-", "median", ")", "//", "x", "for", "v", "in", "nums", ")" ]

[ "r", "Samples", "from", "the", "Gumbel", "-", "Softmax", "distribution", "(", "Link", "1", "_", "Link", "2", "_", ")", "and", "optionally", "discretizes", "." ]

[ "def", "gumbel_softmax", "(", "logits", ":", "Tensor", ",", "tau", ":", "float", "=", "1", ",", "hard", ":", "bool", "=", "False", ",", "eps", ":", "float", "=", "1e-10", ",", "dim", ":", "int", "=", "-", "1", ")", "->", "Tensor", ":", "if", "has_torch_function_unary", "(", "logits", ")", ":", "return", "handle_torch_function", "(", "gumbel_softmax", ",", "(", "logits", ",", ")", ",", "logits", ",", "tau", "=", "tau", ",", "hard", "=", "hard", ",", "eps", "=", "eps", ",", "dim", "=", "dim", ")", "if", "eps", "!=", "1e-10", ":", "warnings", ".", "warn", "(", "\"`eps` parameter is deprecated and has no effect.\"", ")", "gumbels", "=", "(", "-", "torch", ".", "empty_like", "(", "logits", ",", "memory_format", "=", "torch", ".", "legacy_contiguous_format", ")", ".", "exponential_", "(", ")", ".", "log", "(", ")", ")", "# ~Gumbel(0,1)", "gumbels", "=", "(", "logits", "+", "gumbels", ")", "/", "tau", "# ~Gumbel(logits,tau)", "y_soft", "=", "gumbels", ".", "softmax", "(", "dim", ")", "if", "hard", ":", "# Straight through.", "index", "=", "y_soft", ".", "max", "(", "dim", ",", "keepdim", "=", "True", ")", "[", "1", "]", "y_hard", "=", "torch", ".", "zeros_like", "(", "logits", ",", "memory_format", "=", "torch", ".", "legacy_contiguous_format", ")", ".", "scatter_", "(", "dim", ",", "index", ",", "1.0", ")", "ret", "=", "y_hard", "-", "y_soft", ".", "detach", "(", ")", "+", "y_soft", "else", ":", "# Reparametrization trick.", "ret", "=", "y_soft", "return", "ret" ]

[ "Python", "implementation", "of", "batch", "normalization", "." ]

[ "def", "batch_norm_py", "(", "tensor", ",", "mean", ",", "variance", ",", "beta", ",", "gamma", ",", "scale", ")", ":", "return", "nn_impl", ".", "batch_normalization", "(", "tensor", ",", "mean", ",", "variance", ",", "beta", ",", "gamma", "if", "scale", "else", "None", ",", "0.001", ")" ]

[ "Handle", "leftovers", "when", "count", "is", "not", "a", "multiply", "of", "8", "." ]

[ "def", "GenerateLeftoverLoadAggregateStore", "(", "emitter", ",", "leftovers", ",", "lanes", ",", "output_address", ")", ":", "emitter", ".", "EmitNewline", "(", ")", "emitter", ".", "EmitComment", "(", "'Leftover Load Aggregate Store.'", ")", "# Clear load registers.", "for", "lane", "in", "lanes", ":", "emitter", ".", "EmitVMov", "(", "'i8'", ",", "lane", ".", "load", ",", "emitter", ".", "ImmediateConstant", "(", "0", ")", ")", "for", "lane", "in", "lanes", ":", "emitter", ".", "EmitVLoadE", "(", "8", ",", "leftovers", ",", "lane", ".", "load", ",", "lane", ".", "input_address", ",", "None", ")", "# Aggregate.", "for", "lane", "in", "lanes", ":", "emitter", ".", "EmitVAddw", "(", "'u8'", ",", "lane", ".", "aggregator", ",", "lane", ".", "aggregator", ",", "lane", ".", "load", ")", "# Store.", "emitter", ".", "EmitVStoreA", "(", "1", ",", "8", ",", "[", "lane", ".", "load", "for", "lane", "in", "lanes", "]", ",", "emitter", ".", "DereferenceIncrement", "(", "output_address", ",", "64", ")", ")" ]

[ "Sets", "the", "module", "s", "verbosity", "and", "returns", "the", "previous", "setting", "." ]

[ "def", "_SetVerboseLevel", "(", "level", ")", ":", "return", "_cpplint_state", ".", "SetVerboseLevel", "(", "level", ")" ]

[ "Dump", "an", "HTML", "node", "recursive", "behaviour", "children", "are", "printed", "too", "." ]

[ "def", "htmlNodeDumpFormatOutput", "(", "self", ",", "doc", ",", "cur", ",", "encoding", ",", "format", ")", ":", "if", "doc", "is", "None", ":", "doc__o", "=", "None", "else", ":", "doc__o", "=", "doc", ".", "_o", "if", "cur", "is", "None", ":", "cur__o", "=", "None", "else", ":", "cur__o", "=", "cur", ".", "_o", "libxml2mod", ".", "htmlNodeDumpFormatOutput", "(", "self", ".", "_o", ",", "doc__o", ",", "cur__o", ",", "encoding", ",", "format", ")" ]

[ "Implementation", "of", "constant", "." ]

[ "def", "_constant_impl", "(", "value", ",", "dtype", ",", "shape", ",", "name", ",", "verify_shape", ",", "allow_broadcast", ")", ":", "ctx", "=", "context", ".", "context", "(", ")", "if", "ctx", ".", "executing_eagerly", "(", ")", ":", "t", "=", "convert_to_eager_tensor", "(", "value", ",", "ctx", ",", "dtype", ")", "if", "shape", "is", "None", ":", "return", "t", "shape", "=", "tensor_shape", ".", "as_shape", "(", "shape", ")", "if", "shape", "==", "t", ".", "shape", ":", "return", "t", "if", "verify_shape", ":", "raise", "TypeError", "(", "\"Expected Tensor's shape: %s, got %s.\"", "%", "(", "tuple", "(", "shape", ")", ",", "tuple", "(", "t", ".", "shape", ")", ")", ")", "num_t", "=", "t", ".", "shape", ".", "num_elements", "(", ")", "# TODO(josh11b): Implement shape -> eager tensor conversion.", "if", "num_t", "==", "shape", ".", "num_elements", "(", ")", ":", "return", "_eager_reshape", "(", "t", ",", "shape", ".", "as_list", "(", ")", ",", "ctx", ")", "if", "num_t", "==", "1", ":", "if", "t", ".", "dtype", "==", "dtypes", ".", "bool", ":", "# We don't have a Fill kernel for bool dtype on GPU. So we first run", "# Fill on CPU and then copy to GPU if needed.", "with", "ops", ".", "device", "(", "\"/device:CPU:0\"", ")", ":", "x", "=", "_eager_fill", "(", "shape", ".", "as_list", "(", ")", ",", "t", ".", "cpu", "(", ")", ",", "ctx", ")", "return", "_eager_identity", "(", "x", ",", "ctx", ")", "else", ":", "return", "_eager_fill", "(", "shape", ".", "as_list", "(", ")", ",", "t", ",", "ctx", ")", "raise", "TypeError", "(", "\"Eager execution of tf.constant with unsupported shape \"", "\"(value has %d elements, shape is %s with %d elements).\"", "%", "(", "num_t", ",", "shape", ",", "shape", ".", "num_elements", "(", ")", ")", ")", "g", "=", "ops", ".", "get_default_graph", "(", ")", "tensor_value", "=", "attr_value_pb2", ".", "AttrValue", "(", ")", "tensor_value", ".", "tensor", ".", "CopyFrom", "(", "tensor_util", ".", "make_tensor_proto", "(", "value", ",", "dtype", "=", "dtype", ",", "shape", "=", "shape", ",", "verify_shape", "=", "verify_shape", ",", "allow_broadcast", "=", "allow_broadcast", ")", ")", "dtype_value", "=", "attr_value_pb2", ".", "AttrValue", "(", "type", "=", "tensor_value", ".", "tensor", ".", "dtype", ")", "const_tensor", "=", "g", ".", "create_op", "(", "\"Const\"", ",", "[", "]", ",", "[", "dtype_value", ".", "type", "]", ",", "attrs", "=", "{", "\"value\"", ":", "tensor_value", ",", "\"dtype\"", ":", "dtype_value", "}", ",", "name", "=", "name", ")", ".", "outputs", "[", "0", "]", "return", "const_tensor" ]

[ "Takes", "a", "ForceBeads", "instance", "and", "stores", "a", "minimal", "representation", "of", "it", "." ]

[ "def", "store", "(", "self", ",", "forceb", ")", ":", "Input", ".", "store", "(", "self", ",", "forceb", ")", "self", ".", "nbeads", ".", "store", "(", "forceb", ".", "nbeads", ")", "self", ".", "weight", ".", "store", "(", "forceb", ".", "weight", ")" ]

[ "Replace", "functions", "calls", "and", "shared", "names", "in", "node_def", "." ]

[ "def", "fix_node_def", "(", "node_def", ",", "functions", ",", "shared_name_suffix", ",", "debug_name", ")", ":", "if", "\"_gradient_op_type\"", "in", "node_def", ".", "attr", ":", "if", "node_def", ".", "op", "in", "[", "\"StatefulPartitionedCall\"", ",", "\"PartitionedCall\"", "]", ":", "# TODO(andresp): This code assumes that the gradient registered for this", "# function call is the default gradient for the function and not a", "# custom one.", "fname", "=", "node_def", ".", "attr", "[", "\"f\"", "]", ".", "func", ".", "name", "gradient_name", "=", "functions", "[", "fname", "]", ".", "_register_delayed_rewrite_gradient", "(", ")", "# pylint: disable=protected-access", "node_def", ".", "attr", "[", "\"_gradient_op_type\"", "]", ".", "s", "=", "compat", ".", "as_bytes", "(", "gradient_name", ")", "else", ":", "logging", ".", "warning", "(", "\"Importing a function (%s) with ops with custom \"", "\"gradients. Will likely fail if a gradient is \"", "\"requested.\"", ",", "debug_name", ")", "if", "node_def", ".", "op", "in", "functions", ":", "node_def", ".", "op", "=", "functions", "[", "node_def", ".", "op", "]", ".", "name", "for", "_", ",", "attr_value", "in", "node_def", ".", "attr", ".", "items", "(", ")", ":", "if", "attr_value", ".", "func", ".", "name", ":", "attr_value", ".", "func", ".", "name", "=", "functions", "[", "attr_value", ".", "func", ".", "name", "]", ".", "name", "# Fix old table creation bug.", "if", "node_def", ".", "op", "==", "\"HashTableV2\"", ":", "if", "(", "\"use_node_name_sharing\"", "not", "in", "node_def", ".", "attr", "or", "not", "node_def", ".", "attr", "[", "\"use_node_name_sharing\"", "]", ".", "b", ")", ":", "node_def", ".", "attr", "[", "\"use_node_name_sharing\"", "]", ".", "b", "=", "True", "# We are turning on node mame sharing, so have to make sure we don't", "# accidentally share a table resource.", "shared_name_suffix", "+=", "\"_{}\"", ".", "format", "(", "ops", ".", "uid", "(", ")", ")", "# TODO(b/124205571): Avoid accidental sharing and destruction of restored", "# resources. For now uniquify \"shared_name\" when loading functions to avoid", "# sharing.", "if", "\"shared_name\"", "in", "node_def", ".", "attr", ":", "if", "node_def", ".", "attr", "[", "\"shared_name\"", "]", ".", "s", ":", "node_def", ".", "attr", "[", "\"shared_name\"", "]", ".", "s", "+=", "compat", ".", "as_bytes", "(", "shared_name_suffix", ")", "else", ":", "# Blank shared_name attributes would use the node name, so we'll start", "# with that when uniquifying.", "node_def", ".", "attr", "[", "\"shared_name\"", "]", ".", "s", "=", "(", "compat", ".", "as_bytes", "(", "node_def", ".", "name", ")", "+", "compat", ".", "as_bytes", "(", "shared_name_suffix", ")", ")" ]

[ "Return", "a", "string", "representation", "for", "this", "object", "." ]

[ "def", "__unicode__", "(", "self", ")", ":", "prepr", "=", "pprint_thing", "(", "self", ",", "escape_chars", "=", "(", "'\\t'", ",", "'\\r'", ",", "'\\n'", ")", ",", "quote_strings", "=", "True", ")", "return", "\"%s(%s, dtype='%s')\"", "%", "(", "type", "(", "self", ")", ".", "__name__", ",", "prepr", ",", "self", ".", "dtype", ")" ]

[ "Computes", "the", "partial", "statistics", "of", "the", "means", "and", "covariances", "." ]

[ "def", "_define_partial_maximization_operation", "(", "self", ",", "shard_id", ",", "shard", ")", ":", "# Soft assignment of each data point to each of the two clusters.", "self", ".", "_points_in_k", "[", "shard_id", "]", "=", "tf", ".", "reduce_sum", "(", "self", ".", "_w", "[", "shard_id", "]", ",", "0", ",", "keep_dims", "=", "True", ")", "# Partial means.", "w_mul_x", "=", "tf", ".", "expand_dims", "(", "tf", ".", "matmul", "(", "self", ".", "_w", "[", "shard_id", "]", ",", "tf", ".", "squeeze", "(", "shard", ",", "[", "0", "]", ")", ",", "transpose_a", "=", "True", ")", ",", "1", ")", "self", ".", "_w_mul_x", ".", "append", "(", "w_mul_x", ")", "# Partial covariances.", "x", "=", "tf", ".", "concat", "(", "0", ",", "[", "shard", "for", "_", "in", "range", "(", "self", ".", "_num_classes", ")", "]", ")", "x_trans", "=", "tf", ".", "transpose", "(", "x", ",", "perm", "=", "[", "0", ",", "2", ",", "1", "]", ")", "x_mul_w", "=", "tf", ".", "concat", "(", "0", ",", "[", "tf", ".", "expand_dims", "(", "x_trans", "[", "k", ",", ":", ",", ":", "]", "*", "self", ".", "_w", "[", "shard_id", "]", "[", ":", ",", "k", "]", ",", "0", ")", "for", "k", "in", "range", "(", "self", ".", "_num_classes", ")", "]", ")", "self", ".", "_w_mul_x2", ".", "append", "(", "tf", ".", "batch_matmul", "(", "x_mul_w", ",", "x", ")", ")" ]

[ "Convert", "a", "set", "of", "object", "files", "that", "are", "not", "compatible", "with", "the", "default", "linker", "to", "a", "file", "that", "is", "compatible", "." ]

[ "def", "wrap_unlinkable_objects", "(", "self", ",", "objects", ",", "output_dir", ",", "extra_dll_dir", ")", ":", "if", "self", ".", "c_compiler", ".", "compiler_type", "==", "\"msvc\"", ":", "# Compile a DLL and return the lib for the DLL as", "# the object. Also keep track of previous DLLs that", "# we have compiled so that we can link against them.", "# If there are .a archives, assume they are self-contained", "# static libraries, and build separate DLLs for each", "archives", "=", "[", "]", "plain_objects", "=", "[", "]", "for", "obj", "in", "objects", ":", "if", "obj", ".", "lower", "(", ")", ".", "endswith", "(", "'.a'", ")", ":", "archives", ".", "append", "(", "obj", ")", "else", ":", "plain_objects", ".", "append", "(", "obj", ")", "chained_libs", "=", "[", "]", "chained_dlls", "=", "[", "]", "for", "archive", "in", "archives", "[", ":", ":", "-", "1", "]", ":", "lib", ",", "dll", "=", "self", ".", "_link_wrapper_lib", "(", "[", "archive", "]", ",", "output_dir", ",", "extra_dll_dir", ",", "chained_dlls", "=", "chained_dlls", ",", "is_archive", "=", "True", ")", "chained_libs", ".", "insert", "(", "0", ",", "lib", ")", "chained_dlls", ".", "insert", "(", "0", ",", "dll", ")", "if", "not", "plain_objects", ":", "return", "chained_libs", "lib", ",", "dll", "=", "self", ".", "_link_wrapper_lib", "(", "plain_objects", ",", "output_dir", ",", "extra_dll_dir", ",", "chained_dlls", "=", "chained_dlls", ",", "is_archive", "=", "False", ")", "return", "[", "lib", "]", "+", "chained_libs", "else", ":", "raise", "ValueError", "(", "\"Unsupported C compiler\"", ")" ]

[ "Shortcut", "to", "create", "an", "undefined", "single", "precision", "Theano", "shared", "variable", "." ]

[ "def", "shared_single", "(", "dim", "=", "2", ")", ":", "shp", "=", "tuple", "(", "[", "1", "]", "*", "dim", ")", "return", "theano", ".", "shared", "(", "np", ".", "zeros", "(", "shp", ",", "dtype", "=", "'float32'", ")", ")" ]

[ "Set", "up", "the", "environment", "for", "one", "request" ]

[ "def", "setup_environ", "(", "self", ")", ":", "env", "=", "self", ".", "environ", "=", "self", ".", "os_environ", ".", "copy", "(", ")", "self", ".", "add_cgi_vars", "(", ")", "env", "[", "'wsgi.input'", "]", "=", "self", ".", "get_stdin", "(", ")", "env", "[", "'wsgi.errors'", "]", "=", "self", ".", "get_stderr", "(", ")", "env", "[", "'wsgi.version'", "]", "=", "self", ".", "wsgi_version", "env", "[", "'wsgi.run_once'", "]", "=", "self", ".", "wsgi_run_once", "env", "[", "'wsgi.url_scheme'", "]", "=", "self", ".", "get_scheme", "(", ")", "env", "[", "'wsgi.multithread'", "]", "=", "self", ".", "wsgi_multithread", "env", "[", "'wsgi.multiprocess'", "]", "=", "self", ".", "wsgi_multiprocess", "if", "self", ".", "wsgi_file_wrapper", "is", "not", "None", ":", "env", "[", "'wsgi.file_wrapper'", "]", "=", "self", ".", "wsgi_file_wrapper", "if", "self", ".", "origin_server", "and", "self", ".", "server_software", ":", "env", ".", "setdefault", "(", "'SERVER_SOFTWARE'", ",", "self", ".", "server_software", ")" ]

[ "Find", "the", "beginning", "marker", "for", "a", "multiline", "comment", "." ]

[ "def", "FindNextMultiLineCommentStart", "(", "lines", ",", "lineix", ")", ":", "while", "lineix", "<", "len", "(", "lines", ")", ":", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "startswith", "(", "'/*'", ")", ":", "# Only return this marker if the comment goes beyond this line", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "find", "(", "'*/'", ",", "2", ")", "<", "0", ":", "return", "lineix", "lineix", "+=", "1", "return", "len", "(", "lines", ")" ]

[ "Round", "an", "array", "to", "the", "given", "number", "of", "decimals", "." ]

[ "def", "round_", "(", "a", ",", "decimals", "=", "0", ",", "out", "=", "None", ")", ":", "try", ":", "round", "=", "a", ".", "round", "except", "AttributeError", ":", "return", "_wrapit", "(", "a", ",", "'round'", ",", "decimals", ",", "out", ")", "return", "round", "(", "decimals", ",", "out", ")" ]

[ "Parse", "system", "counter", "information", "from", "a", "trace", "file", "sort", "by", "increasing", "timestamp", "order", "and", "plot", "as", "a", "time", "series", "." ]

[ "def", "syscounters", "(", "tracefile", ",", "args", ")", ":", "plotdir", "=", "os", ".", "path", ".", "join", "(", "args", ".", "plotdir", ",", "\"\"", ")", "# Validate output directory actually exists", "if", "not", "os", ".", "path", ".", "exists", "(", "args", ".", "plotdir", ")", ":", "print", "(", "\"syscounters: {plt}: no such file or directory\"", ".", "format", "(", "plt", "=", "args", ".", "plotdir", ")", ")", "sys", ".", "exit", "(", "2", ")", "interpreter", "=", "TraceFileInterpreter", "(", "tracefile", ")", "trace", "=", "interpreter", ".", "interpret", "(", ")", "counters", "=", "defaultdict", "(", "lambda", ":", "[", "]", ")", "# counter_type -> [(timestamp, counter)]", "for", "unit", "in", "trace", ".", "executionUnits", ".", "values", "(", ")", ":", "for", "block_id", "in", "unit", ".", "blocks", ":", "block", "=", "trace", ".", "blocks", "[", "block_id", "]", "for", "point", "in", "block", ".", "points", ":", "counter", "=", "point", ".", "properties", ".", "counterProps", ".", "get", "(", "tt", ".", "CounterUnit", ".", "ITEMS", ",", "None", ")", "if", "not", "counter", ":", "continue", "for", "counterType", ",", "count", "in", "counter", ".", "items", "(", ")", ":", "counters", "[", "counterType", "]", ".", "append", "(", "(", "point", ".", "timestamp", ",", "count", ")", ")", "for", "counterType", ",", "series", "in", "counters", ".", "items", "(", ")", ":", "counters", "[", "counterType", "]", "=", "rescale", "(", "counters", "[", "counterType", "]", ")", "counters", "[", "counterType", "]", ".", "sort", "(", "key", "=", "lambda", "x", ":", "x", "[", "0", "]", ")", "# Now <counters> is a time series for each counter type. We can plot a few", "# of them. Plotting other time series is just a matter of adding here", "# any counter from the list in python/profilo/importer/constants.py", "import", "matplotlib", ".", "pyplot", "as", "plt", "test_counters", "=", "[", "\"NUM_PROCS\"", ",", "\"PROC_CPU_TIME\"", ",", "\"GLOBAL_ALLOC_SIZE\"", ",", "\"ALLOC_FREE_BYTES\"", ",", "]", "for", "tc", "in", "test_counters", ":", "data", "=", "counters", "[", "tc", "]", "x", ",", "y", "=", "list", "(", "zip", "(", "*", "data", ")", ")", "plt", ".", "xlabel", "(", "\"time\"", ")", "plt", ".", "ylabel", "(", "tc", ".", "lower", "(", ")", ")", "plt", ".", "plot", "(", "x", ",", "y", ")", "plt", ".", "axis", "(", "[", "min", "(", "x", ")", ",", "max", "(", "x", ")", ",", "min", "(", "y", ")", ",", "max", "(", "y", ")", "]", ")", "plt", ".", "savefig", "(", "plotdir", "+", "tc", ".", "lower", "(", ")", ")", "plt", ".", "clf", "(", ")" ]

[ "Draws", "the", "wxMAC", "tab", "close", "button", "using", ":", "class", ":", "GraphicsContext", "." ]

[ "def", "DrawMACCloseButton", "(", "colour", ",", "backColour", "=", "None", ")", ":", "bmp", "=", "wx", ".", "EmptyBitmapRGBA", "(", "16", ",", "16", ")", "dc", "=", "wx", ".", "MemoryDC", "(", ")", "dc", ".", "SelectObject", "(", "bmp", ")", "gc", "=", "wx", ".", "GraphicsContext", ".", "Create", "(", "dc", ")", "gc", ".", "SetBrush", "(", "wx", ".", "Brush", "(", "colour", ")", ")", "path", "=", "gc", ".", "CreatePath", "(", ")", "path", ".", "AddCircle", "(", "6.5", ",", "7", ",", "6.5", ")", "path", ".", "CloseSubpath", "(", ")", "gc", ".", "FillPath", "(", "path", ")", "path", "=", "gc", ".", "CreatePath", "(", ")", "if", "backColour", "is", "not", "None", ":", "pen", "=", "wx", ".", "Pen", "(", "backColour", ",", "2", ")", "else", ":", "pen", "=", "wx", ".", "Pen", "(", "\"white\"", ",", "2", ")", "pen", ".", "SetCap", "(", "wx", ".", "CAP_BUTT", ")", "pen", ".", "SetJoin", "(", "wx", ".", "JOIN_BEVEL", ")", "gc", ".", "SetPen", "(", "pen", ")", "path", ".", "MoveToPoint", "(", "3.5", ",", "4", ")", "path", ".", "AddLineToPoint", "(", "9.5", ",", "10", ")", "path", ".", "MoveToPoint", "(", "3.5", ",", "10", ")", "path", ".", "AddLineToPoint", "(", "9.5", ",", "4", ")", "path", ".", "CloseSubpath", "(", ")", "gc", ".", "DrawPath", "(", "path", ")", "dc", ".", "SelectObject", "(", "wx", ".", "NullBitmap", ")", "return", "bmp" ]

[ "Remove", "an", "image", "asynchronously", "in", "the", "background" ]

[ "def", "task_add_remove", "(", "self", ",", "image_spec", ":", "str", ")", "->", "Tuple", "[", "int", ",", "str", ",", "str", "]", ":", "with", "self", ".", "task", ".", "lock", ":", "return", "self", ".", "task", ".", "queue_remove", "(", "image_spec", ")" ]

[ "Copies", "a", "file", "and", "removes", "comments", "behind", "data", "lines", "but", "not", "in", "others", "." ]

[ "def", "CopyAndStrip", "(", "s", ",", "t", ")", ":", "return", "CopyAndStripWithOptionalMerge", "(", "s", ",", "t", ",", "False", ")" ]

[ "Obtain", "a", "node", "name", "that", "is", "the", "single", "element", "of", "a", "collection", "." ]

[ "def", "_get_single_node_name_from_collection", "(", "meta_graph_def", ",", "collection_key", ")", ":", "if", "collection_key", "not", "in", "meta_graph_def", ".", "collection_def", ":", "return", "None", "collection", "=", "meta_graph_def", ".", "collection_def", "[", "collection_key", "]", "if", "not", "collection", ".", "node_list", ".", "value", ":", "raise", "ValueError", "(", "'Collection {} is present but type is not node_list.'", ".", "format", "(", "collection_key", ")", ")", "if", "len", "(", "collection", ".", "node_list", ".", "value", ")", "!=", "1", ":", "raise", "ValueError", "(", "'Collection {} is has {} elements; expected exactly one.'", ".", "format", "(", "collection_key", ",", "collection", ".", "bytes_list", ")", ")", "return", "collection", ".", "node_list", ".", "value", "[", "0", "]" ]

[ "Write", "execution", "report", "file", "." ]

[ "def", "write_exec_trace", "(", "filename", ",", "entry", ")", ":", "with", "open", "(", "filename", ",", "'ab'", ")", "as", "handler", ":", "pid", "=", "str", "(", "entry", ".", "pid", ")", "command", "=", "US", ".", "join", "(", "entry", ".", "cmd", ")", "+", "US", "content", "=", "RS", ".", "join", "(", "[", "pid", ",", "pid", ",", "'wrapper'", ",", "entry", ".", "cwd", ",", "command", "]", ")", "+", "GS", "handler", ".", "write", "(", "content", ".", "encode", "(", "'utf-8'", ")", ")" ]

[ "Load", "(", "TIntIntVH", "self", "TSIn", "SIn", ")" ]

[ "def", "Load", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TIntIntVH_Load", "(", "self", ",", "*", "args", ")" ]

[ "If", "the", "keyed", "message", "exists", "remove", "it", "." ]

[ "def", "discard", "(", "self", ",", "key", ")", ":", "try", ":", "self", ".", "remove", "(", "key", ")", "except", "KeyError", ":", "pass" ]

[ "Checks", "that", "there", "is", "no", "pending", "commit", "in", "the", "sandbox", "." ]

[ "def", "check_no_pending_commit", "(", ")", ":", "stdout", "=", "svn_command", "(", "'status'", ",", "'--xml'", ")", "etree", "=", "ElementTree", ".", "fromstring", "(", "stdout", ")", "msg", "=", "[", "]", "for", "entry", "in", "etree", ".", "getiterator", "(", "'entry'", ")", ":", "path", "=", "entry", ".", "get", "(", "'path'", ")", "status", "=", "entry", ".", "find", "(", "'wc-status'", ")", ".", "get", "(", "'item'", ")", "if", "status", "!=", "'unversioned'", "and", "path", "!=", "'version'", ":", "msg", ".", "append", "(", "'File \"%s\" has pending change (status=\"%s\")'", "%", "(", "path", ",", "status", ")", ")", "if", "msg", ":", "msg", ".", "insert", "(", "0", ",", "'Pending change to commit found in sandbox. Commit them first!'", ")", "return", "'\\n'", ".", "join", "(", "msg", ")" ]

[ "UpdateRanges", "(", "self", ")" ]

[ "def", "UpdateRanges", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextParagraphLayoutBox_UpdateRanges", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "list", "of", "used", "style", "strings", ".", "This", "is", "helpful", "for", "debugging", "and", "for", "writing", "a", "new", "Style", "." ]

[ "def", "get_used_style_strings", "(", "self", ")", "->", "List", "[", "str", "]", ":", "attrs_for_style", "=", "self", ".", "renderer", ".", "_attrs_for_style", "if", "attrs_for_style", ":", "return", "sorted", "(", "[", "re", ".", "sub", "(", "r\"\\s+\"", ",", "\" \"", ",", "style_str", ")", ".", "strip", "(", ")", "for", "style_str", "in", "attrs_for_style", ".", "keys", "(", ")", "]", ")", "return", "[", "]" ]

[ "Iterates", "through", "all", "selected", "prims", "selecting", "their", "bound", "preview", "materials", "." ]

[ "def", "selectBoundMaterialForPurpose", "(", "self", ",", "materialPurpose", ")", ":", "oldPrims", "=", "self", ".", "_dataModel", ".", "selection", ".", "getPrims", "(", ")", "with", "self", ".", "_dataModel", ".", "selection", ".", "batchPrimChanges", ":", "self", ".", "_dataModel", ".", "selection", ".", "clearPrims", "(", ")", "for", "prim", "in", "oldPrims", ":", "(", "boundMaterial", ",", "bindingRel", ")", "=", "UsdShade", ".", "MaterialBindingAPI", "(", "prim", ")", ".", "ComputeBoundMaterial", "(", "materialPurpose", "=", "materialPurpose", ")", "if", "boundMaterial", ":", "self", ".", "_dataModel", ".", "selection", ".", "addPrim", "(", "boundMaterial", ".", "GetPrim", "(", ")", ")" ]

[ "Set", "icon", "menu", "and", "tooltip", "." ]

[ "def", "GetResources", "(", "self", ")", ":", "return", "{", "'Pixmap'", ":", "'Draft_Layer'", ",", "'MenuText'", ":", "QT_TRANSLATE_NOOP", "(", "\"Draft_Layer\"", ",", "\"Layer\"", ")", ",", "'ToolTip'", ":", "QT_TRANSLATE_NOOP", "(", "\"Draft_Layer\"", ",", "\"Adds a layer to the document.\\nObjects added to this layer can share the same visual properties such as line color, line width, and shape color.\"", ")", "}" ]

[ "Key", "bindings", "for", "scrolling", "up", "and", "down", "through", "pages", ".", "This", "are", "separate", "bindings", "because", "GNU", "readline", "doesn", "t", "have", "them", "." ]

[ "def", "load_extra_vi_page_navigation_bindings", "(", ")", ":", "registry", "=", "ConditionalRegistry", "(", "Registry", "(", ")", ",", "ViMode", "(", ")", ")", "handle", "=", "registry", ".", "add_binding", "handle", "(", "Keys", ".", "ControlF", ")", "(", "scroll_forward", ")", "handle", "(", "Keys", ".", "ControlB", ")", "(", "scroll_backward", ")", "handle", "(", "Keys", ".", "ControlD", ")", "(", "scroll_half_page_down", ")", "handle", "(", "Keys", ".", "ControlU", ")", "(", "scroll_half_page_up", ")", "handle", "(", "Keys", ".", "ControlE", ")", "(", "scroll_one_line_down", ")", "handle", "(", "Keys", ".", "ControlY", ")", "(", "scroll_one_line_up", ")", "handle", "(", "Keys", ".", "PageDown", ")", "(", "scroll_page_down", ")", "handle", "(", "Keys", ".", "PageUp", ")", "(", "scroll_page_up", ")", "return", "registry" ]

[ ":", "param", "verbose", ":", "If", "enabled", "a", "higher", "verbosity", "level", "will", "be", "set", "on", "the", "TensorRT", "logger", "." ]

[ "def", "__init__", "(", "self", ",", "verbose", "=", "False", ")", ":", "self", ".", "trt_logger", "=", "trt", ".", "Logger", "(", "trt", ".", "Logger", ".", "INFO", ")", "if", "verbose", ":", "self", ".", "trt_logger", ".", "min_severity", "=", "trt", ".", "Logger", ".", "Severity", ".", "VERBOSE", "trt", ".", "init_libnvinfer_plugins", "(", "self", ".", "trt_logger", ",", "namespace", "=", "\"\"", ")", "self", ".", "builder", "=", "trt", ".", "Builder", "(", "self", ".", "trt_logger", ")", "self", ".", "config", "=", "self", ".", "builder", ".", "create_builder_config", "(", ")", "self", ".", "config", ".", "max_workspace_size", "=", "8", "*", "(", "2", "**", "30", ")", "# 8 GB", "self", ".", "batch_size", "=", "None", "self", ".", "network", "=", "None", "self", ".", "parser", "=", "None" ]

[]

[ "def", "make_headers", "(", "keep_alive", "=", "None", ",", "accept_encoding", "=", "None", ",", "user_agent", "=", "None", ",", "basic_auth", "=", "None", ",", "proxy_basic_auth", "=", "None", ",", "disable_cache", "=", "None", ",", ")", ":", "headers", "=", "{", "}", "if", "accept_encoding", ":", "if", "isinstance", "(", "accept_encoding", ",", "str", ")", ":", "pass", "elif", "isinstance", "(", "accept_encoding", ",", "list", ")", ":", "accept_encoding", "=", "\",\"", ".", "join", "(", "accept_encoding", ")", "else", ":", "accept_encoding", "=", "ACCEPT_ENCODING", "headers", "[", "\"accept-encoding\"", "]", "=", "accept_encoding", "if", "user_agent", ":", "headers", "[", "\"user-agent\"", "]", "=", "user_agent", "if", "keep_alive", ":", "headers", "[", "\"connection\"", "]", "=", "\"keep-alive\"", "if", "basic_auth", ":", "headers", "[", "\"authorization\"", "]", "=", "\"Basic \"", "+", "b64encode", "(", "b", "(", "basic_auth", ")", ")", ".", "decode", "(", "\"utf-8\"", ")", "if", "proxy_basic_auth", ":", "headers", "[", "\"proxy-authorization\"", "]", "=", "\"Basic \"", "+", "b64encode", "(", "b", "(", "proxy_basic_auth", ")", ")", ".", "decode", "(", "\"utf-8\"", ")", "if", "disable_cache", ":", "headers", "[", "\"cache-control\"", "]", "=", "\"no-cache\"", "return", "headers" ]

[ "Creates", "regression", "signature", "from", "given", "examples", "and", "predictions", "." ]

[ "def", "regression_signature_fn", "(", "examples", ",", "unused_features", ",", "predictions", ")", ":", "signatures", "=", "{", "}", "signatures", "[", "'regression'", "]", "=", "exporter", ".", "regression_signature", "(", "input_tensor", "=", "examples", ",", "output_tensor", "=", "predictions", ")", "return", "signatures", "[", "'regression'", "]", ",", "signatures" ]

[ "getFuelConsumption", "(", "string", ")", "-", ">", "double" ]

[ "def", "getFuelConsumption", "(", "self", ",", "edgeID", ")", ":", "return", "self", ".", "_getUniversal", "(", "tc", ".", "VAR_FUELCONSUMPTION", ",", "edgeID", ")" ]

[ "Compares", "the", "values", "numerically", "with", "their", "sign", "ignored", "." ]

[ "def", "min_mag", "(", "self", ",", "a", ",", "b", ")", ":", "a", "=", "_convert_other", "(", "a", ",", "raiseit", "=", "True", ")", "return", "a", ".", "min_mag", "(", "b", ",", "context", "=", "self", ")" ]

[ "calculates", "a", "distance", "to", "another", "config", "Inputs", ":", "konfig", "-", "a", "second", "config", "keys_check", "-", "optional", "a", "list", "of", "keys", "to", "check", "Outputs", ":", "distance", "-", "a", "float", "Currently", "only", "works", "for", "DV_VALUE_NEW", "and", "DV_VALUE_OLD", "Returns", "a", "large", "value", "otherwise" ]

[ "def", "dist", "(", "self", ",", "konfig", ",", "keys_check", "=", "'ALL'", ")", ":", "konfig_diff", "=", "self", ".", "diff", "(", "konfig", ")", "if", "keys_check", "==", "'ALL'", ":", "keys_check", "=", "konfig_diff", ".", "keys", "(", ")", "distance", "=", "0.0", "for", "key", "in", "keys_check", ":", "if", "key", "in", "konfig_diff", ":", "val1", "=", "konfig_diff", "[", "key", "]", "[", "0", "]", "val2", "=", "konfig_diff", "[", "key", "]", "[", "1", "]", "if", "key", "in", "[", "'DV_VALUE_NEW'", ",", "'DV_VALUE_OLD'", "]", ":", "val1", "=", "np", ".", "array", "(", "val1", ")", "val2", "=", "np", ".", "array", "(", "val2", ")", "this_diff", "=", "np", ".", "sqrt", "(", "np", ".", "sum", "(", "(", "val1", "-", "val2", ")", "**", "2", ")", ")", "else", ":", "print", "(", "'Warning, unexpected config difference'", ")", "this_diff", "=", "inf", "distance", "+=", "this_diff", "#: if key different", "#: for each keys_check", "return", "distance" ]

[ "Set", "the", "list", "selection", "by", "using", "a", "string", "value", "@param", "text", ":", "string", "to", "select", "in", "list" ]

[ "def", "SetStringSelection", "(", "self", ",", "text", ")", ":", "self", ".", "_list", ".", "SetStringSelection", "(", "text", ")" ]

[ "Return", "(", "status", "output", ")", "of", "executed", "command", "." ]

[ "def", "exec_command", "(", "command", ",", "execute_in", "=", "''", ",", "use_shell", "=", "None", ",", "use_tee", "=", "None", ",", "_with_python", "=", "1", ",", "*", "*", "env", ")", ":", "log", ".", "debug", "(", "'exec_command(%r,%s)'", "%", "(", "command", ",", "','", ".", "join", "(", "[", "'%s=%r'", "%", "kv", "for", "kv", "in", "env", ".", "items", "(", ")", "]", ")", ")", ")", "if", "use_tee", "is", "None", ":", "use_tee", "=", "os", ".", "name", "==", "'posix'", "if", "use_shell", "is", "None", ":", "use_shell", "=", "os", ".", "name", "==", "'posix'", "execute_in", "=", "os", ".", "path", ".", "abspath", "(", "execute_in", ")", "oldcwd", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "getcwd", "(", ")", ")", "if", "__name__", "[", "-", "12", ":", "]", "==", "'exec_command'", ":", "exec_dir", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "abspath", "(", "__file__", ")", ")", "elif", "os", ".", "path", ".", "isfile", "(", "'exec_command.py'", ")", ":", "exec_dir", "=", "os", ".", "path", ".", "abspath", "(", "'.'", ")", "else", ":", "exec_dir", "=", "os", ".", "path", ".", "abspath", "(", "sys", ".", "argv", "[", "0", "]", ")", "if", "os", ".", "path", ".", "isfile", "(", "exec_dir", ")", ":", "exec_dir", "=", "os", ".", "path", ".", "dirname", "(", "exec_dir", ")", "if", "oldcwd", "!=", "execute_in", ":", "os", ".", "chdir", "(", "execute_in", ")", "log", ".", "debug", "(", "'New cwd: %s'", "%", "execute_in", ")", "else", ":", "log", ".", "debug", "(", "'Retaining cwd: %s'", "%", "oldcwd", ")", "oldenv", "=", "_preserve_environment", "(", "list", "(", "env", ".", "keys", "(", ")", ")", ")", "_update_environment", "(", "*", "*", "env", ")", "try", ":", "# _exec_command is robust but slow, it relies on", "# usable sys.std*.fileno() descriptors. If they", "# are bad (like in win32 Idle, PyCrust environments)", "# then _exec_command_python (even slower)", "# will be used as a last resort.", "#", "# _exec_command_posix uses os.system and is faster", "# but not on all platforms os.system will return", "# a correct status.", "if", "(", "_with_python", "and", "_supports_fileno", "(", "sys", ".", "stdout", ")", "and", "sys", ".", "stdout", ".", "fileno", "(", ")", "==", "-", "1", ")", ":", "st", "=", "_exec_command_python", "(", "command", ",", "exec_command_dir", "=", "exec_dir", ",", "*", "*", "env", ")", "elif", "os", ".", "name", "==", "'posix'", ":", "st", "=", "_exec_command_posix", "(", "command", ",", "use_shell", "=", "use_shell", ",", "use_tee", "=", "use_tee", ",", "*", "*", "env", ")", "else", ":", "st", "=", "_exec_command", "(", "command", ",", "use_shell", "=", "use_shell", ",", "use_tee", "=", "use_tee", ",", "*", "*", "env", ")", "finally", ":", "if", "oldcwd", "!=", "execute_in", ":", "os", ".", "chdir", "(", "oldcwd", ")", "log", ".", "debug", "(", "'Restored cwd to %s'", "%", "oldcwd", ")", "_update_environment", "(", "*", "*", "oldenv", ")", "return", "st" ]

[ "This", "command", "allows", "access", "to", "the", "public", "area", "of", "a", "loaded", "object", "." ]

[ "def", "__init__", "(", "self", ",", "objectHandle", "=", "TPM_HANDLE", "(", ")", ")", ":", "self", ".", "objectHandle", "=", "objectHandle" ]

[ "Main", "function" ]

[ "def", "main", "(", ")", ":", "node", "=", "cyber", ".", "Node", "(", "\"data_collector\"", ")", "data_collector", "=", "DataCollector", "(", "node", ")", "plotter", "=", "Plotter", "(", ")", "node", ".", "create_reader", "(", "'/apollo/localization/pose'", ",", "localization_pb2", ".", "LocalizationEstimate", ",", "data_collector", ".", "callback_localization", ")", "node", ".", "create_reader", "(", "'/apollo/canbus/chassis'", ",", "chassis_pb2", ".", "Chassis", ",", "data_collector", ".", "callback_canbus", ")", "print", "(", "'Enter q to quit.'", ")", "print", "(", "'Enter p to plot result from last run.'", ")", "print", "(", "'Enter x to remove result from last run.'", ")", "print", "(", "'Enter x y z, where x is acceleration command, '", "+", "'y is speed limit, z is decceleration command.'", ")", "print", "(", "'Positive number for throttle and negative number for brake.'", ")", "while", "True", ":", "cmd", "=", "input", "(", "\"Enter commands: \"", ")", ".", "split", "(", ")", "if", "len", "(", "cmd", ")", "==", "0", ":", "print", "(", "'Quiting.'", ")", "break", "elif", "len", "(", "cmd", ")", "==", "1", ":", "if", "cmd", "[", "0", "]", "==", "\"q\"", ":", "break", "elif", "cmd", "[", "0", "]", "==", "\"p\"", ":", "print", "(", "'Plotting result.'", ")", "if", "os", ".", "path", ".", "exists", "(", "data_collector", ".", "outfile", ")", ":", "plotter", ".", "process_data", "(", "data_collector", ".", "outfile", ")", "plotter", ".", "plot_result", "(", ")", "else", ":", "print", "(", "'File does not exist: %s'", "%", "data_collector", ".", "outfile", ")", "elif", "cmd", "[", "0", "]", "==", "\"x\"", ":", "print", "(", "'Removing last result.'", ")", "if", "os", ".", "path", ".", "exists", "(", "data_collector", ".", "outfile", ")", ":", "os", ".", "remove", "(", "data_collector", ".", "outfile", ")", "else", ":", "print", "(", "'File does not exist: %s'", "%", "date_collector", ".", "outfile", ")", "elif", "len", "(", "cmd", ")", "==", "3", ":", "data_collector", ".", "run", "(", "cmd", ")" ]

[ "A", "wrapper", "around", "CommandHandlerRegistry", ".", "register_command_handler", "()", "." ]

[ "def", "register_command_handler", "(", "self", ",", "prefix", ",", "handler", ",", "help_info", ",", "prefix_aliases", "=", "None", ")", ":", "self", ".", "_command_handler_registry", ".", "register_command_handler", "(", "prefix", ",", "handler", ",", "help_info", ",", "prefix_aliases", "=", "prefix_aliases", ")", "self", ".", "_tab_completion_registry", ".", "extend_comp_items", "(", "\"\"", ",", "[", "prefix", "]", ")", "if", "prefix_aliases", ":", "self", ".", "_tab_completion_registry", ".", "extend_comp_items", "(", "\"\"", ",", "prefix_aliases", ")" ]

[ "Check", "a", "TLSConnection", "." ]

[ "def", "__call__", "(", "self", ",", "connection", ")", ":", "if", "not", "self", ".", "checkResumedSession", "and", "connection", ".", "resumed", ":", "return", "if", "self", ".", "cryptoID", "or", "self", ".", "x509Fingerprint", "or", "self", ".", "x509TrustList", ":", "if", "connection", ".", "_client", ":", "chain", "=", "connection", ".", "session", ".", "serverCertChain", "else", ":", "chain", "=", "connection", ".", "session", ".", "clientCertChain", "if", "self", ".", "x509Fingerprint", "or", "self", ".", "x509TrustList", ":", "if", "isinstance", "(", "chain", ",", "X509CertChain", ")", ":", "if", "self", ".", "x509Fingerprint", ":", "if", "chain", ".", "getFingerprint", "(", ")", "!=", "self", ".", "x509Fingerprint", ":", "raise", "TLSFingerprintError", "(", "\"X.509 fingerprint mismatch: %s, %s\"", "%", "(", "chain", ".", "getFingerprint", "(", ")", ",", "self", ".", "x509Fingerprint", ")", ")", "else", ":", "#self.x509TrustList", "if", "not", "chain", ".", "validate", "(", "self", ".", "x509TrustList", ")", ":", "raise", "TLSValidationError", "(", "\"X.509 validation failure\"", ")", "if", "self", ".", "x509CommonName", "and", "(", "chain", ".", "getCommonName", "(", ")", "!=", "self", ".", "x509CommonName", ")", ":", "raise", "TLSAuthorizationError", "(", "\"X.509 Common Name mismatch: %s, %s\"", "%", "(", "chain", ".", "getCommonName", "(", ")", ",", "self", ".", "x509CommonName", ")", ")", "elif", "chain", ":", "raise", "TLSAuthenticationTypeError", "(", ")", "else", ":", "raise", "TLSNoAuthenticationError", "(", ")", "elif", "self", ".", "cryptoID", ":", "import", "cryptoIDlib", ".", "CertChain", "if", "isinstance", "(", "chain", ",", "cryptoIDlib", ".", "CertChain", ".", "CertChain", ")", ":", "if", "chain", ".", "cryptoID", "!=", "self", ".", "cryptoID", ":", "raise", "TLSFingerprintError", "(", "\"cryptoID mismatch: %s, %s\"", "%", "(", "chain", ".", "cryptoID", ",", "self", ".", "cryptoID", ")", ")", "if", "self", ".", "protocol", ":", "if", "not", "chain", ".", "checkProtocol", "(", "self", ".", "protocol", ")", ":", "raise", "TLSAuthorizationError", "(", "\"cryptoID protocol mismatch\"", ")", "if", "not", "chain", ".", "validate", "(", ")", ":", "raise", "TLSValidationError", "(", "\"cryptoID validation failure\"", ")", "elif", "chain", ":", "raise", "TLSAuthenticationTypeError", "(", ")", "else", ":", "raise", "TLSNoAuthenticationError", "(", ")" ]

[ "Extracts", "trace", "results", "from", "the", "output", "." ]

[ "def", "ConsumeOutput", "(", "self", ",", "output", ",", "result_tracker", ")", ":", "result", "=", "None", "stddev", "=", "None", "try", ":", "result", "=", "float", "(", "re", ".", "search", "(", "self", ".", "results_regexp", ",", "output", ".", "stdout", ",", "re", ".", "M", ")", ".", "group", "(", "1", ")", ")", "except", "ValueError", ":", "result_tracker", ".", "AddError", "(", "'Regexp \"%s\" returned a non-numeric for test %s.'", "%", "(", "self", ".", "results_regexp", ",", "self", ".", "name", ")", ")", "except", ":", "result_tracker", ".", "AddError", "(", "'Regexp \"%s\" did not match for test %s.'", "%", "(", "self", ".", "results_regexp", ",", "self", ".", "name", ")", ")", "try", ":", "if", "self", ".", "stddev_regexp", ":", "if", "result_tracker", ".", "TraceHasStdDev", "(", "self", ")", ":", "result_tracker", ".", "AddError", "(", "'Test %s should only run once since a stddev is provided by the '", "'test.'", "%", "self", ".", "name", ")", "stddev", "=", "re", ".", "search", "(", "self", ".", "stddev_regexp", ",", "output", ".", "stdout", ",", "re", ".", "M", ")", ".", "group", "(", "1", ")", "except", ":", "result_tracker", ".", "AddError", "(", "'Regexp \"%s\" did not match for test %s.'", "%", "(", "self", ".", "stddev_regexp", ",", "self", ".", "name", ")", ")", "if", "result", ":", "result_tracker", ".", "AddTraceResult", "(", "self", ",", "result", ",", "stddev", ")", "return", "result" ]

[ "Check", "whether", "the", "MSR", "/", "dev", "files", "have", "the", "right", "permissions", "." ]

[ "def", "_CheckMsrDevNodes", "(", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "MSR_DEV_FILE_PATH", ")", ":", "print", "'Error: %s does not exist.'", "%", "MSR_DEV_FILE_PATH", "return", "False", "if", "not", "os", ".", "access", "(", "MSR_DEV_FILE_PATH", ",", "os", ".", "R_OK", ")", ":", "print", "'Error: Cannot read from %s'", "%", "MSR_DEV_FILE_PATH", "return", "False", "return", "True" ]

[ "Construct", "Slurm", "batch", "script", "manager", "." ]

[ "def", "__init__", "(", "self", ",", "script_file", "=", "None", ",", "work_dir", "=", "os", ".", "getcwd", "(", ")", ",", "nodes", "=", "1", ",", "procs_per_node", "=", "1", ",", "time_limit", "=", "None", ",", "job_name", "=", "None", ",", "partition", "=", "None", ",", "account", "=", "None", ",", "launcher", "=", "'srun'", ",", "launcher_args", "=", "[", "]", ",", "interpreter", "=", "'/bin/bash'", ")", ":", "super", "(", ")", ".", "__init__", "(", "script_file", "=", "script_file", ",", "work_dir", "=", "work_dir", ",", "interpreter", "=", "interpreter", ")", "self", ".", "nodes", "=", "nodes", "self", ".", "procs_per_node", "=", "procs_per_node", "self", ".", "time_limit", "=", "time_limit", "self", ".", "job_name", "=", "job_name", "self", ".", "partition", "=", "partition", "self", ".", "account", "=", "account", "self", ".", "launcher", "=", "launcher", "self", ".", "launcher_args", "=", "launcher_args", "# Configure header with Slurm job options", "self", ".", "add_header_line", "(", "f'#SBATCH --chdir={self.work_dir}'", ")", "self", ".", "add_header_line", "(", "f'#SBATCH --output={self.out_log_file}'", ")", "self", ".", "add_header_line", "(", "f'#SBATCH --error={self.err_log_file}'", ")", "self", ".", "add_header_line", "(", "f'#SBATCH --nodes={self.nodes}'", ")", "self", ".", "add_header_line", "(", "f'#SBATCH --ntasks={self.nodes * self.procs_per_node}'", ")", "self", ".", "add_header_line", "(", "f'#SBATCH --ntasks-per-node={self.procs_per_node}'", ")", "if", "self", ".", "time_limit", "is", "not", "None", ":", "self", ".", "add_header_line", "(", "f'#SBATCH --time={_time_string(self.time_limit)}'", ")", "if", "self", ".", "job_name", ":", "self", ".", "add_header_line", "(", "f'#SBATCH --job-name={self.job_name}'", ")", "if", "self", ".", "partition", ":", "self", ".", "add_header_line", "(", "f'#SBATCH --partition={self.partition}'", ")", "if", "self", ".", "account", ":", "self", ".", "add_header_line", "(", "f'#SBATCH --account={self.account}'", ")", "for", "arg", "in", "self", ".", "launcher_args", ":", "self", ".", "add_header_line", "(", "f'#SBATCH {arg}'", ")" ]

[ "SetFoldMarginHiColour", "(", "self", "bool", "useSetting", "Colour", "fore", ")" ]

[ "def", "SetFoldMarginHiColour", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetFoldMarginHiColour", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "the", "full", "path", "to", "a", "program", ";", "None", "otherwise", "." ]

[ "def", "which", "(", "program", ")", ":", "fpath", ",", "fname", "=", "os", ".", "path", ".", "split", "(", "program", ")", "if", "fpath", ":", "if", "is_exe", "(", "program", ")", ":", "return", "program", "else", ":", "for", "path", "in", "os", ".", "environ", "[", "\"PATH\"", "]", ".", "split", "(", "os", ".", "pathsep", ")", ":", "exe_file", "=", "os", ".", "path", ".", "join", "(", "path", ",", "program", ")", "if", "is_exe", "(", "exe_file", ")", ":", "return", "exe_file", "return", "None" ]

[ "Get", "an", "iterable", "object", "providing", "all", "the", "CompileCommands", "available", "to", "build", "filename", ".", "Returns", "None", "if", "filename", "is", "not", "found", "in", "the", "database", "." ]

[ "def", "getCompileCommands", "(", "self", ",", "filename", ")", ":", "return", "conf", ".", "lib", ".", "clang_CompilationDatabase_getCompileCommands", "(", "self", ",", "filename", ")" ]

[ "StyleSetBackground", "(", "self", "int", "style", "Colour", "back", ")" ]

[ "def", "StyleSetBackground", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_StyleSetBackground", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Const", ":", "CONST", "ConstType", "IDENTIFIER", "EQUALS", "ConstValue", "SEMICOLON" ]

[ "def", "p_Const", "(", "self", ",", "p", ")", ":", "location", "=", "self", ".", "getLocation", "(", "p", ",", "1", ")", "type", "=", "p", "[", "2", "]", "identifier", "=", "IDLUnresolvedIdentifier", "(", "self", ".", "getLocation", "(", "p", ",", "3", ")", ",", "p", "[", "3", "]", ")", "value", "=", "p", "[", "5", "]", "p", "[", "0", "]", "=", "IDLConst", "(", "location", ",", "identifier", ",", "type", ",", "value", ")" ]

[ "Creation", "of", "a", "new", "child", "element", "added", "at", "the", "end", "of" ]

[ "def", "newTextChild", "(", "self", ",", "ns", ",", "name", ",", "content", ")", ":", "if", "ns", "is", "None", ":", "ns__o", "=", "None", "else", ":", "ns__o", "=", "ns", ".", "_o", "ret", "=", "libxml2mod", ".", "xmlNewTextChild", "(", "self", ".", "_o", ",", "ns__o", ",", "name", ",", "content", ")", "if", "ret", "is", "None", ":", "raise", "treeError", "(", "'xmlNewTextChild() failed'", ")", "__tmp", "=", "xmlNode", "(", "_obj", "=", "ret", ")", "return", "__tmp" ]

[ "Return", "true", "if", "the", "token", "requires", "a", "split", "before", "it", "." ]

[ "def", "must_split", "(", "self", ")", ":", "return", "pytree_utils", ".", "GetNodeAnnotation", "(", "self", ".", "node", ",", "pytree_utils", ".", "Annotation", ".", "MUST_SPLIT", ")" ]

[ "Sets", "the", "module", "s", "verbosity", "and", "returns", "the", "previous", "setting", "." ]

[ "def", "SetVerboseLevel", "(", "self", ",", "level", ")", ":", "last_verbose_level", "=", "self", ".", "verbose_level", "self", ".", "verbose_level", "=", "level", "return", "last_verbose_level" ]

[ "r", "/", "\\", "*", "(", ".", "|", "\\", "n", ")", "*", "?", "\\", "*", "/" ]

[ "def", "t_COMMENT", "(", "t", ")", ":", "t", ".", "lexer", ".", "lineno", "+=", "t", ".", "value", ".", "count", "(", "'\\n'", ")", "if", "Search", "(", "r\"/\\*\\*\\s\"", ",", "t", ".", "value", ")", ":", "t", ".", "additional", "=", "'DOXYGEN'", "return", "t" ]

[ "Configuration", "for", "g", "++" ]

[ "def", "configure", "(", "conf", ")", ":", "conf", ".", "find_gxx", "(", ")", "conf", ".", "find_ar", "(", ")", "conf", ".", "gxx_common_flags", "(", ")", "conf", ".", "gxx_modifier_platform", "(", ")", "conf", ".", "cxx_load_tools", "(", ")", "conf", ".", "cxx_add_flags", "(", ")", "conf", ".", "link_add_flags", "(", ")" ]

[ "to", "make", "robot", "turn", "target_radian", "radians", ":", "param", ":", "target_radian", ":", "the", "target", "radian", "that", "robot", "needs", "to", "turn", ":", "type", ":", "float", ":", "return", ":" ]

[ "def", "turn_to_target", "(", "self", ",", "radian_to_turn", "=", "0.0", ")", ":", "# the range of yaw of odom is -pi ~ pi, we transform it to 0 ~ 2*pi", "robot_start_yaw", "=", "(", "self", ".", "__get_robot_pos", "(", ")", "+", "math", ".", "pi", "*", "2", ")", "%", "(", "math", ".", "pi", "*", "2", ")", "# to avoid the radian_to_turn value is bigger than 2*pi or less than -2*pi", "target_yaw", "=", "math", ".", "copysign", "(", "math", ".", "fabs", "(", "radian_to_turn", ")", "%", "(", "math", ".", "pi", "*", "2", ")", ",", "radian_to_turn", ")", "+", "robot_start_yaw", "# to transform the range", "target_yaw", "=", "(", "target_yaw", "+", "math", ".", "pi", "*", "2", ")", "%", "(", "math", ".", "pi", "*", "2", ")", "# to find the shortest direction to turn", "radian_to_move", "=", "target_yaw", "-", "robot_start_yaw", "if", "radian_to_move", "<", "-", "math", ".", "pi", "or", "math", ".", "pi", "<", "radian_to_move", ":", "direction", "=", "1", "if", "radian_to_move", "<", "-", "math", ".", "pi", "else", "-", "1", "else", ":", "direction", "=", "1", "if", "radian_to_move", ">", "0", "else", "-", "1", "self", ".", "brake", "(", ")", "# to stop robot first", "rospy", ".", "logdebug", "(", "\"****************************************************************************\"", ")", "rospy", ".", "logdebug", "(", "\"the robot's Yaw = %f, try to turn to Yaw = %f, the direction = %d\"", "%", "(", "robot_start_yaw", ",", "target_yaw", ",", "direction", ")", ")", "rospy", ".", "logdebug", "(", "\"****************************************************************************\"", ")", "while", "self", ".", "__is_robot_arrived", "(", "target_yaw", ")", "is", "not", "True", ":", "self", ".", "__turn_robot", "(", "turn_direction", "=", "direction", ")", "self", ".", "rate", ".", "sleep", "(", ")", "self", ".", "brake", "(", ")", "rospy", ".", "loginfo", "(", "'arrived the target radian!'", ")" ]