Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Return", "a", "random", "URL", "-", "safe", "text", "string", "in", "Base64", "encoding", "." ]

[ "def", "token_urlsafe", "(", "nbytes", "=", "None", ")", ":", "tok", "=", "token_bytes", "(", "nbytes", ")", "return", "base64", ".", "urlsafe_b64encode", "(", "tok", ")", ".", "rstrip", "(", "b'='", ")", ".", "decode", "(", "'ascii'", ")" ]

[ "Initialize", "your", "data", "structure", "here", "." ]

[ "def", "__init__", "(", "self", ")", ":", "self", ".", "__dq", "=", "collections", ".", "deque", "(", ")", "self", ".", "__printed", "=", "set", "(", ")" ]

[ "Sets", "the", "tab", "control", "height", "." ]

[ "def", "SetTabCtrlHeight", "(", "self", ",", "h", ")", ":", "self", ".", "_tab_ctrl_height", "=", "h" ]

[ "Returns", "a", "list", "of", "sample", "numbers", "of", "same", "length", "as", "the", "number", "of", "entries", "in", "newLevels", ".", "Doubles", "the", "number", "of", "samples", "from", "oldHierarchy", "if", "an", "entry", "of", "newLevels", "exists", "in", "oldHierarchy", ".", "If", "not", "allocate", "a", "default", "newSampleNumber", "to", "the", "entry", "." ]

[ "def", "multiLevelDoubleAllSamples", "(", "inputDict", ",", "newLevels", ")", ":", "oldHierarchy", "=", "inputDict", "[", "\"oldHierarchy\"", "]", "newSampleNumber", "=", "inputDict", "[", "\"newSampleNumber\"", "]", "new_samples", "=", "[", "]", "for", "newLevel", "in", "newLevels", ":", "is_level_found", "=", "False", "for", "oldElement", "in", "oldHierarchy", ":", "if", "newLevel", "==", "oldElement", "[", "0", "]", ":", "new_samples", ".", "append", "(", "2", "*", "oldElement", "[", "1", "]", ")", "is_level_found", "=", "True", "break", "if", "is_level_found", "is", "False", ":", "new_samples", ".", "append", "(", "newSampleNumber", ")", "return", "new_samples" ]

[ "StaticLine_GetDefaultSize", "()", "-", ">", "int" ]

[ "def", "StaticLine_GetDefaultSize", "(", "*", "args", ")", ":", "return", "_controls_", ".", "StaticLine_GetDefaultSize", "(", "*", "args", ")" ]

[ "Handles", "when", "the", "background", "corrections", "mode", "is", "changed", "." ]

[ "def", "handle_mode_combo_box_changed", "(", "self", ")", "->", "None", ":", "self", ".", "model", ".", "set_background_correction_mode", "(", "self", ".", "view", ".", "background_correction_mode", ")", "if", "self", ".", "model", ".", "is_background_mode_none", "(", ")", ":", "self", ".", "view", ".", "set_none_background_correction_options_visible", "(", ")", "elif", "self", ".", "model", ".", "is_background_mode_auto", "(", ")", ":", "self", ".", "view", ".", "set_auto_background_correction_options_visible", "(", ")", "elif", "self", ".", "model", ".", "is_background_mode_manual", "(", ")", ":", "self", ".", "view", ".", "set_manual_background_correction_options_visible", "(", ")", "self", ".", "_run_background_corrections_for_all", "(", ")" ]

[ "Grab", "type_spec", "without", "converting", "array", "-", "likes", "to", "tensors", "." ]

[ "def", "type_spec_from_value", "(", "value", ")", ":", "if", "is_extension_type", "(", "value", ")", ":", "return", "value", ".", "_type_spec", "# pylint: disable=protected-access", "# Get a TensorSpec for array-like data without", "# converting the data to a Tensor", "if", "hasattr", "(", "value", ",", "'shape'", ")", "and", "hasattr", "(", "value", ",", "'dtype'", ")", ":", "return", "tensor_spec", ".", "TensorSpec", "(", "value", ".", "shape", ",", "value", ".", "dtype", ")", "else", ":", "return", "type_spec", ".", "type_spec_from_value", "(", "value", ")" ]

[ "Return", "list", "of", "Chromium", "-", "specific", "properties", "of", "the", "named", "GL", "function", "." ]

[ "def", "ChromiumRelOpCode", "(", "funcName", ")", ":", "d", "=", "GetFunctionDict", "(", ")", "return", "d", "[", "funcName", "]", ".", "chrelopcode" ]

[ "Generate", "the", "text", "for", "the", "description", "edit", "at", "the", "top", "of", "the", "widget", "." ]

[ "def", "text_for_description", "(", "self", ")", ":", "instrument", "=", "self", ".", "_model", ".", "instrument", "n_detectors", "=", "self", ".", "_model", ".", "num_detectors", "main_field", "=", "self", ".", "_model", ".", "main_field_direction", "text", "=", "\"{}, {} detectors\"", ".", "format", "(", "instrument", ",", "n_detectors", ")", "if", "main_field", ":", "text", "+=", "\", main field : {} to muon polarization\"", ".", "format", "(", "main_field", ")", "return", "text" ]

[ "Escape", "a", "string", "to", "protect", "certain", "characters", "." ]

[ "def", "protect_filename", "(", "s", ",", "protectables", "=", "PROTECTABLES", ")", ":", "if", "set", "(", "s", ")", "&", "set", "(", "protectables", ")", ":", "if", "sys", ".", "platform", "==", "\"win32\"", ":", "return", "'\"'", "+", "s", "+", "'\"'", "else", ":", "return", "\"\"", ".", "join", "(", "(", "\"\\\\\"", "+", "c", "if", "c", "in", "protectables", "else", "c", ")", "for", "c", "in", "s", ")", "else", ":", "return", "s" ]

[ "Repeat", "the", "last", "search", "." ]

[ "def", "find_again", "(", "self", ",", "text", ")", ":", "if", "not", "self", ".", "engine", ".", "getpat", "(", ")", ":", "self", ".", "open", "(", "text", ")", "return", "False", "if", "not", "self", ".", "engine", ".", "getprog", "(", ")", ":", "return", "False", "res", "=", "self", ".", "engine", ".", "search_text", "(", "text", ")", "if", "res", ":", "line", ",", "m", "=", "res", "i", ",", "j", "=", "m", ".", "span", "(", ")", "first", "=", "\"%d.%d\"", "%", "(", "line", ",", "i", ")", "last", "=", "\"%d.%d\"", "%", "(", "line", ",", "j", ")", "try", ":", "selfirst", "=", "text", ".", "index", "(", "\"sel.first\"", ")", "sellast", "=", "text", ".", "index", "(", "\"sel.last\"", ")", "if", "selfirst", "==", "first", "and", "sellast", "==", "last", ":", "self", ".", "bell", "(", ")", "return", "False", "except", "TclError", ":", "pass", "text", ".", "tag_remove", "(", "\"sel\"", ",", "\"1.0\"", ",", "\"end\"", ")", "text", ".", "tag_add", "(", "\"sel\"", ",", "first", ",", "last", ")", "text", ".", "mark_set", "(", "\"insert\"", ",", "self", ".", "engine", ".", "isback", "(", ")", "and", "first", "or", "last", ")", "text", ".", "see", "(", "\"insert\"", ")", "return", "True", "else", ":", "self", ".", "bell", "(", ")", "return", "False" ]

[ "Adds", "a", "configuration", "to", "a", "file", "." ]

[ "def", "AddFileConfig", "(", "self", ",", "path", ",", "config", ",", "attrs", "=", "None", ",", "tools", "=", "None", ")", ":", "# Find the file node with the right relative path", "parent", "=", "self", ".", "files_dict", ".", "get", "(", "path", ")", "if", "not", "parent", ":", "raise", "ValueError", "(", "'AddFileConfig: file \"%s\" not in project.'", "%", "path", ")", "# Add the config to the file node", "spec", "=", "self", ".", "_GetSpecForConfiguration", "(", "'FileConfiguration'", ",", "config", ",", "attrs", ",", "tools", ")", "parent", ".", "append", "(", "spec", ")" ]

[ "Given", "a", "node", "and", "a", "sequence", "of", "strings", "in", "names", "return", "a", "dictionary", "containing", "the", "names", "as", "keys", "and", "child", "ELEMENT_NODEs", "that", "have", "a", "tagName", "equal", "to", "the", "name", "." ]

[ "def", "get_specific_nodes", "(", "self", ",", "node", ",", "names", ")", ":", "nodes", "=", "[", "(", "x", ".", "tagName", ",", "x", ")", "for", "x", "in", "node", ".", "childNodes", "if", "x", ".", "nodeType", "==", "x", ".", "ELEMENT_NODE", "and", "x", ".", "tagName", "in", "names", "]", "return", "dict", "(", "nodes", ")" ]

[ "Float", "representation", "." ]

[ "def", "__float__", "(", "self", ")", ":", "if", "self", ".", "_isnan", "(", ")", ":", "if", "self", ".", "is_snan", "(", ")", ":", "raise", "ValueError", "(", "\"Cannot convert signaling NaN to float\"", ")", "s", "=", "\"-nan\"", "if", "self", ".", "_sign", "else", "\"nan\"", "else", ":", "s", "=", "str", "(", "self", ")", "return", "float", "(", "s", ")" ]

[ "Log", "-", "probability", "of", "class", "k", "." ]

[ "def", "log_prob", "(", "self", ",", "k", ",", "name", "=", "\"log_prob\"", ")", ":", "with", "ops", ".", "name_scope", "(", "self", ".", "name", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "k", ",", "self", ".", "logits", "]", ",", "name", ")", ":", "k", "=", "ops", ".", "convert_to_tensor", "(", "k", ",", "name", "=", "\"k\"", ")", "logits", "=", "self", ".", "logits", "*", "array_ops", ".", "ones_like", "(", "array_ops", ".", "expand_dims", "(", "k", ",", "-", "1", ")", ",", "dtype", "=", "self", ".", "logits", ".", "dtype", ")", "k", "*=", "array_ops", ".", "ones", "(", "array_ops", ".", "slice", "(", "array_ops", ".", "shape", "(", "logits", ")", ",", "[", "0", "]", ",", "[", "array_ops", ".", "rank", "(", "logits", ")", "-", "1", "]", ")", ",", "dtype", "=", "k", ".", "dtype", ")", "k", ".", "set_shape", "(", "tensor_shape", ".", "TensorShape", "(", "logits", ".", "get_shape", "(", ")", "[", ":", "-", "1", "]", ")", ")", "return", "-", "nn_ops", ".", "sparse_softmax_cross_entropy_with_logits", "(", "logits", ",", "k", ")" ]

[ "Return", "CPU", "frequency", ".", "On", "Windows", "per", "-", "cpu", "frequency", "is", "not", "supported", "." ]

[ "def", "cpu_freq", "(", ")", ":", "curr", ",", "max_", "=", "cext", ".", "cpu_freq", "(", ")", "min_", "=", "0.0", "return", "[", "_common", ".", "scpufreq", "(", "float", "(", "curr", ")", ",", "min_", ",", "float", "(", "max_", ")", ")", "]" ]

[ "Most", "of", "the", "ECC", "signature", "schemes", "only", "require", "a", "hash", "algorithm", "to", "complete", "the", "definition", "and", "can", "be", "typed", "as", "TPMS_SCHEME_HASH", ".", "Anonymous", "algorithms", "also", "require", "a", "count", "value", "so", "they", "are", "typed", "to", "be", "TPMS_SCHEME_ECDAA", "." ]

[ "def", "__init__", "(", "self", ",", "hashAlg", "=", "TPM_ALG_ID", ".", "NULL", ")", ":", "super", "(", "TPMS_SCHEME_ECDSA", ",", "self", ")", ".", "__init__", "(", "hashAlg", ")" ]

[ "Create", "a", "Path", "object", "that", "can", "be", "used", "to", "make", "requests", "using", "paths", "relative", "to", "the", "specified", "url", "." ]

[ "def", "for_url", "(", "url", ",", "*", "*", "kwargs", ")", ":", "return", "Path", "(", "url", ",", "*", "*", "kwargs", ")" ]

[ "DeleteGroup", "(", "self", "String", "key", ")", "-", ">", "bool" ]

