Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Return", "homogeneous", "rotation", "matrix", "from", "Euler", "angles", "and", "axis", "sequence", "." ]

[ "def", "euler_matrix", "(", "ai", ",", "aj", ",", "ak", ",", "axes", "=", "'sxyz'", ")", ":", "try", ":", "firstaxis", ",", "parity", ",", "repetition", ",", "frame", "=", "_AXES2TUPLE", "[", "axes", "]", "except", "(", "AttributeError", ",", "KeyError", ")", ":", "_", "=", "_TUPLE2AXES", "[", "axes", "]", "firstaxis", ",", "parity", ",", "repetition", ",", "frame", "=", "axes", "i", "=", "firstaxis", "j", "=", "_NEXT_AXIS", "[", "i", "+", "parity", "]", "k", "=", "_NEXT_AXIS", "[", "i", "-", "parity", "+", "1", "]", "if", "frame", ":", "ai", ",", "ak", "=", "ak", ",", "ai", "if", "parity", ":", "ai", ",", "aj", ",", "ak", "=", "-", "ai", ",", "-", "aj", ",", "-", "ak", "si", ",", "sj", ",", "sk", "=", "math", ".", "sin", "(", "ai", ")", ",", "math", ".", "sin", "(", "aj", ")", ",", "math", ".", "sin", "(", "ak", ")", "ci", ",", "cj", ",", "ck", "=", "math", ".", "cos", "(", "ai", ")", ",", "math", ".", "cos", "(", "aj", ")", ",", "math", ".", "cos", "(", "ak", ")", "cc", ",", "cs", "=", "ci", "*", "ck", ",", "ci", "*", "sk", "sc", ",", "ss", "=", "si", "*", "ck", ",", "si", "*", "sk", "M", "=", "numpy", ".", "identity", "(", "4", ")", "if", "repetition", ":", "M", "[", "i", ",", "i", "]", "=", "cj", "M", "[", "i", ",", "j", "]", "=", "sj", "*", "si", "M", "[", "i", ",", "k", "]", "=", "sj", "*", "ci", "M", "[", "j", ",", "i", "]", "=", "sj", "*", "sk", "M", "[", "j", ",", "j", "]", "=", "-", "cj", "*", "ss", "+", "cc", "M", "[", "j", ",", "k", "]", "=", "-", "cj", "*", "cs", "-", "sc", "M", "[", "k", ",", "i", "]", "=", "-", "sj", "*", "ck", "M", "[", "k", ",", "j", "]", "=", "cj", "*", "sc", "+", "cs", "M", "[", "k", ",", "k", "]", "=", "cj", "*", "cc", "-", "ss", "else", ":", "M", "[", "i", ",", "i", "]", "=", "cj", "*", "ck", "M", "[", "i", ",", "j", "]", "=", "sj", "*", "sc", "-", "cs", "M", "[", "i", ",", "k", "]", "=", "sj", "*", "cc", "+", "ss", "M", "[", "j", ",", "i", "]", "=", "cj", "*", "sk", "M", "[", "j", ",", "j", "]", "=", "sj", "*", "ss", "+", "cc", "M", "[", "j", ",", "k", "]", "=", "sj", "*", "cs", "-", "sc", "M", "[", "k", ",", "i", "]", "=", "-", "sj", "M", "[", "k", ",", "j", "]", "=", "cj", "*", "si", "M", "[", "k", ",", "k", "]", "=", "cj", "*", "ci", "return", "M" ]

[ "Checks", "rules", "from", "the", "C", "++", "style", "rules", "section", "of", "cppguide", ".", "html", "." ]