[ "def", "DeleteGroup", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "ConfigBase_DeleteGroup", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Gradient", "function", "for", "Conv2D", "." ]

[ "def", "_Conv2DGrad", "(", "op", ",", "grad", ")", ":", "dilations", "=", "op", ".", "get_attr", "(", "\"dilations\"", ")", "strides", "=", "op", ".", "get_attr", "(", "\"strides\"", ")", "padding", "=", "op", ".", "get_attr", "(", "\"padding\"", ")", "explicit_paddings", "=", "op", ".", "get_attr", "(", "\"explicit_paddings\"", ")", "use_cudnn_on_gpu", "=", "op", ".", "get_attr", "(", "\"use_cudnn_on_gpu\"", ")", "data_format", "=", "op", ".", "get_attr", "(", "\"data_format\"", ")", "shape_0", ",", "shape_1", "=", "array_ops", ".", "shape_n", "(", "[", "op", ".", "inputs", "[", "0", "]", ",", "op", ".", "inputs", "[", "1", "]", "]", ")", "# We call the gen_nn_ops backprop functions instead of nn_ops backprop", "# functions for performance reasons in Eager mode. gen_nn_ops functions take a", "# `explicit_paddings` parameter, but nn_ops functions do not. So if we were", "# to use the nn_ops functions, we would have to convert `padding` and", "# `explicit_paddings` into a single `padding` parameter, increasing overhead", "# in Eager mode.", "return", "[", "gen_nn_ops", ".", "conv2d_backprop_input", "(", "shape_0", ",", "op", ".", "inputs", "[", "1", "]", ",", "grad", ",", "dilations", "=", "dilations", ",", "strides", "=", "strides", ",", "padding", "=", "padding", ",", "explicit_paddings", "=", "explicit_paddings", ",", "use_cudnn_on_gpu", "=", "use_cudnn_on_gpu", ",", "data_format", "=", "data_format", ")", ",", "gen_nn_ops", ".", "conv2d_backprop_filter", "(", "op", ".", "inputs", "[", "0", "]", ",", "shape_1", ",", "grad", ",", "dilations", "=", "dilations", ",", "strides", "=", "strides", ",", "padding", "=", "padding", ",", "explicit_paddings", "=", "explicit_paddings", ",", "use_cudnn_on_gpu", "=", "use_cudnn_on_gpu", ",", "data_format", "=", "data_format", ")", "]" ]

[ "Return", "a", "digital", "filter", "from", "an", "analog", "one", "using", "a", "bilinear", "transform", "." ]

[ "def", "bilinear", "(", "b", ",", "a", ",", "fs", "=", "1.0", ")", ":", "fs", "=", "float", "(", "fs", ")", "a", ",", "b", "=", "map", "(", "atleast_1d", ",", "(", "a", ",", "b", ")", ")", "D", "=", "len", "(", "a", ")", "-", "1", "N", "=", "len", "(", "b", ")", "-", "1", "artype", "=", "float", "M", "=", "max", "(", "[", "N", ",", "D", "]", ")", "Np", "=", "M", "Dp", "=", "M", "bprime", "=", "numpy", ".", "zeros", "(", "Np", "+", "1", ",", "artype", ")", "aprime", "=", "numpy", ".", "zeros", "(", "Dp", "+", "1", ",", "artype", ")", "for", "j", "in", "range", "(", "Np", "+", "1", ")", ":", "val", "=", "0.0", "for", "i", "in", "range", "(", "N", "+", "1", ")", ":", "for", "k", "in", "range", "(", "i", "+", "1", ")", ":", "for", "l", "in", "range", "(", "M", "-", "i", "+", "1", ")", ":", "if", "k", "+", "l", "==", "j", ":", "val", "+=", "(", "comb", "(", "i", ",", "k", ")", "*", "comb", "(", "M", "-", "i", ",", "l", ")", "*", "b", "[", "N", "-", "i", "]", "*", "pow", "(", "2", "*", "fs", ",", "i", ")", "*", "(", "-", "1", ")", "**", "k", ")", "bprime", "[", "j", "]", "=", "real", "(", "val", ")", "for", "j", "in", "range", "(", "Dp", "+", "1", ")", ":", "val", "=", "0.0", "for", "i", "in", "range", "(", "D", "+", "1", ")", ":", "for", "k", "in", "range", "(", "i", "+", "1", ")", ":", "for", "l", "in", "range", "(", "M", "-", "i", "+", "1", ")", ":", "if", "k", "+", "l", "==", "j", ":", "val", "+=", "(", "comb", "(", "i", ",", "k", ")", "*", "comb", "(", "M", "-", "i", ",", "l", ")", "*", "a", "[", "D", "-", "i", "]", "*", "pow", "(", "2", "*", "fs", ",", "i", ")", "*", "(", "-", "1", ")", "**", "k", ")", "aprime", "[", "j", "]", "=", "real", "(", "val", ")", "return", "normalize", "(", "bprime", ",", "aprime", ")" ]

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

[ "def", "BeforeReset", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewModelNotifier_BeforeReset", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "override", "with", "a", "classmethod" ]

[ "def", "plottingscriptname", "(", "cls", ")", ":" ]

[ "Unpacks", "Any", "message", "and", "returns", "the", "unpacked", "message", "." ]

[ "def", "_InternalUnpackAny", "(", "msg", ")", ":", "type_url", "=", "msg", ".", "type_url", "db", "=", "symbol_database", ".", "Default", "(", ")", "if", "not", "type_url", ":", "return", "None", "# TODO(haberman): For now we just strip the hostname. Better logic will be", "# required.", "type_name", "=", "type_url", ".", "split", "(", "\"/\"", ")", "[", "-", "1", "]", "descriptor", "=", "db", ".", "pool", ".", "FindMessageTypeByName", "(", "type_name", ")", "if", "descriptor", "is", "None", ":", "return", "None", "message_class", "=", "db", ".", "GetPrototype", "(", "descriptor", ")", "message", "=", "message_class", "(", ")", "message", ".", "ParseFromString", "(", "msg", ".", "value", ")", "return", "message" ]

[ "Handles", "when", "a", "Background", "table", "cell", "is", "changed", "." ]

[ "def", "handle_background_changed", "(", "self", ")", "->", "None", ":", "runs", ",", "groups", "=", "self", ".", "_selected_runs_and_groups", "(", ")", "background", "=", "self", ".", "view", ".", "selected_background", "(", ")", "for", "run", ",", "group", "in", "zip", "(", "runs", ",", "groups", ")", ":", "self", ".", "_update_background_in_view_and_model", "(", "run", ",", "group", ",", "background", ")", "self", ".", "_perform_background_corrections_for", "(", "runs", ",", "groups", ")" ]

[ "Yield", "non", "-", "empty", "lines", "from", "file", "at", "path" ]

[ "def", "non_empty_lines", "(", "path", ")", ":", "with", "open", "(", "path", ")", "as", "f", ":", "for", "line", "in", "f", ":", "line", "=", "line", ".", "strip", "(", ")", "if", "line", ":", "yield", "line" ]

[ "Divides", "two", "numbers", "and", "returns", "the", "integer", "part", "of", "the", "result", "." ]

[ "def", "divide_int", "(", "self", ",", "a", ",", "b", ")", ":", "a", "=", "_convert_other", "(", "a", ",", "raiseit", "=", "True", ")", "r", "=", "a", ".", "__floordiv__", "(", "b", ",", "context", "=", "self", ")", "if", "r", "is", "NotImplemented", ":", "raise", "TypeError", "(", "\"Unable to convert %s to Decimal\"", "%", "b", ")", "else", ":", "return", "r" ]

[ "Returns", "new", "TPM2_PCR_Reset_REQUEST", "object", "constructed", "from", "its", "marshaled", "representation", "in", "the", "given", "TpmBuffer", "buffer" ]

[ "def", "fromTpm", "(", "buf", ")", ":", "return", "buf", ".", "createObj", "(", "TPM2_PCR_Reset_REQUEST", ")" ]

[ "Get", "data_files", "from", "data_sources", "." ]

[ "def", "get_data_files", "(", "data_sources", ")", ":", "if", "isinstance", "(", "data_sources", ",", "(", "list", ",", "tuple", ")", ")", ":", "data_files", "=", "[", "]", "for", "source", "in", "data_sources", ":", "data_files", "+=", "get_data_files", "(", "source", ")", "else", ":", "if", "'*'", "in", "data_sources", "or", "'?'", "in", "data_sources", "or", "'['", "in", "data_sources", ":", "data_files", "=", "gfile", ".", "Glob", "(", "data_sources", ")", "else", ":", "data_files", "=", "[", "data_sources", "]", "if", "not", "data_files", ":", "raise", "ValueError", "(", "'No data files found in %s'", ",", "data_sources", ")", "return", "data_files" ]

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

[ "def", "Update", "(", "self", ",", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# Update pp_stack first", "self", ".", "UpdatePreprocessor", "(", "line", ")", "# Count parentheses. This is to avoid adding struct arguments to", "# the nesting stack.", "if", "self", ".", "stack", ":", "inner_block", "=", "self", ".", "stack", "[", "-", "1", "]", "depth_change", "=", "line", ".", "count", "(", "'('", ")", "-", "line", ".", "count", "(", "')'", ")", "inner_block", ".", "open_parentheses", "+=", "depth_change", "# Also check if we are starting or ending an inline assembly block.", "if", "inner_block", ".", "inline_asm", "in", "(", "_NO_ASM", ",", "_END_ASM", ")", ":", "if", "(", "depth_change", "!=", "0", "and", "inner_block", ".", "open_parentheses", "==", "1", "and", "_MATCH_ASM", ".", "match", "(", "line", ")", ")", ":", "# Enter assembly block", "inner_block", ".", "inline_asm", "=", "_INSIDE_ASM", "else", ":", "# Not entering assembly block. If previous line was _END_ASM,", "# we will now shift to _NO_ASM state.", "inner_block", ".", "inline_asm", "=", "_NO_ASM", "elif", "(", "inner_block", ".", "inline_asm", "==", "_INSIDE_ASM", "and", "inner_block", ".", "open_parentheses", "==", "0", ")", ":", "# Exit assembly block", "inner_block", ".", "inline_asm", "=", "_END_ASM", "# Consume namespace declaration at the beginning of the line. Do", "# this in a loop so that we catch same line declarations like this:", "# namespace proto2 { namespace bridge { class MessageSet; } }", "while", "True", ":", "# Match start of namespace. The \"\\b\\s*\" below catches namespace", "# declarations even if it weren't followed by a whitespace, this", "# is so that we don't confuse our namespace checker. The", "# missing spaces will be flagged by CheckSpacing.", "namespace_decl_match", "=", "Match", "(", "r'^\\s*namespace\\b\\s*([:\\w]+)?(.*)$'", ",", "line", ")", "if", "not", "namespace_decl_match", ":", "break", "new_namespace", "=", "_NamespaceInfo", "(", "namespace_decl_match", ".", "group", "(", "1", ")", ",", "linenum", ")", "self", ".", "stack", ".", "append", "(", "new_namespace", ")", "line", "=", "namespace_decl_match", ".", "group", "(", "2", ")", "if", "line", ".", "find", "(", "'{'", ")", "!=", "-", "1", ":", "new_namespace", ".", "seen_open_brace", "=", "True", "line", "=", "line", "[", "line", ".", "find", "(", "'{'", ")", "+", "1", ":", "]", "# Look for a class declaration in whatever is left of the line", "# after parsing namespaces. The regexp accounts for decorated classes", "# such as in:", "# class LOCKABLE API Object {", "# };", "#", "# Templates with class arguments may confuse the parser, for example:", "# template <class T", "# class Comparator = less<T>,", "# class Vector = vector<T> >", "# class HeapQueue {", "#", "# Because this parser has no nesting state about templates, by the", "# time it saw \"class Comparator\", it may think that it's a new class.", "# Nested templates have a similar problem:", "# template <", "# typename ExportedType,", "# typename TupleType,", "# template <typename, typename> class ImplTemplate>", "#", "# To avoid these cases, we ignore classes that are followed by '=' or '>'", "class_decl_match", "=", "Match", "(", "r'\\s*(template\\s*<[\\w\\s<>,:]*>\\s*)?'", "r'(class|struct)\\s+([A-Z_]+\\s+)*(\\w+(?:::\\w+)*)'", "r'(([^=>]|<[^<>]*>|<[^<>]*<[^<>]*>\\s*>)*)$'", ",", "line", ")", "if", "(", "class_decl_match", "and", "(", "not", "self", ".", "stack", "or", "self", ".", "stack", "[", "-", "1", "]", ".", "open_parentheses", "==", "0", ")", ")", ":", "self", ".", "stack", ".", "append", "(", "_ClassInfo", "(", "class_decl_match", ".", "group", "(", "4", ")", ",", "class_decl_match", ".", "group", "(", "2", ")", ",", "clean_lines", ",", "linenum", ")", ")", "line", "=", "class_decl_match", ".", "group", "(", "5", ")", "# If we have not yet seen the opening brace for the innermost block,", "# run checks here.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "CheckBegin", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "# Update access control if we are inside a class/struct", "if", "self", ".", "stack", "and", "isinstance", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "_ClassInfo", ")", ":", "classinfo", "=", "self", ".", "stack", "[", "-", "1", "]", "access_match", "=", "Match", "(", "r'^(.*)\\b(public|private|protected|signals)(\\s+(?:slots\\s*)?)?'", "r':(?:[^:]|$)'", ",", "line", ")", "if", "access_match", ":", "classinfo", ".", "access", "=", "access_match", ".", "group", "(", "2", ")", "# Check that access keywords are indented +1 space. Skip this", "# check if the keywords are not preceded by whitespaces.", "indent", "=", "access_match", ".", "group", "(", "1", ")", "if", "(", "len", "(", "indent", ")", "!=", "classinfo", ".", "class_indent", "+", "1", "and", "Match", "(", "r'^\\s*$'", ",", "indent", ")", ")", ":", "if", "classinfo", ".", "is_struct", ":", "parent", "=", "'struct '", "+", "classinfo", ".", "name", "else", ":", "parent", "=", "'class '", "+", "classinfo", ".", "name", "slots", "=", "''", "if", "access_match", ".", "group", "(", "3", ")", ":", "slots", "=", "access_match", ".", "group", "(", "3", ")", "error", "(", "filename", ",", "linenum", ",", "'whitespace/indent'", ",", "3", ",", "'%s%s: should be indented +1 space inside %s'", "%", "(", "access_match", ".", "group", "(", "2", ")", ",", "slots", ",", "parent", ")", ")", "# Consume braces or semicolons from what's left of the line", "while", "True", ":", "# Match first brace, semicolon, or closed parenthesis.", "matched", "=", "Match", "(", "r'^[^{;)}]*([{;)}])(.*)$'", ",", "line", ")", "if", "not", "matched", ":", "break", "token", "=", "matched", ".", "group", "(", "1", ")", "if", "token", "==", "'{'", ":", "# If namespace or class hasn't seen a opening brace yet, mark", "# namespace/class head as complete. Push a new block onto the", "# stack otherwise.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "seen_open_brace", "=", "True", "else", ":", "self", ".", "stack", ".", "append", "(", "_BlockInfo", "(", "True", ")", ")", "if", "_MATCH_ASM", ".", "match", "(", "line", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "inline_asm", "=", "_BLOCK_ASM", "elif", "token", "==", "';'", "or", "token", "==", "')'", ":", "# If we haven't seen an opening brace yet, but we already saw", "# a semicolon, this is probably a forward declaration. Pop", "# the stack for these.", "#", "# Similarly, if we haven't seen an opening brace yet, but we", "# already saw a closing parenthesis, then these are probably", "# function arguments with extra \"class\" or \"struct\" keywords.", "# Also pop these stack for these.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", ".", "pop", "(", ")", "else", ":", "# token == '}'", "# Perform end of block checks and pop the stack.", "if", "self", ".", "stack", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "CheckEnd", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "self", ".", "stack", ".", "pop", "(", ")", "line", "=", "matched", ".", "group", "(", "2", ")" ]

[ "find", "the", "key", "(", "s", ")", "as", "a", "list", "given", "a", "value" ]

[ "def", "get_keys_for_value", "(", "self", ",", "value", ",", "fail_value", "=", "None", ")", ":", "list_result", "=", "[", "item", "[", "0", "]", "for", "item", "in", "self", ".", "items", "(", ")", "if", "item", "[", "1", "]", "==", "value", "]", "if", "len", "(", "list_result", ")", ">", "0", ":", "return", "list_result", "return", "fail_value" ]

[ "Get", "a", ":", "class", ":", "ConnectionPool", "based", "on", "the", "request", "context", "." ]

[ "def", "connection_from_context", "(", "self", ",", "request_context", ")", ":", "scheme", "=", "request_context", "[", "'scheme'", "]", ".", "lower", "(", ")", "pool_key_constructor", "=", "self", ".", "key_fn_by_scheme", "[", "scheme", "]", "pool_key", "=", "pool_key_constructor", "(", "request_context", ")", "return", "self", ".", "connection_from_pool_key", "(", "pool_key", ",", "request_context", "=", "request_context", ")" ]

[ "D", ".", "update", "(", "[", "E", "]", "**", "F", ")", "-", ">", "None", ".", "Update", "D", "from", "mapping", "/", "iterable", "E", "and", "F", ".", "If", "E", "present", "and", "has", "a", ".", "keys", "()", "method", "does", ":", "for", "k", "in", "E", ":", "D", "[", "k", "]", "=", "E", "[", "k", "]", "If", "E", "present", "and", "lacks", ".", "keys", "()", "method", "does", ":", "for", "(", "k", "v", ")", "in", "E", ":", "D", "[", "k", "]", "=", "v", "In", "either", "case", "this", "is", "followed", "by", ":", "for", "k", "v", "in", "F", ".", "items", "()", ":", "D", "[", "k", "]", "=", "v" ]

[ "def", "update", "(", "*", "args", ",", "*", "*", "kwds", ")", ":", "if", "len", "(", "args", ")", ">", "2", ":", "raise", "TypeError", "(", "\"update() takes at most 2 positional \"", "\"arguments ({} given)\"", ".", "format", "(", "len", "(", "args", ")", ")", ")", "elif", "not", "args", ":", "raise", "TypeError", "(", "\"update() takes at least 1 argument (0 given)\"", ")", "self", "=", "args", "[", "0", "]", "other", "=", "args", "[", "1", "]", "if", "len", "(", "args", ")", ">=", "2", "else", "(", ")", "if", "isinstance", "(", "other", ",", "Mapping", ")", ":", "for", "key", "in", "other", ":", "self", "[", "key", "]", "=", "other", "[", "key", "]", "elif", "hasattr", "(", "other", ",", "\"keys\"", ")", ":", "for", "key", "in", "other", ".", "keys", "(", ")", ":", "self", "[", "key", "]", "=", "other", "[", "key", "]", "else", ":", "for", "key", ",", "value", "in", "other", ":", "self", "[", "key", "]", "=", "value", "for", "key", ",", "value", "in", "kwds", ".", "items", "(", ")", ":", "self", "[", "key", "]", "=", "value" ]

[ "Get", "the", "nest", "state", "and", "increment", "the", "current", "index", "." ]

[ "def", "get_next_state", "(", "self", ")", ":", "if", "self", ".", "num_next_states", ">", "0", ":", "self", ".", "current_state_index", "=", "(", "self", ".", "current_state_index", "+", "1", ")", "%", "STATE_CACHE_SIZE", "self", ".", "num_next_states", "=", "self", ".", "num_next_states", "-", "1", "self", ".", "num_prev_states", "=", "self", ".", "num_prev_states", "+", "1", "return", "self", ".", "get_current_state", "(", ")", "return", "None" ]

[ "Return", "a", "factory", "function", "for", "creating", "Nodes", "for", "this", "construction", "environment", "." ]

[ "def", "get_factory", "(", "self", ",", "factory", ",", "default", "=", "'File'", ")", ":", "name", "=", "default", "try", ":", "is_node", "=", "issubclass", "(", "factory", ",", "SCons", ".", "Node", ".", "FS", ".", "Base", ")", "except", "TypeError", ":", "# The specified factory isn't a Node itself--it's", "# most likely None, or possibly a callable.", "pass", "else", ":", "if", "is_node", ":", "# The specified factory is a Node (sub)class. Try to", "# return the FS method that corresponds to the Node's", "# name--that is, we return self.fs.Dir if they want a Dir,", "# self.fs.File for a File, etc.", "try", ":", "name", "=", "factory", ".", "__name__", "except", "AttributeError", ":", "pass", "else", ":", "factory", "=", "None", "if", "not", "factory", ":", "# They passed us None, or we picked up a name from a specified", "# class, so return the FS method. (Note that we *don't*", "# use our own self.{Dir,File} methods because that would", "# cause env.subst() to be called twice on the file name,", "# interfering with files that have $$ in them.)", "factory", "=", "getattr", "(", "self", ".", "fs", ",", "name", ")", "return", "factory" ]

[ "Helper", "returning", "True", "if", "dtype", "is", "known", "to", "be", "unsigned", "." ]

[ "def", "_is_known_unsigned_by_dtype", "(", "dt", ")", ":", "return", "{", "dtypes", ".", "bool", ":", "True", ",", "dtypes", ".", "uint8", ":", "True", ",", "dtypes", ".", "uint16", ":", "True", ",", "}", ".", "get", "(", "dt", ".", "base_dtype", ",", "False", ")" ]

[ "Received", "an", "update", "request", "from", "a", "client", "." ]

[ "def", "handleClientObjectUpdateField", "(", "self", ",", "datagram", ",", "dgi", ",", "targeted", "=", "False", ")", ":", "connection", "=", "datagram", ".", "getConnection", "(", ")", "client", "=", "self", ".", "clientsByConnection", "[", "connection", "]", "if", "targeted", ":", "targetId", "=", "dgi", ".", "getUint32", "(", ")", "doId", "=", "dgi", ".", "getUint32", "(", ")", "fieldId", "=", "dgi", ".", "getUint16", "(", ")", "doIdBase", "=", "self", ".", "getDoIdBase", "(", "doId", ")", "owner", "=", "self", ".", "clientsByDoIdBase", ".", "get", "(", "doIdBase", ")", "object", "=", "owner", "and", "owner", ".", "objectsByDoId", ".", "get", "(", "doId", ")", "if", "not", "object", ":", "self", ".", "notify", ".", "warning", "(", "\"Ignoring update for unknown object %s from client %s\"", "%", "(", "doId", ",", "client", ".", "doIdBase", ")", ")", "return", "dcfield", "=", "object", ".", "dclass", ".", "getFieldByIndex", "(", "fieldId", ")", "if", "dcfield", "is", "None", ":", "self", ".", "notify", ".", "warning", "(", "\"Ignoring update for field %s on object %s from client %s; no such field for class %s.\"", "%", "(", "fieldId", ",", "doId", ",", "client", ".", "doIdBase", ",", "object", ".", "dclass", ".", "getName", "(", ")", ")", ")", "if", "client", "!=", "owner", ":", "# This message was not sent by the object's owner.", "if", "not", "dcfield", ".", "hasKeyword", "(", "'clsend'", ")", "and", "not", "dcfield", ".", "hasKeyword", "(", "'p2p'", ")", ":", "self", ".", "notify", ".", "warning", "(", "\"Ignoring update for %s.%s on object %s from client %s: not owner\"", "%", "(", "object", ".", "dclass", ".", "getName", "(", ")", ",", "dcfield", ".", "getName", "(", ")", ",", "doId", ",", "client", ".", "doIdBase", ")", ")", "return", "# We reformat the message slightly to insert the sender's", "# doIdBase.", "dg", "=", "PyDatagram", "(", ")", "dg", ".", "addUint16", "(", "OBJECT_UPDATE_FIELD_CMU", ")", "dg", ".", "addUint32", "(", "client", ".", "doIdBase", ")", "dg", ".", "addUint32", "(", "doId", ")", "dg", ".", "addUint16", "(", "fieldId", ")", "dg", ".", "appendData", "(", "dgi", ".", "getRemainingBytes", "(", ")", ")", "if", "targeted", ":", "# A targeted update: only to the indicated client.", "target", "=", "self", ".", "clientsByDoIdBase", ".", "get", "(", "targetId", ")", "if", "not", "target", ":", "self", ".", "notify", ".", "warning", "(", "\"Ignoring targeted update to %s for %s.%s on object %s from client %s: target not known\"", "%", "(", "targetId", ",", "dclass", ".", "getName", "(", ")", ",", "dcfield", ".", "getName", "(", ")", ",", "doId", ",", "client", ".", "doIdBase", ")", ")", "return", "self", ".", "cw", ".", "send", "(", "dg", ",", "target", ".", "connection", ")", "self", ".", "needsFlush", ".", "add", "(", "target", ")", "elif", "dcfield", ".", "hasKeyword", "(", "'p2p'", ")", ":", "# p2p: to object owner only", "self", ".", "cw", ".", "send", "(", "dg", ",", "owner", ".", "connection", ")", "self", ".", "needsFlush", ".", "add", "(", "owner", ")", "elif", "dcfield", ".", "hasKeyword", "(", "'broadcast'", ")", ":", "# Broadcast: to everyone except orig sender", "self", ".", "sendToZoneExcept", "(", "object", ".", "zoneId", ",", "dg", ",", "[", "client", "]", ")", "elif", "dcfield", ".", "hasKeyword", "(", "'reflect'", ")", ":", "# Reflect: broadcast to everyone including orig sender", "self", ".", "sendToZoneExcept", "(", "object", ".", "zoneId", ",", "dg", ",", "[", "]", ")", "else", ":", "self", ".", "notify", ".", "warning", "(", "\"Message is not broadcast or p2p\"", ")" ]

[ "Show", "an", "are", "you", "sure?", "prompt", "if", "there", "are", "unknown", "files", "." ]

[ "def", "CheckForUnknownFiles", "(", "self", ")", ":", "unknown_files", "=", "self", ".", "GetUnknownFiles", "(", ")", "if", "unknown_files", ":", "print", "\"The following files are not added to version control:\"", "for", "line", "in", "unknown_files", ":", "print", "line", "prompt", "=", "\"Are you sure to continue?(y/N) \"", "answer", "=", "raw_input", "(", "prompt", ")", ".", "strip", "(", ")", "if", "answer", "!=", "\"y\"", ":", "ErrorExit", "(", "\"User aborted\"", ")" ]

[ "Ensure", "this", "class", "instance", "has", "a", "logger", "associated", "with", "it", "." ]

[ "def", "populate_logger", "(", "self", ",", "name", "=", "None", ")", ":", "if", "hasattr", "(", "self", ",", "'_logger'", ")", ":", "return", "if", "name", "is", "None", ":", "name", "=", "'.'", ".", "join", "(", "[", "self", ".", "__module__", ",", "self", ".", "__class__", ".", "__name__", "]", ")", "self", ".", "_logger", "=", "logging", ".", "getLogger", "(", "name", ")" ]

[ "Returns", "true", "the", "line", "just", "read", "is", "the", "first", "line", "of", "its", "file", "otherwise", "returns", "false", "." ]

[ "def", "isfirstline", "(", ")", ":", "if", "not", "_state", ":", "raise", "RuntimeError", ",", "\"no active input()\"", "return", "_state", ".", "isfirstline", "(", ")" ]

[ "Name", "of", "this", "target", "." ]

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

[ "Create", "a", "mapping", "between", "doxygen", "label", "and", "file", "path", "for", "edit", "on", "github", "button", "." ]

[ "def", "create_mapping", "(", "xml_input", ":", "Path", ",", "output_dir", ":", "Path", ",", "strip_path", ":", "Path", ")", ":", "xml_input", "=", "xml_input", ".", "resolve", "(", ")", "output_dir", "=", "output_dir", ".", "resolve", "(", ")", "strip_path", "=", "strip_path", ".", "resolve", "(", ")", "mapping", "=", "{", "'get_started'", ":", "'openvino/docs/get_started.md'", ",", "'documentation'", ":", "'openvino/docs/documentation.md'", ",", "'index'", ":", "'openvino/docs/index.rst'", ",", "'model_zoo'", ":", "'openvino/docs/model_zoo.md'", ",", "'resources'", ":", "'openvino/docs/resources.md'", ",", "'tutorials'", ":", "'openvino/docs/tutorials.md'", ",", "'tuning_utilities'", ":", "'openvino/docs/tuning_utilities.md'", "}", "output_dir", ".", "mkdir", "(", "parents", "=", "True", ",", "exist_ok", "=", "True", ")", "xml_files", "=", "xml_input", ".", "glob", "(", "'*.xml'", ")", "for", "xml_file", "in", "xml_files", ":", "try", ":", "root", "=", "etree", ".", "parse", "(", "xml_file", ".", "as_posix", "(", ")", ")", ".", "getroot", "(", ")", "compounds", "=", "root", ".", "xpath", "(", "'//compounddef'", ")", "for", "compound", "in", "compounds", ":", "kind", "=", "compound", ".", "attrib", "[", "'kind'", "]", "if", "kind", "in", "[", "'file'", ",", "'dir'", "]", ":", "continue", "name_tag", "=", "compound", ".", "find", "(", "'compoundname'", ")", "name", "=", "name_tag", ".", "text", "name", "=", "name", ".", "replace", "(", "'::'", ",", "'_1_1'", ")", "if", "kind", "==", "'page'", ":", "exclude", "=", "True", "for", "rep", "in", "REPOSITORIES", ":", "if", "name", ".", "startswith", "(", "rep", ")", ":", "exclude", "=", "False", "if", "exclude", ":", "continue", "else", ":", "name", "=", "kind", "+", "name", "location_tag", "=", "compound", ".", "find", "(", "'location'", ")", "file", "=", "Path", "(", "location_tag", ".", "attrib", "[", "'file'", "]", ")", "if", "not", "file", ".", "suffix", ":", "continue", "try", ":", "file", "=", "file", ".", "relative_to", "(", "strip_path", ")", "except", "ValueError", ":", "logging", ".", "warning", "(", "'{}: {} is not relative to {}.'", ".", "format", "(", "xml_file", ",", "file", ",", "strip_path", ")", ")", "mapping", "[", "name", "]", "=", "file", ".", "as_posix", "(", ")", "except", "AttributeError", ":", "logging", ".", "warning", "(", "'{}: Cannot find the origin file.'", ".", "format", "(", "xml_file", ")", ")", "except", "etree", ".", "XMLSyntaxError", "as", "e", ":", "logging", ".", "warning", "(", "'{}: {}.'", ".", "format", "(", "xml_file", ",", "e", ")", ")", "with", "open", "(", "output_dir", ".", "joinpath", "(", "'mapping.json'", ")", ",", "'w'", ")", "as", "f", ":", "json", ".", "dump", "(", "mapping", ",", "f", ")" ]

[ "Normalize", "the", "given", "rows", "of", "a", "RECORD", "file", "." ]

[ "def", "_normalized_outrows", "(", "outrows", ")", ":", "# type: (Iterable[InstalledCSVRow]) -> List[Tuple[str, str, str]]", "# Normally, there should only be one row per path, in which case the", "# second and third elements don't come into play when sorting.", "# However, in cases in the wild where a path might happen to occur twice,", "# we don't want the sort operation to trigger an error (but still want", "# determinism). Since the third element can be an int or string, we", "# coerce each element to a string to avoid a TypeError in this case.", "# For additional background, see--", "# https://github.com/pypa/pip/issues/5868", "return", "sorted", "(", "(", "ensure_str", "(", "record_path", ",", "encoding", "=", "'utf-8'", ")", ",", "hash_", ",", "str", "(", "size", ")", ")", "for", "record_path", ",", "hash_", ",", "size", "in", "outrows", ")" ]

[ "Allows", "to", "use", "a", "unique", "instance", "of", "mspdbsrv", ".", "exe", "per", "linker", "instead", "of", "a", "shared", "one", "." ]

[ "def", "_UseSeparateMspdbsrv", "(", "self", ",", "env", ",", "args", ")", ":", "if", "len", "(", "args", ")", "<", "1", ":", "raise", "Exception", "(", "\"Not enough arguments\"", ")", "if", "args", "[", "0", "]", "!=", "'link.exe'", ":", "return", "# Use the output filename passed to the linker to generate an endpoint name", "# for mspdbsrv.exe.", "endpoint_name", "=", "None", "for", "arg", "in", "args", ":", "m", "=", "_LINK_EXE_OUT_ARG", ".", "match", "(", "arg", ")", "if", "m", ":", "endpoint_name", "=", "re", ".", "sub", "(", "r'\\W+'", ",", "''", ",", "'%s_%d'", "%", "(", "m", ".", "group", "(", "'out'", ")", ",", "os", ".", "getpid", "(", ")", ")", ")", "break", "if", "endpoint_name", "is", "None", ":", "return", "# Adds the appropriate environment variable. This will be read by link.exe", "# to know which instance of mspdbsrv.exe it should connect to (if it's", "# not set then the default endpoint is used).", "env", "[", "'_MSPDBSRV_ENDPOINT_'", "]", "=", "endpoint_name" ]

[ "Scales", "timeouts", "which", "are", "size", "-", "specific" ]

[ "def", "timeout_per_mb", "(", "seconds_per_mb", ",", "size_bytes", ")", ":", "result", "=", "seconds_per_mb", "*", "(", "size_bytes", "/", "1e6", ")", "if", "result", "<", "DEFAULT_TIMEOUT", ":", "return", "DEFAULT_TIMEOUT", "return", "result" ]

[ "Get", "input", "metadata", ".", "Result", "format", "is", "the", "same", "as", "for", ":", "py", ":", "meth", ":", "getOutputs", "method", "but", "the", "general", "case", "is", "that", "there", "is", "only", "one", "input", "named", "audio", "and", "the", "sole", "relevant", "metadata", "are", ":" ]

[ "def", "getInputs", "(", "self", ")", ":", "res", "=", "{", "}", "iList", "=", "yc", ".", "engine_getInputList", "(", "self", ".", "ptr", ")", "for", "inputname", "in", "iterPtrList", "(", "iList", ")", ":", "ptr", "=", "yc", ".", "engine_getInputInfos", "(", "self", ".", "ptr", ",", "to_char", "(", "inputname", ")", ")", "infos", "=", "{", "}", "if", "ptr", ":", "infos", "[", "'sampleRate'", "]", "=", "ptr", ".", "contents", ".", "sampleRate", "infos", "[", "'sampleStep'", "]", "=", "ptr", ".", "contents", ".", "sampleStep", "infos", "[", "'frameLength'", "]", "=", "ptr", ".", "contents", ".", "frameLength", "infos", "[", "'size'", "]", "=", "ptr", ".", "contents", ".", "size", "infos", "[", "'parameters'", "]", "=", "dict", "(", "(", "to_str", "(", "k", ")", ",", "to_str", "(", "v", ")", ")", "for", "k", ",", "v", "in", "iterPtrDict", "(", "ptr", ".", "contents", ".", "parameters", ")", ")", "yc", ".", "engine_freeIOInfos", "(", "ptr", ")", "res", "[", "to_str", "(", "inputname", ")", "]", "=", "infos", "yc", ".", "engine_freeIOList", "(", "iList", ")", "return", "res" ]

[ "Convert", "real", "Schur", "form", "to", "complex", "Schur", "form", "." ]

[ "def", "rsf2csf", "(", "T", ",", "Z", ",", "check_finite", "=", "True", ")", ":", "if", "check_finite", ":", "Z", ",", "T", "=", "map", "(", "asarray_chkfinite", ",", "(", "Z", ",", "T", ")", ")", "else", ":", "Z", ",", "T", "=", "map", "(", "asarray", ",", "(", "Z", ",", "T", ")", ")", "for", "ind", ",", "X", "in", "enumerate", "(", "[", "Z", ",", "T", "]", ")", ":", "if", "X", ".", "ndim", "!=", "2", "or", "X", ".", "shape", "[", "0", "]", "!=", "X", ".", "shape", "[", "1", "]", ":", "raise", "ValueError", "(", "\"Input '{}' must be square.\"", ".", "format", "(", "'ZT'", "[", "ind", "]", ")", ")", "if", "T", ".", "shape", "[", "0", "]", "!=", "Z", ".", "shape", "[", "0", "]", ":", "raise", "ValueError", "(", "\"Input array shapes must match: Z: {} vs. T: {}\"", "\"\"", ".", "format", "(", "Z", ".", "shape", ",", "T", ".", "shape", ")", ")", "N", "=", "T", ".", "shape", "[", "0", "]", "t", "=", "_commonType", "(", "Z", ",", "T", ",", "array", "(", "[", "3.0", "]", ",", "'F'", ")", ")", "Z", ",", "T", "=", "_castCopy", "(", "t", ",", "Z", ",", "T", ")", "for", "m", "in", "range", "(", "N", "-", "1", ",", "0", ",", "-", "1", ")", ":", "if", "abs", "(", "T", "[", "m", ",", "m", "-", "1", "]", ")", ">", "eps", "*", "(", "abs", "(", "T", "[", "m", "-", "1", ",", "m", "-", "1", "]", ")", "+", "abs", "(", "T", "[", "m", ",", "m", "]", ")", ")", ":", "mu", "=", "eigvals", "(", "T", "[", "m", "-", "1", ":", "m", "+", "1", ",", "m", "-", "1", ":", "m", "+", "1", "]", ")", "-", "T", "[", "m", ",", "m", "]", "r", "=", "norm", "(", "[", "mu", "[", "0", "]", ",", "T", "[", "m", ",", "m", "-", "1", "]", "]", ")", "c", "=", "mu", "[", "0", "]", "/", "r", "s", "=", "T", "[", "m", ",", "m", "-", "1", "]", "/", "r", "G", "=", "array", "(", "[", "[", "c", ".", "conj", "(", ")", ",", "s", "]", ",", "[", "-", "s", ",", "c", "]", "]", ",", "dtype", "=", "t", ")", "T", "[", "m", "-", "1", ":", "m", "+", "1", ",", "m", "-", "1", ":", "]", "=", "G", ".", "dot", "(", "T", "[", "m", "-", "1", ":", "m", "+", "1", ",", "m", "-", "1", ":", "]", ")", "T", "[", ":", "m", "+", "1", ",", "m", "-", "1", ":", "m", "+", "1", "]", "=", "T", "[", ":", "m", "+", "1", ",", "m", "-", "1", ":", "m", "+", "1", "]", ".", "dot", "(", "G", ".", "conj", "(", ")", ".", "T", ")", "Z", "[", ":", ",", "m", "-", "1", ":", "m", "+", "1", "]", "=", "Z", "[", ":", ",", "m", "-", "1", ":", "m", "+", "1", "]", ".", "dot", "(", "G", ".", "conj", "(", ")", ".", "T", ")", "T", "[", "m", ",", "m", "-", "1", "]", "=", "0.0", "return", "T", ",", "Z" ]

[ "Copies", "this", "to", "a", "descriptor_pb2", ".", "EnumDescriptorProto", "." ]

[ "def", "CopyToProto", "(", "self", ",", "proto", ")", ":", "# This function is overriden to give a better doc comment.", "super", "(", "EnumDescriptor", ",", "self", ")", ".", "CopyToProto", "(", "proto", ")" ]

[ "Recalculates", "the", ":", "class", ":", "RibbonBar", "minimum", "size", "." ]

[ "def", "RecalculateMinSize", "(", "self", ")", ":", "min_size", "=", "wx", ".", "Size", "(", "-", "1", ",", "-", "1", ")", "numtabs", "=", "len", "(", "self", ".", "_pages", ")", "if", "numtabs", "!=", "0", ":", "min_size", "=", "wx", ".", "Size", "(", "*", "self", ".", "_pages", "[", "0", "]", ".", "page", ".", "GetMinSize", "(", ")", ")", "for", "info", "in", "self", ".", "_pages", ":", "page_min", "=", "info", ".", "page", ".", "GetMinSize", "(", ")", "min_size", ".", "x", "=", "max", "(", "min_size", ".", "x", ",", "page_min", ".", "x", ")", "min_size", ".", "y", "=", "max", "(", "min_size", ".", "y", ",", "page_min", ".", "y", ")", "if", "min_size", ".", "y", "!=", "-", "1", ":", "# TODO: Decide on best course of action when min height is unspecified", "# - should we specify it to the tab minimum, or leave it unspecified?", "min_size", ".", "IncBy", "(", "0", ",", "self", ".", "_tab_height", ")", "self", ".", "_minWidth", "=", "min_size", ".", "GetWidth", "(", ")", "self", ".", "_minHeight", "=", "(", "self", ".", "_arePanelsShown", "and", "[", "min_size", ".", "GetHeight", "(", ")", "]", "or", "[", "self", ".", "_tab_height", "]", ")", "[", "0", "]" ]

[ "actually", "format", "my", "specific", "types" ]

[ "def", "_format_native_types", "(", "self", ",", "na_rep", "=", "\"NaT\"", ",", "date_format", "=", "None", ",", "*", "*", "kwargs", ")", ":", "values", "=", "self", ".", "astype", "(", "object", ")", "if", "date_format", ":", "formatter", "=", "lambda", "dt", ":", "dt", ".", "strftime", "(", "date_format", ")", "else", ":", "formatter", "=", "lambda", "dt", ":", "str", "(", "dt", ")", "if", "self", ".", "_hasnans", ":", "mask", "=", "self", ".", "_isnan", "values", "[", "mask", "]", "=", "na_rep", "imask", "=", "~", "mask", "values", "[", "imask", "]", "=", "np", ".", "array", "(", "[", "formatter", "(", "dt", ")", "for", "dt", "in", "values", "[", "imask", "]", "]", ")", "else", ":", "values", "=", "np", ".", "array", "(", "[", "formatter", "(", "dt", ")", "for", "dt", "in", "values", "]", ")", "return", "values" ]

[ "Convert", "range", "images", "from", "polar", "coordinates", "to", "Cartesian", "coordinates", "." ]

[ "def", "convert_range_image_to_cartesian", "(", "frame", ",", "range_images", ",", "range_image_top_pose", ",", "ri_index", "=", "0", ",", "keep_polar_features", "=", "False", ")", ":", "cartesian_range_images", "=", "{", "}", "frame_pose", "=", "tf", ".", "convert_to_tensor", "(", "value", "=", "np", ".", "reshape", "(", "np", ".", "array", "(", "frame", ".", "pose", ".", "transform", ")", ",", "[", "4", ",", "4", "]", ")", ")", "# [H, W, 6]", "range_image_top_pose_tensor", "=", "tf", ".", "reshape", "(", "tf", ".", "convert_to_tensor", "(", "value", "=", "range_image_top_pose", ".", "data", ")", ",", "range_image_top_pose", ".", "shape", ".", "dims", ")", "# [H, W, 3, 3]", "range_image_top_pose_tensor_rotation", "=", "transform_utils", ".", "get_rotation_matrix", "(", "range_image_top_pose_tensor", "[", "...", ",", "0", "]", ",", "range_image_top_pose_tensor", "[", "...", ",", "1", "]", ",", "range_image_top_pose_tensor", "[", "...", ",", "2", "]", ")", "range_image_top_pose_tensor_translation", "=", "range_image_top_pose_tensor", "[", "...", ",", "3", ":", "]", "range_image_top_pose_tensor", "=", "transform_utils", ".", "get_transform", "(", "range_image_top_pose_tensor_rotation", ",", "range_image_top_pose_tensor_translation", ")", "for", "c", "in", "frame", ".", "context", ".", "laser_calibrations", ":", "range_image", "=", "range_images", "[", "c", ".", "name", "]", "[", "ri_index", "]", "if", "len", "(", "c", ".", "beam_inclinations", ")", "==", "0", ":", "# pylint: disable=g-explicit-length-test", "beam_inclinations", "=", "range_image_utils", ".", "compute_inclination", "(", "tf", ".", "constant", "(", "[", "c", ".", "beam_inclination_min", ",", "c", ".", "beam_inclination_max", "]", ")", ",", "height", "=", "range_image", ".", "shape", ".", "dims", "[", "0", "]", ")", "else", ":", "beam_inclinations", "=", "tf", ".", "constant", "(", "c", ".", "beam_inclinations", ")", "beam_inclinations", "=", "tf", ".", "reverse", "(", "beam_inclinations", ",", "axis", "=", "[", "-", "1", "]", ")", "extrinsic", "=", "np", ".", "reshape", "(", "np", ".", "array", "(", "c", ".", "extrinsic", ".", "transform", ")", ",", "[", "4", ",", "4", "]", ")", "range_image_tensor", "=", "tf", ".", "reshape", "(", "tf", ".", "convert_to_tensor", "(", "value", "=", "range_image", ".", "data", ")", ",", "range_image", ".", "shape", ".", "dims", ")", "pixel_pose_local", "=", "None", "frame_pose_local", "=", "None", "if", "c", ".", "name", "==", "dataset_pb2", ".", "LaserName", ".", "TOP", ":", "pixel_pose_local", "=", "range_image_top_pose_tensor", "pixel_pose_local", "=", "tf", ".", "expand_dims", "(", "pixel_pose_local", ",", "axis", "=", "0", ")", "frame_pose_local", "=", "tf", ".", "expand_dims", "(", "frame_pose", ",", "axis", "=", "0", ")", "range_image_cartesian", "=", "range_image_utils", ".", "extract_point_cloud_from_range_image", "(", "tf", ".", "expand_dims", "(", "range_image_tensor", "[", "...", ",", "0", "]", ",", "axis", "=", "0", ")", ",", "tf", ".", "expand_dims", "(", "extrinsic", ",", "axis", "=", "0", ")", ",", "tf", ".", "expand_dims", "(", "tf", ".", "convert_to_tensor", "(", "value", "=", "beam_inclinations", ")", ",", "axis", "=", "0", ")", ",", "pixel_pose", "=", "pixel_pose_local", ",", "frame_pose", "=", "frame_pose_local", ")", "range_image_cartesian", "=", "tf", ".", "squeeze", "(", "range_image_cartesian", ",", "axis", "=", "0", ")", "if", "keep_polar_features", ":", "# If we want to keep the polar coordinate features of range, intensity,", "# and elongation, concatenate them to be the initial dimensions of the", "# returned Cartesian range image.", "range_image_cartesian", "=", "tf", ".", "concat", "(", "[", "range_image_tensor", "[", "...", ",", "0", ":", "3", "]", ",", "range_image_cartesian", "]", ",", "axis", "=", "-", "1", ")", "cartesian_range_images", "[", "c", ".", "name", "]", "=", "range_image_cartesian", "return", "cartesian_range_images" ]

[ "returns", "a", "minified", "version", "of", "the", "javascript", "string" ]

[ "def", "jsmin", "(", "js", ",", "*", "*", "kwargs", ")", ":", "if", "not", "is_3", ":", "if", "cStringIO", "and", "not", "isinstance", "(", "js", ",", "unicode", ")", ":", "# strings can use cStringIO for a 3x performance", "# improvement, but unicode (in python2) cannot", "klass", "=", "cStringIO", ".", "StringIO", "else", ":", "klass", "=", "StringIO", ".", "StringIO", "else", ":", "klass", "=", "io", ".", "StringIO", "ins", "=", "klass", "(", "js", ")", "outs", "=", "klass", "(", ")", "JavascriptMinify", "(", "ins", ",", "outs", ",", "*", "*", "kwargs", ")", ".", "minify", "(", ")", "return", "outs", ".", "getvalue", "(", ")" ]

[ "Download", "COCO", "images", "from", "mscoco", ".", "org", "server", ".", ":", "param", "tarDir", "(", "str", ")", ":", "COCO", "results", "directory", "name", "imgIds", "(", "list", ")", ":", "images", "to", "be", "downloaded", ":", "return", ":" ]

[ "def", "download", "(", "self", ",", "tarDir", "=", "None", ",", "imgIds", "=", "[", "]", ")", ":", "if", "tarDir", "is", "None", ":", "print", "'Please specify target directory'", "return", "-", "1", "if", "len", "(", "imgIds", ")", "==", "0", ":", "imgs", "=", "self", ".", "imgs", ".", "values", "(", ")", "else", ":", "imgs", "=", "self", ".", "loadImgs", "(", "imgIds", ")", "N", "=", "len", "(", "imgs", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "tarDir", ")", ":", "os", ".", "makedirs", "(", "tarDir", ")", "for", "i", ",", "img", "in", "enumerate", "(", "imgs", ")", ":", "tic", "=", "time", ".", "time", "(", ")", "fname", "=", "os", ".", "path", ".", "join", "(", "tarDir", ",", "img", "[", "'file_name'", "]", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "fname", ")", ":", "urllib", ".", "urlretrieve", "(", "img", "[", "'coco_url'", "]", ",", "fname", ")", "print", "'downloaded %d/%d images (t=%.1fs)'", "%", "(", "i", ",", "N", ",", "time", ".", "time", "(", ")", "-", "tic", ")" ]

[ "Helper", "for", "build", "(", "...", ")", ";", "verifies", "the", "output", "of", "_build_transform", "." ]

[ "def", "_check_output_tensors", "(", "self", ",", "output_tensors", ")", ":", "if", "not", "isinstance", "(", "output_tensors", ",", "self", ".", "return_type", ")", ":", "raise", "TypeError", "(", "\"Expected a NamedTuple of Tensors with elements %s; got %s.\"", "%", "(", "self", ".", "output_names", ",", "type", "(", "output_tensors", ")", ".", "__name__", ")", ")" ]

[ "Add", "the", "next", "edge", "to", "the", "polygon" ]

[ "def", "AddEdge", "(", "self", ",", "azi", ",", "s", ")", ":", "if", "self", ".", "num", "!=", "0", ":", "_", ",", "lat", ",", "lon", ",", "_", ",", "_", ",", "_", ",", "_", ",", "_", ",", "S12", "=", "self", ".", "earth", ".", "_GenDirect", "(", "self", ".", "lat1", ",", "self", ".", "lon1", ",", "azi", ",", "False", ",", "s", ",", "self", ".", "_mask", ")", "self", ".", "_perimetersum", ".", "Add", "(", "s", ")", "if", "not", "self", ".", "polyline", ":", "self", ".", "_areasum", ".", "Add", "(", "S12", ")", "self", ".", "_crossings", "+=", "PolygonArea", ".", "_transitdirect", "(", "self", ".", "lon1", ",", "lon", ")", "self", ".", "lat1", "=", "lat", "self", ".", "lon1", "=", "lon", "self", ".", "num", "+=", "1" ]

[ "load", "json", "file", "to", "a", "dict" ]

[ "def", "load", "(", "self", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "__js_file", ")", ":", "err_m", "(", "'Cannot find json file %s'", "%", "self", ".", "__js_file", ")", "with", "open", "(", "self", ".", "__js_file", ",", "'r'", ")", "as", "f", ":", "tmparray", "=", "f", ".", "readlines", "(", ")", "content", "=", "''", "for", "t", "in", "tmparray", ":", "content", "+=", "t", "try", ":", "return", "defaultdict", "(", "str", ",", "json", ".", "loads", "(", "content", ")", ")", "except", "ValueError", ":", "err_m", "(", "'No json format found in config file %s'", "%", "self", ".", "__js_file", ")" ]

[ "Removes", "//", "-", "comments", "and", "single", "-", "line", "C", "-", "style", "/", "*", "*", "/", "comments", "." ]

[ "def", "CleanseComments", "(", "line", ")", ":", "commentpos", "=", "line", ".", "find", "(", "'//'", ")", "if", "commentpos", "!=", "-", "1", "and", "not", "IsCppString", "(", "line", "[", ":", "commentpos", "]", ")", ":", "line", "=", "line", "[", ":", "commentpos", "]", ".", "rstrip", "(", ")", "# get rid of /* ... */", "return", "_RE_PATTERN_CLEANSE_LINE_C_COMMENTS", ".", "sub", "(", "''", ",", "line", ")" ]

[ "Set", "MPI_HOME", "." ]

[ "def", "set_mpi_home", "(", "environ_cp", ")", ":", "default_mpi_home", "=", "which", "(", "'mpirun'", ")", "or", "which", "(", "'mpiexec'", ")", "or", "''", "default_mpi_home", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "dirname", "(", "default_mpi_home", ")", ")", "ask_mpi_home", "=", "(", "'Please specify the MPI toolkit folder. [Default is %s]: '", ")", "%", "default_mpi_home", "while", "True", ":", "mpi_home", "=", "get_from_env_or_user_or_default", "(", "environ_cp", ",", "'MPI_HOME'", ",", "ask_mpi_home", ",", "default_mpi_home", ")", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "mpi_home", ",", "'include'", ")", ")", "and", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "mpi_home", ",", "'lib'", ")", ")", ":", "break", "print", "(", "'Invalid path to the MPI Toolkit. %s or %s cannot be found'", "%", "(", "os", ".", "path", ".", "join", "(", "mpi_home", ",", "'include'", ")", ",", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "mpi_home", ",", "'lib'", ")", ")", ")", ")", "environ_cp", "[", "'MPI_HOME'", "]", "=", "''", "# Set MPI_HOME", "environ_cp", "[", "'MPI_HOME'", "]", "=", "str", "(", "mpi_home", ")" ]

[ "Read", "in", "docstrings", "from", "lang", "-", "specific", "docstring", "dictionary", "." ]

[ "def", "read_docstrings", "(", "lang", ")", ":", "modname", "=", "\"turtle_docstringdict_%(language)s\"", "%", "{", "'language'", ":", "lang", ".", "lower", "(", ")", "}", "module", "=", "__import__", "(", "modname", ")", "docsdict", "=", "module", ".", "docsdict", "for", "key", "in", "docsdict", ":", "try", ":", "# eval(key).im_func.__doc__ = docsdict[key]", "eval", "(", "key", ")", ".", "__doc__", "=", "docsdict", "[", "key", "]", "except", "Exception", ":", "print", "(", "\"Bad docstring-entry: %s\"", "%", "key", ")" ]

[ "Return", "the", "time", "part", "with", "same", "tzinfo", "." ]

[ "def", "timetz", "(", "self", ")", ":", "return", "time", "(", "self", ".", "hour", ",", "self", ".", "minute", ",", "self", ".", "second", ",", "self", ".", "microsecond", ",", "self", ".", "_tzinfo", ",", "fold", "=", "self", ".", "fold", ")" ]

[ "Get", "a", "Python", "module", "for", "a", "type", "library", "ID" ]

[ "def", "GetModuleForTypelib", "(", "typelibCLSID", ",", "lcid", ",", "major", ",", "minor", ")", ":", "modName", "=", "GetGeneratedFileName", "(", "typelibCLSID", ",", "lcid", ",", "major", ",", "minor", ")", "mod", "=", "_GetModule", "(", "modName", ")", "# If the import worked, it doesn't mean we have actually added this", "# module to our cache though - check that here.", "if", "\"_in_gencache_\"", "not", "in", "mod", ".", "__dict__", ":", "AddModuleToCache", "(", "typelibCLSID", ",", "lcid", ",", "major", ",", "minor", ")", "assert", "\"_in_gencache_\"", "in", "mod", ".", "__dict__", "return", "mod" ]

[ "getPlatoonLeaders", "()", "-", ">", "list", "(", "PVehicle", ")" ]

[ "def", "getPlatoonLeaders", "(", "self", ")", ":", "return", "[", "pltn", ".", "getVehicles", "(", ")", "[", "0", "]", "for", "pltn", "in", "self", ".", "_platoons", ".", "values", "(", ")", "if", "pltn", ".", "size", "(", ")", ">", "1", "]" ]

[ "Send", "DO", "DONT", "WILL", "WONT", "." ]

[ "def", "telnet_send_option", "(", "self", ",", "action", ",", "option", ")", ":", "self", ".", "connection", ".", "write", "(", "IAC", "+", "action", "+", "option", ")" ]

[ "Set", "TF_CUDA_COMPUTE_CAPABILITIES", "." ]

[ "def", "set_tf_cuda_compute_capabilities", "(", "environ_cp", ")", ":", "while", "True", ":", "native_cuda_compute_capabilities", "=", "get_native_cuda_compute_capabilities", "(", "environ_cp", ")", "if", "not", "native_cuda_compute_capabilities", ":", "default_cuda_compute_capabilities", "=", "_DEFAULT_CUDA_COMPUTE_CAPABILITIES", "else", ":", "default_cuda_compute_capabilities", "=", "native_cuda_compute_capabilities", "ask_cuda_compute_capabilities", "=", "(", "'Please specify a list of comma-separated '", "'Cuda compute capabilities you want to '", "'build with.\\nYou can find the compute '", "'capability of your device at: '", "'https://developer.nvidia.com/cuda-gpus.\\nPlease'", "' note that each additional compute '", "'capability significantly increases your '", "'build time and binary size. [Default is: %s]'", "%", "default_cuda_compute_capabilities", ")", "tf_cuda_compute_capabilities", "=", "get_from_env_or_user_or_default", "(", "environ_cp", ",", "'TF_CUDA_COMPUTE_CAPABILITIES'", ",", "ask_cuda_compute_capabilities", ",", "default_cuda_compute_capabilities", ")", "# Check whether all capabilities from the input is valid", "all_valid", "=", "True", "for", "compute_capability", "in", "tf_cuda_compute_capabilities", ".", "split", "(", "','", ")", ":", "m", "=", "re", ".", "match", "(", "'[0-9]+.[0-9]+'", ",", "compute_capability", ")", "if", "not", "m", ":", "print", "(", "'Invalid compute capability: '", "%", "compute_capability", ")", "all_valid", "=", "False", "else", ":", "ver", "=", "int", "(", "m", ".", "group", "(", "0", ")", ".", "split", "(", "'.'", ")", "[", "0", "]", ")", "if", "ver", "<", "3", ":", "print", "(", "'Only compute capabilities 3.0 or higher are supported.'", ")", "all_valid", "=", "False", "if", "all_valid", ":", "break", "# Reset and Retry", "environ_cp", "[", "'TF_CUDA_COMPUTE_CAPABILITIES'", "]", "=", "''", "# Set TF_CUDA_COMPUTE_CAPABILITIES", "environ_cp", "[", "'TF_CUDA_COMPUTE_CAPABILITIES'", "]", "=", "tf_cuda_compute_capabilities", "write_action_env_to_bazelrc", "(", "'TF_CUDA_COMPUTE_CAPABILITIES'", ",", "tf_cuda_compute_capabilities", ")" ]

[ "Returns", "the", "names", "of", "the", "arrays", "as", "a", "list", "." ]

[ "def", "keys", "(", "self", ")", ":", "return", "self", ".", "ArrayNames" ]

[ "Returns", "reason", "why", "the", "Op", "at", "op_idx", "is", "traced", "or", "not", "." ]

[ "def", "reason", "(", "op_idx", ",", "details", ")", ":", "return", "'%d %s'", "%", "(", "op_idx", ",", "details", ")" ]

[ "Removes", "the", "selection", "anchor", "." ]

[ "def", "anchor_clear", "(", "self", ")", ":", "self", ".", "tk", ".", "call", "(", "self", ",", "'anchor'", ",", "'clear'", ")" ]

[ "Initializes", "the", "tree", "by", "FieldMask", "." ]

[ "def", "__init__", "(", "self", ",", "field_mask", "=", "None", ")", ":", "self", ".", "_root", "=", "{", "}", "if", "field_mask", ":", "self", ".", "MergeFromFieldMask", "(", "field_mask", ")" ]

[ "Helper", "function", "for", "reading", "in", "next", "sample", "." ]

[ "def", "next_sample", "(", "self", ")", ":", "if", "self", ".", "_allow_read", "is", "False", ":", "raise", "StopIteration", "if", "self", ".", "seq", "is", "not", "None", ":", "if", "self", ".", "cur", "<", "self", ".", "num_image", ":", "idx", "=", "self", ".", "seq", "[", "self", ".", "cur", "]", "else", ":", "if", "self", ".", "last_batch_handle", "!=", "'discard'", ":", "self", ".", "cur", "=", "0", "raise", "StopIteration", "self", ".", "cur", "+=", "1", "if", "self", ".", "imgrec", "is", "not", "None", ":", "s", "=", "self", ".", "imgrec", ".", "read_idx", "(", "idx", ")", "header", ",", "img", "=", "recordio", ".", "unpack", "(", "s", ")", "if", "self", ".", "imglist", "is", "None", ":", "return", "header", ".", "label", ",", "img", "else", ":", "return", "self", ".", "imglist", "[", "idx", "]", "[", "0", "]", ",", "img", "else", ":", "label", ",", "fname", "=", "self", ".", "imglist", "[", "idx", "]", "return", "label", ",", "self", ".", "read_image", "(", "fname", ")", "else", ":", "s", "=", "self", ".", "imgrec", ".", "read", "(", ")", "if", "s", "is", "None", ":", "if", "self", ".", "last_batch_handle", "!=", "'discard'", ":", "self", ".", "imgrec", ".", "reset", "(", ")", "raise", "StopIteration", "header", ",", "img", "=", "recordio", ".", "unpack", "(", "s", ")", "return", "header", ".", "label", ",", "img" ]

[ "Return", "inverse", "of", "square", "transformation", "matrix", "." ]

[ "def", "inverse_matrix", "(", "matrix", ")", ":", "return", "numpy", ".", "linalg", ".", "inv", "(", "matrix", ")" ]

[ "Return", "the", "total", "torque", "acting", "on", "the", "particle" ]

[ "def", "torque", "(", "self", ")", ":", "return", "self", ".", "get", "(", "\"torque\"", ",", "self", ".", "index", ")" ]

[ "Rules", "for", "symbols", "in", "the", "baremetal", "configuration", "." ]

[ "def", "keep_in_baremetal", "(", "name", ")", ":", "if", "name", "in", "EXCLUDE_FROM_BAREMETAL", ":", "return", "False", "return", "True" ]

[ "Generates", "the", "various", "output", "paths", "and", "file", "names", "to", "be", "used", "during", "saving", "or", "as", "workspace", "names", ":", "param", "run_details", ":", "The", "run", "details", "associated", "with", "this", "run", ":", "return", ":", "A", "dictionary", "containing", "the", "various", "output", "paths", "and", "generated", "output", "name" ]

[ "def", "_generate_out_file_paths", "(", "self", ",", "run_details", ")", ":", "output_directory", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_output_dir", ",", "run_details", ".", "label", ",", "self", ".", "_user_name", ")", "output_directory", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "expanduser", "(", "output_directory", ")", ")", "dat_files_directory", "=", "output_directory", "if", "self", ".", "_inst_settings", ".", "dat_files_directory", ":", "dat_files_directory", "=", "os", ".", "path", ".", "join", "(", "output_directory", ",", "self", ".", "_inst_settings", ".", "dat_files_directory", ")", "file_type", "=", "\"\"", "if", "run_details", ".", "file_extension", "is", "None", "else", "run_details", ".", "file_extension", ".", "lstrip", "(", "\".\"", ")", "out_file_names", "=", "{", "\"output_folder\"", ":", "output_directory", "}", "format_options", "=", "{", "\"inst\"", ":", "self", ".", "_inst_prefix", ",", "\"instlow\"", ":", "self", ".", "_inst_prefix", ".", "lower", "(", ")", ",", "\"instshort\"", ":", "self", ".", "_inst_prefix_short", ",", "\"runno\"", ":", "run_details", ".", "output_run_string", ",", "\"fileext\"", ":", "file_type", ",", "\"_fileext\"", ":", "\"_\"", "+", "file_type", "if", "file_type", "else", "\"\"", ",", "\"suffix\"", ":", "run_details", ".", "output_suffix", "if", "run_details", ".", "output_suffix", "else", "\"\"", "}", "format_options", "=", "self", ".", "_add_formatting_options", "(", "format_options", ")", "output_formats", "=", "{", "\"nxs_filename\"", ":", "output_directory", ",", "\"gss_filename\"", ":", "output_directory", ",", "\"tof_xye_filename\"", ":", "dat_files_directory", ",", "\"dspacing_xye_filename\"", ":", "dat_files_directory", "}", "for", "key", ",", "output_dir", "in", "output_formats", ".", "items", "(", ")", ":", "filepath", "=", "os", ".", "path", ".", "join", "(", "output_dir", ",", "getattr", "(", "self", ".", "_inst_settings", ",", "key", ")", ".", "format", "(", "*", "*", "format_options", ")", ")", "out_file_names", "[", "key", "]", "=", "filepath", "out_file_names", "[", "'output_name'", "]", "=", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "out_file_names", "[", "'nxs_filename'", "]", ")", ")", "[", "0", "]", "return", "out_file_names" ]

[ "Estimate", "propensity", "for", "clicks", "in", "a", "list", "." ]

[ "def", "estimatePropensityWeightsForOneList", "(", "self", ",", "click_list", ",", "use_non_clicked_data", "=", "False", ")", ":", "propensity_weights", "=", "[", "]", "for", "r", "in", "range", "(", "len", "(", "click_list", ")", ")", ":", "pw", "=", "0.0", "if", "use_non_clicked_data", "|", "click_list", "[", "r", "]", ">", "0", ":", "pw", "=", "1.0", "/", "self", ".", "getExamProb", "(", "r", ")", "*", "self", ".", "getExamProb", "(", "0", ")", "propensity_weights", ".", "append", "(", "pw", ")", "return", "propensity_weights" ]

[ "Peak", "-", "to", "-", "peak", "value", "of", "x", "." ]

[ "def", "_ptp", "(", "x", ")", ":", "return", "_unsigned_subtract", "(", "x", ".", "max", "(", ")", ",", "x", ".", "min", "(", ")", ")" ]

[ "distribution", "analyzer" ]

[ "def", "print_distribution_results", "(", "self", ",", "data", ")", ":", "if", "len", "(", "data", ")", "==", "0", ":", "print", "(", "PrintColors", ".", "FAIL", "+", "\"No Data Generated!\"", "+", "PrintColors", ".", "ENDC", ")", "return", "total", "=", "0", "for", "k", ",", "v", "in", "data", ".", "items", "(", ")", ":", "total", "+=", "v", "for", "k", ",", "v", "in", "data", ".", "items", "(", ")", ":", "percentage", "=", "\"{0:.2f}\"", ".", "format", "(", "(", "float", "(", "v", ")", "/", "total", ")", "*", "100", ")", "print", "(", "PrintColors", ".", "OKBLUE", "+", "k", "+", "\" = \"", "+", "str", "(", "v", ")", "+", "\"(\"", "+", "percentage", "+", "\"%)\"", "+", "PrintColors", ".", "ENDC", ")" ]

[ "Get", "the", "protected", "OpMsg", "deserializer", "method", "for", "a", "struct", "." ]

[ "def", "get_op_msg_request_deserializer_method", "(", "self", ")", ":", "# type: () -> Optional[MethodInfo]", "# pylint: disable=invalid-name", "pass" ]

[ "RichTextBuffer_FindHandlerByFilename", "(", "String", "filename", "int", "imageType", ")", "-", ">", "RichTextFileHandler" ]

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

[ "Returns", "a", "unique", "token", "." ]

[ "def", "_next_unique_token", "(", "self", ")", ":", "with", "self", ".", "_lock", ":", "uid", "=", "self", ".", "_unique_id", "self", ".", "_unique_id", "+=", "1", "return", "\"pyfunc_%d\"", "%", "uid" ]

[ "Return", "default", "parameters", "of", "the", "given", "model", "specified", "by", "a", "string", "." ]

[ "def", "GetDefaults", "(", "model", ",", "keys", "=", "None", ",", "output", "=", "''", ")", ":", "if", "keys", "is", "None", ":", "cmd", "=", "\"/{0} GetDefaults\"", ".", "format", "(", "model", ")", "elif", "is_literal", "(", "keys", ")", ":", "cmd", "=", "'/{0} GetDefaults /{1} get'", ".", "format", "(", "model", ",", "keys", ")", "elif", "is_iterable", "(", "keys", ")", ":", "keys_str", "=", "\" \"", ".", "join", "(", "\"/{0}\"", ".", "format", "(", "x", ")", "for", "x", "in", "keys", ")", "cmd", "=", "\"/{0} GetDefaults [ {1} ] {{ 1 index exch get }}\"", ".", "format", "(", "model", ",", "keys_str", ")", "+", "\" Map exch pop\"", "else", ":", "raise", "TypeError", "(", "\"keys should be either a string or an iterable\"", ")", "sr", "(", "cmd", ")", "result", "=", "spp", "(", ")", "if", "output", "==", "'json'", ":", "result", "=", "to_json", "(", "result", ")", "return", "result" ]

[ "Returns", "the", "gradient", "of", "ComplexAbs", "." ]

[ "def", "_ComplexAbsGrad", "(", "op", ",", "grad", ")", ":", "# TODO(b/27786104): The cast to complex could be removed once arithmetic", "# supports mixtures of complex64 and real values.", "return", "(", "math_ops", ".", "complex", "(", "grad", ",", "array_ops", ".", "zeros_like", "(", "grad", ")", ")", "*", "math_ops", ".", "sign", "(", "op", ".", "inputs", "[", "0", "]", ")", ")" ]

[ "Args", ":", "parent_message", ":", "The", "message", "whose", "_Modified", "()", "method", "we", "should", "call", "when", "we", "receive", "Modified", "()", "messages", "." ]

[ "def", "__init__", "(", "self", ",", "parent_message", ")", ":", "# This listener establishes a back reference from a child (contained) object", "# to its parent (containing) object. We make this a weak reference to avoid", "# creating cyclic garbage when the client finishes with the 'parent' object", "# in the tree.", "if", "isinstance", "(", "parent_message", ",", "weakref", ".", "ProxyType", ")", ":", "self", ".", "_parent_message_weakref", "=", "parent_message", "else", ":", "self", ".", "_parent_message_weakref", "=", "weakref", ".", "proxy", "(", "parent_message", ")", "# As an optimization, we also indicate directly on the listener whether", "# or not the parent message is dirty. This way we can avoid traversing", "# up the tree in the common case.", "self", ".", "dirty", "=", "False" ]

[ "StyleSetWeight", "(", "self", "int", "style", "int", "weight", ")" ]

[ "def", "StyleSetWeight", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_StyleSetWeight", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Pick", "a", "point", "of", "reference", "." ]

[ "def", "pickRef", "(", "self", ")", ":", "self", ".", "pickmode", "=", "True", "if", "self", ".", "node", ":", "self", ".", "node", "=", "self", ".", "node", "[", ":", "1", "]", "# remove previous picks", "_msg", "(", "translate", "(", "\"draft\"", ",", "\"Pick reference distance from base point\"", ")", ")", "self", ".", "call", "=", "self", ".", "view", ".", "addEventCallback", "(", "\"SoEvent\"", ",", "self", ".", "action", ")" ]

[ "Exports", "the", "internal", "state", "of", "this", "tape", "." ]

[ "def", "export", "(", "self", ")", ":", "return", "pywrap_tensorflow", ".", "TFE_Py_TapeExport", "(", "self", ".", "_tape", ")" ]

[ "Initialize", "the", "parameters", "for", "an", "LSTM", "cell", "." ]

[ "def", "__init__", "(", "self", ",", "num_units", ",", "use_peepholes", "=", "False", ",", "share_time_frequency_weights", "=", "False", ",", "cell_clip", "=", "None", ",", "initializer", "=", "None", ",", "num_unit_shards", "=", "1", ",", "forget_bias", "=", "1.0", ",", "feature_size", "=", "None", ",", "frequency_skip", "=", "None", ",", "num_frequency_blocks", "=", "None", ",", "start_freqindex_list", "=", "None", ",", "end_freqindex_list", "=", "None", ",", "couple_input_forget_gates", "=", "False", ",", "state_is_tuple", "=", "True", ",", "reuse", "=", "None", ")", ":", "super", "(", "GridLSTMCell", ",", "self", ")", ".", "__init__", "(", "_reuse", "=", "reuse", ")", "if", "not", "state_is_tuple", ":", "logging", ".", "warn", "(", "\"%s: Using a concatenated state is slower and will soon be \"", "\"deprecated. Use state_is_tuple=True.\"", ",", "self", ")", "self", ".", "_num_units", "=", "num_units", "self", ".", "_use_peepholes", "=", "use_peepholes", "self", ".", "_share_time_frequency_weights", "=", "share_time_frequency_weights", "self", ".", "_couple_input_forget_gates", "=", "couple_input_forget_gates", "self", ".", "_state_is_tuple", "=", "state_is_tuple", "self", ".", "_cell_clip", "=", "cell_clip", "self", ".", "_initializer", "=", "initializer", "self", ".", "_num_unit_shards", "=", "num_unit_shards", "self", ".", "_forget_bias", "=", "forget_bias", "self", ".", "_feature_size", "=", "feature_size", "self", ".", "_frequency_skip", "=", "frequency_skip", "self", ".", "_start_freqindex_list", "=", "start_freqindex_list", "self", ".", "_end_freqindex_list", "=", "end_freqindex_list", "self", ".", "_num_frequency_blocks", "=", "num_frequency_blocks", "self", ".", "_total_blocks", "=", "0", "self", ".", "_reuse", "=", "reuse", "if", "self", ".", "_num_frequency_blocks", "is", "None", ":", "raise", "ValueError", "(", "\"Must specify num_frequency_blocks\"", ")", "for", "block_index", "in", "range", "(", "len", "(", "self", ".", "_num_frequency_blocks", ")", ")", ":", "self", ".", "_total_blocks", "+=", "int", "(", "self", ".", "_num_frequency_blocks", "[", "block_index", "]", ")", "if", "state_is_tuple", ":", "state_names", "=", "\"\"", "for", "block_index", "in", "range", "(", "len", "(", "self", ".", "_num_frequency_blocks", ")", ")", ":", "for", "freq_index", "in", "range", "(", "self", ".", "_num_frequency_blocks", "[", "block_index", "]", ")", ":", "name_prefix", "=", "\"state_f%02d_b%02d\"", "%", "(", "freq_index", ",", "block_index", ")", "state_names", "+=", "(", "\"%s_c, %s_m,\"", "%", "(", "name_prefix", ",", "name_prefix", ")", ")", "self", ".", "_state_tuple_type", "=", "collections", ".", "namedtuple", "(", "\"GridLSTMStateTuple\"", ",", "state_names", ".", "strip", "(", "\",\"", ")", ")", "self", ".", "_state_size", "=", "self", ".", "_state_tuple_type", "(", "*", "(", "[", "num_units", ",", "num_units", "]", "*", "self", ".", "_total_blocks", ")", ")", "else", ":", "self", ".", "_state_tuple_type", "=", "None", "self", ".", "_state_size", "=", "num_units", "*", "self", ".", "_total_blocks", "*", "2", "self", ".", "_output_size", "=", "num_units", "*", "self", ".", "_total_blocks", "*", "2" ]

[ "Find", "the", "ModuleRef", "corresponding", "to", "the", "given", "pointer", "." ]

[ "def", "_find_module_ptr", "(", "self", ",", "module_ptr", ")", ":", "ptr", "=", "cast", "(", "module_ptr", ",", "c_void_p", ")", ".", "value", "for", "module", "in", "self", ".", "_modules", ":", "if", "cast", "(", "module", ".", "_ptr", ",", "c_void_p", ")", ".", "value", "==", "ptr", ":", "return", "module", "return", "None" ]

[ "Creates", "a", "patch", "for", "the", "Selectable", "ability", "of", "a", "line", "." ]

[ "def", "selectable_ability", "(", "converter_group", ",", "line", ",", "container_obj_ref", ",", "diff", "=", "None", ")", ":", "head_unit_id", "=", "line", ".", "get_head_unit_id", "(", ")", "tech_id", "=", "converter_group", ".", "get_id", "(", ")", "dataset", "=", "line", ".", "data", "patches", "=", "[", "]", "name_lookup_dict", "=", "internal_name_lookups", ".", "get_entity_lookups", "(", "dataset", ".", "game_version", ")", "tech_lookup_dict", "=", "internal_name_lookups", ".", "get_tech_lookups", "(", "dataset", ".", "game_version", ")", "game_entity_name", "=", "name_lookup_dict", "[", "head_unit_id", "]", "[", "0", "]", "# First patch: Sound for the SelectableSelf ability", "changed", "=", "False", "if", "diff", ":", "diff_selection_sound", "=", "diff", "[", "\"selection_sound_id\"", "]", "if", "not", "isinstance", "(", "diff_selection_sound", ",", "NoDiffMember", ")", ":", "changed", "=", "True", "if", "isinstance", "(", "line", ",", "GenieUnitLineGroup", ")", ":", "ability_name", "=", "\"SelectableSelf\"", "else", ":", "ability_name", "=", "\"Selectable\"", "if", "changed", ":", "patch_target_ref", "=", "f\"{game_entity_name}.{ability_name}\"", "patch_target_forward_ref", "=", "ForwardRef", "(", "line", ",", "patch_target_ref", ")", "# Wrapper", "wrapper_name", "=", "f\"Change{game_entity_name}{ability_name}Wrapper\"", "wrapper_ref", "=", "f\"{container_obj_ref}.{wrapper_name}\"", "wrapper_raw_api_object", "=", "RawAPIObject", "(", "wrapper_ref", ",", "wrapper_name", ",", "dataset", ".", "nyan_api_objects", ")", "wrapper_raw_api_object", ".", "add_raw_parent", "(", "\"engine.util.patch.Patch\"", ")", "if", "isinstance", "(", "line", ",", "GenieBuildingLineGroup", ")", ":", "# Store building upgrades next to their game entity definition,", "# not in the Age up techs.", "wrapper_raw_api_object", ".", "set_location", "(", "\"data/game_entity/generic/%s/\"", "%", "(", "name_lookup_dict", "[", "head_unit_id", "]", "[", "1", "]", ")", ")", "wrapper_raw_api_object", ".", "set_filename", "(", "f\"{tech_lookup_dict[tech_id][1]}_upgrade\"", ")", "else", ":", "wrapper_raw_api_object", ".", "set_location", "(", "ForwardRef", "(", "converter_group", ",", "container_obj_ref", ")", ")", "# Nyan patch", "nyan_patch_name", "=", "f\"Change{game_entity_name}{ability_name}\"", "nyan_patch_ref", "=", "f\"{container_obj_ref}.{wrapper_name}.{nyan_patch_name}\"", "nyan_patch_location", "=", "ForwardRef", "(", "converter_group", ",", "wrapper_ref", ")", "nyan_patch_raw_api_object", "=", "RawAPIObject", "(", "nyan_patch_ref", ",", "nyan_patch_name", ",", "dataset", ".", "nyan_api_objects", ",", "nyan_patch_location", ")", "nyan_patch_raw_api_object", ".", "add_raw_parent", "(", "\"engine.util.patch.NyanPatch\"", ")", "nyan_patch_raw_api_object", ".", "set_patch_target", "(", "patch_target_forward_ref", ")", "# Change sound", "diff_selection_sound_id", "=", "diff_selection_sound", ".", "get_value", "(", ")", "sounds_set", "=", "[", "]", "if", "diff_selection_sound_id", ">", "-", "1", ":", "# Patch the new sound in", "sound_forward_ref", "=", "AoCUpgradeAbilitySubprocessor", ".", "create_sound", "(", "converter_group", ",", "diff_selection_sound_id", ",", "nyan_patch_ref", ",", "ability_name", ",", "\"select_\"", ")", "sounds_set", ".", "append", "(", "sound_forward_ref", ")", "nyan_patch_raw_api_object", ".", "add_raw_patch_member", "(", "\"sounds\"", ",", "sounds_set", ",", "\"engine.ability.property.type.CommandSound\"", ",", "MemberOperator", ".", "ASSIGN", ")", "patch_forward_ref", "=", "ForwardRef", "(", "converter_group", ",", "nyan_patch_ref", ")", "wrapper_raw_api_object", ".", "add_raw_member", "(", "\"patch\"", ",", "patch_forward_ref", ",", "\"engine.util.patch.Patch\"", ")", "converter_group", ".", "add_raw_api_object", "(", "wrapper_raw_api_object", ")", "converter_group", ".", "add_raw_api_object", "(", "nyan_patch_raw_api_object", ")", "wrapper_forward_ref", "=", "ForwardRef", "(", "converter_group", ",", "wrapper_ref", ")", "patches", ".", "append", "(", "wrapper_forward_ref", ")", "# Second patch: Selection box", "changed", "=", "False", "if", "diff", ":", "diff_radius_x", "=", "diff", "[", "\"selection_shape_x\"", "]", "diff_radius_y", "=", "diff", "[", "\"selection_shape_y\"", "]", "if", "any", "(", "not", "isinstance", "(", "value", ",", "NoDiffMember", ")", "for", "value", "in", "(", "diff_radius_x", ",", "diff_radius_y", ")", ")", ":", "changed", "=", "True", "if", "changed", ":", "patch_target_ref", "=", "f\"{game_entity_name}.{ability_name}.Rectangle\"", "patch_target_forward_ref", "=", "ForwardRef", "(", "line", ",", "patch_target_ref", ")", "# Wrapper", "wrapper_name", "=", "f\"Change{game_entity_name}{ability_name}RectangleWrapper\"", "wrapper_ref", "=", "f\"{container_obj_ref}.{wrapper_name}\"", "wrapper_raw_api_object", "=", "RawAPIObject", "(", "wrapper_ref", ",", "wrapper_name", ",", "dataset", ".", "nyan_api_objects", ")", "wrapper_raw_api_object", ".", "add_raw_parent", "(", "\"engine.util.patch.Patch\"", ")", "if", "isinstance", "(", "line", ",", "GenieBuildingLineGroup", ")", ":", "# Store building upgrades next to their game entity definition,", "# not in the Age up techs.", "wrapper_raw_api_object", ".", "set_location", "(", "\"data/game_entity/generic/%s/\"", "%", "(", "name_lookup_dict", "[", "head_unit_id", "]", "[", "1", "]", ")", ")", "wrapper_raw_api_object", ".", "set_filename", "(", "f\"{tech_lookup_dict[tech_id][1]}_upgrade\"", ")", "else", ":", "wrapper_raw_api_object", ".", "set_location", "(", "ForwardRef", "(", "converter_group", ",", "container_obj_ref", ")", ")", "# Nyan patch", "nyan_patch_name", "=", "f\"Change{game_entity_name}{ability_name}Rectangle\"", "nyan_patch_ref", "=", "f\"{container_obj_ref}.{wrapper_name}.{nyan_patch_name}\"", "nyan_patch_location", "=", "ForwardRef", "(", "converter_group", ",", "wrapper_ref", ")", "nyan_patch_raw_api_object", "=", "RawAPIObject", "(", "nyan_patch_ref", ",", "nyan_patch_name", ",", "dataset", ".", "nyan_api_objects", ",", "nyan_patch_location", ")", "nyan_patch_raw_api_object", ".", "add_raw_parent", "(", "\"engine.util.patch.NyanPatch\"", ")", "nyan_patch_raw_api_object", ".", "set_patch_target", "(", "patch_target_forward_ref", ")", "if", "not", "isinstance", "(", "diff_radius_x", ",", "NoDiffMember", ")", ":", "diff_width_value", "=", "diff_radius_x", ".", "get_value", "(", ")", "nyan_patch_raw_api_object", ".", "add_raw_patch_member", "(", "\"width\"", ",", "diff_width_value", ",", "\"engine.util.selection_box.type.Rectangle\"", ",", "MemberOperator", ".", "ADD", ")", "if", "not", "isinstance", "(", "diff_radius_y", ",", "NoDiffMember", ")", ":", "diff_height_value", "=", "diff_radius_y", ".", "get_value", "(", ")", "nyan_patch_raw_api_object", ".", "add_raw_patch_member", "(", "\"height\"", ",", "diff_height_value", ",", "\"engine.util.selection_box.type.Rectangle\"", ",", "MemberOperator", ".", "ADD", ")", "patch_forward_ref", "=", "ForwardRef", "(", "converter_group", ",", "nyan_patch_ref", ")", "wrapper_raw_api_object", ".", "add_raw_member", "(", "\"patch\"", ",", "patch_forward_ref", ",", "\"engine.util.patch.Patch\"", ")", "converter_group", ".", "add_raw_api_object", "(", "wrapper_raw_api_object", ")", "converter_group", ".", "add_raw_api_object", "(", "nyan_patch_raw_api_object", ")", "wrapper_forward_ref", "=", "ForwardRef", "(", "converter_group", ",", "wrapper_ref", ")", "patches", ".", "append", "(", "wrapper_forward_ref", ")", "return", "patches" ]

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

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

[ "Create", "a", "DOLFINx", "Form", "or", "an", "array", "of", "Forms" ]

[ "def", "form", "(", "form", ":", "typing", ".", "Union", "[", "ufl", ".", "Form", ",", "typing", ".", "Iterable", "[", "ufl", ".", "Form", "]", "]", ",", "dtype", ":", "np", ".", "dtype", "=", "PETSc", ".", "ScalarType", ",", "form_compiler_parameters", ":", "dict", "=", "{", "}", ",", "jit_parameters", ":", "dict", "=", "{", "}", ")", "->", "FormMetaClass", ":", "if", "dtype", "==", "np", ".", "float32", ":", "ftype", "=", "_cpp", ".", "fem", ".", "Form_float32", "form_compiler_parameters", "[", "\"scalar_type\"", "]", "=", "\"float\"", "elif", "dtype", "==", "np", ".", "float64", ":", "ftype", "=", "_cpp", ".", "fem", ".", "Form_float64", "form_compiler_parameters", "[", "\"scalar_type\"", "]", "=", "\"double\"", "elif", "dtype", "==", "np", ".", "complex128", ":", "ftype", "=", "_cpp", ".", "fem", ".", "Form_complex128", "form_compiler_parameters", "[", "\"scalar_type\"", "]", "=", "\"double _Complex\"", "else", ":", "raise", "NotImplementedError", "(", "f\"Type {dtype} not supported.\"", ")", "formcls", "=", "type", "(", "\"Form\"", ",", "(", "FormMetaClass", ",", "ftype", ")", ",", "{", "}", ")", "def", "_form", "(", "form", ")", ":", "\"\"\"\"Compile a single UFL form\"\"\"", "# Extract subdomain data from UFL form", "sd", "=", "form", ".", "subdomain_data", "(", ")", "subdomains", ",", "=", "list", "(", "sd", ".", "values", "(", ")", ")", "# Assuming single domain", "domain", ",", "=", "list", "(", "sd", ".", "keys", "(", ")", ")", "# Assuming single domain", "mesh", "=", "domain", ".", "ufl_cargo", "(", ")", "if", "mesh", "is", "None", ":", "raise", "RuntimeError", "(", "\"Expecting to find a Mesh in the form.\"", ")", "ufcx_form", ",", "module", ",", "code", "=", "jit", ".", "ffcx_jit", "(", "mesh", ".", "comm", ",", "form", ",", "form_compiler_parameters", "=", "form_compiler_parameters", ",", "jit_parameters", "=", "jit_parameters", ")", "# For each argument in form extract its function space", "V", "=", "[", "arg", ".", "ufl_function_space", "(", ")", ".", "_cpp_object", "for", "arg", "in", "form", ".", "arguments", "(", ")", "]", "# Prepare coefficients data. For every coefficient in form take its", "# C++ object.", "original_coefficients", "=", "form", ".", "coefficients", "(", ")", "coeffs", "=", "[", "original_coefficients", "[", "ufcx_form", ".", "original_coefficient_position", "[", "i", "]", "]", ".", "_cpp_object", "for", "i", "in", "range", "(", "ufcx_form", ".", "num_coefficients", ")", "]", "constants", "=", "[", "c", ".", "_cpp_object", "for", "c", "in", "form", ".", "constants", "(", ")", "]", "# Subdomain markers (possibly None for some dimensions)", "subdomains", "=", "{", "_cpp", ".", "fem", ".", "IntegralType", ".", "cell", ":", "subdomains", ".", "get", "(", "\"cell\"", ")", ",", "_cpp", ".", "fem", ".", "IntegralType", ".", "exterior_facet", ":", "subdomains", ".", "get", "(", "\"exterior_facet\"", ")", ",", "_cpp", ".", "fem", ".", "IntegralType", ".", "interior_facet", ":", "subdomains", ".", "get", "(", "\"interior_facet\"", ")", ",", "_cpp", ".", "fem", ".", "IntegralType", ".", "vertex", ":", "subdomains", ".", "get", "(", "\"vertex\"", ")", "}", "return", "formcls", "(", "ufcx_form", ",", "V", ",", "coeffs", ",", "constants", ",", "subdomains", ",", "mesh", ",", "code", ")", "def", "_create_form", "(", "form", ")", ":", "\"\"\"Recursively convert ufl.Forms to dolfinx.fem.Form, otherwise\n return form argument\"\"\"", "if", "isinstance", "(", "form", ",", "ufl", ".", "Form", ")", ":", "return", "_form", "(", "form", ")", "elif", "isinstance", "(", "form", ",", "collections", ".", "Iterable", ")", ":", "return", "list", "(", "map", "(", "lambda", "sub_form", ":", "_create_form", "(", "sub_form", ")", ",", "form", ")", ")", "return", "form", "return", "_create_form", "(", "form", ")" ]

[ "Create", "a", "comparison", "method", "that", "dispatches", "to", "cls", ".", "values", "." ]

[ "def", "_create_comparison_method", "(", "cls", ",", "op", ")", ":", "def", "wrapper", "(", "self", ",", "other", ")", ":", "if", "isinstance", "(", "other", ",", "ABCSeries", ")", ":", "# the arrays defer to Series for comparison ops but the indexes", "# don't, so we have to unwrap here.", "other", "=", "other", ".", "_values", "result", "=", "op", "(", "self", ".", "_data", ",", "maybe_unwrap_index", "(", "other", ")", ")", "return", "result", "wrapper", ".", "__doc__", "=", "op", ".", "__doc__", "wrapper", ".", "__name__", "=", "'__{}__'", ".", "format", "(", "op", ".", "__name__", ")", "return", "wrapper" ]

[ "Convert", "a", "subdirectory", "-", "relative", "path", "into", "a", "base", "-", "relative", "path", ".", "Skips", "over", "paths", "that", "contain", "variables", "." ]

[ "def", "Absolutify", "(", "self", ",", "path", ")", ":", "if", "'$('", "in", "path", ":", "# Don't call normpath in this case, as it might collapse the", "# path too aggressively if it features '..'. However it's still", "# important to strip trailing slashes.", "return", "path", ".", "rstrip", "(", "'/'", ")", "return", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "path", ")", ")" ]

[ "shift_expression", ":", "additive_expression" ]

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

[ "The", "number", "of", "dimensions", "in", "this", "shape", "or", "None", "if", "unknown", "." ]

[ "def", "rank", "(", "self", ")", ":", "inner_ndims", "=", "tensor_shape", ".", "dimension_value", "(", "self", ".", "_inner_dim_sizes", ".", "shape", "[", "0", "]", ")", "if", "inner_ndims", "is", "None", ":", "return", "None", "else", ":", "return", "len", "(", "self", ".", "_partitioned_dim_sizes", ")", "+", "inner_ndims" ]

[ "Determine", "if", "the", "Python", "version", "supports", "abi3", "." ]

[ "def", "_abi3_applies", "(", "python_version", ")", ":", "# type: (PythonVersion) -> bool", "return", "len", "(", "python_version", ")", ">", "1", "and", "tuple", "(", "python_version", ")", ">=", "(", "3", ",", "2", ")" ]

[ "Reset", "mocks", "." ]

[ "def", "Reset", "(", "*", "args", ")", ":", "for", "mock", "in", "args", ":", "mock", ".", "_Reset", "(", ")" ]

[ "DeleteSelection", "(", "self", ")" ]

[ "def", "DeleteSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_DeleteSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parses", "the", "given", "file", ".", "Returns", "number", "or", "errors", ".", "Raises", "exception", "on", "fatal", "trouble", "." ]

[ "def", "parse", "(", "self", ")", ":", "#self.debug('Parsing %s' % (self.sSrcFile,));", "while", "self", ".", "iLine", "<", "len", "(", "self", ".", "asLines", ")", ":", "sLine", "=", "self", ".", "asLines", "[", "self", ".", "iLine", "]", "self", ".", "iLine", "+=", "1", "# We only look for comments, so only lines with a slash might possibly", "# influence the parser state.", "offSlash", "=", "sLine", ".", "find", "(", "'/'", ")", "if", "offSlash", ">=", "0", ":", "if", "offSlash", "+", "1", ">=", "len", "(", "sLine", ")", "or", "sLine", "[", "offSlash", "+", "1", "]", "!=", "'/'", "or", "self", ".", "iState", "!=", "self", ".", "kiCode", ":", "offLine", "=", "0", "while", "offLine", "<", "len", "(", "sLine", ")", ":", "if", "self", ".", "iState", "==", "self", ".", "kiCode", ":", "offHit", "=", "sLine", ".", "find", "(", "'/*'", ",", "offLine", ")", "# only multiline comments for now.", "if", "offHit", ">=", "0", ":", "self", ".", "checkCodeForMacro", "(", "sLine", "[", "offLine", ":", "offHit", "]", ")", "self", ".", "sComment", "=", "''", "self", ".", "iCommentLine", "=", "self", ".", "iLine", "self", ".", "iState", "=", "self", ".", "kiCommentMulti", "offLine", "=", "offHit", "+", "2", "else", ":", "self", ".", "checkCodeForMacro", "(", "sLine", "[", "offLine", ":", "]", ")", "offLine", "=", "len", "(", "sLine", ")", "elif", "self", ".", "iState", "==", "self", ".", "kiCommentMulti", ":", "offHit", "=", "sLine", ".", "find", "(", "'*/'", ",", "offLine", ")", "if", "offHit", ">=", "0", ":", "self", ".", "sComment", "+=", "sLine", "[", "offLine", ":", "offHit", "]", "self", ".", "iState", "=", "self", ".", "kiCode", "offLine", "=", "offHit", "+", "2", "self", ".", "parseComment", "(", ")", "else", ":", "self", ".", "sComment", "+=", "sLine", "[", "offLine", ":", "]", "offLine", "=", "len", "(", "sLine", ")", "else", ":", "assert", "False", "# C++ line comment.", "elif", "offSlash", ">", "0", ":", "self", ".", "checkCodeForMacro", "(", "sLine", "[", ":", "offSlash", "]", ")", "# No slash, but append the line if in multi-line comment.", "elif", "self", ".", "iState", "==", "self", ".", "kiCommentMulti", ":", "#self.debug('line %d: multi' % (self.iLine,));", "self", ".", "sComment", "+=", "sLine", "# No slash, but check code line for relevant macro.", "elif", "self", ".", "iState", "==", "self", ".", "kiCode", "and", "sLine", ".", "find", "(", "'IEMOP_'", ")", ">=", "0", ":", "#self.debug('line %d: macro' % (self.iLine,));", "self", ".", "checkCodeForMacro", "(", "sLine", ")", "# If the line is a '}' in the first position, complete the instructions.", "elif", "self", ".", "iState", "==", "self", ".", "kiCode", "and", "sLine", "[", "0", "]", "==", "'}'", ":", "#self.debug('line %d: }' % (self.iLine,));", "self", ".", "doneInstructions", "(", ")", "self", ".", "doneInstructions", "(", ")", "self", ".", "debug", "(", "'%3s stubs out of %3s instructions in %s'", "%", "(", "self", ".", "cTotalStubs", ",", "self", ".", "cTotalInstr", ",", "os", ".", "path", ".", "basename", "(", "self", ".", "sSrcFile", ")", ",", ")", ")", "return", "self", ".", "printErrors", "(", ")" ]

[ "The", "constructor", "of", "the", "metric", "class", "." ]

[ "def", "__init__", "(", "self", ",", "name", ")", ":", "self", ".", "_name", "=", "str", "(", "name", ")", "if", "name", "!=", "None", "else", "self", ".", "__class__", ".", "__name__" ]

[ "TAG", "[", ".", "postDISTANCE", "[", ".", "dev0", "]", "+", "gHEX", "]", "." ]

[ "def", "render_pep440_post", "(", "pieces", ")", ":", "if", "pieces", "[", "\"closest-tag\"", "]", ":", "rendered", "=", "pieces", "[", "\"closest-tag\"", "]", "if", "pieces", "[", "\"distance\"", "]", "or", "pieces", "[", "\"dirty\"", "]", ":", "rendered", "+=", "\".post%d\"", "%", "pieces", "[", "\"distance\"", "]", "if", "pieces", "[", "\"dirty\"", "]", ":", "rendered", "+=", "\".dev0\"", "rendered", "+=", "plus_or_dot", "(", "pieces", ")", "rendered", "+=", "\"g%s\"", "%", "pieces", "[", "\"short\"", "]", "else", ":", "# exception #1", "rendered", "=", "\"0.post%d\"", "%", "pieces", "[", "\"distance\"", "]", "if", "pieces", "[", "\"dirty\"", "]", ":", "rendered", "+=", "\".dev0\"", "rendered", "+=", "\"+g%s\"", "%", "pieces", "[", "\"short\"", "]", "return", "rendered" ]