[ "def", "CheckStyle", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "file_extension", ",", "nesting_state", ",", "error", ")", ":", "# Don't use \"elided\" lines here, otherwise we can't check commented lines.", "# Don't want to use \"raw\" either, because we don't want to check inside C++11", "# raw strings,", "raw_lines", "=", "clean_lines", ".", "lines_without_raw_strings", "line", "=", "raw_lines", "[", "linenum", "]", "prev", "=", "raw_lines", "[", "linenum", "-", "1", "]", "if", "linenum", ">", "0", "else", "''", "if", "line", ".", "find", "(", "'\\t'", ")", "!=", "-", "1", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/tab'", ",", "1", ",", "'Tab found; better to use spaces'", ")", "# One or three blank spaces at the beginning of the line is weird; it's", "# hard to reconcile that with 2-space indents.", "# NOTE: here are the conditions rob pike used for his tests. Mine aren't", "# as sophisticated, but it may be worth becoming so: RLENGTH==initial_spaces", "# if(RLENGTH > 20) complain = 0;", "# if(match($0, \" +(error|private|public|protected):\")) complain = 0;", "# if(match(prev, \"&& *$\")) complain = 0;", "# if(match(prev, \"\\\\|\\\\| *$\")) complain = 0;", "# if(match(prev, \"[\\\",=><] *$\")) complain = 0;", "# if(match($0, \" <<\")) complain = 0;", "# if(match(prev, \" +for \\\\(\")) complain = 0;", "# if(prevodd && match(prevprev, \" +for \\\\(\")) complain = 0;", "scope_or_label_pattern", "=", "r'\\s*\\w+\\s*:\\s*\\\\?$'", "classinfo", "=", "nesting_state", ".", "InnermostClass", "(", ")", "initial_spaces", "=", "0", "cleansed_line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "while", "initial_spaces", "<", "len", "(", "line", ")", "and", "line", "[", "initial_spaces", "]", "==", "' '", ":", "initial_spaces", "+=", "1", "# There are certain situations we allow one space, notably for", "# section labels, and also lines containing multi-line raw strings.", "# We also don't check for lines that look like continuation lines", "# (of lines ending in double quotes, commas, equals, or angle brackets)", "# because the rules for how to indent those are non-trivial.", "if", "(", "not", "Search", "(", "r'[\",=><] *$'", ",", "prev", ")", "and", "(", "initial_spaces", "==", "1", "or", "initial_spaces", "==", "3", ")", "and", "not", "Match", "(", "scope_or_label_pattern", ",", "cleansed_line", ")", "and", "not", "(", "clean_lines", ".", "raw_lines", "[", "linenum", "]", "!=", "line", "and", "Match", "(", "r'^\\s*\"\"'", ",", "line", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/indent'", ",", "3", ",", "'Weird number of spaces at line-start. '", "'Are you using a 2-space indent?'", ")", "if", "line", "and", "line", "[", "-", "1", "]", ".", "isspace", "(", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/end_of_line'", ",", "4", ",", "'Line ends in whitespace. Consider deleting these extra spaces.'", ")", "# Check if the line is a header guard.", "is_header_guard", "=", "False", "if", "IsHeaderExtension", "(", "file_extension", ")", ":", "cppvar", "=", "GetHeaderGuardCPPVariable", "(", "filename", ")", "if", "(", "line", ".", "startswith", "(", "'#ifndef %s'", "%", "cppvar", ")", "or", "line", ".", "startswith", "(", "'#define %s'", "%", "cppvar", ")", "or", "line", ".", "startswith", "(", "'#endif // %s'", "%", "cppvar", ")", ")", ":", "is_header_guard", "=", "True", "# #include lines and header guards can be long, since there's no clean way to", "# split them.", "#", "# URLs can be long too. It's possible to split these, but it makes them", "# harder to cut&paste.", "#", "# The \"$Id:...$\" comment may also get very long without it being the", "# developers fault.", "if", "(", "not", "line", ".", "startswith", "(", "'#include'", ")", "and", "not", "is_header_guard", "and", "not", "Match", "(", "r'^\\s*//.*http(s?)://\\S*$'", ",", "line", ")", "and", "not", "Match", "(", "r'^\\s*//\\s*[^\\s]*$'", ",", "line", ")", "and", "not", "Match", "(", "r'^// \\$Id:.*#[0-9]+ \\$$'", ",", "line", ")", ")", ":", "line_width", "=", "GetLineWidth", "(", "line", ")", "if", "line_width", ">", "_line_length", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/line_length'", ",", "2", ",", "'Lines should be <= %i characters long'", "%", "_line_length", ")", "if", "(", "cleansed_line", ".", "count", "(", "';'", ")", ">", "1", "and", "# for loops are allowed two ;'s (and may run over two lines).", "cleansed_line", ".", "find", "(", "'for'", ")", "==", "-", "1", "and", "(", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", "[", "0", "]", ".", "find", "(", "'for'", ")", "==", "-", "1", "or", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", "[", "0", "]", ".", "find", "(", "';'", ")", "!=", "-", "1", ")", "and", "# It's ok to have many commands in a switch case that fits in 1 line", "not", "(", "(", "cleansed_line", ".", "find", "(", "'case '", ")", "!=", "-", "1", "or", "cleansed_line", ".", "find", "(", "'default:'", ")", "!=", "-", "1", ")", "and", "cleansed_line", ".", "find", "(", "'break;'", ")", "!=", "-", "1", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/newline'", ",", "0", ",", "'More than one command on the same line'", ")", "# Some more style checks", "CheckBraces", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckTrailingSemicolon", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckEmptyBlockBody", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", "CheckOperatorSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckParenthesisSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckCommaSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckBracesSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", "CheckSpacingForFunctionCall", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckCheck", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckAltTokens", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "classinfo", "=", "nesting_state", ".", "InnermostClass", "(", ")", "if", "classinfo", ":", "CheckSectionSpacing", "(", "filename", ",", "clean_lines", ",", "classinfo", ",", "linenum", ",", "error", ")" ]

[ "Gets", "the", "extension", "of", "the", "specified", "message", "with", "the", "specified", "number", "." ]

[ "def", "FindExtensionByNumber", "(", "self", ",", "message_descriptor", ",", "number", ")", ":", "try", ":", "return", "self", ".", "_extensions_by_number", "[", "message_descriptor", "]", "[", "number", "]", "except", "KeyError", ":", "self", ".", "_TryLoadExtensionFromDB", "(", "message_descriptor", ",", "number", ")", "return", "self", ".", "_extensions_by_number", "[", "message_descriptor", "]", "[", "number", "]" ]

[ "decode_stmt", ":", "FORMAT", "push_format_id", "LBRACE", "decode_stmt_list", "RBRACE" ]

[ "def", "p_decode_stmt_format", "(", "self", ",", "t", ")", ":", "# The format will be pushed on the stack when 'push_format_id'", "# is processed (see below). Once the parser has recognized", "# the full production (though the right brace), we're done", "# with the format, so now we can pop it.", "self", ".", "formatStack", ".", "pop", "(", ")", "t", "[", "0", "]", "=", "t", "[", "4", "]" ]

[ "Run", "any", "setup", "that", "requires", "mantid", "to", "have", "been", "initialized" ]

[ "def", "post_mantid_init", "(", "self", ")", ":", "self", ".", "redirect_python_warnings", "(", ")", "self", ".", "populate_menus", "(", ")", "self", ".", "algorithm_selector", ".", "refresh", "(", ")", "# turn on algorithm factory notifications", "from", "mantid", ".", "api", "import", "AlgorithmFactory", "algorithm_factory", "=", "AlgorithmFactory", ".", "Instance", "(", ")", "algorithm_factory", ".", "enableNotifications", "(", ")" ]

[ "The", "Indicator", "is", "constant", "if", "all", "constraints", "have", "constant", "args", "." ]

[ "def", "is_constant", "(", "self", ")", "->", "bool", ":", "all_args", "=", "sum", "(", "[", "c", ".", "args", "for", "c", "in", "self", ".", "args", "]", ",", "[", "]", ")", "return", "all", "(", "[", "arg", ".", "is_constant", "(", ")", "for", "arg", "in", "all_args", "]", ")" ]

[ "Initialize", "the", "widget", ".", ":", "param", "fit_context", ":", "A", "reference", "to", "the", "a", "FitContext", "object", "used", "to", "store", "fit", "results", ":", "param", "parent", ":", "A", "parent", "widget", "for", "the", "view" ]

[ "def", "__init__", "(", "self", ",", "fit_context", ",", "context", ",", "parent", ")", ":", "self", ".", "results_tab_view", "=", "ResultsTabView", "(", "parent", "=", "parent", ")", "self", ".", "results_tab_presenter", "=", "ResultsTabPresenter", "(", "self", ".", "results_tab_view", ",", "ResultsTabModel", "(", "fit_context", ",", "context", ".", "results_context", ")", ")", "context", ".", "update_view_from_model_notifier", ".", "add_subscriber", "(", "self", ".", "results_tab_presenter", ".", "update_view_from_model_observer", ")", "fit_context", ".", "fit_removed_notifier", ".", "add_subscriber", "(", "self", ".", "results_tab_presenter", ".", "new_fit_performed_observer", ")" ]

[ "Given", "a", "string", "returns", "an", "regex", "pattern", "to", "match", "that", "string", "." ]

[ "def", "_generate_pattern", "(", "self", ",", "text", ")", ":", "chars", "=", "list", "(", "text", ")", "for", "i", "in", "range", "(", "len", "(", "chars", ")", ")", ":", "chars", "[", "i", "]", "=", "r'[%s]'", "%", "chars", "[", "i", "]", "return", "r'(?P<abbr>\\b%s\\b)'", "%", "(", "r''", ".", "join", "(", "chars", ")", ")" ]

[ "GetCsFromBf", "(", "char", "*", "Bf", "int", "const", "&", "BfL", ")", "-", ">", "TCs" ]

[ "def", "GetCsFromBf", "(", "*", "args", ")", ":", "return", "_snap", ".", "TCs_GetCsFromBf", "(", "*", "args", ")" ]

[ "Calls", "tokeniter", "+", "tokenize", "and", "wraps", "it", "in", "a", "token", "stream", "." ]

[ "def", "tokenize", "(", "self", ",", "source", ",", "name", "=", "None", ",", "filename", "=", "None", ",", "state", "=", "None", ")", ":", "stream", "=", "self", ".", "tokeniter", "(", "source", ",", "name", ",", "filename", ",", "state", ")", "return", "TokenStream", "(", "self", ".", "wrap", "(", "stream", ",", "name", ",", "filename", ")", ",", "name", ",", "filename", ")" ]

[ "r", "Compute", "the", "cdf", "via", "the", "below", "formula", "where", "g", "is", "the", "exp", "bijector", "and", "P", "is", "the", "cdf", "of", "the", "underlying", "normal", "dist", "..", "math", "::", "Y", "=", "g", "(", "X", ")", "P", "(", "Y", "<", "=", "a", ")", "=", "P", "(", "X", "<", "=", "g^", "{", "-", "1", "}", "(", "a", "))" ]

[ "def", "_cdf", "(", "self", ",", "value", ",", "loc", "=", "None", ",", "scale", "=", "None", ")", ":", "mean", ",", "sd", "=", "self", ".", "_check_param_type", "(", "loc", ",", "scale", ")", "inverse_value", "=", "self", ".", "bijector", "(", "\"inverse\"", ",", "value", ")", "cdf", "=", "self", ".", "distribution", "(", "\"cdf\"", ",", "inverse_value", ",", "mean", ",", "sd", ")", "# to increase numerical stability, set cdf = 0 when value <= 0", "zeros", "=", "self", ".", "fill", "(", "self", ".", "dtypeop", "(", "cdf", ")", ",", "self", ".", "shape", "(", "cdf", ")", ",", "0.0", ")", "return", "self", ".", "select", "(", "self", ".", "greater", "(", "value", ",", "0.", ")", ",", "cdf", ",", "zeros", ")" ]

[ "Decorator", "for", "command", "entry", "methods", "." ]

[ "def", "command_entry_point", "(", "function", ")", ":", "@", "functools", ".", "wraps", "(", "function", ")", "def", "wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\" Do housekeeping tasks and execute the wrapped method. \"\"\"", "try", ":", "logging", ".", "basicConfig", "(", "format", "=", "'%(name)s: %(message)s'", ",", "level", "=", "logging", ".", "WARNING", ",", "stream", "=", "sys", ".", "stdout", ")", "# This hack to get the executable name as %(name).", "logging", ".", "getLogger", "(", ")", ".", "name", "=", "os", ".", "path", ".", "basename", "(", "sys", ".", "argv", "[", "0", "]", ")", "return", "function", "(", "*", "args", ",", "*", "*", "kwargs", ")", "except", "KeyboardInterrupt", ":", "logging", ".", "warning", "(", "'Keyboard interrupt'", ")", "return", "130", "# Signal received exit code for bash.", "except", "Exception", ":", "logging", ".", "exception", "(", "'Internal error.'", ")", "if", "logging", ".", "getLogger", "(", ")", ".", "isEnabledFor", "(", "logging", ".", "DEBUG", ")", ":", "logging", ".", "error", "(", "\"Please report this bug and attach the output \"", "\"to the bug report\"", ")", "else", ":", "logging", ".", "error", "(", "\"Please run this command again and turn on \"", "\"verbose mode (add '-vvvv' as argument).\"", ")", "return", "64", "# Some non used exit code for internal errors.", "finally", ":", "logging", ".", "shutdown", "(", ")", "return", "wrapper" ]

[ "Given", "input_path", "returns", "a", "tuple", "with", "sourceTree", "and", "path", "values", "." ]

[ "def", "SourceTreeAndPathFromPath", "(", "input_path", ")", ":", "source_group_match", "=", "_path_leading_variable", ".", "match", "(", "input_path", ")", "if", "source_group_match", ":", "source_tree", "=", "source_group_match", ".", "group", "(", "1", ")", "output_path", "=", "source_group_match", ".", "group", "(", "3", ")", "# This may be None.", "else", ":", "source_tree", "=", "None", "output_path", "=", "input_path", "return", "(", "source_tree", ",", "output_path", ")" ]

[ "Inserts", "the", "item", "at", "the", "specified", "position", ".", "Similar", "to", "list", ".", "insert", "()", "." ]

[ "def", "insert", "(", "self", ",", "key", ",", "value", ")", ":", "self", ".", "_type_checker", ".", "CheckValue", "(", "value", ")", "self", ".", "_values", ".", "insert", "(", "key", ",", "value", ")", "if", "not", "self", ".", "_message_listener", ".", "dirty", ":", "self", ".", "_message_listener", ".", "Modified", "(", ")" ]

[ "Returns", "a", "Python", "property", "for", "the", "given", "repeated", "composite", "field", "." ]

[ "def", "RepeatedCompositeProperty", "(", "cdescriptor", ",", "message_type", ")", ":", "def", "Getter", "(", "self", ")", ":", "container", "=", "self", ".", "_composite_fields", ".", "get", "(", "cdescriptor", ".", "name", ",", "None", ")", "if", "container", "is", "None", ":", "container", "=", "RepeatedCompositeContainer", "(", "self", ",", "cdescriptor", ",", "message_type", ".", "_concrete_class", ")", "self", ".", "_composite_fields", "[", "cdescriptor", ".", "name", "]", "=", "container", "return", "container", "def", "Setter", "(", "self", ",", "new_value", ")", ":", "raise", "AttributeError", "(", "'Assignment not allowed to repeated field '", "'\"%s\" in protocol message object.'", "%", "cdescriptor", ".", "name", ")", "doc", "=", "'Magic attribute generated for \"%s\" proto field.'", "%", "cdescriptor", ".", "name", "return", "property", "(", "Getter", ",", "Setter", ",", "doc", "=", "doc", ")" ]

[ "Create", "(", "self", "Wizard", "parent", "Bitmap", "bitmap", "=", "wxNullBitmap", ")", "-", ">", "bool" ]

[ "def", "Create", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_wizard", ".", "PyWizardPage_Create", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

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

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

[ "Verification", "based", "on", "notebook", "name" ]

[ "def", "verify_notebook_name", "(", "notebook_name", ":", "str", ")", "->", "bool", ":", "return", "notebook_name", "[", ":", "3", "]", ".", "isdigit", "(", ")", "and", "notebook_name", "[", "-", "4", ":", "]", "==", "\".rst\"" ]

[ "Encode", "a", "sequence", "of", "character", "/", "output", "classes", "into", "a", "sequence", "of", "labels", ".", "Characters", "are", "assumed", "to", "always", "take", "a", "single", "Unicode", "codepoint", ".", "Characters", "must", "be", "in", "the", "alphabet", "this", "method", "will", "assert", "that", ".", "Use", "CanEncode", "and", "CanEncodeSingle", "to", "test", "." ]

[ "def", "Encode", "(", "self", ",", "input", ")", ":", "# Convert SWIG's UnsignedIntVec to a Python list", "res", "=", "super", "(", "UTF8Alphabet", ",", "self", ")", ".", "Encode", "(", "input", ".", "encode", "(", "'utf-8'", ")", ")", "return", "[", "el", "for", "el", "in", "res", "]" ]

[ "CmpI", "(", "TStr", "self", "TStr", "Str", ")", "-", ">", "int" ]

[ "def", "CmpI", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TStr_CmpI", "(", "self", ",", "*", "args", ")" ]

[ "Infers", "control", "flow", "through", "assert", "operation", "node", ".", "It", "marks", "output", "data", "nodes", "executability", "according", "to", "executability", "of", "current", "node", "and", "assert", "data", "value", ":", "param", "node", ":", "Node", "instance", "to", "infer", "control", "flow", "through", ":", "param", "is_executable", ":", "if", "current", "node", "is", "executable", ":", "param", "mark_executability", ":", "function", "to", "mark", "executability", "of", "node" ]

[ "def", "assert_control_flow_infer", "(", "node", ":", "Node", ",", "is_executable", ":", "bool", ",", "mark_executability", ":", "callable", ")", ":", "graph", "=", "node", ".", "graph", "assert_value", "=", "node", ".", "out_node", "(", ")", ".", "value", "for", "n", "in", "[", "v", "for", "_", ",", "v", "in", "graph", ".", "out_edges", "(", "node", ".", "id", ")", "]", ":", "mark_executability", "(", "n", ",", "assert_value", "and", "is_executable", ")" ]

[ "Multiplies", "matrix", "a", "by", "matrix", "b", "producing", "a", "*", "b", "." ]

[ "def", "matmul", "(", "a", ",", "b", ",", "transpose_a", "=", "False", ",", "transpose_b", "=", "False", ",", "adjoint_a", "=", "False", ",", "adjoint_b", "=", "False", ",", "a_is_sparse", "=", "False", ",", "b_is_sparse", "=", "False", ",", "output_type", "=", "None", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"MatMul\"", ",", "[", "a", ",", "b", "]", ")", "as", "name", ":", "if", "transpose_a", "and", "adjoint_a", ":", "raise", "ValueError", "(", "f\"Only one of `transpose_a` and `adjoint_a` can be True. \"", "f\"Received `transpose_a`={transpose_a}, \"", "f\"`adjoint_a`={adjoint_a}.\"", ")", "if", "transpose_b", "and", "adjoint_b", ":", "raise", "ValueError", "(", "f\"Only one of `transpose_b` and `adjoint_b` can be True. \"", "f\"Received `transpose_b`={transpose_b}, \"", "f\"`adjoint_b`={adjoint_b}.\"", ")", "if", "context", ".", "executing_eagerly", "(", ")", ":", "if", "not", "isinstance", "(", "a", ",", "(", "ops", ".", "EagerTensor", ",", "_resource_variable_type", ")", ")", ":", "a", "=", "ops", ".", "convert_to_tensor", "(", "a", ",", "name", "=", "\"a\"", ")", "if", "not", "isinstance", "(", "b", ",", "(", "ops", ".", "EagerTensor", ",", "_resource_variable_type", ")", ")", ":", "b", "=", "ops", ".", "convert_to_tensor", "(", "b", ",", "dtype_hint", "=", "a", ".", "dtype", ".", "base_dtype", ",", "name", "=", "\"b\"", ")", "else", ":", "a", "=", "ops", ".", "convert_to_tensor", "(", "a", ",", "name", "=", "\"a\"", ")", "b", "=", "ops", ".", "convert_to_tensor", "(", "b", ",", "dtype_hint", "=", "a", ".", "dtype", ".", "base_dtype", ",", "name", "=", "\"b\"", ")", "# TODO(apassos) remove _shape_tuple here when it is not needed.", "a_shape", "=", "a", ".", "_shape_tuple", "(", ")", "# pylint: disable=protected-access", "b_shape", "=", "b", ".", "_shape_tuple", "(", ")", "# pylint: disable=protected-access", "output_may_have_non_empty_batch_shape", "=", "(", "(", "a_shape", "is", "None", "or", "len", "(", "a_shape", ")", ">", "2", ")", "or", "(", "b_shape", "is", "None", "or", "len", "(", "b_shape", ")", ">", "2", ")", ")", "# TODO(b/178749687): remove this boolean and all related branches once the", "# bridges are ready.", "# batch_matmul_v3 is for when input type is different from output type.", "use_batch_matmul_v3", "=", "False", "if", "output_type", "and", "(", "output_type", "!=", "a", ".", "dtype", "or", "output_type", "!=", "b", ".", "dtype", ")", ":", "use_batch_matmul_v3", "=", "True", "if", "(", "not", "a_is_sparse", "and", "not", "b_is_sparse", ")", "and", "output_may_have_non_empty_batch_shape", ":", "# BatchMatmul does not support transpose, so we conjugate the matrix and", "# use adjoint instead. Conj() is a noop for real matrices.", "if", "transpose_a", ":", "a", "=", "conj", "(", "a", ")", "adjoint_a", "=", "True", "if", "transpose_b", ":", "b", "=", "conj", "(", "b", ")", "adjoint_b", "=", "True", "if", "use_batch_matmul_v3", ":", "return", "gen_math_ops", ".", "batch_mat_mul_v3", "(", "a", ",", "b", ",", "adj_x", "=", "adjoint_a", ",", "adj_y", "=", "adjoint_b", ",", "Tout", "=", "output_type", ",", "name", "=", "name", ")", "else", ":", "return", "gen_math_ops", ".", "batch_mat_mul_v2", "(", "a", ",", "b", ",", "adj_x", "=", "adjoint_a", ",", "adj_y", "=", "adjoint_b", ",", "name", "=", "name", ")", "# Neither matmul nor sparse_matmul support adjoint, so we conjugate", "# the matrix and use transpose instead. Conj() is a noop for real", "# matrices.", "if", "adjoint_a", ":", "a", "=", "conj", "(", "a", ")", "transpose_a", "=", "True", "if", "adjoint_b", ":", "b", "=", "conj", "(", "b", ")", "transpose_b", "=", "True", "use_sparse_matmul", "=", "False", "if", "a_is_sparse", "or", "b_is_sparse", ":", "sparse_matmul_types", "=", "[", "dtypes", ".", "bfloat16", ",", "dtypes", ".", "float32", "]", "use_sparse_matmul", "=", "(", "a", ".", "dtype", "in", "sparse_matmul_types", "and", "b", ".", "dtype", "in", "sparse_matmul_types", ")", "if", "(", "(", "(", "a", ".", "dtype", "==", "dtypes", ".", "bfloat16", "and", "b", ".", "dtype", "not", "in", "(", "dtypes", ".", "int8", ",", "dtypes", ".", "uint8", ")", ")", "or", "(", "b", ".", "dtype", "==", "dtypes", ".", "bfloat16", "and", "a", ".", "dtype", "not", "in", "(", "dtypes", ".", "int8", ",", "dtypes", ".", "uint8", ")", ")", ")", "and", "a", ".", "dtype", "!=", "b", ".", "dtype", ")", ":", "# matmul currently doesn't handle mixed-precision inputs other than", "# fp16 * int8 which is supported in BatchMatMulV3.", "use_sparse_matmul", "=", "True", "if", "use_sparse_matmul", ":", "ret", "=", "sparse_matmul", "(", "a", ",", "b", ",", "transpose_a", "=", "transpose_a", ",", "transpose_b", "=", "transpose_b", ",", "a_is_sparse", "=", "a_is_sparse", ",", "b_is_sparse", "=", "b_is_sparse", ",", "name", "=", "name", ")", "# sparse_matmul always returns float32, even with", "# bfloat16 inputs. This prevents us from configuring bfloat16 training.", "# casting to bfloat16 also matches non-sparse matmul behavior better.", "if", "a", ".", "dtype", "==", "dtypes", ".", "bfloat16", "and", "b", ".", "dtype", "==", "dtypes", ".", "bfloat16", ":", "ret", "=", "cast", "(", "ret", ",", "dtypes", ".", "bfloat16", ")", "return", "ret", "else", ":", "if", "use_batch_matmul_v3", ":", "adjoint_a", "=", "adjoint_a", "or", "transpose_a", "adjoint_b", "=", "adjoint_b", "or", "transpose_b", "return", "gen_math_ops", ".", "batch_mat_mul_v3", "(", "a", ",", "b", ",", "adj_x", "=", "adjoint_a", ",", "adj_y", "=", "adjoint_b", ",", "Tout", "=", "output_type", ",", "name", "=", "name", ")", "else", ":", "return", "gen_math_ops", ".", "mat_mul", "(", "a", ",", "b", ",", "transpose_a", "=", "transpose_a", ",", "transpose_b", "=", "transpose_b", ",", "name", "=", "name", ")" ]

[ "The", "function", "will", "return", "SparseTensor", "contained", "in", "this", "OrtValue" ]

[ "def", "as_sparse_tensor", "(", "self", ")", ":", "return", "SparseTensor", "(", "self", ".", "_ortvalue", ".", "as_sparse_tensor", "(", ")", ")" ]

[ "Returns", "a", "string", "describing", "the", "current", "Git", "HEAD", "version", "as", "descriptively", "as", "possible", "." ]

[ "def", "describe", "(", "directory", ")", ":", "try", ":", "# decode() is needed here for Python3 compatibility. In Python2,", "# str and bytes are the same type, but not in Python3.", "# Popen.communicate() returns a bytes instance, which needs to be", "# decoded into text data first in Python3. And this decode() won't", "# hurt Python2.", "return", "command_output", "(", "[", "'git'", ",", "'describe'", "]", ",", "directory", ")", ".", "rstrip", "(", ")", ".", "decode", "(", ")", "except", ":", "try", ":", "return", "command_output", "(", "[", "'git'", ",", "'rev-parse'", ",", "'HEAD'", "]", ",", "directory", ")", ".", "rstrip", "(", ")", ".", "decode", "(", ")", "except", ":", "# This is the fallback case where git gives us no information,", "# e.g. because the source tree might not be in a git tree.", "# In this case, usually use a timestamp. However, to ensure", "# reproducible builds, allow the builder to override the wall", "# clock time with environment variable SOURCE_DATE_EPOCH", "# containing a (presumably) fixed timestamp.", "timestamp", "=", "int", "(", "os", ".", "environ", ".", "get", "(", "'SOURCE_DATE_EPOCH'", ",", "time", ".", "time", "(", ")", ")", ")", "formatted", "=", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "timestamp", ")", ".", "isoformat", "(", ")", "return", "'unknown hash, {}'", ".", "format", "(", "formatted", ")" ]

[ "Process_comp_outline", "(", "doc", "comp_outline", "comp_height", ")", "-", ">", "part", "shape", "Create", "solid", "component", "shape", "base", "on", "its", "outline" ]

[ "def", "Process_comp_outline", "(", "doc", ",", "comp_outline", ",", "comp_height", ")", ":", "vertex_index", "=", "-", "1", "#presume no vertex", "out_shape", "=", "[", "]", "if", "comp_outline", "==", "[", "]", ":", "#force 0.2mm circle shape for components without place outline definition", "comp_outline", ".", "append", "(", "[", "0.0", ",", "0.0", ",", "0.0", "]", ")", "comp_outline", ".", "append", "(", "[", "0.1", ",", "0.0", ",", "360.0", "]", ")", "for", "point", "in", "comp_outline", ":", "vertex", "=", "Base", ".", "Vector", "(", "point", "[", "0", "]", ",", "point", "[", "1", "]", ",", "0", ")", "vertex_index", "+=", "1", "if", "vertex_index", ">", "0", ":", "if", "point", "[", "2", "]", "!=", "0", "and", "point", "[", "2", "]", "!=", "360", ":", "out_shape", ".", "append", "(", "Part", ".", "Arc", "(", "prev_vertex", ",", "mid_point", "(", "prev_vertex", ",", "vertex", ",", "point", "[", "2", "]", ")", ",", "vertex", ")", ")", "FreeCAD", ".", "Console", ".", "PrintMessage", "(", "\"mid point \"", "+", "str", "(", "mid_point", ")", "+", "\"\\n\"", ")", "elif", "point", "[", "2", "]", "==", "360", ":", "per_point", "=", "Per_point", "(", "prev_vertex", ",", "vertex", ")", "out_shape", ".", "append", "(", "Part", ".", "Arc", "(", "per_point", ",", "mid_point", "(", "per_point", ",", "vertex", ",", "point", "[", "2", "]", "/", "2", ")", ",", "vertex", ")", ")", "out_shape", ".", "append", "(", "Part", ".", "Arc", "(", "per_point", ",", "mid_point", "(", "per_point", ",", "vertex", ",", "-", "point", "[", "2", "]", "/", "2", ")", ",", "vertex", ")", ")", "else", ":", "out_shape", ".", "append", "(", "Part", ".", "LineSegment", "(", "prev_vertex", ",", "vertex", ")", ")", "prev_vertex", "=", "vertex", "out_shape", "=", "Part", ".", "Shape", "(", "out_shape", ")", "out_shape", "=", "Part", ".", "Wire", "(", "out_shape", ".", "Edges", ")", "out_shape", "=", "Part", ".", "Face", "(", "out_shape", ")", "out_shape", "=", "out_shape", ".", "extrude", "(", "Base", ".", "Vector", "(", "0", ",", "0", ",", "comp_height", ")", ")", "#Part.show(out_shape)", "return", "out_shape" ]

[ "Enables", "or", "disables", "the", "tool", "." ]

[ "def", "EnableTool", "(", "self", ",", "tool_id", ",", "state", ")", ":", "tool", "=", "self", ".", "FindTool", "(", "tool_id", ")", "if", "tool", ":", "if", "state", ":", "tool", ".", "state", "&=", "~", "AUI_BUTTON_STATE_DISABLED", "else", ":", "tool", ".", "state", "|=", "AUI_BUTTON_STATE_DISABLED" ]

[ "Builds", "a", "dictionary", "of", "all", "the", "messages", "available", "in", "a", "set", "of", "files", "." ]

[ "def", "GetMessages", "(", "file_protos", ")", ":", "result", "=", "{", "}", "for", "file_proto", "in", "file_protos", ":", "_DB", ".", "Add", "(", "file_proto", ")", "for", "file_proto", "in", "file_protos", ":", "for", "desc", "in", "_GetAllDescriptors", "(", "file_proto", ".", "message_type", ",", "file_proto", ".", "package", ")", ":", "result", "[", "desc", ".", "full_name", "]", "=", "_FACTORY", ".", "GetPrototype", "(", "desc", ")", "return", "result" ]

[ "Convenience", "function", ":", "sets", "the", "sampling", "bound", "and", "the", "space", "properties", "in", "one", "line", "." ]

[ "def", "setBounds", "(", "self", ",", "bound", ")", ":", "self", ".", "bound", "=", "bound", "self", ".", "properties", "[", "\"minimum\"", "]", "=", "[", "b", "[", "0", "]", "for", "b", "in", "bound", "]", "self", ".", "properties", "[", "\"maximum\"", "]", "=", "[", "b", "[", "1", "]", "for", "b", "in", "bound", "]", "volume", "=", "1", "for", "b", "in", "self", ".", "bound", ":", "if", "b", "[", "0", "]", "!=", "b", "[", "1", "]", ":", "volume", "*=", "b", "[", "1", "]", "-", "b", "[", "0", "]", "self", ".", "properties", "[", "'volume'", "]", "=", "volume" ]

[ "Verify", "the", "correct", "version", "request", "for", "this", "server", "." ]

[ "def", "_get_version", "(", "self", ",", "request", ")", ":", "try", ":", "version", "=", "request", ".", "get_parameter", "(", "'oauth_version'", ")", "except", ":", "version", "=", "VERSION", "if", "version", "and", "version", "!=", "self", ".", "version", ":", "raise", "Error", "(", "'OAuth version %s not supported.'", "%", "str", "(", "version", ")", ")", "return", "version" ]

[ "Parse", "a", "config", ".", "h", "-", "style", "file", "." ]

[ "def", "parse_config_h", "(", "fp", ",", "vars", "=", "None", ")", ":", "if", "vars", "is", "None", ":", "vars", "=", "{", "}", "import", "re", "define_rx", "=", "re", ".", "compile", "(", "\"#define ([A-Z][A-Za-z0-9_]+) (.*)\\n\"", ")", "undef_rx", "=", "re", ".", "compile", "(", "\"/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\\n\"", ")", "while", "True", ":", "line", "=", "fp", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "m", "=", "define_rx", ".", "match", "(", "line", ")", "if", "m", ":", "n", ",", "v", "=", "m", ".", "group", "(", "1", ",", "2", ")", "try", ":", "v", "=", "int", "(", "v", ")", "except", "ValueError", ":", "pass", "vars", "[", "n", "]", "=", "v", "else", ":", "m", "=", "undef_rx", ".", "match", "(", "line", ")", "if", "m", ":", "vars", "[", "m", ".", "group", "(", "1", ")", "]", "=", "0", "return", "vars" ]

[ "Helper", "which", "ensures", "that", "input", "is", "a", "non", "-", "negative", "int32", "scalar", "." ]

[ "def", "_assert_non_negative_int32_scalar", "(", "self", ",", "x", ")", ":", "x", "=", "ops", ".", "convert_to_tensor", "(", "x", ",", "name", "=", "\"x\"", ")", "if", "x", ".", "dtype", ".", "base_dtype", "!=", "dtypes", ".", "int32", ".", "base_dtype", ":", "raise", "TypeError", "(", "\"%s.dtype=%s is not %s\"", "%", "(", "x", ".", "name", ",", "x", ".", "dtype", ",", "dtypes", ".", "int32", ")", ")", "x_value_static", "=", "tensor_util", ".", "constant_value", "(", "x", ")", "if", "x", ".", "get_shape", "(", ")", ".", "ndims", "is", "not", "None", "and", "x_value_static", "is", "not", "None", ":", "if", "x", ".", "get_shape", "(", ")", ".", "ndims", "!=", "0", ":", "raise", "ValueError", "(", "\"%s.ndims=%d is not 0 (scalar)\"", "%", "(", "x", ".", "name", ",", "x", ".", "get_shape", "(", ")", ".", "ndims", ")", ")", "if", "x_value_static", "<", "0", ":", "raise", "ValueError", "(", "\"%s.value=%d cannot be negative\"", "%", "(", "x", ".", "name", ",", "x_value_static", ")", ")", "return", "x", "if", "self", ".", "validate_args", ":", "x", "=", "control_flow_ops", ".", "with_dependencies", "(", "[", "check_ops", ".", "assert_rank", "(", "x", ",", "0", ")", ",", "check_ops", ".", "assert_non_negative", "(", "x", ")", "]", ",", "x", ")", "return", "x" ]

[ "Computes", "embeddings", "from", "a", "list", "of", "goals", "." ]

[ "def", "_batch_goal_embedding", "(", "self", ",", "goals", ":", "List", "[", "Text", "]", ")", "->", "BATCH_GOAL_EMB_TYPE", ":", "pass" ]

[ "File", "base", "name", "-", "text", "after", "the", "final", "slash", "before", "the", "final", "period", "." ]

[ "def", "BaseName", "(", "self", ")", ":", "return", "self", ".", "Split", "(", ")", "[", "1", "]" ]

[ "Create", "and", "return", "a", "non", "-", "section", "node", "for", "the", "parse", "tree", "." ]

[ "def", "_make_interpolation_node", "(", "self", ",", "tag_type", ",", "tag_key", ",", "leading_whitespace", ")", ":", "# TODO: switch to using a dictionary instead of a bunch of ifs and elifs.", "if", "tag_type", "==", "'!'", ":", "return", "_CommentNode", "(", ")", "if", "tag_type", "==", "'='", ":", "delimiters", "=", "tag_key", ".", "split", "(", ")", "self", ".", "_change_delimiters", "(", "delimiters", ")", "return", "_ChangeNode", "(", "delimiters", ")", "if", "tag_type", "==", "''", ":", "return", "_EscapeNode", "(", "tag_key", ")", "if", "tag_type", "==", "'&'", ":", "return", "_LiteralNode", "(", "tag_key", ")", "if", "tag_type", "==", "'>'", ":", "return", "_PartialNode", "(", "tag_key", ",", "leading_whitespace", ")", "raise", "Exception", "(", "\"Invalid symbol for interpolation tag: %s\"", "%", "repr", "(", "tag_type", ")", ")" ]

[ "After", "layout", "permutation", "(", "shape", "change", "in", "data", "nodes", ")", "shape", "sub", "-", "graphs", "contain", "values", "in", "the", "old", "layout", "To", "change", "that", "we", "execute", "full", "partial", "inference", "on", "the", "shape", "-", "of", "sub", "-", "graphs" ]

[ "def", "shape_of_sub_graph_reinference", "(", "graph", ":", "Graph", ")", ":", "shape_ops", "=", "graph", ".", "get_op_nodes", "(", "op", "=", "'ShapeOf'", ")", "for", "shape", "in", "shape_ops", ":", "shape", ".", "infer", "(", "shape", ")", "def", "reinfer_once", "(", "in_port", ":", "Port", ")", ":", "node", "=", "in_port", ".", "node", "if", "not", "node", ".", "soft_get", "(", "'reinferred'", ",", "False", ")", ":", "node", ".", "infer", "(", "node", ")", "node", "[", "'reinferred'", "]", "=", "True", "LayoutChangeForConstantShapePaths", "(", ")", ".", "find_shape_subgraph_endpoints", "(", "out_ports", "=", "[", "shape", ".", "out_port", "(", "0", ")", "for", "shape", "in", "shape_ops", "]", ",", "action", "=", "reinfer_once", ")" ]

[ ":", "type", "arr1", ":", "List", "[", "int", "]", ":", "type", "arr2", ":", "List", "[", "int", "]", ":", "rtype", ":", "List", "[", "int", "]" ]

[ "def", "addNegabinary", "(", "self", ",", "arr1", ",", "arr2", ")", ":", "m", ",", "n", "=", "len", "(", "arr1", ")", "-", "1", ",", "len", "(", "arr2", ")", "-", "1", "if", "m", "<", "n", ":", "return", "self", ".", "addNegabinary", "(", "arr2", ",", "arr1", ")", "temp", ",", "res", "=", "0", ",", "0", "while", "m", ">=", "0", ":", "temp", "=", "arr1", "[", "m", "]", "+", "res", "if", "n", ">=", "0", ":", "temp", "+=", "arr2", "[", "n", "]", "if", "temp", "==", "2", ":", "arr1", "[", "m", "]", "=", "0", "res", "=", "-", "1", "else", ":", "arr1", "[", "m", "]", "=", "temp", "res", "=", "0", "if", "n", ">=", "0", ":", "n", "-=", "1", "m", "-=", "1", "if", "res", "==", "-", "1", ":", "arr1", "=", "[", "-", "1", "]", "+", "arr1", "m", "=", "len", "(", "arr1", ")", "-", "1", "while", "m", ">=", "0", ":", "if", "arr1", "[", "m", "]", "==", "-", "1", ":", "arr1", "[", "m", "]", "=", "1", "if", "m", "-", "1", ">=", "0", ":", "arr1", "[", "m", "-", "1", "]", "+=", "1", "else", ":", "arr1", "=", "[", "1", "]", "+", "arr1", "elif", "arr1", "[", "m", "]", "==", "2", ":", "arr1", "[", "m", "]", "=", "0", "if", "m", "-", "1", ">=", "0", ":", "arr1", "[", "m", "-", "1", "]", "-=", "1", "else", ":", "arr1", "=", "[", "1", ",", "1", "]", "+", "arr1", "m", "-=", "1", "while", "len", "(", "arr1", ")", ">", "1", "and", "arr1", "[", "0", "]", "==", "0", ":", "arr1", "=", "arr1", "[", "1", ":", "]", "return", "arr1" ]

[ "Array", "copy", "." ]

[ "def", "_array_copy", "(", "context", ",", "builder", ",", "sig", ",", "args", ")", ":", "arytype", "=", "sig", ".", "args", "[", "0", "]", "ary", "=", "make_array", "(", "arytype", ")", "(", "context", ",", "builder", ",", "value", "=", "args", "[", "0", "]", ")", "shapes", "=", "cgutils", ".", "unpack_tuple", "(", "builder", ",", "ary", ".", "shape", ")", "rettype", "=", "sig", ".", "return_type", "ret", "=", "_empty_nd_impl", "(", "context", ",", "builder", ",", "rettype", ",", "shapes", ")", "src_data", "=", "ary", ".", "data", "dest_data", "=", "ret", ".", "data", "assert", "rettype", ".", "layout", "in", "\"CF\"", "if", "arytype", ".", "layout", "==", "rettype", ".", "layout", ":", "# Fast path: memcpy", "cgutils", ".", "raw_memcpy", "(", "builder", ",", "dest_data", ",", "src_data", ",", "ary", ".", "nitems", ",", "ary", ".", "itemsize", ",", "align", "=", "1", ")", "else", ":", "src_strides", "=", "cgutils", ".", "unpack_tuple", "(", "builder", ",", "ary", ".", "strides", ")", "dest_strides", "=", "cgutils", ".", "unpack_tuple", "(", "builder", ",", "ret", ".", "strides", ")", "intp_t", "=", "context", ".", "get_value_type", "(", "types", ".", "intp", ")", "with", "cgutils", ".", "loop_nest", "(", "builder", ",", "shapes", ",", "intp_t", ")", "as", "indices", ":", "src_ptr", "=", "cgutils", ".", "get_item_pointer2", "(", "context", ",", "builder", ",", "src_data", ",", "shapes", ",", "src_strides", ",", "arytype", ".", "layout", ",", "indices", ")", "dest_ptr", "=", "cgutils", ".", "get_item_pointer2", "(", "context", ",", "builder", ",", "dest_data", ",", "shapes", ",", "dest_strides", ",", "rettype", ".", "layout", ",", "indices", ")", "builder", ".", "store", "(", "builder", ".", "load", "(", "src_ptr", ")", ",", "dest_ptr", ")", "return", "impl_ret_new_ref", "(", "context", ",", "builder", ",", "sig", ".", "return_type", ",", "ret", ".", "_getvalue", "(", ")", ")" ]

[ "Parameters", ":", "-", "request" ]

[ "def", "postUtter", "(", "self", ",", "request", ")", ":", "pass" ]

[ "Returns", "a", "list", "of", "all", "the", "supported", "filesystems", "(", "valid", "values", "for", "the", "*", "sourcefs", "*", "key", "in", "an", "item", "." ]

[ "def", "get_supported_filesystems", "(", ")", ":", "return", "[", "\"file\"", "]", "+", "get_supported_filesystems_kernel", "(", ")" ]

[ "Iterate", "over", "functions", "by", "category", ".", "If", "cat", "is", "None", "all", "known", "functions", "are", "iterated", "in", "category", "order", ".", "See", "classify_category", "for", "details", "of", "the", "ordering", ".", "Within", "a", "category", "functions", "are", "sorted", "by", "name", ".", "If", "cat", "is", "not", "None", "then", "only", "functions", "in", "that", "category", "are", "iterated", "." ]

[ "def", "functionIterateByCategory", "(", "self", ",", "cat", "=", "None", ")", ":", "lists", "=", "[", "{", "}", ",", "{", "}", ",", "{", "}", ",", "{", "}", "]", "for", "func", "in", "self", ".", "functionIterateAll", "(", ")", ":", "[", "cat_name", ",", "cat_number", "]", "=", "self", ".", "category_dict", "[", "func", ".", "name", "]", "if", "(", "cat", "==", "None", ")", "or", "(", "cat", "==", "cat_name", ")", ":", "[", "func_cat_type", ",", "key", "]", "=", "classify_category", "(", "cat_name", ",", "cat_number", ")", "if", "not", "lists", "[", "func_cat_type", "]", ".", "has_key", "(", "key", ")", ":", "lists", "[", "func_cat_type", "]", "[", "key", "]", "=", "{", "}", "lists", "[", "func_cat_type", "]", "[", "key", "]", "[", "func", ".", "name", "]", "=", "func", "functions", "=", "[", "]", "for", "func_cat_type", "in", "range", "(", "0", ",", "4", ")", ":", "keys", "=", "lists", "[", "func_cat_type", "]", ".", "keys", "(", ")", "keys", ".", "sort", "(", ")", "for", "key", "in", "keys", ":", "names", "=", "lists", "[", "func_cat_type", "]", "[", "key", "]", ".", "keys", "(", ")", "names", ".", "sort", "(", ")", "for", "name", "in", "names", ":", "functions", ".", "append", "(", "lists", "[", "func_cat_type", "]", "[", "key", "]", "[", "name", "]", ")", "return", "functions", ".", "__iter__", "(", ")" ]

[ "Implement", "PSE", "Loss", "." ]

[ "def", "__init__", "(", "self", ",", "Lambda", ",", "ratio", "=", "3", ",", "reduction", "=", "'mean'", ")", ":", "super", "(", "PSELoss", ",", "self", ")", ".", "__init__", "(", ")", "assert", "reduction", "in", "[", "'mean'", ",", "'sum'", "]", ",", "\" reduction must in ['mean','sum']\"", "self", ".", "Lambda", "=", "Lambda", "self", ".", "ratio", "=", "ratio", "self", ".", "reduction", "=", "reduction" ]

[ "Encoder", "for", "extensions", "of", "MessageSet", "." ]

[ "def", "MessageSetItemEncoder", "(", "field_number", ")", ":", "start_bytes", "=", "b\"\"", ".", "join", "(", "[", "TagBytes", "(", "1", ",", "wire_format", ".", "WIRETYPE_START_GROUP", ")", ",", "TagBytes", "(", "2", ",", "wire_format", ".", "WIRETYPE_VARINT", ")", ",", "_VarintBytes", "(", "field_number", ")", ",", "TagBytes", "(", "3", ",", "wire_format", ".", "WIRETYPE_LENGTH_DELIMITED", ")", "]", ")", "end_bytes", "=", "TagBytes", "(", "1", ",", "wire_format", ".", "WIRETYPE_END_GROUP", ")", "local_EncodeVarint", "=", "_EncodeVarint", "def", "EncodeField", "(", "write", ",", "value", ",", "deterministic", ")", ":", "write", "(", "start_bytes", ")", "local_EncodeVarint", "(", "write", ",", "value", ".", "ByteSize", "(", ")", ",", "deterministic", ")", "value", ".", "_InternalSerialize", "(", "write", ",", "deterministic", ")", "return", "write", "(", "end_bytes", ")", "return", "EncodeField" ]

[ "r", "enableSelfCollision", "(", "RobotModel", "self", "int", "link1", "int", "link2", "bool", "value", ")" ]

[ "def", "enableSelfCollision", "(", "self", ",", "link1", ":", "\"int\"", ",", "link2", ":", "\"int\"", ",", "value", ":", "\"bool\"", ")", "->", "\"void\"", ":", "return", "_robotsim", ".", "RobotModel_enableSelfCollision", "(", "self", ",", "link1", ",", "link2", ",", "value", ")" ]

[ "Function", "(", "override", ")", "to", "convert", "the", "carla", "image", "to", "a", "numpy", "data", "array", "as", "input", "for", "the", "cv_bridge", ".", "cv2_to_imgmsg", "()", "function" ]

[ "def", "get_carla_image_data_array", "(", "self", ",", "carla_image", ")", ":", "carla_image", ".", "convert", "(", "carla", ".", "ColorConverter", ".", "CityScapesPalette", ")", "carla_image_data_array", "=", "numpy", ".", "ndarray", "(", "shape", "=", "(", "carla_image", ".", "height", ",", "carla_image", ".", "width", ",", "4", ")", ",", "dtype", "=", "numpy", ".", "uint8", ",", "buffer", "=", "carla_image", ".", "raw_data", ")", "return", "carla_image_data_array", ",", "'bgra8'" ]

[ "Returns", "a", "map", "(", "filename", "lineno", ")", "-", ">", "(", "filename", "lineno", "function_name", ")", "." ]

[ "def", "get_effective_source_map", "(", "self", ")", ":", "raise", "NotImplementedError", "(", "'subclasses need to override this'", ")" ]

[ "Create", "const", "with", "batch", "taken", "from", "input_out_port", "and", "second", "dimension", "equals", "second_dim", ":", "param", "producer_port", ":", "take", "batch", "from", "this", "port", ":", "param", "second_dim", ":", "second", "dimension", "for", "created", "constant", ":", "param", "value", ":", "value", "to", "initialize", "constant", ":", "param", "precision", ":", "precision", "for", "constant", ":", "return", "created", "constant", "node" ]

[ "def", "create_const_with_batch_from_input", "(", "producer_port", ":", "Port", ",", "second_dim", ",", "value", "=", "0", ",", "precision", "=", "np", ".", "float32", ")", ":", "graph", "=", "producer_port", ".", "node", ".", "graph", "input_name", "=", "producer_port", ".", "node", ".", "soft_get", "(", "'name'", ",", "producer_port", ".", "node", ".", "id", ")", "shape_of_input", "=", "None", "for", "dest", "in", "producer_port", ".", "get_destinations", "(", ")", ":", "if", "dest", ".", "node", ".", "soft_get", "(", "'op'", ")", "==", "\"ShapeOf\"", ":", "shape_of_input", "=", "dest", ".", "node", "break", "if", "shape_of_input", "is", "None", ":", "shape_of_input", "=", "Shape", "(", "graph", ",", "{", "'name'", ":", "input_name", "+", "'/Shape'", "}", ")", ".", "create_node", "(", ")", "shape_of_input", ".", "in_port", "(", "0", ")", ".", "connect", "(", "producer_port", ")", "get_batch", "=", "None", "for", "dest", "in", "shape_of_input", ".", "out_port", "(", "0", ")", ".", "get_destinations", "(", ")", ":", "if", "dest", ".", "node", ".", "soft_get", "(", "'op'", ")", "==", "\"Crop\"", "and", "dest", ".", "node", ".", "in_port", "(", "1", ")", ".", "get_source", "(", ")", ".", "node", ".", "soft_get", "(", "'value'", ",", "[", "]", ")", "==", "int64_array", "(", "[", "1", "]", ")", ":", "get_batch", "=", "dest", ".", "node", "break", "if", "get_batch", "is", "None", ":", "get_batch", "=", "create_op_node_with_second_input", "(", "graph", ",", "Crop", ",", "int64_array", "(", "[", "1", "]", ")", ",", "{", "'name'", ":", "shape_of_input", ".", "name", "+", "'/Crop'", ",", "'axis'", ":", "int64_array", "(", "[", "0", "]", ")", ",", "'offset'", ":", "int64_array", "(", "[", "0", "]", ")", "}", ",", "shape_of_input", ")", "mem_shape", "=", "None", "for", "dest", "in", "get_batch", ".", "out_port", "(", "0", ")", ".", "get_destinations", "(", ")", ":", "if", "dest", ".", "node", ".", "soft_get", "(", "'op'", ")", "==", "\"Concat\"", "and", "dest", ".", "node", ".", "in_port", "(", "1", ")", ".", "get_source", "(", ")", ".", "node", ".", "soft_get", "(", "'value'", ",", "[", "]", ")", "==", "int64_array", "(", "[", "second_dim", "]", ")", ":", "mem_shape", "=", "dest", ".", "node", "break", "if", "mem_shape", "is", "None", ":", "mem_shape", "=", "create_op_node_with_second_input", "(", "graph", ",", "Concat", ",", "int64_array", "(", "[", "second_dim", "]", ")", ",", "{", "'name'", ":", "get_batch", ".", "name", "+", "'/Concat'", ",", "'axis'", ":", "0", ",", "'in_ports_count'", ":", "2", "}", ",", "get_batch", ")", "init_value_prev_lstm_output", "=", "None", "for", "dest", "in", "mem_shape", ".", "out_port", "(", "0", ")", ".", "get_destinations", "(", ")", ":", "if", "dest", ".", "node", ".", "soft_get", "(", "'op'", ")", "==", "\"Broadcast\"", "and", "dest", ".", "node", ".", "in_port", "(", "1", ")", ".", "get_source", "(", ")", ".", "node", ".", "soft_get", "(", "'value'", ",", "[", "]", ")", "==", "mo_array", "(", "[", "value", "]", ",", "dtype", "=", "precision", ")", ":", "init_value_prev_lstm_output", "=", "dest", ".", "node", "break", "if", "init_value_prev_lstm_output", "is", "None", ":", "init_value_prev_lstm_output", "=", "create_op_with_const_inputs", "(", "graph", ",", "Broadcast", ",", "{", "0", ":", "mo_array", "(", "[", "value", "]", ",", "dtype", "=", "precision", ")", "}", ",", "{", "'name'", ":", "mem_shape", ".", "name", "+", "'/Broadcast'", "}", ")", "init_value_prev_lstm_output", ".", "in_port", "(", "1", ")", ".", "connect", "(", "mem_shape", ".", "out_port", "(", "0", ")", ")", "return", "init_value_prev_lstm_output" ]

[ "Finds", "the", "file", "descriptor", "proto", "by", "file", "name", "." ]

[ "def", "FindFileByName", "(", "self", ",", "name", ")", ":", "return", "self", ".", "_file_desc_protos_by_file", "[", "name", "]" ]

[ "True", "if", "this", "file", "is", "closed", "." ]

[ "def", "closed", "(", "self", ")", ":", "return", "self", ".", "_mode", "==", "_MODE_CLOSED" ]

[ "Context", "to", "colocate", "with", "op", "if", "colocate_gradients_with_ops", "." ]

[ "def", "_maybe_colocate_with", "(", "op", ",", "gradient_uid", ",", "colocate_gradients_with_ops", ")", ":", "# pylint: disable=invalid-name", "if", "colocate_gradients_with_ops", ":", "with", "ops", ".", "_colocate_with_for_gradient", "(", "op", ",", "gradient_uid", ")", ":", "# pylint: disable=protected-access", "yield", "else", ":", "yield" ]

[ "Decorate", "call", "and", "optionally", "adds", "training", "argument", "." ]

[ "def", "maybe_add_training_arg", "(", "original_call", ",", "wrapped_call", ",", "expects_training_arg", ",", "default_training_value", ")", ":", "if", "not", "expects_training_arg", ":", "return", "wrapped_call", ",", "None", "def", "wrap_with_training_arg", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\"Wrap the `wrapped_call` function, and set training argument.\"\"\"", "training_arg_index", "=", "get_training_arg_index", "(", "original_call", ")", "training", "=", "get_training_arg", "(", "training_arg_index", ",", "args", ",", "kwargs", ")", "if", "training", "is", "None", ":", "training", "=", "default_training_value", "or", "K", ".", "learning_phase", "(", ")", "args", "=", "list", "(", "args", ")", "kwargs", "=", "kwargs", ".", "copy", "(", ")", "def", "replace_training_and_call", "(", "training", ")", ":", "set_training_arg", "(", "training", ",", "training_arg_index", ",", "args", ",", "kwargs", ")", "return", "wrapped_call", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "control_flow_util", ".", "smart_cond", "(", "training", ",", "lambda", ":", "replace_training_and_call", "(", "True", ")", ",", "lambda", ":", "replace_training_and_call", "(", "False", ")", ")", "# Create arg spec for decorated function. If 'training' is not defined in the", "# args of the original arg spec, then add it to kwonlyargs.", "arg_spec", "=", "tf_inspect", ".", "getfullargspec", "(", "original_call", ")", "defaults", "=", "list", "(", "arg_spec", ".", "defaults", ")", "if", "arg_spec", ".", "defaults", "is", "not", "None", "else", "[", "]", "kwonlyargs", "=", "arg_spec", ".", "kwonlyargs", "kwonlydefaults", "=", "arg_spec", ".", "kwonlydefaults", "or", "{", "}", "# Add training arg if it does not exist, or set the default training value.", "if", "'training'", "not", "in", "arg_spec", ".", "args", ":", "kwonlyargs", ".", "append", "(", "'training'", ")", "kwonlydefaults", "[", "'training'", "]", "=", "default_training_value", "else", ":", "index", "=", "arg_spec", ".", "args", ".", "index", "(", "'training'", ")", "training_default_index", "=", "len", "(", "arg_spec", ".", "args", ")", "-", "index", "if", "(", "arg_spec", ".", "defaults", "and", "len", "(", "arg_spec", ".", "defaults", ")", ">=", "training_default_index", "and", "defaults", "[", "-", "training_default_index", "]", "is", "None", ")", ":", "defaults", "[", "-", "training_default_index", "]", "=", "default_training_value", "decorator_argspec", "=", "tf_inspect", ".", "FullArgSpec", "(", "args", "=", "arg_spec", ".", "args", ",", "varargs", "=", "arg_spec", ".", "varargs", ",", "varkw", "=", "arg_spec", ".", "varkw", ",", "defaults", "=", "defaults", ",", "kwonlyargs", "=", "kwonlyargs", ",", "kwonlydefaults", "=", "kwonlydefaults", ",", "annotations", "=", "arg_spec", ".", "annotations", ")", "return", "wrap_with_training_arg", ",", "decorator_argspec" ]

[ "Returns", "the", "real", "and", "imaginary", "components", "of", "grad", "respectively", "." ]

[ "def", "_ComplexGrad", "(", "op", ",", "grad", ")", ":", "x", "=", "op", ".", "inputs", "[", "0", "]", "y", "=", "op", ".", "inputs", "[", "1", "]", "sx", "=", "array_ops", ".", "shape", "(", "x", ")", "sy", "=", "array_ops", ".", "shape", "(", "y", ")", "rx", ",", "ry", "=", "gen_array_ops", ".", "_broadcast_gradient_args", "(", "sx", ",", "sy", ")", "return", "(", "array_ops", ".", "reshape", "(", "math_ops", ".", "reduce_sum", "(", "math_ops", ".", "real", "(", "grad", ")", ",", "rx", ")", ",", "sx", ")", ",", "array_ops", ".", "reshape", "(", "math_ops", ".", "reduce_sum", "(", "math_ops", ".", "imag", "(", "grad", ")", ",", "ry", ")", ",", "sy", ")", ")" ]

[ "computes", "the", "root", "relative", "squared", "error", "(", "condensed", "using", "standard", "deviation", "formula", ")" ]

[ "def", "rse", "(", "label", ",", "pred", ")", ":", "numerator", "=", "np", ".", "sqrt", "(", "np", ".", "mean", "(", "np", ".", "square", "(", "label", "-", "pred", ")", ",", "axis", "=", "None", ")", ")", "denominator", "=", "np", ".", "std", "(", "label", ",", "axis", "=", "None", ")", "return", "numerator", "/", "denominator" ]

[ "Verify", "that", "extras_require", "mapping", "is", "valid" ]

[ "def", "check_extras", "(", "dist", ",", "attr", ",", "value", ")", ":", "try", ":", "list", "(", "itertools", ".", "starmap", "(", "_check_extra", ",", "value", ".", "items", "(", ")", ")", ")", "except", "(", "TypeError", ",", "ValueError", ",", "AttributeError", ")", ":", "raise", "DistutilsSetupError", "(", "\"'extras_require' must be a dictionary whose values are \"", "\"strings or lists of strings containing valid project/version \"", "\"requirement specifiers.\"", ")" ]

[ "Raise", "other", "to", "the", "power", "self", "masking", "the", "potential", "NaNs", "/", "Infs" ]

[ "def", "__rpow__", "(", "self", ",", "other", ")", ":", "return", "power", "(", "other", ",", "self", ")" ]

[ "Get", "a", "subwidget", "name", "(", "returns", "a", "String", "not", "a", "Widget", "!", ")" ]

[ "def", "_subwidget_name", "(", "self", ",", "name", ")", ":", "try", ":", "return", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'subwidget'", ",", "name", ")", "except", "TclError", ":", "return", "None" ]

[ "The", "API", "calls", "for", "byte", "offsets", "into", "the", "UTF", "-", "8", "encoded", "version", "of", "the", "buffer", ".", "However", "ycmd", "internally", "uses", "unicode", "strings", ".", "This", "means", "that", "when", "we", "need", "to", "walk", "characters", "within", "the", "buffer", "such", "as", "when", "checking", "for", "semantic", "triggers", "and", "similar", "we", "must", "use", "codepoint", "offsets", "rather", "than", "byte", "offsets", "." ]

[ "def", "ByteOffsetToCodepointOffset", "(", "line_value", ",", "byte_offset", ")", ":", "byte_line_value", "=", "ToBytes", "(", "line_value", ")", "return", "len", "(", "ToUnicode", "(", "byte_line_value", "[", ":", "byte_offset", "-", "1", "]", ")", ")", "+", "1" ]

[ "If", "input", "points", "to", "(", "or", "{", "or", "[", "or", "<", "finds", "the", "position", "that", "closes", "it", "." ]

[ "def", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "startchar", "=", "line", "[", "pos", "]", "if", "startchar", "not", "in", "'({[<'", ":", "return", "(", "line", ",", "clean_lines", ".", "NumLines", "(", ")", ",", "-", "1", ")", "if", "startchar", "==", "'('", ":", "endchar", "=", "')'", "if", "startchar", "==", "'['", ":", "endchar", "=", "']'", "if", "startchar", "==", "'{'", ":", "endchar", "=", "'}'", "if", "startchar", "==", "'<'", ":", "endchar", "=", "'>'", "# Check first line", "(", "end_pos", ",", "num_open", ")", "=", "FindEndOfExpressionInLine", "(", "line", ",", "pos", ",", "0", ",", "startchar", ",", "endchar", ")", "if", "end_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "end_pos", ")", "# Continue scanning forward", "while", "linenum", "<", "clean_lines", ".", "NumLines", "(", ")", "-", "1", ":", "linenum", "+=", "1", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "(", "end_pos", ",", "num_open", ")", "=", "FindEndOfExpressionInLine", "(", "line", ",", "0", ",", "num_open", ",", "startchar", ",", "endchar", ")", "if", "end_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "end_pos", ")", "# Did not find endchar before end of file, give up", "return", "(", "line", ",", "clean_lines", ".", "NumLines", "(", ")", ",", "-", "1", ")" ]

[ "Parse", "a", "range", "diff", "line", "." ]

[ "def", "Parse", "(", "self", ",", "diff_lines", ")", ":", "match", "=", "re", ".", "match", "(", "RE_RANGE", ",", "diff_lines", "[", "0", "]", ")", "if", "not", "match", ":", "raise", "Error", "(", "context", "=", "diff_lines", "[", "0", "]", ",", "error", "=", "'Bad range info'", ")", "# Range in source file. The line count is optional and defaults to 1.", "self", ".", "src_start_line", "=", "int", "(", "match", ".", "group", "(", "1", ")", ")", "self", ".", "src_line_count", "=", "1", "if", "(", "match", ".", "group", "(", "2", ")", ")", ":", "self", ".", "src_line_count", "=", "int", "(", "match", ".", "group", "(", "2", ")", ")", "# Range in destination file. The line count is optional and defaults to 1.", "self", ".", "dest_start_line", "=", "int", "(", "match", ".", "group", "(", "3", ")", ")", "self", ".", "dest_line_count", "=", "1", "if", "(", "match", ".", "group", "(", "4", ")", ")", ":", "self", ".", "dest_line_count", "=", "int", "(", "match", ".", "group", "(", "4", ")", ")", "diff_lines", ".", "pop", "(", "0", ")" ]

[ "Make", "a", "subgraph", "from", "a", "name", "scope", "." ]

[ "def", "make_view_from_scope", "(", "scope", ",", "graph", ")", ":", "ops", "=", "select", ".", "get_name_scope_ops", "(", "graph", ",", "scope", ")", "return", "SubGraphView", "(", "ops", ")" ]

[ "Determines", "whether", "config", "appears", "to", "be", "a", "valid", "layer", "config", "." ]

[ "def", "validate_config", "(", "config", ")", ":", "return", "isinstance", "(", "config", ",", "dict", ")", "and", "_LAYER_UNDEFINED_CONFIG_KEY", "not", "in", "config" ]

[ "Drops", "common", "suffixes", "like", "_test", ".", "cc", "or", "-", "inl", ".", "h", "from", "filename", "." ]

[ "def", "_DropCommonSuffixes", "(", "filename", ")", ":", "for", "suffix", "in", "(", "'test.cc'", ",", "'regtest.cc'", ",", "'unittest.cc'", ",", "'inl.h'", ",", "'impl.h'", ",", "'internal.h'", ")", ":", "if", "(", "filename", ".", "endswith", "(", "suffix", ")", "and", "len", "(", "filename", ")", ">", "len", "(", "suffix", ")", "and", "filename", "[", "-", "len", "(", "suffix", ")", "-", "1", "]", "in", "(", "'-'", ",", "'_'", ")", ")", ":", "return", "filename", "[", ":", "-", "len", "(", "suffix", ")", "-", "1", "]", "return", "os", ".", "path", ".", "splitext", "(", "filename", ")", "[", "0", "]" ]

[ "distributed", "max", "in", "fleet" ]

[ "def", "max", "(", "input", ",", "scope", "=", "None", ",", "util", "=", "None", ")", ":", "if", "scope", "is", "None", ":", "scope", "=", "paddle", ".", "static", ".", "global_scope", "(", ")", "if", "util", "is", "None", ":", "util", "=", "paddle", ".", "distributed", ".", "fleet", ".", "util", "if", "isinstance", "(", "input", ",", "Variable", ")", ":", "input", "=", "np", ".", "array", "(", "scope", ".", "find_var", "(", "input", ".", "name", ")", ".", "get_tensor", "(", ")", ")", "elif", "isinstance", "(", "input", ",", "str", ")", ":", "input", "=", "np", ".", "array", "(", "scope", ".", "find_var", "(", "input", ")", ".", "get_tensor", "(", ")", ")", "old_shape", "=", "np", ".", "array", "(", "input", ".", "shape", ")", "output", "=", "np", ".", "copy", "(", "input", ")", "*", "0", "output", "=", "util", ".", "all_reduce", "(", "input", ",", "\"max\"", ")", "output", "=", "output", ".", "reshape", "(", "old_shape", ")", "return", "output" ]

[ "used", "by", "process", "zero", "(", "broadcast", "send", "process", ")", "as", "well", "as", "other", "processes", "\\", "n", "(", "broadcast", "recieve", "processes", ")", "to", "actually", "take", "the", "info", "in", "json", "format", "\\", "n", "and", "set", "the", "system", "up", "for", "proper", "behavior", "after", "restart", "particularly", "\\", "n", "data", "ranges", "and", "plots", "over", "time" ]

[ "def", "DuringRestartUseJsonToSetUp", "(", "jsonIn", ",", "ioPipeAndViewsState", ")", ":", "#go through representations and have each add it's state info to jsonOut", "if", "\"RepresentationsRestartInfo\"", "not", "in", "jsonIn", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\"StartOfVisualizationCallback returning, no rep info\\n\"", ")", "return", "representationsJsonIn", "=", "jsonIn", "[", "\"RepresentationsRestartInfo\"", "]", "for", "oneRepName", ",", "oneRep", "in", "ioPipeAndViewsState", ".", "mRepresentationBlocks", ".", "items", "(", ")", ":", "if", "oneRepName", "in", "representationsJsonIn", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\"restart setup callback json for rep: \"", "+", "oneRepName", "+", "\"\\n\"", ")", "oneRep", ".", "SetFromRestartInfo", "(", "representationsJsonIn", "[", "oneRepName", "]", ")", "else", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\"warning: Representation named \"", "+", "oneRepName", "+", "\" not in restart info\"", ")", "plotsOverTimeJsonIn", "=", "jsonIn", "[", "\"PlotsOverTimeRestartInfo\"", "]", "for", "onePlotOtName", ",", "onePlotOt", "in", "ioPipeAndViewsState", ".", "mPlotOverTimeBlocks", ".", "items", "(", ")", ":", "if", "onePlotOtName", "in", "plotsOverTimeJsonIn", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\"plot over time setup callback json for rep: \"", "+", "onePlotOtName", "+", "\"\\n\"", ")", "onePlotOt", ".", "SetFromRestartInfo", "(", "plotsOverTimeJsonIn", "[", "onePlotOtName", "]", ")", "else", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\"warning: plot over time named \"", "+", "onePlotOtName", "+", "\" not in restart info\"", ")" ]

[ "NamedColour", "(", "String", "colourName", ")", "-", ">", "Colour" ]

[ "def", "NamedColour", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_gdi_", ".", "new_NamedColour", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Return", "true", "iff", "packable", "=", "true", "is", "valid", "for", "fields", "of", "this", "type", "." ]

[ "def", "IsTypePackable", "(", "field_type", ")", ":", "return", "field_type", "not", "in", "NON_PACKABLE_TYPES" ]

[ "expression", ":", "LPAREN", "expression", "RPAREN" ]

[ "def", "p_expression_group", "(", "p", ")", ":", "p", "[", "0", "]", "=", "p", "[", "2", "]" ]

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

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

[ "Returns", "the", "gallery", "item", "which", "the", "event", "relates", "to", "or", "None", "if", "it", "does", "not", "relate", "to", "an", "item", "." ]

[ "def", "GetGalleryItem", "(", "self", ")", ":", "return", "self", ".", "_item" ]

[ "Filters", "routes", "for", "specified", "address", "\\", "n", "address", "=", "Address", ".", "from_host_port_family", "(", "host", ".", "com", ":", "1025", ":", "2", ")", "routes", "=", "routes", ".", "filter_by_address", "(", "address", ")" ]

[ "def", "filter_by_address", "(", "self", ",", "address", ")", ":", "return", "RouteList", "(", "[", "route", "for", "route", "in", "self", ".", "routes", "if", "route", ".", "address", "==", "address", "]", ")" ]

[ "Find", "the", "first", "index", "in", "self", ".", "completions", "where", "completions", "[", "i", "]", "is", "greater", "or", "equal", "to", "s", "or", "the", "last", "index", "if", "there", "is", "no", "such", "one", "." ]

[ "def", "_binary_search", "(", "self", ",", "s", ")", ":", "i", "=", "0", "j", "=", "len", "(", "self", ".", "completions", ")", "while", "j", ">", "i", ":", "m", "=", "(", "i", "+", "j", ")", "//", "2", "if", "self", ".", "completions", "[", "m", "]", ">=", "s", ":", "j", "=", "m", "else", ":", "i", "=", "m", "+", "1", "return", "min", "(", "i", ",", "len", "(", "self", ".", "completions", ")", "-", "1", ")" ]

[ "Parse", "a", "floating", "point", "number", "." ]

[ "def", "ParseFloat", "(", "text", ")", ":", "try", ":", "# Assume Python compatible syntax.", "return", "float", "(", "text", ")", "except", "ValueError", ":", "# Check alternative spellings.", "if", "_FLOAT_INFINITY", ".", "match", "(", "text", ")", ":", "if", "text", "[", "0", "]", "==", "'-'", ":", "return", "float", "(", "'-inf'", ")", "else", ":", "return", "float", "(", "'inf'", ")", "elif", "_FLOAT_NAN", ".", "match", "(", "text", ")", ":", "return", "float", "(", "'nan'", ")", "else", ":", "# assume '1.0f' format", "try", ":", "return", "float", "(", "text", ".", "rstrip", "(", "'f'", ")", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "'Couldn\\'t parse float: %s'", "%", "text", ")" ]

[ "Initialize", "targets", "for", "the", "ninja", "flavor", "." ]

[ "def", "_InitNinjaFlavor", "(", "params", ",", "target_list", ",", "target_dicts", ")", ":", "for", "qualified_target", "in", "target_list", ":", "spec", "=", "target_dicts", "[", "qualified_target", "]", "if", "spec", ".", "get", "(", "'msvs_external_builder'", ")", ":", "# The spec explicitly defined an external builder, so don't change it.", "continue", "path_to_ninja", "=", "spec", ".", "get", "(", "'msvs_path_to_ninja'", ",", "'ninja.exe'", ")", "spec", "[", "'msvs_external_builder'", "]", "=", "'ninja'", "if", "not", "spec", ".", "get", "(", "'msvs_external_builder_out_dir'", ")", ":", "gyp_file", ",", "_", ",", "_", "=", "gyp", ".", "common", ".", "ParseQualifiedTarget", "(", "qualified_target", ")", "gyp_dir", "=", "os", ".", "path", ".", "dirname", "(", "gyp_file", ")", "configuration", "=", "'$(Configuration)'", "if", "params", ".", "get", "(", "'target_arch'", ")", "==", "'x64'", ":", "configuration", "+=", "'_x64'", "spec", "[", "'msvs_external_builder_out_dir'", "]", "=", "os", ".", "path", ".", "join", "(", "gyp", ".", "common", ".", "RelativePath", "(", "params", "[", "'options'", "]", ".", "toplevel_dir", ",", "gyp_dir", ")", ",", "ninja_generator", ".", "ComputeOutputDir", "(", "params", ")", ",", "configuration", ")", "if", "not", "spec", ".", "get", "(", "'msvs_external_builder_build_cmd'", ")", ":", "spec", "[", "'msvs_external_builder_build_cmd'", "]", "=", "[", "path_to_ninja", ",", "'-C'", ",", "'$(OutDir)'", ",", "'$(ProjectName)'", ",", "]", "if", "not", "spec", ".", "get", "(", "'msvs_external_builder_clean_cmd'", ")", ":", "spec", "[", "'msvs_external_builder_clean_cmd'", "]", "=", "[", "path_to_ninja", ",", "'-C'", ",", "'$(OutDir)'", ",", "'-tclean'", ",", "'$(ProjectName)'", ",", "]" ]

[ "Converts", "a", "dict", "into", "an", "XML", "string", "." ]

[ "def", "convert_dict", "(", "obj", ",", "ids", ",", "parent", ",", "attr_type", ",", "item_func", ",", "cdata", ")", ":", "LOG", ".", "info", "(", "'Inside convert_dict(): obj type is: \"%s\", obj=\"%s\"'", "%", "(", "type", "(", "obj", ")", ".", "__name__", ",", "unicode_me", "(", "obj", ")", ")", ")", "output", "=", "[", "]", "addline", "=", "output", ".", "append", "item_name", "=", "item_func", "(", "parent", ")", "for", "key", ",", "val", "in", "obj", ".", "items", "(", ")", ":", "LOG", ".", "info", "(", "'Looping inside convert_dict(): key=\"%s\", val=\"%s\", type(val)=\"%s\"'", "%", "(", "unicode_me", "(", "key", ")", ",", "unicode_me", "(", "val", ")", ",", "type", "(", "val", ")", ".", "__name__", ")", ")", "attr", "=", "{", "}", "if", "not", "ids", "else", "{", "'id'", ":", "'%s'", "%", "(", "get_unique_id", "(", "parent", ")", ")", "}", "key", ",", "attr", "=", "make_valid_xml_name", "(", "key", ",", "attr", ")", "if", "isinstance", "(", "val", ",", "numbers", ".", "Number", ")", "or", "type", "(", "val", ")", "in", "(", "str", ",", "unicode", ")", ":", "addline", "(", "convert_kv", "(", "key", ",", "val", ",", "attr_type", ",", "attr", ",", "cdata", ")", ")", "elif", "hasattr", "(", "val", ",", "'isoformat'", ")", ":", "# datetime", "addline", "(", "convert_kv", "(", "key", ",", "val", ".", "isoformat", "(", ")", ",", "attr_type", ",", "attr", ",", "cdata", ")", ")", "elif", "type", "(", "val", ")", "==", "bool", ":", "addline", "(", "convert_bool", "(", "key", ",", "val", ",", "attr_type", ",", "attr", ",", "cdata", ")", ")", "elif", "isinstance", "(", "val", ",", "dict", ")", ":", "if", "attr_type", ":", "attr", "[", "'type'", "]", "=", "get_xml_type", "(", "val", ")", "addline", "(", "'<%s%s>%s</%s>'", "%", "(", "key", ",", "make_attrstring", "(", "attr", ")", ",", "convert_dict", "(", "val", ",", "ids", ",", "key", ",", "attr_type", ",", "item_func", ",", "cdata", ")", ",", "key", ")", ")", "elif", "isinstance", "(", "val", ",", "Iterable", ")", ":", "if", "attr_type", ":", "attr", "[", "'type'", "]", "=", "get_xml_type", "(", "val", ")", "addline", "(", "'<%s%s>%s</%s>'", "%", "(", "key", ",", "make_attrstring", "(", "attr", ")", ",", "convert_list", "(", "val", ",", "ids", ",", "key", ",", "attr_type", ",", "item_func", ",", "cdata", ")", ",", "key", ")", ")", "elif", "val", "is", "None", ":", "addline", "(", "convert_none", "(", "key", ",", "val", ",", "attr_type", ",", "attr", ",", "cdata", ")", ")", "else", ":", "raise", "TypeError", "(", "'Unsupported data type: %s (%s)'", "%", "(", "val", ",", "type", "(", "val", ")", ".", "__name__", ")", ")", "return", "''", ".", "join", "(", "output", ")" ]

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

[ "def", "GetType", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "ImageHandler_GetType", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Remove", "the", "last", "dot", "and", "what", "follows", "from", "the", "basename", "." ]

[ "def", "without_last_extension", "(", "self", ")", ":", "ext", "=", "'.'", ".", "join", "(", "self", ".", "extension", ".", "split", "(", "'.'", ")", "[", ":", "-", "1", "]", ")", "return", "self", ".", "with_extension", "(", "ext", ")" ]

[ "PIE", ":", "DllCharacteristics", "bit", "0x20", "signifies", "high", "-", "entropy", "ASLR" ]

[ "def", "check_PE_HIGH_ENTROPY_VA", "(", "executable", ")", ":", "(", "arch", ",", "bits", ")", "=", "get_PE_dll_characteristics", "(", "executable", ")", "if", "arch", "==", "'i386:x86-64'", ":", "reqbits", "=", "IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA", "else", ":", "# Unnecessary on 32-bit", "assert", "(", "arch", "==", "'i386'", ")", "reqbits", "=", "0", "return", "(", "bits", "&", "reqbits", ")", "==", "reqbits" ]

[ "Restores", "filters", "previously", "backed", "up", "." ]

[ "def", "_RestoreFilters", "(", ")", ":", "_cpplint_state", ".", "RestoreFilters", "(", ")" ]

[ "IsItemEnabled", "(", "self", "unsigned", "int", "n", ")", "-", ">", "bool" ]

[ "def", "IsItemEnabled", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "RadioBox_IsItemEnabled", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Check", "for", "problems", "with", "punctuations", "." ]

[ "def", "_checkPunctuation", "(", "self", ")", ":", "if", "self", ".", "_source", "==", "''", "or", "self", ".", "_translation", "==", "''", ":", "return", "lastSourceChar", "=", "self", ".", "_source", "[", "-", "1", "]", "lastTranslationChar", "=", "self", ".", "_translation", "[", "-", "1", "]", "if", "lastSourceChar", "not", "in", "self", ".", "SENTENCE_ENDING_PUNCTUATIONS", "and", "lastTranslationChar", "not", "in", "self", ".", "SENTENCE_ENDING_PUNCTUATIONS", ":", "return", "# If source and translation don't end in a punctuation", "if", "lastSourceChar", "!=", "lastTranslationChar", ":", "if", "not", "(", "lastSourceChar", "==", "'.'", "and", "self", ".", "_source", ".", "endswith", "(", "'...'", ")", "and", "self", ".", "_translation", ".", "endswith", "(", "'…'))", " ", "a", "d \\", "not", "(", "lastSourceChar", "==", "'…' a", "d s", "lf._", "t", "ranslation.e", "n", "dswith('", ".", "..'))", ":", "", "", "self", ".", "warning", "(", "'punctuation_end_differ'", ",", "self", ".", "_calculatePosition", "(", "self", ".", "_translation", ",", "len", "(", "self", ".", "_translation", ")", "-", "1", ",", "self", ".", "_translationPos", ")", ",", "punctuation", "=", "self", ".", "_escapeText", "(", "lastSourceChar", ")", ",", "actual", "=", "self", ".", "_escapeText", "(", "lastTranslationChar", ")", ")" ]

[ "Set", "default", "values", "for", "all", "the", "options", "that", "this", "command", "supports", ".", "Note", "that", "these", "defaults", "may", "be", "overridden", "by", "other", "commands", "by", "the", "setup", "script", "by", "config", "files", "or", "by", "the", "command", "-", "line", ".", "Thus", "this", "is", "not", "the", "place", "to", "code", "dependencies", "between", "options", ";", "generally", "initialize_options", "()", "implementations", "are", "just", "a", "bunch", "of", "self", ".", "foo", "=", "None", "assignments", "." ]

[ "def", "initialize_options", "(", "self", ")", ":", "raise", "RuntimeError", ",", "\"abstract method -- subclass %s must override\"", "%", "self", ".", "__class__" ]

[ "Custom", "freeze_graph", "implementation", "for", "Cloud", "TPU", "." ]

[ "def", "freeze_graph_tpu", "(", "model_path", ")", ":", "assert", "model_path", "assert", "FLAGS", ".", "tpu_name", "if", "FLAGS", ".", "tpu_name", ".", "startswith", "(", "'grpc://'", ")", ":", "tpu_grpc_url", "=", "FLAGS", ".", "tpu_name", "else", ":", "tpu_cluster_resolver", "=", "contrib_cluster_resolver", ".", "TPUClusterResolver", "(", "FLAGS", ".", "tpu_name", ",", "zone", "=", "None", ",", "project", "=", "None", ")", "tpu_grpc_url", "=", "tpu_cluster_resolver", ".", "get_master", "(", ")", "sess", "=", "tf", ".", "Session", "(", "tpu_grpc_url", ")", "output_names", "=", "[", "]", "with", "sess", ".", "graph", ".", "as_default", "(", ")", ":", "# Replicate the inference function for each TPU core.", "replicated_features", "=", "[", "]", "feature_type", "=", "tf", ".", "bool", "if", "FLAGS", ".", "bool_features", "else", "tf", ".", "float32", "for", "i", "in", "range", "(", "FLAGS", ".", "num_tpu_cores", ")", ":", "name", "=", "'pos_tensor_%d'", "%", "i", "features", "=", "tf", ".", "placeholder", "(", "feature_type", ",", "[", "None", "]", ",", "name", "=", "name", ")", "replicated_features", ".", "append", "(", "(", "features", ",", ")", ")", "outputs", "=", "contrib_tpu", ".", "replicate", "(", "tpu_model_inference_fn", ",", "replicated_features", ")", "# The replicate op assigns names like output_0_shard_0 to the output", "# names. Give them human readable names.", "for", "i", ",", "(", "policy_output", ",", "value_output", ",", "_", ")", "in", "enumerate", "(", "outputs", ")", ":", "policy_name", "=", "'policy_output_%d'", "%", "i", "value_name", "=", "'value_output_%d'", "%", "i", "output_names", ".", "extend", "(", "[", "policy_name", ",", "value_name", "]", ")", "tf", ".", "identity", "(", "policy_output", ",", "policy_name", ")", "tf", ".", "identity", "(", "value_output", ",", "value_name", ")", "tf", ".", "train", ".", "Saver", "(", ")", ".", "restore", "(", "sess", ",", "model_path", ")", "out_graph", "=", "tf", ".", "graph_util", ".", "convert_variables_to_constants", "(", "sess", ",", "sess", ".", "graph", ".", "as_graph_def", "(", ")", ",", "output_names", ")", "metadata", "=", "make_model_metadata", "(", "{", "'engine'", ":", "'tpu'", ",", "'num_replicas'", ":", "FLAGS", ".", "num_tpu_cores", ",", "}", ")", "minigo_model", ".", "write_graph_def", "(", "out_graph", ",", "metadata", ",", "model_path", "+", "'.minigo'", ")" ]

[ "Empty", "(", "TStr", "self", ")", "-", ">", "bool" ]

[ "def", "Empty", "(", "self", ")", ":", "return", "_snap", ".", "TStr_Empty", "(", "self", ")" ]

[ "Find", "eggs", "in", "zip", "files", ";", "possibly", "multiple", "nested", "eggs", "." ]

[ "def", "find_eggs_in_zip", "(", "importer", ",", "path_item", ",", "only", "=", "False", ")", ":", "if", "importer", ".", "archive", ".", "endswith", "(", "'.whl'", ")", ":", "# wheels are not supported with this finder", "# they don't have PKG-INFO metadata, and won't ever contain eggs", "return", "metadata", "=", "EggMetadata", "(", "importer", ")", "if", "metadata", ".", "has_metadata", "(", "'PKG-INFO'", ")", ":", "yield", "Distribution", ".", "from_filename", "(", "path_item", ",", "metadata", "=", "metadata", ")", "if", "only", ":", "# don't yield nested distros", "return", "for", "subitem", "in", "metadata", ".", "resource_listdir", "(", "''", ")", ":", "if", "_is_egg_path", "(", "subitem", ")", ":", "subpath", "=", "os", ".", "path", ".", "join", "(", "path_item", ",", "subitem", ")", "dists", "=", "find_eggs_in_zip", "(", "zipimport", ".", "zipimporter", "(", "subpath", ")", ",", "subpath", ")", "for", "dist", "in", "dists", ":", "yield", "dist", "elif", "subitem", ".", "lower", "(", ")", ".", "endswith", "(", "'.dist-info'", ")", ":", "subpath", "=", "os", ".", "path", ".", "join", "(", "path_item", ",", "subitem", ")", "submeta", "=", "EggMetadata", "(", "zipimport", ".", "zipimporter", "(", "subpath", ")", ")", "submeta", ".", "egg_info", "=", "subpath", "yield", "Distribution", ".", "from_location", "(", "path_item", ",", "subitem", ",", "submeta", ")" ]

[ "Print", "new", "messages", "on", "topic", "to", "screen", ".", ":", "param", "topic", ":", "topic", "name", "str", ":", "param", "bag_file", ":", "name", "of", "bag", "file", "to", "echo", "messages", "from", "or", "None", "str" ]

[ "def", "_rostopic_echo", "(", "topic", ",", "callback_echo", ",", "bag_file", "=", "None", ",", "echo_all_topics", "=", "False", ")", ":", "# we have to init a node regardless and bag echoing can print timestamps", "if", "bag_file", ":", "# initialize rospy time due to potential timestamp printing", "rospy", ".", "rostime", ".", "set_rostime_initialized", "(", "True", ")", "_rostopic_echo_bag", "(", "callback_echo", ",", "bag_file", ")", "else", ":", "_check_master", "(", ")", "rospy", ".", "init_node", "(", "NAME", ",", "anonymous", "=", "True", ")", "msg_class", ",", "real_topic", ",", "msg_eval", "=", "get_topic_class", "(", "topic", ",", "blocking", "=", "True", ")", "if", "msg_class", "is", "None", ":", "# occurs on ctrl-C", "return", "callback_echo", ".", "msg_eval", "=", "msg_eval", "# extract type information for submessages", "type_information", "=", "None", "if", "len", "(", "topic", ")", ">", "len", "(", "real_topic", ")", ":", "subtopic", "=", "topic", "[", "len", "(", "real_topic", ")", ":", "]", "subtopic", "=", "subtopic", ".", "strip", "(", "'/'", ")", "if", "subtopic", ":", "fields", "=", "subtopic", ".", "split", "(", "'/'", ")", "submsg_class", "=", "msg_class", "while", "fields", ":", "field", "=", "fields", "[", "0", "]", ".", "split", "(", "'['", ")", "[", "0", "]", "del", "fields", "[", "0", "]", "index", "=", "submsg_class", ".", "__slots__", ".", "index", "(", "field", ")", "type_information", "=", "submsg_class", ".", "_slot_types", "[", "index", "]", "if", "fields", ":", "submsg_class", "=", "roslib", ".", "message", ".", "get_message_class", "(", "type_information", ".", "split", "(", "'['", ",", "1", ")", "[", "0", "]", ")", "if", "not", "submsg_class", ":", "raise", "ROSTopicException", "(", "\"Cannot load message class for [%s]. Are your messages built?\"", "%", "type_information", ")", "use_sim_time", "=", "rospy", ".", "get_param", "(", "'/use_sim_time'", ",", "False", ")", "sub", "=", "rospy", ".", "Subscriber", "(", "real_topic", ",", "msg_class", ",", "callback_echo", ".", "callback", ",", "{", "'topic'", ":", "topic", ",", "'type_information'", ":", "type_information", "}", ")", "if", "use_sim_time", ":", "# #2950: print warning if nothing received for two seconds", "timeout_t", "=", "time", ".", "time", "(", ")", "+", "2.", "while", "time", ".", "time", "(", ")", "<", "timeout_t", "and", "callback_echo", ".", "count", "==", "0", "and", "not", "rospy", ".", "is_shutdown", "(", ")", "and", "not", "callback_echo", ".", "done", ":", "_sleep", "(", "0.1", ")", "if", "callback_echo", ".", "count", "==", "0", "and", "not", "rospy", ".", "is_shutdown", "(", ")", "and", "not", "callback_echo", ".", "done", ":", "sys", ".", "stderr", ".", "write", "(", "\"WARNING: no messages received and simulated time is active.\\nIs /clock being published?\\n\"", ")", "while", "not", "rospy", ".", "is_shutdown", "(", ")", "and", "not", "callback_echo", ".", "done", ":", "_sleep", "(", "0.1", ")" ]

[ "Return", "a", "camelCased", "version", "of", "a", "string", "." ]

[ "def", "camel_case", "(", "name", ")", ":", "# type: (str) -> str", "return", "name", "[", "0", ":", "1", "]", ".", "lower", "(", ")", "+", "name", "[", "1", ":", "]" ]

[ "Set", "the", "given", "flags", "and", "unset", "all", "others", "." ]

[ "def", "set_flags", "(", "self", ",", "flags", ")", ":", "self", ".", "_info", "=", "'2,'", "+", "''", ".", "join", "(", "sorted", "(", "flags", ")", ")" ]

[ "An", "emitter", "for", "TeX", "and", "LaTeX", "sources", ".", "For", "LaTeX", "sources", "we", "try", "and", "find", "the", "common", "created", "files", "that", "are", "needed", "on", "subsequent", "runs", "of", "latex", "to", "finish", "tables", "of", "contents", "bibliographies", "indices", "lists", "of", "figures", "and", "hyperlink", "references", "." ]

[ "def", "tex_emitter_core", "(", "target", ",", "source", ",", "env", ",", "graphics_extensions", ")", ":", "basename", "=", "SCons", ".", "Util", ".", "splitext", "(", "str", "(", "source", "[", "0", "]", ")", ")", "[", "0", "]", "basefile", "=", "os", ".", "path", ".", "split", "(", "str", "(", "basename", ")", ")", "[", "1", "]", "targetdir", "=", "os", ".", "path", ".", "split", "(", "str", "(", "target", "[", "0", "]", ")", ")", "[", "0", "]", "targetbase", "=", "os", ".", "path", ".", "join", "(", "targetdir", ",", "basefile", ")", "basedir", "=", "os", ".", "path", ".", "split", "(", "str", "(", "source", "[", "0", "]", ")", ")", "[", "0", "]", "abspath", "=", "os", ".", "path", ".", "abspath", "(", "basedir", ")", "target", "[", "0", "]", ".", "attributes", ".", "path", "=", "abspath", "#", "# file names we will make use of in searching the sources and log file", "#", "emit_suffixes", "=", "[", "'.aux'", ",", "'.log'", ",", "'.ilg'", ",", "'.blg'", ",", "'.nls'", ",", "'.nlg'", ",", "'.gls'", ",", "'.glg'", ",", "'.alg'", "]", "+", "all_suffixes", "auxfilename", "=", "targetbase", "+", "'.aux'", "logfilename", "=", "targetbase", "+", "'.log'", "flsfilename", "=", "targetbase", "+", "'.fls'", "syncfilename", "=", "targetbase", "+", "'.synctex.gz'", "env", ".", "SideEffect", "(", "auxfilename", ",", "target", "[", "0", "]", ")", "env", ".", "SideEffect", "(", "logfilename", ",", "target", "[", "0", "]", ")", "env", ".", "SideEffect", "(", "flsfilename", ",", "target", "[", "0", "]", ")", "env", ".", "SideEffect", "(", "syncfilename", ",", "target", "[", "0", "]", ")", "if", "Verbose", ":", "print", "(", "\"side effect :\"", ",", "auxfilename", ",", "logfilename", ",", "flsfilename", ",", "syncfilename", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "auxfilename", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "logfilename", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "flsfilename", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "syncfilename", ")", "content", "=", "source", "[", "0", "]", ".", "get_text_contents", "(", ")", "# set up list with the regular expressions", "# we use to find features used", "file_tests_search", "=", "[", "auxfile_re", ",", "makeindex_re", ",", "bibliography_re", ",", "bibunit_re", ",", "multibib_re", ",", "addbibresource_re", ",", "tableofcontents_re", ",", "listoffigures_re", ",", "listoftables_re", ",", "hyperref_re", ",", "makenomenclature_re", ",", "makeglossary_re", ",", "makeglossaries_re", ",", "makeacronyms_re", ",", "beamer_re", ",", "newglossary_re", ",", "biblatex_re", "]", "# set up list with the file suffixes that need emitting", "# when a feature is found", "file_tests_suff", "=", "[", "[", "'.aux'", ",", "'aux_file'", "]", ",", "[", "'.idx'", ",", "'.ind'", ",", "'.ilg'", ",", "'makeindex'", "]", ",", "[", "'.bbl'", ",", "'.blg'", ",", "'bibliography'", "]", ",", "[", "'.bbl'", ",", "'.blg'", ",", "'bibunit'", "]", ",", "[", "'.bbl'", ",", "'.blg'", ",", "'multibib'", "]", ",", "[", "'.bbl'", ",", "'.blg'", ",", "'.bcf'", ",", "'addbibresource'", "]", ",", "[", "'.toc'", ",", "'contents'", "]", ",", "[", "'.lof'", ",", "'figures'", "]", ",", "[", "'.lot'", ",", "'tables'", "]", ",", "[", "'.out'", ",", "'hyperref'", "]", ",", "[", "'.nlo'", ",", "'.nls'", ",", "'.nlg'", ",", "'nomenclature'", "]", ",", "[", "'.glo'", ",", "'.gls'", ",", "'.glg'", ",", "'glossary'", "]", ",", "[", "'.glo'", ",", "'.gls'", ",", "'.glg'", ",", "'glossaries'", "]", ",", "[", "'.acn'", ",", "'.acr'", ",", "'.alg'", ",", "'acronyms'", "]", ",", "[", "'.nav'", ",", "'.snm'", ",", "'.out'", ",", "'.toc'", ",", "'beamer'", "]", ",", "[", "'newglossary'", ",", "]", ",", "[", "'.bcf'", ",", "'.blg'", ",", "'biblatex'", "]", "]", "# for newglossary the suffixes are added as we find the command", "# build the list of lists", "file_tests", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "file_tests_search", ")", ")", ":", "file_tests", ".", "append", "(", "[", "None", ",", "file_tests_suff", "[", "i", "]", "]", ")", "# TO-DO: need to add a way for the user to extend this list for whatever", "# auxiliary files they create in other (or their own) packages", "# get path list from both env['TEXINPUTS'] and env['ENV']['TEXINPUTS']", "savedpath", "=", "modify_env_var", "(", "env", ",", "'TEXINPUTS'", ",", "abspath", ")", "paths", "=", "env", "[", "'ENV'", "]", "[", "'TEXINPUTS'", "]", "if", "SCons", ".", "Util", ".", "is_List", "(", "paths", ")", ":", "pass", "else", ":", "# Split at os.pathsep to convert into absolute path", "paths", "=", "paths", ".", "split", "(", "os", ".", "pathsep", ")", "# now that we have the path list restore the env", "if", "savedpath", "is", "_null", ":", "try", ":", "del", "env", "[", "'ENV'", "]", "[", "'TEXINPUTS'", "]", "except", "KeyError", ":", "pass", "# was never set", "else", ":", "env", "[", "'ENV'", "]", "[", "'TEXINPUTS'", "]", "=", "savedpath", "if", "Verbose", ":", "print", "(", "\"search path \"", ",", "paths", ")", "# scan all sources for side effect files", "aux_files", "=", "[", "]", "file_tests", "=", "ScanFiles", "(", "source", "[", "0", "]", ",", "target", ",", "paths", ",", "file_tests", ",", "file_tests_search", ",", "env", ",", "graphics_extensions", ",", "targetdir", ",", "aux_files", ")", "for", "(", "theSearch", ",", "suffix_list", ")", "in", "file_tests", ":", "# add side effects if feature is present.If file is to be generated,add all side effects", "if", "Verbose", "and", "theSearch", ":", "print", "(", "\"check side effects for \"", ",", "suffix_list", "[", "-", "1", "]", ")", "if", "theSearch", "is", "not", "None", "or", "not", "source", "[", "0", "]", ".", "exists", "(", ")", ":", "file_list", "=", "[", "targetbase", ",", "]", "# for bibunit we need a list of files", "if", "suffix_list", "[", "-", "1", "]", "==", "'bibunit'", ":", "file_basename", "=", "os", ".", "path", ".", "join", "(", "targetdir", ",", "'bu*.aux'", ")", "file_list", "=", "glob", ".", "glob", "(", "file_basename", ")", "# remove the suffix '.aux'", "for", "fl", "in", "file_list", ".", "copy", "(", ")", ":", "file_list", ".", "append", "(", "SCons", ".", "Util", ".", "splitext", "(", "fl", ")", "[", "0", "]", ")", "# for multibib we need a list of files", "if", "suffix_list", "[", "-", "1", "]", "==", "'multibib'", ":", "for", "multibibmatch", "in", "multibib_re", ".", "finditer", "(", "content", ")", ":", "if", "Verbose", ":", "print", "(", "\"multibib match \"", ",", "multibibmatch", ".", "group", "(", "1", ")", ")", "if", "multibibmatch", "is", "not", "None", ":", "baselist", "=", "multibibmatch", ".", "group", "(", "1", ")", ".", "split", "(", "','", ")", "if", "Verbose", ":", "print", "(", "\"multibib list \"", ",", "baselist", ")", "for", "bl", "in", "baselist", ":", "file_list", ".", "append", "(", "os", ".", "path", ".", "join", "(", "targetdir", ",", "bl", ")", ")", "# now define the side effects", "for", "file_name", "in", "file_list", ":", "for", "suffix", "in", "suffix_list", "[", ":", "-", "1", "]", ":", "env", ".", "SideEffect", "(", "file_name", "+", "suffix", ",", "target", "[", "0", "]", ")", "if", "Verbose", ":", "print", "(", "\"side effect tst :\"", ",", "file_name", "+", "suffix", ",", "\" target is \"", ",", "str", "(", "target", "[", "0", "]", ")", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "file_name", "+", "suffix", ")", "for", "aFile", "in", "aux_files", ":", "aFile_base", "=", "SCons", ".", "Util", ".", "splitext", "(", "aFile", ")", "[", "0", "]", "env", ".", "SideEffect", "(", "aFile_base", "+", "'.aux'", ",", "target", "[", "0", "]", ")", "if", "Verbose", ":", "print", "(", "\"side effect aux :\"", ",", "aFile_base", "+", "'.aux'", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "aFile_base", "+", "'.aux'", ")", "# read fls file to get all other files that latex creates and will read on the next pass", "# remove files from list that we explicitly dealt with above", "if", "os", ".", "path", ".", "isfile", "(", "flsfilename", ")", ":", "with", "open", "(", "flsfilename", ",", "\"r\"", ")", "as", "f", ":", "content", "=", "f", ".", "read", "(", ")", "out_files", "=", "openout_re", ".", "findall", "(", "content", ")", "myfiles", "=", "[", "auxfilename", ",", "logfilename", ",", "flsfilename", ",", "targetbase", "+", "'.dvi'", ",", "targetbase", "+", "'.pdf'", "]", "for", "filename", "in", "out_files", "[", ":", "]", ":", "if", "filename", "in", "myfiles", ":", "out_files", ".", "remove", "(", "filename", ")", "env", ".", "SideEffect", "(", "out_files", ",", "target", "[", "0", "]", ")", "if", "Verbose", ":", "print", "(", "\"side effect fls :\"", ",", "out_files", ")", "env", ".", "Clean", "(", "target", "[", "0", "]", ",", "out_files", ")", "return", "(", "target", ",", "source", ")" ]

[ "Get", "skew", "for", "given", "checkerboard", "detection", ".", "Scaled", "to", "[", "0", "1", "]", "which", "0", "=", "no", "skew", "1", "=", "high", "skew", "Skew", "is", "proportional", "to", "the", "divergence", "of", "three", "outside", "corners", "from", "90", "degrees", "." ]

[ "def", "_calculate_skew", "(", "corners", ")", ":", "# TODO Using three nearby interior corners might be more robust, outside corners occasionally", "# get mis-detected", "up_left", ",", "up_right", ",", "down_right", ",", "_", "=", "corners", "def", "angle", "(", "a", ",", "b", ",", "c", ")", ":", "\"\"\"\n Return angle between lines ab, bc\n \"\"\"", "ab", "=", "a", "-", "b", "cb", "=", "c", "-", "b", "return", "math", ".", "acos", "(", "numpy", ".", "dot", "(", "ab", ",", "cb", ")", "/", "(", "numpy", ".", "linalg", ".", "norm", "(", "ab", ")", "*", "numpy", ".", "linalg", ".", "norm", "(", "cb", ")", ")", ")", "skew", "=", "min", "(", "1.0", ",", "2.", "*", "abs", "(", "(", "math", ".", "pi", "/", "2.", ")", "-", "angle", "(", "up_left", ",", "up_right", ",", "down_right", ")", ")", ")", "return", "skew" ]

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

[ "def", "IsShownOnScreen", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "Window_IsShownOnScreen", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Create", "the", "parsed", "C", "++", "header", "file", "parse", "tree", "headerFileName", "-", "Name", "of", "the", "file", "to", "parse", "OR", "actual", "file", "contents", "(", "depends", "on", "argType", ")", "argType", "-", "Indicates", "how", "to", "interpret", "headerFileName", "as", "a", "file", "string", "or", "file", "name", "kwargs", "-", "Supports", "the", "following", "keywords" ]

[ "def", "__init__", "(", "self", ",", "headerFileName", ",", "argType", "=", "\"file\"", ",", "*", "*", "kwargs", ")", ":", "## reset global state ##", "global", "doxygenCommentCache", "doxygenCommentCache", "=", "\"\"", "CppVariable", ".", "Vars", "=", "[", "]", "CppStruct", ".", "Structs", "=", "[", "]", "if", "(", "argType", "==", "\"file\"", ")", ":", "self", ".", "headerFileName", "=", "os", ".", "path", ".", "expandvars", "(", "headerFileName", ")", "self", ".", "mainClass", "=", "os", ".", "path", ".", "split", "(", "self", ".", "headerFileName", ")", "[", "1", "]", "[", ":", "-", "2", "]", "headerFileStr", "=", "\"\"", "elif", "argType", "==", "\"string\"", ":", "self", ".", "headerFileName", "=", "\"\"", "self", ".", "mainClass", "=", "\"???\"", "headerFileStr", "=", "headerFileName", "else", ":", "raise", "Exception", "(", "\"Arg type must be either file or string\"", ")", "self", ".", "curClass", "=", "\"\"", "# nested classes have parent::nested, but no extra namespace,", "# this keeps the API compatible, TODO proper namespace for everything. ", "Resolver", ".", "CLASSES", "=", "{", "}", "self", ".", "classes", "=", "Resolver", ".", "CLASSES", "#Functions that are not part of a class", "self", ".", "functions", "=", "[", "]", "self", ".", "pragmas", "=", "[", "]", "self", ".", "defines", "=", "[", "]", "self", ".", "includes", "=", "[", "]", "self", ".", "_precomp_macro_buf", "=", "[", "]", "#for internal purposes, will end up filling out pragmras and defines at the end", "self", ".", "enums", "=", "[", "]", "self", ".", "variables", "=", "[", "]", "self", ".", "global_enums", "=", "{", "}", "self", ".", "nameStack", "=", "[", "]", "self", ".", "nameSpaces", "=", "[", "]", "self", ".", "curAccessSpecifier", "=", "'private'", "# private is default", "self", ".", "curTemplate", "=", "None", "self", ".", "accessSpecifierStack", "=", "[", "]", "self", ".", "accessSpecifierScratch", "=", "[", "]", "debug_print", "(", "\"curAccessSpecifier changed/defaulted to %s\"", "%", "self", ".", "curAccessSpecifier", ")", "self", ".", "initextra", "(", ")", "# Old namestacks for a given level", "self", ".", "nameStackHistory", "=", "[", "]", "self", ".", "anon_struct_counter", "=", "0", "self", ".", "anon_union_counter", "=", "[", "-", "1", ",", "0", "]", "self", ".", "templateRegistry", "=", "[", "]", "if", "(", "len", "(", "self", ".", "headerFileName", ")", ")", ":", "fd", "=", "open", "(", "self", ".", "headerFileName", ")", "headerFileStr", "=", "\"\"", ".", "join", "(", "fd", ".", "readlines", "(", ")", ")", "fd", ".", "close", "(", ")", "# Make sure supportedAccessSpecifier are sane", "for", "i", "in", "range", "(", "0", ",", "len", "(", "supportedAccessSpecifier", ")", ")", ":", "if", "\" \"", "not", "in", "supportedAccessSpecifier", "[", "i", "]", ":", "continue", "supportedAccessSpecifier", "[", "i", "]", "=", "re", ".", "sub", "(", "\"[ ]+\"", ",", "\" \"", ",", "supportedAccessSpecifier", "[", "i", "]", ")", ".", "strip", "(", ")", "# Strip out template declarations", "templateSectionsToSliceOut", "=", "[", "]", "try", ":", "for", "m", "in", "re", ".", "finditer", "(", "\"template[\\t ]*<[^>]*>\"", ",", "headerFileStr", ")", ":", "start", "=", "m", ".", "start", "(", ")", "# Search for the final '>' which may or may not be caught in the case of nexted <>'s", "for", "i", "in", "range", "(", "start", ",", "len", "(", "headerFileStr", ")", ")", ":", "if", "headerFileStr", "[", "i", "]", "==", "'<'", ":", "firstBracket", "=", "i", "break", "ltgtStackCount", "=", "1", "#Now look for fianl '>'", "for", "i", "in", "range", "(", "firstBracket", "+", "1", ",", "len", "(", "headerFileStr", ")", ")", ":", "if", "headerFileStr", "[", "i", "]", "==", "'<'", ":", "ltgtStackCount", "+=", "1", "elif", "headerFileStr", "[", "i", "]", "==", "'>'", ":", "ltgtStackCount", "-=", "1", "if", "ltgtStackCount", "==", "0", ":", "end", "=", "i", "break", "templateSectionsToSliceOut", ".", "append", "(", "(", "start", ",", "end", ")", ")", "# Now strip out all instances of the template", "templateSectionsToSliceOut", ".", "reverse", "(", ")", "for", "tslice", "in", "templateSectionsToSliceOut", ":", "# Replace the template symbol with a single symbol", "template_symbol", "=", "\"CppHeaderParser_template_%d\"", "%", "len", "(", "self", ".", "templateRegistry", ")", "self", ".", "templateRegistry", ".", "append", "(", "headerFileStr", "[", "tslice", "[", "0", "]", ":", "tslice", "[", "1", "]", "+", "1", "]", ")", "newlines", "=", "headerFileStr", "[", "tslice", "[", "0", "]", ":", "tslice", "[", "1", "]", "]", ".", "count", "(", "\"\\n\"", ")", "*", "\"\\n\"", "#Keep line numbers the same", "headerFileStr", "=", "headerFileStr", "[", ":", "tslice", "[", "0", "]", "]", "+", "newlines", "+", "\" \"", "+", "template_symbol", "+", "\" \"", "+", "headerFileStr", "[", "tslice", "[", "1", "]", "+", "1", ":", "]", "except", ":", "pass", "# Change multi line #defines and expressions to single lines maintaining line nubmers", "# Based from http://stackoverflow.com/questions/2424458/regular-expression-to-match-cs-multiline-preprocessor-statements", "matches", "=", "re", ".", "findall", "(", "r'(?m)^(?:.*\\\\\\r?\\n)+.*$'", ",", "headerFileStr", ")", "is_define", "=", "re", ".", "compile", "(", "r'[ \\t\\v]*#[Dd][Ee][Ff][Ii][Nn][Ee]'", ")", "for", "m", "in", "matches", ":", "#Keep the newlines so that linecount doesnt break", "num_newlines", "=", "len", "(", "[", "a", "for", "a", "in", "m", "if", "a", "==", "\"\\n\"", "]", ")", "if", "is_define", ".", "match", "(", "m", ")", ":", "new_m", "=", "m", ".", "replace", "(", "\"\\n\"", ",", "\"<CppHeaderParser_newline_temp_replacement>\\\\n\"", ")", "else", ":", "# Just expression taking up multiple lines, make it take 1 line for easier parsing", "new_m", "=", "m", ".", "replace", "(", "\"\\\\\\n\"", ",", "\" \"", ")", "if", "(", "num_newlines", ">", "0", ")", ":", "new_m", "+=", "\"\\n\"", "*", "(", "num_newlines", ")", "headerFileStr", "=", "headerFileStr", ".", "replace", "(", "m", ",", "new_m", ")", "#Filter out Extern \"C\" statements. These are order dependent", "matches", "=", "re", ".", "findall", "(", "re", ".", "compile", "(", "r'extern[\\t ]+\"[Cc]\"[\\t \\n\\r]*{'", ",", "re", ".", "DOTALL", ")", ",", "headerFileStr", ")", "for", "m", "in", "matches", ":", "#Keep the newlines so that linecount doesnt break", "num_newlines", "=", "len", "(", "[", "a", "for", "a", "in", "m", "if", "a", "==", "\"\\n\"", "]", ")", "headerFileStr", "=", "headerFileStr", ".", "replace", "(", "m", ",", "\"\\n\"", "*", "num_newlines", ")", "headerFileStr", "=", "re", ".", "sub", "(", "r'extern[ ]+\"[Cc]\"[ ]*'", ",", "\"\"", ",", "headerFileStr", ")", "#Filter out any ignore symbols that end with \"()\" to account for #define magic functions", "for", "ignore", "in", "ignoreSymbols", ":", "if", "not", "ignore", ".", "endswith", "(", "\"()\"", ")", ":", "continue", "while", "True", ":", "locStart", "=", "headerFileStr", ".", "find", "(", "ignore", "[", ":", "-", "1", "]", ")", "if", "locStart", "==", "-", "1", ":", "break", "locEnd", "=", "None", "#Now walk till we find the last paren and account for sub parens", "parenCount", "=", "1", "inQuotes", "=", "False", "for", "i", "in", "range", "(", "locStart", "+", "len", "(", "ignore", ")", "-", "1", ",", "len", "(", "headerFileStr", ")", ")", ":", "c", "=", "headerFileStr", "[", "i", "]", "if", "not", "inQuotes", ":", "if", "c", "==", "\"(\"", ":", "parenCount", "+=", "1", "elif", "c", "==", "\")\"", ":", "parenCount", "-=", "1", "elif", "c", "==", "'\"'", ":", "inQuotes", "=", "True", "if", "parenCount", "==", "0", ":", "locEnd", "=", "i", "+", "1", "break", "else", ":", "if", "c", "==", "'\"'", "and", "headerFileStr", "[", "i", "-", "1", "]", "!=", "'\\\\'", ":", "inQuotes", "=", "False", "if", "locEnd", ":", "#Strip it out but keep the linecount the same so line numbers are right", "match_str", "=", "headerFileStr", "[", "locStart", ":", "locEnd", "]", "debug_print", "(", "\"Striping out '%s'\"", "%", "match_str", ")", "num_newlines", "=", "len", "(", "[", "a", "for", "a", "in", "match_str", "if", "a", "==", "\"\\n\"", "]", ")", "headerFileStr", "=", "headerFileStr", ".", "replace", "(", "headerFileStr", "[", "locStart", ":", "locEnd", "]", ",", "\"\\n\"", "*", "num_newlines", ")", "self", ".", "braceDepth", "=", "0", "lex", ".", "lex", "(", ")", "lex", ".", "input", "(", "headerFileStr", ")", "global", "curLine", "global", "curChar", "curLine", "=", "0", "curChar", "=", "0", "try", ":", "while", "True", ":", "tok", "=", "lex", ".", "token", "(", ")", "if", "not", "tok", ":", "break", "if", "self", ".", "anon_union_counter", "[", "0", "]", "==", "self", ".", "braceDepth", "and", "self", ".", "anon_union_counter", "[", "1", "]", ":", "self", ".", "anon_union_counter", "[", "1", "]", "-=", "1", "tok", ".", "value", "=", "TagStr", "(", "tok", ".", "value", ",", "lineno", "=", "tok", ".", "lineno", ")", "#debug_print(\"TOK: %s\"%tok)", "if", "tok", ".", "type", "==", "'NAME'", "and", "tok", ".", "value", "in", "self", ".", "IGNORE_NAMES", ":", "continue", "if", "tok", ".", "type", "!=", "'TEMPLATE_NAME'", ":", "self", ".", "stack", ".", "append", "(", "tok", ".", "value", ")", "curLine", "=", "tok", ".", "lineno", "curChar", "=", "tok", ".", "lexpos", "if", "(", "tok", ".", "type", "in", "(", "'PRECOMP_MACRO'", ",", "'PRECOMP_MACRO_CONT'", ")", ")", ":", "debug_print", "(", "\"PRECOMP: %s\"", "%", "tok", ")", "self", ".", "_precomp_macro_buf", ".", "append", "(", "tok", ".", "value", ")", "self", ".", "stack", "=", "[", "]", "self", ".", "nameStack", "=", "[", "]", "continue", "if", "tok", ".", "type", "==", "'TEMPLATE_NAME'", ":", "try", ":", "templateId", "=", "int", "(", "tok", ".", "value", ".", "replace", "(", "\"CppHeaderParser_template_\"", ",", "\"\"", ")", ")", "self", ".", "curTemplate", "=", "self", ".", "templateRegistry", "[", "templateId", "]", "except", ":", "pass", "if", "(", "tok", ".", "type", "==", "'OPEN_BRACE'", ")", ":", "if", "len", "(", "self", ".", "nameStack", ")", ">=", "2", "and", "is_namespace", "(", "self", ".", "nameStack", ")", ":", "# namespace {} with no name used in boost, this sets default?", "if", "self", ".", "nameStack", "[", "1", "]", "==", "\"__IGNORED_NAMESPACE__CppHeaderParser__\"", ":", "#Used in filtering extern \"C\"", "self", ".", "nameStack", "[", "1", "]", "=", "\"\"", "self", ".", "nameSpaces", ".", "append", "(", "self", ".", "nameStack", "[", "1", "]", ")", "ns", "=", "self", ".", "cur_namespace", "(", ")", "self", ".", "stack", "=", "[", "]", "if", "ns", "not", "in", "self", ".", "namespaces", ":", "self", ".", "namespaces", ".", "append", "(", "ns", ")", "# Detect special condition of macro magic before class declaration so we", "# can filter it out", "if", "'class'", "in", "self", ".", "nameStack", "and", "self", ".", "nameStack", "[", "0", "]", "!=", "'class'", "and", "self", ".", "nameStack", "[", "0", "]", "!=", "'enum'", ":", "classLocationNS", "=", "self", ".", "nameStack", ".", "index", "(", "\"class\"", ")", "classLocationS", "=", "self", ".", "stack", ".", "index", "(", "\"class\"", ")", "if", "\"(\"", "not", "in", "self", ".", "nameStack", "[", "classLocationNS", ":", "]", ":", "debug_print", "(", "\"keyword 'class' found in unexpected location in nameStack, must be following #define magic. Process that before moving on\"", ")", "origNameStack", "=", "self", ".", "nameStack", "origStack", "=", "self", ".", "stack", "#Process first part of stack which is probably #define macro magic and may cause issues", "self", ".", "nameStack", "=", "self", ".", "nameStack", "[", ":", "classLocationNS", "]", "self", ".", "stack", "=", "self", ".", "stack", "[", ":", "classLocationS", "]", "try", ":", "self", ".", "evaluate_stack", "(", ")", "except", ":", "debug_print", "(", "\"Error processing #define magic... Oh well\"", ")", "#Process rest of stack", "self", ".", "nameStack", "=", "origNameStack", "[", "classLocationNS", ":", "]", "self", ".", "stack", "=", "origStack", "[", "classLocationS", ":", "]", "if", "len", "(", "self", ".", "nameStack", ")", "and", "not", "is_enum_namestack", "(", "self", ".", "nameStack", ")", ":", "self", ".", "evaluate_stack", "(", ")", "else", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "if", "self", ".", "stack", "and", "self", ".", "stack", "[", "0", "]", "==", "'class'", ":", "self", ".", "stack", "=", "[", "]", "self", ".", "braceDepth", "+=", "1", "elif", "(", "tok", ".", "type", "==", "'CLOSE_BRACE'", ")", ":", "if", "self", ".", "braceDepth", "==", "0", ":", "continue", "if", "(", "self", ".", "braceDepth", "==", "len", "(", "self", ".", "nameSpaces", ")", ")", ":", "tmp", "=", "self", ".", "nameSpaces", ".", "pop", "(", ")", "self", ".", "stack", "=", "[", "]", "# clear stack when namespace ends?", "if", "len", "(", "self", ".", "nameStack", ")", "and", "is_enum_namestack", "(", "self", ".", "nameStack", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "self", ".", "braceDepth", "<", "10", ":", "self", ".", "evaluate_stack", "(", ")", "else", ":", "self", ".", "nameStack", "=", "[", "]", "self", ".", "braceDepth", "-=", "1", "#self.stack = []; print 'BRACE DEPTH', self.braceDepth, 'NS', len(self.nameSpaces)", "if", "self", ".", "curClass", ":", "debug_print", "(", "'CURBD %s'", "%", "self", ".", "_classes_brace_level", "[", "self", ".", "curClass", "]", ")", "if", "(", "self", ".", "braceDepth", "==", "0", ")", "or", "(", "self", ".", "curClass", "and", "self", ".", "_classes_brace_level", "[", "self", ".", "curClass", "]", "==", "self", ".", "braceDepth", ")", ":", "trace_print", "(", "'END OF CLASS DEF'", ")", "if", "self", ".", "accessSpecifierStack", ":", "self", ".", "curAccessSpecifier", "=", "self", ".", "accessSpecifierStack", "[", "-", "1", "]", "self", ".", "accessSpecifierStack", "=", "self", ".", "accessSpecifierStack", "[", ":", "-", "1", "]", "if", "self", ".", "curClass", "and", "self", ".", "classes", "[", "self", ".", "curClass", "]", "[", "'parent'", "]", ":", "self", ".", "curClass", "=", "self", ".", "classes", "[", "self", ".", "curClass", "]", "[", "'parent'", "]", "else", ":", "self", ".", "curClass", "=", "\"\"", "#self.curStruct = None", "self", ".", "stack", "=", "[", "]", "#if self.curStruct: self.curStruct = None", "if", "self", ".", "braceDepth", "==", "0", "or", "(", "self", ".", "curStruct", "and", "self", ".", "_structs_brace_level", "[", "self", ".", "curStruct", "[", "'type'", "]", "]", "==", "self", ".", "braceDepth", ")", ":", "trace_print", "(", "'END OF STRUCT DEF'", ")", "self", ".", "curStruct", "=", "None", "if", "self", ".", "_method_body", "and", "(", "self", ".", "braceDepth", "+", "1", ")", "<=", "self", ".", "_method_body", ":", "self", ".", "_method_body", "=", "None", "self", ".", "stack", "=", "[", "]", "self", ".", "nameStack", "=", "[", "]", "trace_print", "(", "'FORCE CLEAR METHBODY'", ")", "if", "(", "tok", ".", "type", "==", "'OPEN_PAREN'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'CLOSE_PAREN'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'OPEN_SQUARE_BRACKET'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'CLOSE_SQUARE_BRACKET'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'TAB'", ")", ":", "pass", "elif", "(", "tok", ".", "type", "==", "'EQUALS'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'COMMA'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'BACKSLASH'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'DIVIDE'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'PIPE'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'PERCENT'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'CARET'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'EXCLAMATION'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'SQUOTE'", ")", ":", "pass", "elif", "(", "tok", ".", "type", "==", "'NUMBER'", "or", "tok", ".", "type", "==", "'FLOAT_NUMBER'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'MINUS'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'PLUS'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'STRING_LITERAL'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "(", "tok", ".", "type", "==", "'NAME'", "or", "tok", ".", "type", "==", "'AMPERSTAND'", "or", "tok", ".", "type", "==", "'ASTERISK'", "or", "tok", ".", "type", "==", "'CHAR_LITERAL'", ")", ":", "if", "tok", ".", "value", "in", "ignoreSymbols", ":", "debug_print", "(", "\"Ignore symbol %s\"", "%", "tok", ".", "value", ")", "elif", "(", "tok", ".", "value", "==", "'class'", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "tok", ".", "value", "in", "supportedAccessSpecifier", ":", "if", "len", "(", "self", ".", "nameStack", ")", "and", "self", ".", "nameStack", "[", "0", "]", "in", "(", "\"class\"", ",", "\"struct\"", ",", "\"union\"", ")", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "elif", "self", ".", "braceDepth", "==", "len", "(", "self", ".", "nameSpaces", ")", "+", "1", "or", "self", ".", "braceDepth", "==", "(", "len", "(", "self", ".", "nameSpaces", ")", "+", "len", "(", "self", ".", "curClass", ".", "split", "(", "\"::\"", ")", ")", ")", ":", "self", ".", "curAccessSpecifier", "=", "tok", ".", "value", "self", ".", "accessSpecifierScratch", ".", "append", "(", "tok", ".", "value", ")", "debug_print", "(", "\"curAccessSpecifier updated to %s\"", "%", "self", ".", "curAccessSpecifier", ")", "self", ".", "stack", "=", "[", "]", "else", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "if", "self", ".", "anon_union_counter", "[", "0", "]", "==", "self", ".", "braceDepth", ":", "self", ".", "anon_union_counter", "=", "[", "-", "1", ",", "0", "]", "elif", "(", "tok", ".", "type", "==", "'COLON'", ")", ":", "#Dont want colon to be first in stack", "if", "len", "(", "self", ".", "nameStack", ")", "==", "0", ":", "self", ".", "accessSpecifierScratch", "=", "[", "]", "continue", "# Handle situation where access specifiers can be multi words such as \"public slots\"", "jns", "=", "\" \"", ".", "join", "(", "self", ".", "accessSpecifierScratch", "+", "self", ".", "nameStack", ")", "if", "jns", "in", "supportedAccessSpecifier", ":", "self", ".", "curAccessSpecifier", "=", "jns", "debug_print", "(", "\"curAccessSpecifier updated to %s\"", "%", "self", ".", "curAccessSpecifier", ")", "self", ".", "stack", "=", "[", "]", "self", ".", "nameStack", "=", "[", "]", "else", ":", "self", ".", "nameStack", ".", "append", "(", "tok", ".", "value", ")", "self", ".", "accessSpecifierScratch", "=", "[", "]", "elif", "(", "tok", ".", "type", "==", "'SEMI_COLON'", ")", ":", "if", "self", ".", "anon_union_counter", "[", "0", "]", "==", "self", ".", "braceDepth", "and", "self", ".", "anon_union_counter", "[", "1", "]", ":", "debug_print", "(", "\"Creating anonymous union\"", ")", "#Force the processing of an anonymous union", "saved_namestack", "=", "self", ".", "nameStack", "[", ":", "]", "saved_stack", "=", "self", ".", "stack", "[", ":", "]", "self", ".", "nameStack", "=", "[", "\"\"", "]", "self", ".", "stack", "=", "self", ".", "nameStack", "+", "[", "\";\"", "]", "self", ".", "nameStack", "=", "self", ".", "nameStack", "[", "0", ":", "1", "]", "debug_print", "(", "\"pre eval anon stack\"", ")", "self", ".", "evaluate_stack", "(", "tok", ".", "type", ")", "debug_print", "(", "\"post eval anon stack\"", ")", "self", ".", "nameStack", "=", "saved_namestack", "self", ".", "stack", "=", "saved_stack", "self", ".", "anon_union_counter", "=", "[", "-", "1", ",", "0", "]", "if", "(", "self", ".", "braceDepth", "<", "10", ")", ":", "self", ".", "evaluate_stack", "(", "tok", ".", "type", ")", "self", ".", "stack", "=", "[", "]", "self", ".", "nameStack", "=", "[", "]", "except", ":", "if", "(", "debug", ")", ":", "raise", "raise", "CppParseError", "(", "\"Not able to parse %s on line %d evaluating \\\"%s\\\"\\nError around: %s\"", "%", "(", "self", ".", "headerFileName", ",", "tok", ".", "lineno", ",", "tok", ".", "value", ",", "\" \"", ".", "join", "(", "self", ".", "nameStack", ")", ")", ")", "self", ".", "finalize", "(", ")", "global", "parseHistory", "parseHistory", "=", "[", "]", "# Delete some temporary variables", "for", "key", "in", "[", "\"_precomp_macro_buf\"", ",", "\"nameStack\"", ",", "\"nameSpaces\"", ",", "\"curAccessSpecifier\"", ",", "\"accessSpecifierStack\"", ",", "\"accessSpecifierScratch\"", ",", "\"nameStackHistory\"", ",", "\"anon_struct_counter\"", ",", "\"anon_union_counter\"", ",", "\"_classes_brace_level\"", ",", "\"_forward_decls\"", ",", "\"stack\"", ",", "\"mainClass\"", ",", "\"curStruct\"", ",", "\"_template_typenames\"", ",", "\"_method_body\"", ",", "\"braceDepth\"", ",", "\"_structs_brace_level\"", ",", "\"typedefs_order\"", ",", "\"curTemplate\"", ",", "\"templateRegistry\"", "]", ":", "del", "self", ".", "__dict__", "[", "key", "]" ]

[ "A", "control", "trigger", "node", "for", "synchronization", "in", "the", "forward", "loop", "." ]

[ "def", "forward_sync", "(", "self", ")", ":", "if", "self", ".", "_forward_sync", "is", "None", ":", "with", "ops", ".", "control_dependencies", "(", "None", ")", ":", "self", ".", "_forward_sync", "=", "control_trigger", "(", "name", "=", "\"f_sync\"", ")", "self", ".", "_forward_sync", ".", "_set_control_flow_context", "(", "self", ".", "_forward_context", ")", "self", ".", "_forward_index", ".", "op", ".", "_add_control_input", "(", "self", ".", "_forward_sync", ")", "return", "self", ".", "_forward_sync" ]

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

[ "def", "GetRowOrCol", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "GridSizeEvent_GetRowOrCol", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Calculate", "structure", "factor", "by", "dispatching", "to", "appropriate", "1d", "or", "2d", "workflow" ]

[ "def", "_calculate_s", "(", "self", ")", "->", "SData", ":", "from", "abins", ".", "constants", "import", "ONE_DIMENSIONAL_INSTRUMENTS", ",", "TWO_DIMENSIONAL_INSTRUMENTS", "# Compute tensors and traces, write to cache for access during atomic s calculations", "powder_calculator", "=", "abins", ".", "PowderCalculator", "(", "filename", "=", "self", ".", "_input_filename", ",", "abins_data", "=", "self", ".", "_abins_data", ")", "self", ".", "_powder_data", "=", "powder_calculator", ".", "get_formatted_data", "(", ")", "# Dispatch to appropriate routine", "if", "self", ".", "_instrument", ".", "get_name", "(", ")", "in", "ONE_DIMENSIONAL_INSTRUMENTS", ":", "return", "self", ".", "_calculate_s_powder_1d", "(", "isotropic_fundamentals", "=", "abins", ".", "parameters", ".", "development", ".", "get", "(", "'isotropic_fundamentals'", ",", "False", ")", ")", "elif", "self", ".", "_instrument", ".", "get_name", "(", ")", "in", "TWO_DIMENSIONAL_INSTRUMENTS", ":", "return", "self", ".", "_calculate_s_powder_2d", "(", ")", "else", ":", "raise", "ValueError", "(", "'Instrument \"{}\" is not recognised, cannot perform semi-empirical '", "'powder averaging.'", ".", "format", "(", "self", ".", "_instrument", ".", "get_name", "(", ")", ")", ")" ]

[ "Either", "raise", "an", "error", "for", "an", "unsupported", "op", "type", "or", "return", "custom", "layer", "add", "function" ]

[ "def", "unsupported_op", "(", "self", ",", "node", ",", "# type: Node", ")", ":", "# type: (...) -> Callable[[Any, Node, Graph, ErrorHandling], None]", "if", "self", ".", "add_custom_layers", ":", "from", ".", "_operators", "import", "_convert_custom", "return", "_convert_custom", "else", ":", "raise", "TypeError", "(", "\"ONNX node of type {} is not supported. {}\\n\"", ".", "format", "(", "node", ".", "op_type", ",", "self", ".", "rerun_suggestion", ")", ")" ]

[ "Does", "line", "terminate", "so", "that", "the", "next", "symbol", "is", "in", "string", "constant", "." ]

[ "def", "IsCppString", "(", "line", ")", ":", "line", "=", "line", ".", "replace", "(", "r'\\\\'", ",", "'XX'", ")", "# after this, \\\\\" does not match to \\\"", "return", "(", "(", "line", ".", "count", "(", "'\"'", ")", "-", "line", ".", "count", "(", "r'\\\"'", ")", "-", "line", ".", "count", "(", "\"'\\\"'\"", ")", ")", "&", "1", ")", "==", "1" ]

[ "Yield", "a", "tuple", "of", "(", "fieldname", "value", ")", "for", "each", "field", "in", "node", ".", "_fields", "that", "is", "present", "on", "*", "node", "*", "." ]

[ "def", "iter_fields", "(", "node", ")", ":", "for", "field", "in", "node", ".", "_fields", ":", "try", ":", "yield", "field", ",", "getattr", "(", "node", ",", "field", ")", "except", "AttributeError", ":", "pass" ]

[ "IsWithin", "(", "self", "RichTextRange", "range", ")", "-", ">", "bool" ]

[ "def", "IsWithin", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextRange_IsWithin", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ ":", "type", "buckets", ":", "int", ":", "type", "minutesToDie", ":", "int", ":", "type", "minutesToTest", ":", "int", ":", "rtype", ":", "int" ]

[ "def", "poorPigs", "(", "self", ",", "buckets", ",", "minutesToDie", ",", "minutesToTest", ")", ":", "return", "int", "(", "math", ".", "ceil", "(", "math", ".", "log", "(", "buckets", ")", "/", "math", ".", "log", "(", "minutesToTest", "/", "minutesToDie", "+", "1", ")", ")", ")" ]

[ "Validator", "to", "check", "if", "Path", "is", "a", "directory", "." ]

[ "def", "PathIsDir", "(", "self", ",", "key", ",", "val", ",", "env", ")", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "val", ")", ":", "if", "os", ".", "path", ".", "isfile", "(", "val", ")", ":", "m", "=", "'Directory path for option %s is a file: %s'", "else", ":", "m", "=", "'Directory path for option %s does not exist: %s'", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "m", "%", "(", "key", ",", "val", ")", ")" ]

[ "Run", "the", "given", "command", "and", "return", "the", "standard", "output", "in", "bytes" ]

[ "def", "check_output", "(", "cmd", ")", ":", "log", ".", "debug", "(", "'Running %s'", "%", "command_string", "(", "cmd", ")", ")", "try", ":", "return", "subprocess", ".", "check_output", "(", "cmd", ")", "except", "OSError", "as", "e", ":", "printf", "(", "'error: %s: %s\\n'", ",", "cmd", "[", "0", "]", ",", "e", ".", "strerror", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "e", ".", "errno", ")" ]