Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ ":", "returns", ":", ":", "class", ":", "Installer", "class", "associated", "with", "*", "installer_key", "*", ".", ":", "raises", ":", ":", "exc", ":", "KeyError", "If", "not", "associated", "installer", ":", "raises", ":", ":", "exc", ":", "InstallFailed", "If", "installer", "cannot", "produce", "an", "install", "command", "(", "e", ".", "g", ".", "if", "installer", "is", "not", "installed", ")" ]

[ "def", "get_installer", "(", "self", ",", "installer_key", ")", ":", "return", "self", ".", "installers", "[", "installer_key", "]" ]

[ "Dump", "YAML", "to", "a", "string", "and", "remove", "null", "." ]

[ "def", "dump", "(", "dict_", ")", ":", "return", "yaml", ".", "dump", "(", "dict_", ",", "default_flow_style", "=", "False", ",", "allow_unicode", "=", "True", ",", "Dumper", "=", "ESPHomeDumper", ")" ]

[ "GetText", "(", "self", ")", "-", ">", "String" ]

[ "def", "GetText", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "TextDataObject_GetText", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "a", "new", "input", "to", "this", "operation", "." ]

[ "def", "_add_input", "(", "self", ",", "tensor", ",", "dtype", "=", "None", ")", ":", "assert", "not", "self", ".", "_c_op", ",", "(", "\"Operation._add_input doesn't work with C API\"", ")", "if", "not", "isinstance", "(", "tensor", ",", "Tensor", ")", ":", "raise", "TypeError", "(", "\"tensor must be a Tensor: %s\"", "%", "tensor", ")", "_assert_same_graph", "(", "self", ",", "tensor", ")", "if", "dtype", "is", "None", ":", "dtype", "=", "tensor", ".", "dtype", "else", ":", "dtype", "=", "dtypes", ".", "as_dtype", "(", "dtype", ")", "if", "not", "dtype", ".", "is_compatible_with", "(", "tensor", ".", "dtype", ")", ":", "raise", "TypeError", "(", "\"Cannot convert a tensor of type %s to an input of type %s\"", "%", "(", "tensor", ".", "dtype", ".", "name", ",", "dtype", ".", "name", ")", ")", "self", ".", "_inputs", ".", "append", "(", "tensor", ")", "self", ".", "_input_types_val", ".", "append", "(", "dtype", ")", "tensor", ".", "_add_consumer", "(", "self", ")", "# pylint: disable=protected-access", "self", ".", "_recompute_node_def", "(", ")" ]

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

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

[ "Get", "list", "of", "action", "probability", "tuples", "for", "simultaneous", "node", "." ]

[ "def", "joint_action_probabilities_counterfactual", "(", "self", ",", "state", ")", ":", "actions_per_player", ",", "probs_per_player", "=", "(", "openspiel_policy", ".", "joint_action_probabilities_aux", "(", "state", ",", "self", ".", "_policy", ")", ")", "probs_per_player", "[", "self", ".", "_player_id", "]", "=", "[", "1.0", "for", "_", "in", "probs_per_player", "[", "self", ".", "_player_id", "]", "]", "return", "[", "(", "list", "(", "actions", ")", ",", "np", ".", "prod", "(", "probs", ")", ")", "for", "actions", ",", "probs", "in", "zip", "(", "itertools", ".", "product", "(", "*", "actions_per_player", ")", ",", "itertools", ".", "product", "(", "*", "probs_per_player", ")", ")", "]" ]

[ "Return", "the", "(", "unsigned", ")", "byte", "at", "the", "specified", "byte", "index", "." ]

[ "def", "ByteAt", "(", "self", ",", "index", ")", ":", "return", "ord", "(", "self", ".", "CharAt", "(", "index", ")", ")" ]

[ "list", "[", "hoomd", ".", "operation", ".", "Updater", "]", ":", "A", "list", "of", "updater", "operations", "." ]

[ "def", "updaters", "(", "self", ")", ":", "return", "self", ".", "_updaters" ]

[ "Yields", "tuples", "of", "ploidy", "ints", "for", "the", "given", "number", "of", "alt", "alleles", "." ]

[ "def", "_genotype_order_in_likelihoods", "(", "num_alts", ",", "ploidy", "=", "2", ")", ":", "if", "ploidy", "==", "1", ":", "for", "i", "in", "range", "(", "num_alts", "+", "1", ")", ":", "yield", "(", "i", ",", ")", "elif", "ploidy", "==", "2", ":", "for", "j", "in", "range", "(", "num_alts", "+", "1", ")", ":", "for", "i", "in", "range", "(", "j", "+", "1", ")", ":", "yield", "(", "i", ",", "j", ")", "else", ":", "raise", "NotImplementedError", "(", "'Only haploid and diploid supported.'", ")" ]

[ "Compute", "several", "descriptive", "statistics", "of", "the", "passed", "array", "." ]

[ "def", "describe", "(", "a", ",", "axis", "=", "0", ",", "ddof", "=", "1", ",", "bias", "=", "True", ",", "nan_policy", "=", "'propagate'", ")", ":", "a", ",", "axis", "=", "_chk_asarray", "(", "a", ",", "axis", ")", "contains_nan", ",", "nan_policy", "=", "_contains_nan", "(", "a", ",", "nan_policy", ")", "if", "contains_nan", "and", "nan_policy", "==", "'omit'", ":", "a", "=", "ma", ".", "masked_invalid", "(", "a", ")", "return", "mstats_basic", ".", "describe", "(", "a", ",", "axis", ",", "ddof", ",", "bias", ")", "if", "a", ".", "size", "==", "0", ":", "raise", "ValueError", "(", "\"The input must not be empty.\"", ")", "n", "=", "a", ".", "shape", "[", "axis", "]", "mm", "=", "(", "np", ".", "min", "(", "a", ",", "axis", "=", "axis", ")", ",", "np", ".", "max", "(", "a", ",", "axis", "=", "axis", ")", ")", "m", "=", "np", ".", "mean", "(", "a", ",", "axis", "=", "axis", ")", "v", "=", "np", ".", "var", "(", "a", ",", "axis", "=", "axis", ",", "ddof", "=", "ddof", ")", "sk", "=", "skew", "(", "a", ",", "axis", ",", "bias", "=", "bias", ")", "kurt", "=", "kurtosis", "(", "a", ",", "axis", ",", "bias", "=", "bias", ")", "return", "DescribeResult", "(", "n", ",", "mm", ",", "m", ",", "v", ",", "sk", ",", "kurt", ")" ]

[ "Build", "modules", "packages", "and", "copy", "data", "files", "to", "build", "directory" ]

[ "def", "run", "(", "self", ")", ":", "if", "not", "self", ".", "py_modules", "and", "not", "self", ".", "packages", ":", "return", "if", "self", ".", "py_modules", ":", "self", ".", "build_modules", "(", ")", "if", "self", ".", "packages", ":", "self", ".", "build_packages", "(", ")", "self", ".", "build_package_data", "(", ")", "self", ".", "run_2to3", "(", "self", ".", "__updated_files", ",", "False", ")", "self", ".", "run_2to3", "(", "self", ".", "__updated_files", ",", "True", ")", "self", ".", "run_2to3", "(", "self", ".", "__doctests_2to3", ",", "True", ")", "# Only compile actual .py files, using our base class' idea of what our", "# output files are.", "self", ".", "byte_compile", "(", "orig", ".", "build_py", ".", "get_outputs", "(", "self", ",", "include_bytecode", "=", "0", ")", ")" ]

[ "Decapitate", "the", "payload", "of", "a", "NaN", "to", "fit", "the", "context" ]

[ "def", "_fix_nan", "(", "self", ",", "context", ")", ":", "payload", "=", "self", ".", "_int", "# maximum length of payload is precision if clamp=0,", "# precision-1 if clamp=1.", "max_payload_len", "=", "context", ".", "prec", "-", "context", ".", "clamp", "if", "len", "(", "payload", ")", ">", "max_payload_len", ":", "payload", "=", "payload", "[", "len", "(", "payload", ")", "-", "max_payload_len", ":", "]", ".", "lstrip", "(", "'0'", ")", "return", "_dec_from_triple", "(", "self", ".", "_sign", ",", "payload", ",", "self", ".", "_exp", ",", "True", ")", "return", "Decimal", "(", "self", ")" ]

[ "Handle", "selection", "of", "an", "extension", "from", "the", "list", "." ]

[ "def", "extension_selected", "(", "self", ",", "event", ")", ":", "newsel", "=", "self", ".", "extension_list", ".", "curselection", "(", ")", "if", "newsel", ":", "newsel", "=", "self", ".", "extension_list", ".", "get", "(", "newsel", ")", "if", "newsel", "is", "None", "or", "newsel", "!=", "self", ".", "current_extension", ":", "if", "self", ".", "current_extension", ":", "self", ".", "details_frame", ".", "config", "(", "text", "=", "''", ")", "self", ".", "config_frame", "[", "self", ".", "current_extension", "]", ".", "grid_forget", "(", ")", "self", ".", "current_extension", "=", "None", "if", "newsel", ":", "self", ".", "details_frame", ".", "config", "(", "text", "=", "newsel", ")", "self", ".", "config_frame", "[", "newsel", "]", ".", "grid", "(", "column", "=", "0", ",", "row", "=", "0", ",", "sticky", "=", "'nsew'", ")", "self", ".", "current_extension", "=", "newsel" ]

[ "Run", "this", "RNN", "cell", "on", "inputs", "starting", "from", "the", "given", "state", "." ]

[ "def", "__call__", "(", "self", ",", "inputs", ",", "state", ",", "scope", "=", "None", ")", ":", "raise", "NotImplementedError", "(", "\"Abstract method\"", ")" ]

[ "Called", "when", "we", "stop", "or", "break", "at", "a", "line", "." ]

[ "def", "user_line", "(", "self", ",", "frame", ")", ":", "pass" ]

[ "Remove", "dimension", "arrows", "in", "the", "dimension", "lines", "." ]

[ "def", "remove_dim_arrows", "(", "self", ")", ":", "self", ".", "node", ".", "removeChild", "(", "self", ".", "marks", ")", "self", ".", "node3d", ".", "removeChild", "(", "self", ".", "marks", ")" ]

[ "r", "Generate", "initialized", "states", "according", "to", "provided", "shape", "data", "type", "and", "value", "." ]

[ "def", "get_initial_states", "(", "self", ",", "batch_ref", ",", "shape", "=", "None", ",", "dtype", "=", "'float32'", ",", "init_value", "=", "0", ",", "batch_dim_idx", "=", "0", ")", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", ")", ":", "integer_types", "=", "(", "int", ",", "long", ",", ")", "else", ":", "integer_types", "=", "(", "int", ",", ")", "check_variable_and_dtype", "(", "batch_ref", ",", "'batch_ref'", ",", "[", "'float32'", ",", "'float64'", ",", "'int32'", ",", "'int64'", "]", ",", "'RNNCell'", ")", "check_type", "(", "shape", ",", "'shape'", ",", "(", "list", ",", "tuple", ",", "type", "(", "None", ")", ",", "integer_types", ")", ",", "'RNNCell'", ")", "if", "isinstance", "(", "shape", ",", "(", "list", ",", "tuple", ")", ")", ":", "shapes", "=", "map_structure", "(", "lambda", "x", ":", "x", ",", "shape", ")", "if", "isinstance", "(", "shape", ",", "list", ")", ":", "for", "i", ",", "_shape", "in", "enumerate", "(", "shapes", ")", ":", "check_type", "(", "_shape", ",", "'shapes['", "+", "str", "(", "i", ")", "+", "']'", ",", "integer_types", ",", "'RNNCell'", ")", "else", ":", "check_type", "(", "shapes", ",", "'shapes'", ",", "integer_types", ",", "'RNNCell'", ")", "check_dtype", "(", "dtype", ",", "'dtype'", ",", "[", "'float32'", ",", "'float64'", "]", ",", "'RNNCell'", ")", "# TODO: use inputs and batch_size", "batch_ref", "=", "flatten", "(", "batch_ref", ")", "[", "0", "]", "def", "_is_shape_sequence", "(", "seq", ")", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", ")", ":", "integer_types", "=", "(", "int", ",", "long", ",", ")", "else", ":", "integer_types", "=", "(", "int", ",", ")", "\"\"\"For shape, list/tuple of integer is the finest-grained objection\"\"\"", "if", "(", "isinstance", "(", "seq", ",", "list", ")", "or", "isinstance", "(", "seq", ",", "tuple", ")", ")", ":", "if", "reduce", "(", "lambda", "flag", ",", "x", ":", "isinstance", "(", "x", ",", "integer_types", ")", "and", "flag", ",", "seq", ",", "True", ")", ":", "return", "False", "# TODO: Add check for the illegal", "if", "isinstance", "(", "seq", ",", "dict", ")", ":", "return", "True", "return", "(", "isinstance", "(", "seq", ",", "collections", ".", "Sequence", ")", "and", "not", "isinstance", "(", "seq", ",", "six", ".", "string_types", ")", ")", "class", "Shape", "(", "object", ")", ":", "def", "__init__", "(", "self", ",", "shape", ")", ":", "self", ".", "shape", "=", "shape", "if", "shape", "[", "0", "]", "==", "-", "1", "else", "(", "[", "-", "1", "]", "+", "list", "(", "shape", ")", ")", "# nested structure of shapes", "states_shapes", "=", "self", ".", "state_shape", "if", "shape", "is", "None", "else", "shape", "is_sequence_ori", "=", "utils", ".", "is_sequence", "utils", ".", "is_sequence", "=", "_is_shape_sequence", "states_shapes", "=", "map_structure", "(", "lambda", "shape", ":", "Shape", "(", "shape", ")", ",", "states_shapes", ")", "utils", ".", "is_sequence", "=", "is_sequence_ori", "# nested structure of dtypes", "try", ":", "states_dtypes", "=", "self", ".", "state_dtype", "if", "dtype", "is", "None", "else", "dtype", "except", "NotImplementedError", ":", "# use fp32 as default", "states_dtypes", "=", "\"float32\"", "if", "len", "(", "flatten", "(", "states_dtypes", ")", ")", "==", "1", ":", "dtype", "=", "flatten", "(", "states_dtypes", ")", "[", "0", "]", "states_dtypes", "=", "map_structure", "(", "lambda", "shape", ":", "dtype", ",", "states_shapes", ")", "init_states", "=", "map_structure", "(", "lambda", "shape", ",", "dtype", ":", "tensor", ".", "fill_constant_batch_size_like", "(", "input", "=", "batch_ref", ",", "shape", "=", "shape", ".", "shape", ",", "dtype", "=", "dtype", ",", "value", "=", "init_value", ",", "input_dim_idx", "=", "batch_dim_idx", ")", ",", "states_shapes", ",", "states_dtypes", ")", "return", "init_states" ]

[ "Install", "package", "using", "pip", "." ]

[ "def", "install", "(", "self", ",", "package", ",", "commit", "=", "None", ")", ":", "if", "commit", ":", "package", "=", "'git+https://github.com/{0}.git@{1}'", ".", "format", "(", "package", ",", "commit", ")", "print", "(", "'Installing {0}'", ".", "format", "(", "package", ")", ")", "check_call", "(", "[", "self", ".", "path", ",", "'install'", ",", "package", "]", ")" ]

[ "maximum", "value", "of", "dtype" ]

[ "def", "max_value", "(", "dtype", ")", ":", "return", "_api_internal", ".", "_max_value", "(", "dtype", ")" ]

[ "Returns", "the", "class", "of", "the", "primitive", "produced", "by", "the", "wrapper", "." ]

[ "def", "primitive_class", "(", "self", ")", "->", "Type", "[", "P", "]", ":", "raise", "NotImplementedError", "(", ")" ]

[ "3d", "cross", "product" ]

[ "def", "__xor__", "(", "self", ",", "other", ")", ":", "return", "self", ".", "cross", "(", "other", ")" ]

[ "Update", "shape", "and", "values", "for", "If", "output", "ports", "." ]

[ "def", "update_if_output_ports_shape", "(", "if_node", ":", "Node", ")", ":", "node_name", "=", "if_node", ".", "soft_get", "(", "'name'", ",", "if_node", ".", "id", ")", "then_outputs", "=", "[", "node", "for", "node", "in", "if_node", ".", "then_graph", ".", "get_op_nodes", "(", ")", "if", "node", ".", "has", "(", "'output_id'", ")", "]", "else_outputs", "=", "[", "node", "for", "node", "in", "if_node", ".", "else_graph", ".", "get_op_nodes", "(", ")", "if", "node", ".", "has", "(", "'output_id'", ")", "]", "outputs_mapping", "=", "{", "}", "outputs_number", "=", "len", "(", "if_node", ".", "out_ports", "(", ")", ")", "if", "outputs_number", "==", "0", "and", "len", "(", "if_node", ".", "out_ports", "(", "control_flow", "=", "True", ")", ")", "!=", "0", ":", "# Some models have if with control flow outputs.", "# These shape inference for such ifs", "# TODO: need to rethink and redo support for control flow edges in if operation", "for", "node", "in", "if_node", ".", "out_nodes", "(", "control_flow", "=", "True", ")", ".", "values", "(", ")", ":", "node", ".", "shape", "=", "int64_array", "(", "[", "]", ")", "return", "for", "port_id", "in", "if_node", ".", "out_ports", "(", ")", ".", "keys", "(", ")", ":", "outputs_mapping", "[", "port_id", "]", "=", "{", "}", "# variables then_contains_fake_outputs/else_contains_fake_outputs contains True value", "# if all outputs from then_body/else_body have shape [0]. It means then_body/else_body does not return data", "# and further shape_inference for this branch is not possible.", "# TODO: exclude support fake_outputs from this code when we will support shape_inference with empty tensors", "then_contains_fake_outputs", "=", "If", ".", "results_mapping_and_finding_fake_outputs", "(", "then_outputs", ",", "'then_graph'", ",", "outputs_mapping", ")", "else_contains_fake_outputs", "=", "If", ".", "results_mapping_and_finding_fake_outputs", "(", "else_outputs", ",", "'else_graph'", ",", "outputs_mapping", ")", "# use_then_shape is True when else_body or when both bodies do not return data. If use_then_shape is True If's", "# outputs will have the same shapes as then_body results", "use_then_shape", "=", "else_contains_fake_outputs", "or", "not", "then_contains_fake_outputs", "cond_value", "=", "if_node", ".", "in_port", "(", "0", ")", ".", "data", ".", "get_value", "(", ")", "for", "port_id", "in", "outputs_mapping", ":", "then_else_nodes", "=", "outputs_mapping", "[", "port_id", "]", "assert", "'then_graph'", "in", "then_else_nodes", ".", "keys", "(", ")", ",", "'then_graph does not connect with If.out_port[{0}] '", "'in {1} node!'", ".", "format", "(", "port_id", ",", "node_name", ")", "assert", "'else_graph'", "in", "then_else_nodes", ".", "keys", "(", ")", ",", "'else_graph does not connect with If.out_port[{0}] '", "'in {1} node!'", ".", "format", "(", "port_id", ",", "node_name", ")", "then_shape", "=", "then_else_nodes", "[", "'then_graph'", "]", ".", "in_port", "(", "0", ")", ".", "data", ".", "get_shape", "(", ")", "then_value", "=", "then_else_nodes", "[", "'then_graph'", "]", ".", "in_port", "(", "0", ")", ".", "data", ".", "get_value", "(", ")", "else_shape", "=", "then_else_nodes", "[", "'else_graph'", "]", ".", "in_port", "(", "0", ")", ".", "data", ".", "get_shape", "(", ")", "else_value", "=", "then_else_nodes", "[", "'else_graph'", "]", ".", "in_port", "(", "0", ")", ".", "data", ".", "get_value", "(", ")", "if", "is_fully_defined", "(", "cond_value", ")", ":", "if", "cond_value", ".", "item", "(", ")", "is", "True", ":", "if", "then_value", "is", "not", "None", ":", "if_node", ".", "out_port", "(", "port_id", ")", ".", "data", ".", "set_value", "(", "then_value", ")", "else", ":", "if_node", ".", "out_port", "(", "port_id", ")", ".", "data", ".", "set_shape", "(", "then_shape", ")", "else", ":", "if", "else_value", "is", "not", "None", ":", "if_node", ".", "out_port", "(", "port_id", ")", ".", "data", ".", "set_value", "(", "else_value", ")", "else", ":", "if_node", ".", "out_port", "(", "port_id", ")", ".", "data", ".", "set_shape", "(", "else_shape", ")", "else", ":", "if", "then_contains_fake_outputs", "^", "else_contains_fake_outputs", ":", "# if exactly one of the outputs is fake then use another one", "if_node", ".", "out_port", "(", "port_id", ")", ".", "data", ".", "set_shape", "(", "then_shape", "if", "use_then_shape", "else", "else_shape", ")", "else", ":", "# find \"intersection\" which is equal to the dimension value if corresponding dimensions are equal", "# and dynamic otherwise", "assert", "len", "(", "then_shape", ")", "==", "len", "(", "else_shape", ")", ",", "'Ranks of \"then\" and \"else\" output tensors are '", "'different for node {} for port {}'", ".", "format", "(", "node_name", ",", "port_id", ")", "output_shape", "=", "[", "d1", "if", "is_fully_defined", "(", "d1", ")", "and", "is_fully_defined", "(", "d2", ")", "and", "d1", "==", "d2", "else", "dynamic_dimension_value", "for", "d1", ",", "d2", "in", "zip", "(", "then_shape", ",", "else_shape", ")", "]", "if_node", ".", "out_port", "(", "port_id", ")", ".", "data", ".", "set_shape", "(", "output_shape", ")" ]

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

[ "def", "GetSelStart", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "Slider_GetSelStart", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Send", "gradient", "to", "TPU", "embedding", "." ]

[ "def", "generate_send_gradients_op", "(", "self", ",", "feature_to_gradient_dict", ",", "learning_rates", "=", "None", ")", ":", "if", "self", ".", "_mode", "!=", "TRAINING", ":", "raise", "RuntimeError", "(", "'Only in training mode gradients need to '", "'be sent to TPU embedding; got mode {}.'", ".", "format", "(", "self", ".", "_mode", ")", ")", "if", "learning_rates", "is", "None", ":", "learning_rates", "=", "dict", "(", ")", "gradients", "=", "[", "]", "for", "table", "in", "self", ".", "_table_to_features_dict", ":", "features", "=", "self", ".", "_table_to_features_dict", "[", "table", "]", "table_gradients", "=", "[", "]", "for", "feature", "in", "features", ":", "gradient", "=", "feature_to_gradient_dict", "[", "feature", "]", "# Expand dims for non-sequence feature to match sequence features.", "if", "gradient", ".", "shape", ".", "ndims", "==", "2", ":", "gradient", "=", "array_ops", ".", "expand_dims", "(", "gradient", ",", "1", ")", "table_gradients", ".", "append", "(", "gradient", ")", "interleaved_table_grads", "=", "array_ops", ".", "reshape", "(", "array_ops", ".", "concat", "(", "table_gradients", ",", "axis", "=", "1", ")", ",", "[", "-", "1", ",", "array_ops", ".", "shape", "(", "table_gradients", "[", "0", "]", ")", "[", "-", "1", "]", "]", ")", "gradients", ".", "append", "(", "interleaved_table_grads", ")", "return", "tpu_ops", ".", "send_tpu_embedding_gradients", "(", "inputs", "=", "gradients", ",", "learning_rates", "=", "[", "learning_rates", "[", "tag", "]", "for", "tag", "in", "self", ".", "_learning_rate_keys", "]", ",", "config", "=", "self", ".", "config_proto", ".", "SerializeToString", "(", ")", ")" ]

[ "Find", "the", "position", "of", "the", "next", "non", "-", "editable", "character", "in", "the", "mask", "." ]

[ "def", "_findNextTemplateChar", "(", "self", ",", "pos", ")", ":", "while", "not", "self", ".", "_isTemplateChar", "(", "pos", ")", "and", "pos", "<", "self", ".", "_masklength", ":", "pos", "+=", "1", "return", "pos" ]

[ "Generate", "Config", "Option", "instances", "." ]

[ "def", "gen_config_options", "(", "self", ",", "spec", ",", "header_file_name", ")", ":", "# type: (ast.IDLAST, str) -> None", "# pylint: disable=too-many-branches,too-many-statements", "has_storage_targets", "=", "False", "for", "opt", "in", "spec", ".", "configs", ":", "if", "opt", ".", "cpp_varname", "is", "not", "None", ":", "has_storage_targets", "=", "True", "if", "opt", ".", "cpp_vartype", "is", "not", "None", ":", "with", "self", ".", "_condition", "(", "opt", ".", "condition", ",", "preprocessor_only", "=", "True", ")", ":", "init", "=", "(", "'{%s}'", "%", "(", "opt", ".", "default", ".", "expr", ")", ")", "if", "opt", ".", "default", "else", "''", "self", ".", "_writer", ".", "write_line", "(", "'%s %s%s;'", "%", "(", "opt", ".", "cpp_vartype", ",", "opt", ".", "cpp_varname", ",", "init", ")", ")", "self", ".", "write_empty_line", "(", ")", "root_opts", "=", "[", "]", "# type: List[ast.ConfigOption]", "sections", "=", "{", "}", "# type: Dict[str, List[ast.ConfigOption]]", "for", "opt", "in", "spec", ".", "configs", ":", "if", "opt", ".", "section", ":", "try", ":", "sections", "[", "opt", ".", "section", "]", ".", "append", "(", "opt", ")", "except", "KeyError", ":", "sections", "[", "opt", ".", "section", "]", "=", "[", "opt", "]", "else", ":", "root_opts", ".", "append", "(", "opt", ")", "initializer", "=", "spec", ".", "globals", ".", "configs", "and", "spec", ".", "globals", ".", "configs", ".", "initializer", "# pylint: disable=consider-using-ternary", "blockname", "=", "(", "initializer", "and", "initializer", ".", "name", ")", "or", "(", "'idl_'", "+", "hashlib", ".", "sha1", "(", "header_file_name", ".", "encode", "(", ")", ")", ".", "hexdigest", "(", ")", ")", "if", "initializer", "and", "initializer", ".", "register", ":", "with", "self", ".", "_block", "(", "'Status %s(optionenvironment::OptionSection* options_ptr) {'", "%", "initializer", ".", "register", ",", "'}'", ")", ":", "self", ".", "_writer", ".", "write_line", "(", "'auto& options = *options_ptr;'", ")", "self", ".", "_gen_config_options_register", "(", "root_opts", ",", "sections", ",", "True", ")", "else", ":", "with", "self", ".", "gen_namespace_block", "(", "''", ")", ":", "with", "self", ".", "_block", "(", "'MONGO_MODULE_STARTUP_OPTIONS_REGISTER(%s)(InitializerContext*) {'", "%", "(", "blockname", ")", ",", "'}'", ")", ":", "self", ".", "_writer", ".", "write_line", "(", "'auto& options = optionenvironment::startupOptions;'", ")", "self", ".", "_gen_config_options_register", "(", "root_opts", ",", "sections", ",", "False", ")", "self", ".", "write_empty_line", "(", ")", "if", "has_storage_targets", ":", "if", "initializer", "and", "initializer", ".", "store", ":", "with", "self", ".", "_block", "(", "'Status %s(const optionenvironment::Environment& params) {'", "%", "initializer", ".", "store", ",", "'}'", ")", ":", "self", ".", "_gen_config_options_store", "(", "spec", ".", "configs", ",", "True", ")", "else", ":", "with", "self", ".", "gen_namespace_block", "(", "''", ")", ":", "with", "self", ".", "_block", "(", "'MONGO_STARTUP_OPTIONS_STORE(%s)(InitializerContext*) {'", "%", "(", "blockname", ")", ",", "'}'", ")", ":", "# If all options are guarded by non-passing #ifdefs, then params will be unused.", "self", ".", "_writer", ".", "write_line", "(", "'[[maybe_unused]] const auto& params = optionenvironment::startupOptionsParsed;'", ")", "self", ".", "_gen_config_options_store", "(", "spec", ".", "configs", ",", "False", ")", "self", ".", "write_empty_line", "(", ")" ]

[ "Parses", "through", "the", "module", "output", "and", "returns", "output", "names", "and", "dynamic", "axes" ]

[ "def", "_parse_outputs_and_extract_names_and_dynamic_axes", "(", "module_output", ")", ":", "def", "_populate_output_names_and_dynamic_axes", "(", "output", ",", "output_names", ",", "output_dynamic_axes", ",", "output_idx", ")", ":", "# Depth first traversal to traverse through the entire output collecting output names and dynamic axes", "if", "output", "is", "None", ":", "return", "elif", "isinstance", "(", "output", ",", "torch", ".", "Tensor", ")", ":", "# Naming the outputs with a hyphen ensures that there can be no input with the same", "# name, preventing collisions with other NodeArgs (for example an input to forward called output0)", "output_name", "=", "f'output-{output_idx[0]}'", "output_idx", "[", "0", "]", "+=", "1", "output_names", ".", "append", "(", "output_name", ")", "output_dynamic_axes", "[", "output_name", "]", "=", "{", "}", "for", "dim_idx", "in", "range", "(", "len", "(", "output", ".", "shape", ")", ")", ":", "output_dynamic_axes", "[", "output_name", "]", ".", "update", "(", "{", "dim_idx", ":", "f'{output_name}_dim{dim_idx}'", "}", ")", "return", "if", "isinstance", "(", "output", ",", "abc", ".", "Sequence", ")", ":", "for", "value", "in", "output", ":", "_populate_output_names_and_dynamic_axes", "(", "value", ",", "output_names", ",", "output_dynamic_axes", ",", "output_idx", ")", "elif", "isinstance", "(", "output", ",", "abc", ".", "Mapping", ")", ":", "for", "_", ",", "value", "in", "sorted", "(", "output", ".", "items", "(", ")", ")", ":", "_populate_output_names_and_dynamic_axes", "(", "value", ",", "output_names", ",", "output_dynamic_axes", ",", "output_idx", ")", "else", ":", "raise", "wrap_exception", "(", "ORTModuleIOError", ",", "TypeError", "(", "f'ORTModule does not support the following model output type {type(output)}'", ")", ")", "output_names", "=", "[", "]", "output_dynamic_axes", "=", "{", "}", "output_idx", "=", "[", "0", "]", "_populate_output_names_and_dynamic_axes", "(", "module_output", ",", "output_names", ",", "output_dynamic_axes", ",", "output_idx", ")", "return", "output_names", ",", "output_dynamic_axes" ]

[ "Gets", "the", "shape", "required", "for", "the", "input", "tensor", "." ]

[ "def", "get_input_tensor_shape", "(", "self", ")", ":", "return", "self", ".", "_engine", ".", "get_input_tensor_shape", "(", ")" ]

[ "Creates", "an", "input_fn", "closure", "to", "be", "passed", "to", "Estimator", "." ]

[ "def", "file_based_input_fn_builder", "(", "input_file", ",", "batch_size", ",", "seq_length", ",", "is_training", ",", "drop_remainder", ",", "hvd", "=", "None", ")", ":", "name_to_features", "=", "{", "\"input_ids\"", ":", "tf", ".", "FixedLenFeature", "(", "[", "seq_length", "]", ",", "tf", ".", "int64", ")", ",", "\"input_mask\"", ":", "tf", ".", "FixedLenFeature", "(", "[", "seq_length", "]", ",", "tf", ".", "int64", ")", ",", "\"segment_ids\"", ":", "tf", ".", "FixedLenFeature", "(", "[", "seq_length", "]", ",", "tf", ".", "int64", ")", ",", "\"label_ids\"", ":", "tf", ".", "FixedLenFeature", "(", "[", "]", ",", "tf", ".", "int64", ")", ",", "}", "def", "_decode_record", "(", "record", ",", "name_to_features", ")", ":", "\"\"\"Decodes a record to a TensorFlow example.\"\"\"", "example", "=", "tf", ".", "parse_single_example", "(", "record", ",", "name_to_features", ")", "# tf.Example only supports tf.int64, but the TPU only supports tf.int32.", "# So cast all int64 to int32.", "for", "name", "in", "list", "(", "example", ".", "keys", "(", ")", ")", ":", "t", "=", "example", "[", "name", "]", "if", "t", ".", "dtype", "==", "tf", ".", "int64", ":", "t", "=", "tf", ".", "to_int32", "(", "t", ")", "example", "[", "name", "]", "=", "t", "return", "example", "def", "input_fn", "(", ")", ":", "\"\"\"The actual input function.\"\"\"", "# For training, we want a lot of parallel reading and shuffling.", "# For eval, we want no shuffling and parallel reading doesn't matter.", "d", "=", "tf", ".", "data", ".", "TFRecordDataset", "(", "input_file", ")", "if", "is_training", ":", "if", "hvd", "is", "not", "None", ":", "d", "=", "d", ".", "shard", "(", "hvd", ".", "size", "(", ")", ",", "hvd", ".", "rank", "(", ")", ")", "d", "=", "d", ".", "repeat", "(", ")", "d", "=", "d", ".", "shuffle", "(", "buffer_size", "=", "100", ")", "d", "=", "d", ".", "apply", "(", "tf", ".", "contrib", ".", "data", ".", "map_and_batch", "(", "lambda", "record", ":", "_decode_record", "(", "record", ",", "name_to_features", ")", ",", "batch_size", "=", "batch_size", ",", "drop_remainder", "=", "drop_remainder", ")", ")", "return", "d", "return", "input_fn" ]

[ "init" ]

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

[ "SetStyleBits", "(", "self", "int", "bits", ")" ]

[ "def", "SetStyleBits", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetStyleBits", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "unregister", "handler", "/", "subscriber" ]

[ "def", "unregister_handler", "(", "self", ",", "type_", ",", "handler", ")", ":", "# handlerList = self._handlers[type_]", "# if handler in handlerList:", "# self._handlers.remove(handler)", "# if not handlerList:", "# del self._handlers[type_]", "pass" ]

[ "List", "mailbox", "names", "in", "directory", "matching", "pattern", "." ]

[ "def", "list", "(", "self", ",", "directory", "=", "'\"\"'", ",", "pattern", "=", "'*'", ")", ":", "name", "=", "'LIST'", "typ", ",", "dat", "=", "self", ".", "_simple_command", "(", "name", ",", "directory", ",", "pattern", ")", "return", "self", ".", "_untagged_response", "(", "typ", ",", "dat", ",", "name", ")" ]

[ "The", "configuration", "test", "declares", "a", "unique", "task", "generator", "so", "we", "create", "other", "task", "generators", "from", "there", "for", "fortran", "link", "tests" ]

[ "def", "link_main_routines_tg_method", "(", "self", ")", ":", "def", "write_test_file", "(", "task", ")", ":", "task", ".", "outputs", "[", "0", "]", ".", "write", "(", "task", ".", "generator", ".", "code", ")", "bld", "=", "self", ".", "bld", "bld", "(", "rule", "=", "write_test_file", ",", "target", "=", "'main.c'", ",", "code", "=", "MAIN_CODE", "%", "self", ".", "__dict__", ")", "bld", "(", "rule", "=", "write_test_file", ",", "target", "=", "'test.f'", ",", "code", "=", "ROUTINES_CODE", ")", "bld", "(", "features", "=", "'fc fcstlib'", ",", "source", "=", "'test.f'", ",", "target", "=", "'test'", ")", "bld", "(", "features", "=", "'c fcprogram'", ",", "source", "=", "'main.c'", ",", "target", "=", "'app'", ",", "use", "=", "'test'", ")" ]

[ "Dumps", "debug", "information", "for", "the", "document", "it", "s", "recursive" ]

[ "def", "debugDumpDocument", "(", "self", ",", "output", ")", ":", "libxml2mod", ".", "xmlDebugDumpDocument", "(", "output", ",", "self", ".", "_o", ")" ]

[ ":", "param", "allowed", ":", "A", "dict", "of", "algorithm", "names", "pointing", "to", "lists", "of", "allowed", "hex", "digests", ":", "param", "gots", ":", "A", "dict", "of", "algorithm", "names", "pointing", "to", "hashes", "we", "actually", "got", "from", "the", "files", "under", "suspicion" ]

[ "def", "__init__", "(", "self", ",", "allowed", ",", "gots", ")", ":", "# type: (Dict[str, List[str]], Dict[str, _Hash]) -> None", "self", ".", "allowed", "=", "allowed", "self", ".", "gots", "=", "gots" ]

[ "Return", "a", "format", "data", "dict", "for", "an", "object", "." ]

[ "def", "format", "(", "self", ",", "obj", ",", "include", "=", "None", ",", "exclude", "=", "None", ")", ":", "format_dict", "=", "{", "}", "md_dict", "=", "{", "}", "if", "self", ".", "ipython_display_formatter", "(", "obj", ")", ":", "# object handled itself, don't proceed", "return", "{", "}", ",", "{", "}", "format_dict", ",", "md_dict", "=", "self", ".", "mimebundle_formatter", "(", "obj", ",", "include", "=", "include", ",", "exclude", "=", "exclude", ")", "if", "format_dict", "or", "md_dict", ":", "if", "include", ":", "format_dict", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "format_dict", ".", "items", "(", ")", "if", "k", "in", "include", "}", "md_dict", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "md_dict", ".", "items", "(", ")", "if", "k", "in", "include", "}", "if", "exclude", ":", "format_dict", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "format_dict", ".", "items", "(", ")", "if", "k", "not", "in", "exclude", "}", "md_dict", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "md_dict", ".", "items", "(", ")", "if", "k", "not", "in", "exclude", "}", "for", "format_type", ",", "formatter", "in", "self", ".", "formatters", ".", "items", "(", ")", ":", "if", "format_type", "in", "format_dict", ":", "# already got it from mimebundle, don't render again", "continue", "if", "include", "and", "format_type", "not", "in", "include", ":", "continue", "if", "exclude", "and", "format_type", "in", "exclude", ":", "continue", "md", "=", "None", "try", ":", "data", "=", "formatter", "(", "obj", ")", "except", ":", "# FIXME: log the exception", "raise", "# formatters can return raw data or (data, metadata)", "if", "isinstance", "(", "data", ",", "tuple", ")", "and", "len", "(", "data", ")", "==", "2", ":", "data", ",", "md", "=", "data", "if", "data", "is", "not", "None", ":", "format_dict", "[", "format_type", "]", "=", "data", "if", "md", "is", "not", "None", ":", "md_dict", "[", "format_type", "]", "=", "md", "return", "format_dict", ",", "md_dict" ]

[ "Find", "a", "project", "using", "its", "filename", "." ]

[ "def", "find_project", "(", "filename", ")", ":", "# Find longest prefix match.", "found_path_len", "=", "0", "found_project", "=", "BASE_PROJECT", "for", "project", ",", "path", "in", "SUBPROJECTS", ".", "items", "(", ")", ":", "if", "filename", ".", "startswith", "(", "path", ")", "and", "len", "(", "path", ")", ">", "found_path_len", ":", "found_path_len", "=", "len", "(", "path", ")", "found_project", "=", "project", "return", "found_project" ]

[ "Provide", "custom", "logic", "to", "compare", "objects", "." ]

[ "def", "__eq__", "(", "self", ",", "rhs", ")", ":", "return", "(", "isinstance", "(", "rhs", ",", "MockAnything", ")", "and", "self", ".", "_replay_mode", "==", "rhs", ".", "_replay_mode", "and", "self", ".", "_expected_calls_queue", "==", "rhs", ".", "_expected_calls_queue", ")" ]

[ "Add", "ops", "to", "save", "variables", "that", "are", "on", "the", "same", "shard", "." ]

[ "def", "_AddSaveOps", "(", "self", ",", "filename_tensor", ",", "vars_to_save", ")", ":", "save", "=", "self", ".", "save_op", "(", "filename_tensor", ",", "vars_to_save", ")", "return", "control_flow_ops", ".", "with_dependencies", "(", "[", "save", "]", ",", "filename_tensor", ")" ]

[ "Check", "if", "line", "contains", "a", "redundant", "virtual", "function", "-", "specifier", "." ]

[ "def", "CheckRedundantVirtual", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "# Look for \"virtual\" on current line.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "virtual", "=", "Match", "(", "r'^(.*)(\\bvirtual\\b)(.*)$'", ",", "line", ")", "if", "not", "virtual", ":", "return", "# Ignore \"virtual\" keywords that are near access-specifiers. These", "# are only used in class base-specifier and do not apply to member", "# functions.", "if", "(", "Search", "(", "r'\\b(public|protected|private)\\s+$'", ",", "virtual", ".", "group", "(", "1", ")", ")", "or", "Match", "(", "r'^\\s+(public|protected|private)\\b'", ",", "virtual", ".", "group", "(", "3", ")", ")", ")", ":", "return", "# Ignore the \"virtual\" keyword from virtual base classes. Usually", "# there is a column on the same line in these cases (virtual base", "# classes are rare in google3 because multiple inheritance is rare).", "if", "Match", "(", "r'^.*[^:]:[^:].*$'", ",", "line", ")", ":", "return", "# Look for the next opening parenthesis. This is the start of the", "# parameter list (possibly on the next line shortly after virtual).", "# TODO(unknown): doesn't work if there are virtual functions with", "# decltype() or other things that use parentheses, but csearch suggests", "# that this is rare.", "end_col", "=", "-", "1", "end_line", "=", "-", "1", "start_col", "=", "len", "(", "virtual", ".", "group", "(", "2", ")", ")", "for", "start_line", "in", "xrange", "(", "linenum", ",", "min", "(", "linenum", "+", "3", ",", "clean_lines", ".", "NumLines", "(", ")", ")", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "start_line", "]", "[", "start_col", ":", "]", "parameter_list", "=", "Match", "(", "r'^([^(]*)\\('", ",", "line", ")", "if", "parameter_list", ":", "# Match parentheses to find the end of the parameter list", "(", "_", ",", "end_line", ",", "end_col", ")", "=", "CloseExpression", "(", "clean_lines", ",", "start_line", ",", "start_col", "+", "len", "(", "parameter_list", ".", "group", "(", "1", ")", ")", ")", "break", "start_col", "=", "0", "if", "end_col", "<", "0", ":", "return", "# Couldn't find end of parameter list, give up", "# Look for \"override\" or \"final\" after the parameter list", "# (possibly on the next few lines).", "for", "i", "in", "xrange", "(", "end_line", ",", "min", "(", "end_line", "+", "3", ",", "clean_lines", ".", "NumLines", "(", ")", ")", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "i", "]", "[", "end_col", ":", "]", "match", "=", "Search", "(", "r'\\b(override|final)\\b'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/inheritance'", ",", "4", ",", "(", "'\"virtual\" is redundant since function is '", "'already declared as \"%s\"'", "%", "match", ".", "group", "(", "1", ")", ")", ")", "# Set end_col to check whole lines after we are done with the", "# first line.", "end_col", "=", "0", "if", "Search", "(", "r'[^\\w]\\s*$'", ",", "line", ")", ":", "break" ]

[ "Instruct", "the", "window", "manager", "that", "this", "widget", "is", "transient", "with", "regard", "to", "widget", "MASTER", "." ]

[ "def", "wm_transient", "(", "self", ",", "master", "=", "None", ")", ":", "return", "self", ".", "tk", ".", "call", "(", "'wm'", ",", "'transient'", ",", "self", ".", "_w", ",", "master", ")" ]

[ "Registers", "the", "command", "-", "line", "options", "." ]

[ "def", "_ParseArgs", "(", ")", ":", "usage", "=", "'usage: %prog [options]'", "parser", "=", "optparse", ".", "OptionParser", "(", "usage", "=", "usage", ")", "parser", ".", "add_option", "(", "'--label'", ",", "type", "=", "'string'", ",", "default", "=", "'MY_TEST'", ",", "help", "=", "(", "'Label of the test, used to identify different '", "'tests. Default: %default'", ")", ")", "parser", ".", "add_option", "(", "'--ref_video'", ",", "type", "=", "'string'", ",", "help", "=", "'Reference video to compare with (YUV).'", ")", "parser", ".", "add_option", "(", "'--test_video'", ",", "type", "=", "'string'", ",", "help", "=", "(", "'Test video to be compared with the reference '", "'video (YUV).'", ")", ")", "parser", ".", "add_option", "(", "'--frame_analyzer'", ",", "type", "=", "'string'", ",", "help", "=", "'Path to the frame analyzer executable.'", ")", "parser", ".", "add_option", "(", "'--barcode_decoder'", ",", "type", "=", "'string'", ",", "help", "=", "(", "'Path to the barcode decoder script. By default, we '", "'will assume we can find it in barcode_tools/'", "'relative to this directory.'", ")", ")", "parser", ".", "add_option", "(", "'--ffmpeg_path'", ",", "type", "=", "'string'", ",", "help", "=", "(", "'The path to where the ffmpeg executable is located. '", "'If omitted, it will be assumed to be present in the '", "'PATH with the name ffmpeg[.exe].'", ")", ")", "parser", ".", "add_option", "(", "'--zxing_path'", ",", "type", "=", "'string'", ",", "help", "=", "(", "'The path to where the zxing executable is located. '", "'If omitted, it will be assumed to be present in the '", "'PATH with the name zxing[.exe].'", ")", ")", "parser", ".", "add_option", "(", "'--stats_file_ref'", ",", "type", "=", "'string'", ",", "default", "=", "'stats_ref.txt'", ",", "help", "=", "(", "'Path to the temporary stats file to be created and '", "'used for the reference video file. '", "'Default: %default'", ")", ")", "parser", ".", "add_option", "(", "'--stats_file_test'", ",", "type", "=", "'string'", ",", "default", "=", "'stats_test.txt'", ",", "help", "=", "(", "'Path to the temporary stats file to be created and '", "'used for the test video file. Default: %default'", ")", ")", "parser", ".", "add_option", "(", "'--stats_file'", ",", "type", "=", "'string'", ",", "help", "=", "(", "'DEPRECATED'", ")", ")", "parser", ".", "add_option", "(", "'--yuv_frame_width'", ",", "type", "=", "'int'", ",", "default", "=", "640", ",", "help", "=", "'Width of the YUV file\\'s frames. Default: %default'", ")", "parser", ".", "add_option", "(", "'--yuv_frame_height'", ",", "type", "=", "'int'", ",", "default", "=", "480", ",", "help", "=", "'Height of the YUV file\\'s frames. Default: %default'", ")", "options", ",", "_", "=", "parser", ".", "parse_args", "(", ")", "if", "options", ".", "stats_file", ":", "options", ".", "stats_file_test", "=", "options", ".", "stats_file", "print", "(", "'WARNING: Using deprecated switch --stats_file. '", "'The new flag is --stats_file_test.'", ")", "if", "not", "options", ".", "ref_video", ":", "parser", ".", "error", "(", "'You must provide a path to the reference video!'", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "options", ".", "ref_video", ")", ":", "parser", ".", "error", "(", "'Cannot find the reference video at %s'", "%", "options", ".", "ref_video", ")", "if", "not", "options", ".", "test_video", ":", "parser", ".", "error", "(", "'You must provide a path to the test video!'", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "options", ".", "test_video", ")", ":", "parser", ".", "error", "(", "'Cannot find the test video at %s'", "%", "options", ".", "test_video", ")", "if", "not", "options", ".", "frame_analyzer", ":", "parser", ".", "error", "(", "'You must provide the path to the frame analyzer executable!'", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "options", ".", "frame_analyzer", ")", ":", "parser", ".", "error", "(", "'Cannot find frame analyzer executable at %s!'", "%", "options", ".", "frame_analyzer", ")", "return", "options" ]

[ "Return", "a", "list", "of", "info", "objects", "about", "serial", "ports" ]

[ "def", "comports", "(", "include_links", "=", "False", ")", ":", "return", "list", "(", "iterate_comports", "(", ")", ")" ]

[ "Set", "selinux", "task", "context" ]

[ "def", "set_selinux_task_context", "(", "task", ")", ":", "cred", "=", "task", "[", "\"cred\"", "]", "security", "=", "cred", "[", "\"security\"", "]", "security_struct_t", "=", "gdb", ".", "lookup_type", "(", "\"struct task_security_struct\"", ")", ".", "pointer", "(", ")", "security_struct", "=", "security", ".", "cast", "(", "security_struct_t", ")", "osid", "=", "security_struct", "[", "\"osid\"", "]", "sid", "=", "security_struct", "[", "\"sid\"", "]", "write32", "(", "osid", ".", "address", ",", "0x1", ")", "# SECINITSID_KERNEL = 1 = kernel", "write32", "(", "sid", ".", "address", ",", "0x1", ")" ]

[ "benchmark", "mx", ".", "nd", ".", "dot", "(", "sparse_ndarray", "dense_ndarray", ")", "with", "given", "density", ".", "t_sparse", "is", "the", "time", "cost", "of", "dot", "(", "csr", "dns", ")", "while", "t_dense", "is", "the", "time", "cost", "of", "dot", "(", "dns", "dns", ")", "with", "the", "same", "matrix", "except", "that", "it", "is", "in", "default", "storage", "type", "." ]

[ "def", "test_dot_synthetic", "(", ")", ":", "def", "measure_cost_forward_baseline", "(", "repeat", ",", "dot", ",", "lhs", ",", "rhs", ")", ":", "start", "=", "time", ".", "time", "(", ")", "for", "i", "in", "range", "(", "repeat", ")", ":", "dot", "(", "lhs", ",", "rhs", ")", "end", "=", "time", ".", "time", "(", ")", "diff", "=", "end", "-", "start", "return", "diff", "/", "repeat", "def", "measure_cost_backward_baseline", "(", "repeat", ",", "dot", ",", "transpose", ",", "lhs", ",", "rhs", ")", ":", "start", "=", "time", ".", "time", "(", ")", "for", "i", "in", "range", "(", "repeat", ")", ":", "dot", "(", "transpose", "(", "lhs", ")", ",", "rhs", ")", "end", "=", "time", ".", "time", "(", ")", "diff", "=", "end", "-", "start", "return", "diff", "/", "repeat", "def", "bench_dot_forward", "(", "m", ",", "k", ",", "n", ",", "density", ",", "ctx", ",", "repeat", ")", ":", "set_default_context", "(", "ctx", ")", "dns", "=", "mx", ".", "nd", ".", "random", ".", "uniform", "(", "shape", "=", "(", "k", ",", "n", ")", ")", ".", "copyto", "(", "ctx", ")", "data_shape", "=", "(", "m", ",", "k", ")", "csr_data", "=", "rand_ndarray", "(", "data_shape", ",", "'csr'", ",", "density", ")", "dns_data", "=", "csr_data", ".", "tostype", "(", "'default'", ")", "rhs_dns_np", "=", "dns", ".", "asnumpy", "(", ")", "lhs_csr_sp", "=", "sp", ".", "csr_matrix", "(", "dns_data", ".", "asnumpy", "(", ")", ")", "# csr in scipy", "lhs_dns_np", "=", "lhs_csr_sp", ".", "tostype", "(", "'default'", ")", "data", "=", "[", "dns_data", ",", "csr_data", "]", "costs", "=", "[", "]", "for", "d", "in", "data", ":", "dns", ".", "wait_to_read", "(", ")", "d", ".", "wait_to_read", "(", ")", "cost", "=", "measure_cost", "(", "repeat", ",", "mx", ".", "nd", ".", "dot", ",", "d", ",", "dns", ")", "costs", ".", "append", "(", "cost", ")", "ratio", "=", "costs", "[", "0", "]", "/", "costs", "[", "1", "]", "costs_baseline", "=", "[", "]", "cost", "=", "measure_cost_forward_baseline", "(", "repeat", ",", "np", ".", "dot", ",", "lhs_dns_np", ",", "rhs_dns_np", ")", "costs_baseline", ".", "append", "(", "cost", ")", "cost", "=", "measure_cost_forward_baseline", "(", "repeat", ",", "sp", ".", "spmatrix", ".", "dot", ",", "lhs_csr_sp", ",", "rhs_dns_np", ")", "costs_baseline", ".", "append", "(", "cost", ")", "ratio_baseline", "=", "costs_baseline", "[", "0", "]", "/", "costs_baseline", "[", "1", "]", "fmt", "=", "\"%0.1f\\t\\t%s\\t%d\\t%d\\t%d\\t%0.2f\\t\\t\\t%0.2f\\t%0.5f\\t\\t%0.2f\\t\\t\\t\\t%0.6f\\t%0.5f\"", "print", "(", "fmt", "%", "(", "density", "*", "100", ",", "str", "(", "ctx", ")", ",", "n", ",", "m", ",", "k", ",", "ratio", ",", "costs", "[", "0", "]", ",", "costs", "[", "1", "]", ",", "ratio_baseline", ",", "costs_baseline", "[", "0", "]", ",", "costs_baseline", "[", "1", "]", ")", ")", "def", "bench_dot_backward", "(", "m", ",", "k", ",", "n", ",", "density", ",", "ctx", ",", "repeat", ")", ":", "set_default_context", "(", "ctx", ")", "dns", "=", "mx", ".", "nd", ".", "random", ".", "uniform", "(", "shape", "=", "(", "m", ",", "n", ")", ")", ".", "copyto", "(", "ctx", ")", "data_shape", "=", "(", "m", ",", "k", ")", "csr_data", "=", "rand_ndarray", "(", "data_shape", ",", "'csr'", ",", "density", ")", "dns_data", "=", "csr_data", ".", "tostype", "(", "'default'", ")", "rhs_dns_np", "=", "dns", ".", "asnumpy", "(", ")", "lhs_csr_sp", "=", "sp", ".", "csr_matrix", "(", "dns_data", ".", "asnumpy", "(", ")", ")", "lhs_dns_np", "=", "lhs_csr_sp", ".", "tostype", "(", "'default'", ")", "data", "=", "[", "dns_data", ",", "csr_data", "]", "costs", "=", "[", "]", "for", "d", "in", "data", ":", "dns", ".", "wait_to_read", "(", ")", "d", ".", "wait_to_read", "(", ")", "cost", "=", "measure_cost", "(", "repeat", ",", "mx", ".", "nd", ".", "dot", ",", "d", ",", "dns", ",", "transpose_a", "=", "True", ")", "costs", ".", "append", "(", "cost", ")", "ratio", "=", "costs", "[", "0", "]", "/", "costs", "[", "1", "]", "costs_baseline", "=", "[", "]", "cost", "=", "measure_cost_backward_baseline", "(", "repeat", ",", "np", ".", "dot", ",", "np", ".", "transpose", ",", "lhs_dns_np", ",", "rhs_dns_np", ")", "costs_baseline", ".", "append", "(", "cost", ")", "cost", "=", "measure_cost_backward_baseline", "(", "repeat", ",", "sp", ".", "spmatrix", ".", "dot", ",", "sp", ".", "spmatrix", ".", "transpose", ",", "lhs_csr_sp", ",", "rhs_dns_np", ")", "costs_baseline", ".", "append", "(", "cost", ")", "ratio_baseline", "=", "costs_baseline", "[", "0", "]", "/", "costs_baseline", "[", "1", "]", "fmt", "=", "\"%0.1f\\t\\t%s\\t%d\\t%d\\t%d\\t%0.2f\\t\\t\\t%0.2f\\t%0.5f\\t\\t%0.2f\\t\\t\\t\\t%0.6f\\t%0.5f\"", "print", "(", "fmt", "%", "(", "density", "*", "100", ",", "str", "(", "ctx", ")", ",", "n", ",", "m", ",", "k", ",", "ratio", ",", "costs", "[", "0", "]", ",", "costs", "[", "1", "]", ",", "ratio_baseline", ",", "costs_baseline", "[", "0", "]", ",", "costs_baseline", "[", "1", "]", ")", ")", "print", "(", "\"A = sparse NDArray of shape(m, k)\"", ")", "print", "(", "\"B = dense NDArray of shape(k, n)\"", ")", "print", "(", "\"dot_forward\\tdot(csr, dns)\"", ")", "print", "(", "'density(%)\\tcontext\\tn\\tm\\tk\\tt_dense/t_sparse\\tt_dense\\tt_sparse'", "'\\tt_scipy_dense/t_scipy_sparse\\tt_scipy_dense\\tt_scipy_sparse'", ")", "check_call", "(", "_LIB", ".", "MXSetNumOMPThreads", "(", "ctypes", ".", "c_int", "(", "args", ".", "num_omp_threads", ")", ")", ")", "# TODO(haibin) make these runtime options", "m", "=", "512", "k", "=", "[", "50000", ",", "100000", "]", "n", "=", "[", "64", ",", "128", "]", "density", "=", "[", "1.00", ",", "0.90", ",", "0.70", ",", "0.50", ",", "0.30", ",", "0.20", ",", "0.10", ",", "0.07", ",", "0.05", ",", "0.02", ",", "0.01", ",", "0.005", ",", "0.001", "]", "num_repeat", "=", "10", "# contexts = [mx.cpu(), mx.gpu(0)]", "contexts", "=", "[", "mx", ".", "cpu", "(", ")", "]", "for", "i", "in", "range", "(", "2", ")", ":", "for", "ctx", "in", "contexts", ":", "for", "den", "in", "density", ":", "bench_dot_forward", "(", "m", ",", "k", "[", "i", "]", ",", "n", "[", "i", "]", ",", "den", ",", "ctx", ",", "num_repeat", ")", "print", "(", "\"dot_backward\\tdot(csr.T, dns)\"", ")", "print", "(", "'density(%)\\tcontext\\tn\\tm\\tk\\tt_dense/t_sparse\\tt_dense\\tt_sparse'", "'\\tt_scipy_dense/t_scipy_sparse\\tt_scipy_dense\\tt_scipy_sparse'", ")", "for", "i", "in", "range", "(", "2", ")", ":", "for", "ctx", "in", "contexts", ":", "for", "den", "in", "density", ":", "bench_dot_backward", "(", "m", ",", "k", "[", "i", "]", ",", "n", "[", "i", "]", ",", "den", ",", "ctx", ",", "num_repeat", ")" ]

[ "Gets", "the", "LbAttributes", ".", "The", "Attributes", "will", "be", "cached", "." ]

[ "def", "get_attributes", "(", "self", ",", "force", "=", "False", ")", ":", "if", "not", "self", ".", "_attributes", "or", "force", ":", "self", ".", "_attributes", "=", "self", ".", "connection", ".", "get_all_lb_attributes", "(", "self", ".", "name", ")", "return", "self", ".", "_attributes" ]

[ "Construct", "a", "Union", "trait", "." ]

[ "def", "__init__", "(", "self", ",", "trait_types", ",", "*", "*", "kwargs", ")", ":", "self", ".", "trait_types", "=", "trait_types", "self", ".", "info_text", "=", "\" or \"", ".", "join", "(", "[", "tt", ".", "info", "(", ")", "for", "tt", "in", "self", ".", "trait_types", "]", ")", "super", "(", "Union", ",", "self", ")", ".", "__init__", "(", "*", "*", "kwargs", ")" ]

[ "FindById", "(", "self", "int", "toolid", ")", "-", ">", "ToolBarToolBase" ]

[ "def", "FindById", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ToolBarBase_FindById", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Callable", "used", "for", "the", "check", "sub", "-", "command", "." ]

[ "def", "checking_metadata", "(", "self", ")", ":", "return", "self", ".", "metadata_check" ]

[ "Arbitrary", "set", "of", "heuristics", "to", "determine", "if", "directory", "is", "an", "llvm", "dir", "." ]

[ "def", "_looks_like_llvm_dir", "(", "directory", ")", ":", "contents", "=", "set", "(", "os", ".", "listdir", "(", "directory", ")", ")", "expected_contents", "=", "[", "'CODE_OWNERS.TXT'", ",", "'cmake'", ",", "'docs'", ",", "'include'", ",", "'utils'", ",", "]", "if", "not", "all", "(", "c", "in", "contents", "for", "c", "in", "expected_contents", ")", ":", "return", "False", "try", ":", "include_listing", "=", "os", ".", "listdir", "(", "os", ".", "path", ".", "join", "(", "directory", ",", "'include'", ")", ")", "except", "NotADirectoryError", ":", "return", "False", "return", "'llvm'", "in", "include_listing" ]

[ "Get", "the", "values", "of", "the", "highest", "and", "lowest", "boundaries" ]

[ "def", "get_range", "(", "self", ")", ":", "return", "str", "(", "self", ".", "wav_low", ")", "+", "'_'", "+", "str", "(", "self", ".", "wav_high", ")" ]

[ "The", "list", "of", "dtypes", "for", "each", "component", "of", "a", "queue", "element", "." ]

[ "def", "dtypes", "(", "self", ")", ":", "return", "self", ".", "_dtypes" ]

[ "Constructs", "a", "zero", "AO", "basis", "set" ]

[ "def", "constructor_zero_ao_basis", "(", "self", ")", ":", "if", "not", "self", ".", "initialized_shared", ":", "self", ".", "initialize_singletons", "(", ")", "# Add a dummy atom at the origin, to hold this basis function", "self", ".", "molecule", "=", "Molecule", "(", ")", "self", ".", "molecule", ".", "add_atom", "(", "0", ",", "0.0", ",", "0.0", ",", "0.0", ",", "'X'", ")", "# Fill with data representing a single S function, at the origin, with 0 exponent", "self", ".", "n_uprimitive", "=", "1", "self", ".", "n_shells", "=", "1", "self", ".", "PYnprimitive", "=", "1", "self", ".", "PYnao", "=", "1", "self", ".", "PYnbf", "=", "1", "self", ".", "uerd_coefficients", "=", "[", "1.0", "]", "self", ".", "n_prim_per_shell", "=", "[", "1", "]", "self", ".", "uexponents", "=", "[", "0.0", "]", "self", ".", "ucoefficients", "=", "[", "1.0", "]", "self", ".", "uoriginal_coefficients", "=", "[", "1.0", "]", "self", ".", "shell_first_ao", "=", "[", "0", "]", "self", ".", "shell_first_basis_function", "=", "[", "0", "]", "self", ".", "ao_to_shell", "=", "[", "0", "]", "self", ".", "function_to_shell", "=", "[", "0", "]", "self", ".", "function_center", "=", "[", "0", "]", "self", ".", "shell_center", "=", "[", "0", "]", "self", ".", "center_to_nshell", "=", "[", "0", "]", "self", ".", "center_to_shell", "=", "[", "0", "]", "self", ".", "puream", "=", "False", "self", ".", "PYmax_am", "=", "0", "self", ".", "PYmax_nprimitive", "=", "1", "self", ".", "xyz", "=", "[", "0.0", ",", "0.0", ",", "0.0", "]", "self", ".", "name", "=", "'(Empty Basis Set)'", "self", ".", "shells", "=", "[", "]", "self", ".", "shells", ".", "append", "(", "ShellInfo", "(", "0", ",", "self", ".", "uoriginal_coefficients", ",", "self", ".", "uexponents", ",", "'Cartesian'", ",", "0", ",", "self", ".", "xyz", ",", "0", ")", ")" ]

[ "Returns", "the", "current", "buffers", "of", "changes", "not", "yet", "passed", "into", "the", "data", "source", ".", "It", "is", "a", "tuple", "of", "the", "current", "deletions", "and", "additions", "which", "each", "are", "in", "a", "form", "like", "[", "(", "delete", "rrset", ")", "(", "delete", "rrset", ")", "...", "]", "and", "[", "(", "add", "rrset", ")", "(", "add", "rrset", ")", "..", "]", "." ]

[ "def", "get_single_update_buffers", "(", "self", ")", ":", "if", "not", "self", ".", "__single_update_mode", ":", "raise", "ValueError", "(", "\"Separate buffers requested in single-update mode\"", ")", "else", ":", "return", "(", "self", ".", "__deletions", ",", "self", ".", "__additions", ")" ]

[ "Restore", "actiation", "loss", "from", "SavedModel", "." ]

[ "def", "_restore_layer_activation_loss", "(", "layer", ")", ":", "# Use wrapped activity regularizer function if the layer's activity", "# regularizer wasn't created during initialization.", "activity_regularizer", "=", "getattr", "(", "_get_keras_attr", "(", "layer", ")", ",", "'activity_regularizer_fn'", ",", "None", ")", "if", "activity_regularizer", "and", "not", "layer", ".", "activity_regularizer", ":", "try", ":", "layer", ".", "activity_regularizer", "=", "activity_regularizer", "except", "AttributeError", ":", "# This may happen if a layer wrapper is saved with an activity", "# regularizer. The wrapper object's activity regularizer is unsettable.", "pass" ]

[ "Adds", "bias", "to", "value", "." ]

[ "def", "bias_add", "(", "value", ",", "bias", ",", "data_format", "=", "None", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "value", ",", "bias", "]", ",", "name", ",", "\"BiasAdd\"", ")", "as", "name", ":", "value", "=", "ops", ".", "convert_to_tensor", "(", "value", ",", "name", "=", "\"input\"", ")", "bias", "=", "ops", ".", "convert_to_tensor", "(", "bias", ",", "dtype", "=", "value", ".", "dtype", ",", "name", "=", "\"bias\"", ")", "return", "gen_nn_ops", ".", "_bias_add", "(", "value", ",", "bias", ",", "data_format", "=", "data_format", ",", "name", "=", "name", ")" ]

[ "Produces", "the", "integers", "from", "0", "to", "limit", "-", "1", "in", "a", "queue", "." ]

[ "def", "range_input_producer", "(", "limit", ",", "num_epochs", "=", "None", ",", "shuffle", "=", "True", ",", "seed", "=", "None", ",", "capacity", "=", "32", ",", "shared_name", "=", "None", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"input_producer\"", ",", "[", "limit", "]", ")", "as", "name", ":", "range_tensor", "=", "math_ops", ".", "range", "(", "limit", ")", "return", "input_producer", "(", "range_tensor", ",", "[", "]", ",", "num_epochs", ",", "shuffle", ",", "seed", ",", "capacity", ",", "shared_name", ",", "name", ",", "\"fraction_of_%d_full\"", "%", "capacity", ")" ]

[ "Determine", "whether", "this", "Type", "represents", "plain", "old", "data", "(", "POD", ")", "." ]

[ "def", "is_pod", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_isPODType", "(", "self", ")" ]

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

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

[ "Output", "slot", "index", "from", "which", "the", "tensor", "value", "was", "dumped", "." ]

[ "def", "output_slot", "(", "self", ")", ":", "return", "self", ".", "_output_slot" ]

[ "Does", "nothing", "." ]

[ "def", "noop", "(", "self", ")", ":", "return", "self", ".", "_shortcmd", "(", "'NOOP'", ")" ]

[ "Returns", "the", "current", "target", "." ]

[ "def", "current_target", "(", "allow_none", "=", "True", ")", ":", "if", "Target", ".", "current", ":", "return", "Target", ".", "current", "if", "not", "allow_none", ":", "raise", "RuntimeError", "(", "\"Requires a current target in generic function, but it is not set. \"", "\"Please set it using `with TargetObject:`\"", ")", "return", "Target", ".", "current" ]

[ "Initializes", "mapping", "from", "tensor", "s", "name", "to", "ops", "that", "take", "it", "." ]

[ "def", "__init__", "(", "self", ",", "graph", ")", ":", "self", ".", "mapping", "=", "collections", ".", "defaultdict", "(", "set", ")", "for", "op", "in", "(", "op", "for", "op", "in", "graph", ".", "get_operations", "(", ")", ")", ":", "if", "op", ".", "name", ".", "startswith", "(", "common", ".", "SKIPPED_PREFIXES", ")", ":", "continue", "for", "op_input", "in", "op", ".", "inputs", ":", "self", ".", "mapping", "[", "op_input", "]", ".", "add", "(", "op", ")" ]

[ "__init__", "(", "self", "Window", "parent", "PrintDialogData", "data", "=", "None", ")", "-", ">", "PrintDialog" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_windows_", ".", "PrintDialog_swiginit", "(", "self", ",", "_windows_", ".", "new_PrintDialog", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Returns", "true", "if", "the", "specified", "error", "category", "is", "suppressed", "on", "this", "line", "." ]

[ "def", "IsErrorSuppressedByNolint", "(", "category", ",", "linenum", ")", ":", "return", "(", "linenum", "in", "_error_suppressions", ".", "get", "(", "category", ",", "set", "(", ")", ")", "or", "linenum", "in", "_error_suppressions", ".", "get", "(", "None", ",", "set", "(", ")", ")", ")" ]

[ "Draws", "a", "caffe", "net", "and", "returns", "the", "image", "string", "encoded", "using", "the", "given", "extension", "." ]

[ "def", "draw_net", "(", "caffe_net", ",", "rankdir", ",", "ext", "=", "'png'", ")", ":", "return", "get_pydot_graph", "(", "caffe_net", ",", "rankdir", ")", ".", "create", "(", "format", "=", "ext", ")" ]

[ "extended_message", ":", "Message", "instance", "for", "which", "we", "are", "the", "Extensions", "dict", "." ]

[ "def", "__init__", "(", "self", ",", "extended_message", ")", ":", "self", ".", "_extended_message", "=", "extended_message" ]

[ "addIKConstraint", "(", "RobotPoser", "self", "IKObjective", "obj", ")" ]

[ "def", "addIKConstraint", "(", "self", ",", "obj", ")", ":", "return", "_robotsim", ".", "RobotPoser_addIKConstraint", "(", "self", ",", "obj", ")" ]

[ "Yield", "next", "batch", "of", "data", "." ]

[ "def", "next", "(", "self", ",", "input_data", ")", ":", "if", "self", ".", "it", "==", "len", "(", "self", ".", "_data", ")", ":", "# Return 0 when there's no more batch.", "return", "0", "input_data", "(", "data", "=", "self", ".", "data", "(", ")", ",", "label", "=", "self", ".", "labels", "(", ")", ",", "weight", "=", "self", ".", "weights", "(", ")", ")", "self", ".", "it", "+=", "1", "return", "1" ]

[ "Looks", "for", "redundant", "trailing", "semicolon", "." ]

[ "def", "CheckTrailingSemicolon", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# Block bodies should not be followed by a semicolon. Due to C++11", "# brace initialization, there are more places where semicolons are", "# required than not, so we explicitly list the allowed rules rather", "# than listing the disallowed ones. These are the places where \"};\"", "# should be replaced by just \"}\":", "# 1. Some flavor of block following closing parenthesis:", "# for (;;) {};", "# while (...) {};", "# switch (...) {};", "# Function(...) {};", "# if (...) {};", "# if (...) else if (...) {};", "#", "# 2. else block:", "# if (...) else {};", "#", "# 3. const member function:", "# Function(...) const {};", "#", "# 4. Block following some statement:", "# x = 42;", "# {};", "#", "# 5. Block at the beginning of a function:", "# Function(...) {", "# {};", "# }", "#", "# Note that naively checking for the preceding \"{\" will also match", "# braces inside multi-dimensional arrays, but this is fine since", "# that expression will not contain semicolons.", "#", "# 6. Block following another block:", "# while (true) {}", "# {};", "#", "# 7. End of namespaces:", "# namespace {};", "#", "# These semicolons seems far more common than other kinds of", "# redundant semicolons, possibly due to people converting classes", "# to namespaces. For now we do not warn for this case.", "#", "# Try matching case 1 first.", "match", "=", "Match", "(", "r'^(.*\\)\\s*)\\{'", ",", "line", ")", "if", "match", ":", "# Matched closing parenthesis (case 1). Check the token before the", "# matching opening parenthesis, and don't warn if it looks like a", "# macro. This avoids these false positives:", "# - macro that defines a base class", "# - multi-line macro that defines a base class", "# - macro that defines the whole class-head", "#", "# But we still issue warnings for macros that we know are safe to", "# warn, specifically:", "# - TEST, TEST_F, TEST_P, MATCHER, MATCHER_P", "# - TYPED_TEST", "# - INTERFACE_DEF", "# - EXCLUSIVE_LOCKS_REQUIRED, SHARED_LOCKS_REQUIRED, LOCKS_EXCLUDED:", "#", "# We implement a list of safe macros instead of a list of", "# unsafe macros, even though the latter appears less frequently in", "# google code and would have been easier to implement. This is because", "# the downside for getting the allowed checks wrong means some extra", "# semicolons, while the downside for getting disallowed checks wrong", "# would result in compile errors.", "#", "# In addition to macros, we also don't want to warn on", "# - Compound literals", "# - Lambdas", "# - alignas specifier with anonymous structs", "# - decltype", "closing_brace_pos", "=", "match", ".", "group", "(", "1", ")", ".", "rfind", "(", "')'", ")", "opening_parenthesis", "=", "ReverseCloseExpression", "(", "clean_lines", ",", "linenum", ",", "closing_brace_pos", ")", "if", "opening_parenthesis", "[", "2", "]", ">", "-", "1", ":", "line_prefix", "=", "opening_parenthesis", "[", "0", "]", "[", "0", ":", "opening_parenthesis", "[", "2", "]", "]", "macro", "=", "Search", "(", "r'\\b([A-Z_][A-Z0-9_]*)\\s*$'", ",", "line_prefix", ")", "func", "=", "Match", "(", "r'^(.*\\])\\s*$'", ",", "line_prefix", ")", "if", "(", "(", "macro", "and", "macro", ".", "group", "(", "1", ")", "not", "in", "(", "'TEST'", ",", "'TEST_F'", ",", "'MATCHER'", ",", "'MATCHER_P'", ",", "'TYPED_TEST'", ",", "'EXCLUSIVE_LOCKS_REQUIRED'", ",", "'SHARED_LOCKS_REQUIRED'", ",", "'LOCKS_EXCLUDED'", ",", "'INTERFACE_DEF'", ")", ")", "or", "(", "func", "and", "not", "Search", "(", "r'\\boperator\\s*\\[\\s*\\]'", ",", "func", ".", "group", "(", "1", ")", ")", ")", "or", "Search", "(", "r'\\b(?:struct|union)\\s+alignas\\s*$'", ",", "line_prefix", ")", "or", "Search", "(", "r'\\bdecltype$'", ",", "line_prefix", ")", "or", "Search", "(", "r'\\s+=\\s*$'", ",", "line_prefix", ")", ")", ":", "match", "=", "None", "if", "(", "match", "and", "opening_parenthesis", "[", "1", "]", ">", "1", "and", "Search", "(", "r'\\]\\s*$'", ",", "clean_lines", ".", "elided", "[", "opening_parenthesis", "[", "1", "]", "-", "1", "]", ")", ")", ":", "# Multi-line lambda-expression", "match", "=", "None", "else", ":", "# Try matching cases 2-3.", "match", "=", "Match", "(", "r'^(.*(?:else|\\)\\s*const)\\s*)\\{'", ",", "line", ")", "if", "not", "match", ":", "# Try matching cases 4-6. These are always matched on separate lines.", "#", "# Note that we can't simply concatenate the previous line to the", "# current line and do a single match, otherwise we may output", "# duplicate warnings for the blank line case:", "# if (cond) {", "# // blank line", "# }", "prevline", "=", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", "[", "0", "]", "if", "prevline", "and", "Search", "(", "r'[;{}]\\s*$'", ",", "prevline", ")", ":", "match", "=", "Match", "(", "r'^(\\s*)\\{'", ",", "line", ")", "# Check matching closing brace", "if", "match", ":", "(", "endline", ",", "endlinenum", ",", "endpos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "len", "(", "match", ".", "group", "(", "1", ")", ")", ")", "if", "endpos", ">", "-", "1", "and", "Match", "(", "r'^\\s*;'", ",", "endline", "[", "endpos", ":", "]", ")", ":", "# Current {} pair is eligible for semicolon check, and we have found", "# the redundant semicolon, output warning here.", "#", "# Note: because we are scanning forward for opening braces, and", "# outputting warnings for the matching closing brace, if there are", "# nested blocks with trailing semicolons, we will get the error", "# messages in reversed order.", "# We need to check the line forward for NOLINT", "raw_lines", "=", "clean_lines", ".", "raw_lines", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "endlinenum", "-", "1", "]", ",", "endlinenum", "-", "1", ",", "error", ")", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "endlinenum", "]", ",", "endlinenum", ",", "error", ")", "error", "(", "filename", ",", "endlinenum", ",", "'readability/braces'", ",", "4", ",", "\"You don't need a ; after a }\"", ")" ]

[ "Put", "imports", "on", "separate", "lines", "." ]

[ "def", "fix_e401", "(", "self", ",", "result", ")", ":", "line_index", "=", "result", "[", "'line'", "]", "-", "1", "target", "=", "self", ".", "source", "[", "line_index", "]", "offset", "=", "result", "[", "'column'", "]", "-", "1", "if", "not", "target", ".", "lstrip", "(", ")", ".", "startswith", "(", "'import'", ")", ":", "return", "[", "]", "indentation", "=", "re", ".", "split", "(", "pattern", "=", "r'\\bimport\\b'", ",", "string", "=", "target", ",", "maxsplit", "=", "1", ")", "[", "0", "]", "fixed", "=", "(", "target", "[", ":", "offset", "]", ".", "rstrip", "(", "'\\t ,'", ")", "+", "'\\n'", "+", "indentation", "+", "'import '", "+", "target", "[", "offset", ":", "]", ".", "lstrip", "(", "'\\t ,'", ")", ")", "self", ".", "source", "[", "line_index", "]", "=", "fixed" ]

[ "Persist", "the", "authorization_code", "." ]

[ "def", "save_authorization_code", "(", "self", ",", "client_id", ",", "code", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "raise", "NotImplementedError", "(", "'Subclasses must implement this method.'", ")" ]

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

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

[ "Creates", "an", "item", "and", "sends", "it", "to", "the", "ReverbService", "." ]

[ "def", "create_item", "(", "self", ",", "table", ":", "str", ",", "num_timesteps", ":", "int", ",", "priority", ":", "float", ")", ":", "if", "num_timesteps", "<", "1", ":", "raise", "ValueError", "(", "'num_timesteps (%d) must be a positive integer'", ")", "self", ".", "_writer", ".", "CreateItem", "(", "table", ",", "num_timesteps", ",", "priority", ")" ]

[ "Exit", "a", "with", "block", ".", "Typically", "this", "will", "close", "the", "file", "." ]

[ "def", "__exit__", "(", "self", ",", "unused_type", ",", "unused_value", ",", "unused_traceback", ")", ":" ]

[ "Export", "1D", "cuts", "in", "the", "X", "/", "Y", "direction", "for", "the", "extent", ".", "Signature", "matches", "other", "export", "functions", ".", "slicepoint", "bin_params", "are", "unused", ":", "param", "limits", ":", "An", "optional", "ND", "sequence", "containing", "limits", "for", "plotting", "dimensions", ".", "If", "not", "provided", "the", "full", "extent", "of", "each", "dimension", "is", "used", ":", "param", "transpose", ":", "If", "true", "then", "the", "limits", "are", "transposed", ".", "w", ".", "r", ".", "t", ".", "the", "data", ":", "param", "cut", ":", "A", "string", "denoting", "which", "cut", "to", "export", ".", "Options", "=", "c", "x", "y", "." ]

[ "def", "export_cuts_to_workspace_matrix", "(", "self", ",", "slicepoint", ",", "bin_params", ",", "limits", ":", "tuple", ",", "transpose", ":", "bool", ",", "dimension_indices", ":", "Sequence", "[", "int", "]", ",", "cut", ":", "str", ")", ":", "workspace", "=", "self", ".", "_get_ws", "(", ")", "if", "transpose", ":", "# swap back to model order", "limits", "=", "limits", "[", "1", "]", ",", "limits", "[", "0", "]", "yaxis", "=", "workspace", ".", "getAxis", "(", "1", ")", "(", "xmin", ",", "xmax", ")", ",", "(", "ymin", ",", "ymax", ")", "=", "limits", "[", "0", "]", ",", "limits", "[", "1", "]", "xcut_name", ",", "ycut_name", ",", "help_msg", "=", "self", ".", "_cut_names", "(", "cut", ")", "if", "transpose", ":", "xcut_name", ",", "ycut_name", "=", "ycut_name", ",", "xcut_name", "if", "yaxis", ".", "isSpectra", "(", ")", "or", "yaxis", ".", "isNumeric", "(", ")", ":", "extract_cuts_matrix", "(", "workspace", ",", "xmin", ",", "xmax", ",", "ymin", ",", "ymax", ",", "xcut_name", ",", "ycut_name", ")", "else", ":", "help_msg", "=", "'Unknown Y axis type. Unable to perform cuts'", "return", "help_msg" ]

[ "Updates", "the", "fit", "functions", "after", "a", "sequential", "fit", "has", "been", "run", "on", "the", "Sequential", "fitting", "tab", "." ]

[ "def", "_update_fit_functions_after_sequential_fit", "(", "self", ",", "workspaces", ":", "list", ",", "functions", ":", "list", ")", "->", "None", ":", "if", "self", ".", "fitting_context", ".", "simultaneous_fitting_mode", ":", "self", ".", "_update_simultaneous_fit_function_after_sequential", "(", "workspaces", ",", "functions", ")", "else", ":", "super", "(", ")", ".", "_update_fit_functions_after_sequential_fit", "(", "workspaces", ",", "functions", ")" ]

[ "Replace", "all", "instances", "of", "theStr", "with", "repl", "for", "each", "file", "in", "the", "files", "list", ".", "Returns", "a", "dictionary", "with", "data", "about", "the", "matches", "found", "." ]

[ "def", "replaceStrInFiles", "(", "files", ",", "theStr", ",", "repl", ")", ":", "pattern", "=", "_escapeRegexChars", "(", "theStr", ")", "return", "FindAndReplace", "(", "files", ",", "pattern", ",", "repl", ")", ".", "results", "(", ")" ]

[ "Add", "Nodes", "Parsing", "a", "NoteCase", "File" ]

[ "def", "nodes_add_from_notecase_file", "(", "self", ",", "action", ")", ":", "filepath", "=", "support", ".", "dialog_file_select", "(", "filter_pattern", "=", "[", "\"*.ncd\"", "]", ",", "filter_name", "=", "_", "(", "\"NoteCase Document\"", ")", ",", "curr_folder", "=", "self", ".", "pick_dir_import", ",", "parent", "=", "self", ".", "window", ")", "if", "not", "filepath", ":", "return", "self", ".", "pick_dir_import", "=", "os", ".", "path", ".", "dirname", "(", "filepath", ")", "try", ":", "file_descriptor", "=", "open", "(", "filepath", ",", "'r'", ")", "notecase_string", "=", "file_descriptor", ".", "read", "(", ")", "file_descriptor", ".", "close", "(", ")", "except", ":", "support", ".", "dialog_error", "(", "\"Error importing the file %s\"", "%", "filepath", ",", "self", ".", "window", ")", "raise", "return", "notecase", "=", "imports", ".", "NotecaseHandler", "(", "self", ")", "cherrytree_string", "=", "notecase", ".", "get_cherrytree_xml", "(", "notecase_string", ")", "self", ".", "nodes_add_from_cherrytree_data", "(", "cherrytree_string", ")" ]

[ "Consumes", "a", "signed", "32bit", "integer", "number", "." ]

[ "def", "ConsumeInt32", "(", "self", ")", ":", "try", ":", "result", "=", "ParseInteger", "(", "self", ".", "token", ",", "is_signed", "=", "True", ",", "is_long", "=", "False", ")", "except", "ValueError", ",", "e", ":", "raise", "self", ".", "_ParseError", "(", "str", "(", "e", ")", ")", "self", ".", "NextToken", "(", ")", "return", "result" ]

[ "Install", "a", "single", "source", "package", "." ]

[ "def", "installPackageOnly", "(", "self", ",", "output", "=", "None", ")", ":", "if", "'Install-command'", "in", "self", ".", "_dict", ":", "return", "\"%s: Binary package cannot have Install-command\"", "%", "self", ".", "fullname", "(", ")", "if", "'Pre-install-command'", "in", "self", ".", "_dict", ":", "if", "_cmd", "(", "output", ",", "'/tmp'", ",", "self", ".", "_dict", "[", "'Pre-install-command'", "]", ")", ":", "return", "\"pre-install %s: running \\\"%s\\\" failed\"", "%", "(", "self", ".", "fullname", "(", ")", ",", "self", ".", "_dict", "[", "'Pre-install-command'", "]", ")", "self", ".", "beforeInstall", "(", ")", "# Install by unpacking", "filename", "=", "os", ".", "path", ".", "split", "(", "self", ".", "archiveFilename", ")", "[", "1", "]", "for", "ext", ",", "unpackerClass", ",", "arg", "in", "ARCHIVE_FORMATS", ":", "if", "filename", "[", "-", "len", "(", "ext", ")", ":", "]", "==", "ext", ":", "break", "else", ":", "return", "\"%s: unknown extension for archive file: %s\"", "%", "(", "self", ".", "fullname", "(", ")", ",", "filename", ")", "self", ".", "basename", "=", "filename", "[", ":", "-", "len", "(", "ext", ")", "]", "install_renames", "=", "[", "]", "for", "k", ",", "newloc", "in", "self", ".", "_db", ".", "preferences", ".", "installLocations", ":", "if", "not", "newloc", ":", "continue", "if", "k", "==", "\"--install-lib\"", ":", "oldloc", "=", "DEFAULT_INSTALLDIR", "else", ":", "return", "\"%s: Don't know installLocation %s\"", "%", "(", "self", ".", "fullname", "(", ")", ",", "k", ")", "install_renames", ".", "append", "(", "(", "oldloc", ",", "newloc", ")", ")", "unpacker", "=", "unpackerClass", "(", "arg", ",", "dir", "=", "\"/\"", ",", "renames", "=", "install_renames", ")", "rv", "=", "unpacker", ".", "unpack", "(", "self", ".", "archiveFilename", ",", "output", "=", "output", ",", "package", "=", "self", ")", "if", "rv", ":", "return", "rv", "self", ".", "afterInstall", "(", ")", "if", "'Post-install-command'", "in", "self", ".", "_dict", ":", "if", "_cmd", "(", "output", ",", "'/tmp'", ",", "self", ".", "_dict", "[", "'Post-install-command'", "]", ")", ":", "return", "\"%s: post-install: running \\\"%s\\\" failed\"", "%", "(", "self", ".", "fullname", "(", ")", ",", "self", ".", "_dict", "[", "'Post-install-command'", "]", ")", "return", "None" ]

[ "downloads", "--", "Selects", "the", "downloads", "tab", "." ]

[ "def", "do_downloads", "(", "self", ",", "line", ")", ":", "self", ".", "tab", "=", "FakeTab", "(", "\"statictab\"", ",", "\"downloadtab\"", ")", "self", ".", "tab_changed", "(", ")" ]

[ "FindNext", "(", "self", ")", "-", ">", "String" ]

[ "def", "FindNext", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "ZipFSHandler_FindNext", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "unpack", "serialized", "message", "in", "str", "into", "this", "message", "instance", ":", "param", "str", ":", "byte", "array", "of", "serialized", "message", "str" ]

[ "def", "deserialize", "(", "self", ",", "str", ")", ":", "try", ":", "if", "self", ".", "header", "is", "None", ":", "self", ".", "header", "=", "std_msgs", ".", "msg", ".", "Header", "(", ")", "end", "=", "0", "_x", "=", "self", "start", "=", "end", "end", "+=", "12", "(", "_x", ".", "header", ".", "seq", ",", "_x", ".", "header", ".", "stamp", ".", "secs", ",", "_x", ".", "header", ".", "stamp", ".", "nsecs", ",", ")", "=", "_struct_3I", ".", "unpack", "(", "str", "[", "start", ":", "end", "]", ")", "start", "=", "end", "end", "+=", "4", "(", "length", ",", ")", "=", "_struct_I", ".", "unpack", "(", "str", "[", "start", ":", "end", "]", ")", "start", "=", "end", "end", "+=", "length", "if", "python3", ":", "self", ".", "header", ".", "frame_id", "=", "str", "[", "start", ":", "end", "]", ".", "decode", "(", "'utf-8'", ")", "else", ":", "self", ".", "header", ".", "frame_id", "=", "str", "[", "start", ":", "end", "]", "_x", "=", "self", "start", "=", "end", "end", "+=", "106", "(", "_x", ".", "quad_time", ",", "_x", ".", "des_thrust", ",", "_x", ".", "des_roll", ",", "_x", ".", "des_pitch", ",", "_x", ".", "des_yaw", ",", "_x", ".", "est_roll", ",", "_x", ".", "est_pitch", ",", "_x", ".", "est_yaw", ",", "_x", ".", "est_angvel_x", ",", "_x", ".", "est_angvel_y", ",", "_x", ".", "est_angvel_z", ",", "_x", ".", "est_acc_x", ",", "_x", ".", "est_acc_y", ",", "_x", ".", "est_acc_z", ",", ")", "=", "_struct_H13d", ".", "unpack", "(", "str", "[", "start", ":", "end", "]", ")", "start", "=", "end", "end", "+=", "8", "self", ".", "pwm", "=", "_struct_4H", ".", "unpack", "(", "str", "[", "start", ":", "end", "]", ")", "return", "self", "except", "struct", ".", "error", "as", "e", ":", "raise", "genpy", ".", "DeserializationError", "(", "e", ")" ]

[ "Shape", "function", "for", "ops", "that", "take", "a", "scalar", "and", "produce", "no", "outputs", "." ]

[ "def", "_ScalarToVoidShape", "(", "op", ")", ":", "op", ".", "inputs", "[", "0", "]", ".", "get_shape", "(", ")", ".", "merge_with", "(", "tensor_shape", ".", "scalar", "(", ")", ")", "return", "[", "]" ]

[ "splituser", "(", "user", "[", ":", "passwd", "]" ]

[ "def", "_splituser", "(", "host", ")", ":", "user", ",", "delim", ",", "host", "=", "host", ".", "rpartition", "(", "'@'", ")", "return", "(", "user", "if", "delim", "else", "None", ")", ",", "host" ]

[ "Processes", "a", "single", "line", "in", "the", "file", "." ]

[ "def", "ProcessLine", "(", "filename", ",", "file_extension", ",", "clean_lines", ",", "line", ",", "include_state", ",", "function_state", ",", "class_state", ",", "error", ",", "extra_check_functions", "=", "[", "]", ")", ":", "raw_lines", "=", "clean_lines", ".", "raw_lines", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "line", "]", ",", "line", ",", "error", ")", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "line", ",", "function_state", ",", "error", ")", "CheckForMultilineCommentsAndStrings", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckStyle", "(", "filename", ",", "clean_lines", ",", "line", ",", "file_extension", ",", "class_state", ",", "error", ")", "CheckLanguage", "(", "filename", ",", "clean_lines", ",", "line", ",", "file_extension", ",", "include_state", ",", "error", ")", "CheckForNonStandardConstructs", "(", "filename", ",", "clean_lines", ",", "line", ",", "class_state", ",", "error", ")", "CheckPosixThreading", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckInvalidIncrement", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckMakePairUsesDeduction", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "for", "check_fn", "in", "extra_check_functions", ":", "check_fn", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")" ]

[ "PrePyControl", "()", "-", ">", "PyControl" ]

[ "def", "PrePyControl", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_controls_", ".", "new_PrePyControl", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Prepends", "an", "item", "as", "a", "first", "child", "of", "parent", "." ]

[ "def", "PrependItem", "(", "self", ",", "parent", ",", "text", ",", "ct_type", "=", "0", ",", "wnd", "=", "None", ",", "image", "=", "-", "1", ",", "selImage", "=", "-", "1", ",", "data", "=", "None", ",", "separator", "=", "False", ")", ":", "return", "self", ".", "DoInsertItem", "(", "parent", ",", "0", ",", "text", ",", "ct_type", ",", "wnd", ",", "image", ",", "selImage", ",", "data", ",", "separator", ")" ]

[ "A", "hash", "for", "this", "builder" ]

[ "def", "hash", "(", "self", ")", ":", "return", "None" ]

[ "Ensure", "that", "all", "properties", "identified", "as", "required", "by", "the", "schema", "are", "set", "." ]

[ "def", "VerifyHasRequiredProperties", "(", "self", ")", ":", "# TODO(mark): A stronger verification mechanism is needed. Some", "# subclasses need to perform validation beyond what the schema can enforce.", "for", "property", ",", "attributes", "in", "self", ".", "_schema", ".", "iteritems", "(", ")", ":", "(", "is_list", ",", "property_type", ",", "is_strong", ",", "is_required", ")", "=", "attributes", "[", "0", ":", "4", "]", "if", "is_required", "and", "not", "property", "in", "self", ".", "_properties", ":", "raise", "KeyError", "(", "self", ".", "__class__", ".", "__name__", "+", "' requires '", "+", "property", ")" ]

[ "Set", "strategy", "checkpoint", "save", "path", "." ]

[ "def", "set_strategy_ckpt_save_file", "(", "self", ",", "strategy_ckpt_save_file", ")", ":", "self", ".", "check_context_handle", "(", ")", "dir_path", "=", "os", ".", "path", ".", "dirname", "(", "strategy_ckpt_save_file", ")", "if", "dir_path", "and", "not", "os", ".", "path", ".", "exists", "(", "dir_path", ")", ":", "os", ".", "makedirs", "(", "dir_path", ")", "self", ".", "_context_handle", ".", "set_strategy_ckpt_save_file", "(", "strategy_ckpt_save_file", ")" ]

[ "Creation", "of", "a", "new", "node", "containing", "a", "comment", "." ]

[ "def", "newComment", "(", "content", ")", ":", "ret", "=", "libxml2mod", ".", "xmlNewComment", "(", "content", ")", "if", "ret", "is", "None", ":", "raise", "treeError", "(", "'xmlNewComment() failed'", ")", "return", "xmlNode", "(", "_obj", "=", "ret", ")" ]

[ "Reports", "for", "long", "function", "bodies", "." ]

[ "def", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "function_state", ",", "error", ")", ":", "lines", "=", "clean_lines", ".", "lines", "line", "=", "lines", "[", "linenum", "]", "raw", "=", "clean_lines", ".", "raw_lines", "raw_line", "=", "raw", "[", "linenum", "]", "joined_line", "=", "''", "starting_func", "=", "False", "regexp", "=", "r'(\\w(\\w|::|\\*|\\&|\\s)*)\\('", "# decls * & space::name( ...", "match_result", "=", "Match", "(", "regexp", ",", "line", ")", "if", "match_result", ":", "# If the name is all caps and underscores, figure it's a macro and", "# ignore it, unless it's TEST or TEST_F.", "function_name", "=", "match_result", ".", "group", "(", "1", ")", ".", "split", "(", ")", "[", "-", "1", "]", "if", "function_name", "==", "'TEST'", "or", "function_name", "==", "'TEST_F'", "or", "(", "not", "Match", "(", "r'[A-Z_]+$'", ",", "function_name", ")", ")", ":", "starting_func", "=", "True", "if", "starting_func", ":", "body_found", "=", "False", "for", "start_linenum", "in", "xrange", "(", "linenum", ",", "clean_lines", ".", "NumLines", "(", ")", ")", ":", "start_line", "=", "lines", "[", "start_linenum", "]", "joined_line", "+=", "' '", "+", "start_line", ".", "lstrip", "(", ")", "if", "Search", "(", "r'(;|})'", ",", "start_line", ")", ":", "# Declarations and trivial functions", "body_found", "=", "True", "break", "# ... ignore", "elif", "Search", "(", "r'{'", ",", "start_line", ")", ":", "body_found", "=", "True", "function", "=", "Search", "(", "r'((\\w|:)*)\\('", ",", "line", ")", ".", "group", "(", "1", ")", "if", "Match", "(", "r'TEST'", ",", "function", ")", ":", "# Handle TEST... macros", "parameter_regexp", "=", "Search", "(", "r'(\\(.*\\))'", ",", "joined_line", ")", "if", "parameter_regexp", ":", "# Ignore bad syntax", "function", "+=", "parameter_regexp", ".", "group", "(", "1", ")", "else", ":", "function", "+=", "'()'", "function_state", ".", "Begin", "(", "function", ")", "break", "if", "not", "body_found", ":", "# No body for the function (or evidence of a non-function) was found.", "error", "(", "filename", ",", "linenum", ",", "'readability/fn_size'", ",", "5", ",", "'Lint failed to find start of function body.'", ")", "elif", "Match", "(", "r'^\\}\\s*$'", ",", "line", ")", ":", "# function end", "function_state", ".", "Check", "(", "error", ",", "filename", ",", "linenum", ")", "function_state", ".", "End", "(", ")", "elif", "not", "Match", "(", "r'^\\s*$'", ",", "line", ")", ":", "function_state", ".", "Count", "(", ")" ]

[ "Using", "assignment", "map", "initializes", "current", "variables", "with", "loaded", "tensors", "." ]

[ "def", "init_from_checkpoint", "(", "checkpoint_dir", ",", "assignment_map", ")", ":", "filepattern", "=", "_get_checkpoint_filename", "(", "checkpoint_dir", ")", "reader", "=", "load_checkpoint", "(", "checkpoint_dir", ")", "variable_map", "=", "reader", ".", "get_variable_to_shape_map", "(", ")", "for", "tensor_name_in_ckpt", ",", "current_var_or_name", "in", "six", ".", "iteritems", "(", "assignment_map", ")", ":", "var", "=", "None", "# Check if this is Variable object or list of Variable objects (in case of", "# partitioned variables).", "is_var", "=", "lambda", "x", ":", "isinstance", "(", "x", ",", "variables", ".", "Variable", ")", "if", "is_var", "(", "current_var_or_name", ")", "or", "(", "isinstance", "(", "current_var_or_name", ",", "list", ")", "and", "all", "(", "is_var", "(", "v", ")", "for", "v", "in", "current_var_or_name", ")", ")", ":", "var", "=", "current_var_or_name", "else", ":", "var_scope", "=", "vs", ".", "_get_default_variable_store", "(", ")", "# Check if this variable is in var_store.", "var", "=", "var_scope", ".", "_vars", ".", "get", "(", "current_var_or_name", ",", "None", ")", "# Also check if variable is partitioned as list.", "if", "var", "is", "None", ":", "var", "=", "_collect_partitioned_variable", "(", "current_var_or_name", ",", "var_scope", ")", "if", "var", "is", "not", "None", ":", "# If 1 to 1 mapping was provided, find variable in the checkpoint.", "if", "tensor_name_in_ckpt", "not", "in", "variable_map", ":", "raise", "ValueError", "(", "\"Tensor %s is not found in %s checkpoint %s\"", "%", "(", "tensor_name_in_ckpt", ",", "checkpoint_dir", ",", "variable_map", ")", ")", "if", "is_var", "(", "var", ")", ":", "# Additional at-call-time checks.", "if", "not", "var", ".", "get_shape", "(", ")", ".", "is_compatible_with", "(", "variable_map", "[", "tensor_name_in_ckpt", "]", ")", ":", "raise", "ValueError", "(", "\"Shape of variable %s (%s) doesn't match with shape of \"", "\"tensor %s (%s) from checkpoint reader.\"", "%", "(", "var", ".", "name", ",", "str", "(", "var", ".", "get_shape", "(", ")", ")", ",", "tensor_name_in_ckpt", ",", "str", "(", "variable_map", "[", "tensor_name_in_ckpt", "]", ")", ")", ")", "var_name", "=", "var", ".", "name", "else", ":", "var_name", "=", "\",\"", ".", "join", "(", "[", "v", ".", "name", "for", "v", "in", "var", "]", ")", "_set_variable_or_list_initializer", "(", "var", ",", "filepattern", ",", "tensor_name_in_ckpt", ")", "logging", ".", "info", "(", "\"Initialize variable %s from checkpoint %s with %s\"", "%", "(", "var_name", ",", "checkpoint_dir", ",", "tensor_name_in_ckpt", ")", ")", "else", ":", "scopes", "=", "\"\"", "# TODO(vihanjain): Support list of 'current_var_or_name' here.", "if", "\"/\"", "in", "current_var_or_name", ":", "scopes", "=", "current_var_or_name", "[", ":", "current_var_or_name", ".", "rindex", "(", "\"/\"", ")", "]", "if", "not", "tensor_name_in_ckpt", ".", "endswith", "(", "\"/\"", ")", ":", "raise", "ValueError", "(", "\"Assignment map with scope only name {} should map to scope only \"", "\"{}. Should be 'scope/': 'other_scope/'.\"", ".", "format", "(", "scopes", ",", "tensor_name_in_ckpt", ")", ")", "# If scope to scope mapping was provided, find all variables in the scope", "# and create variable to variable mapping.", "scope_variables", "=", "set", "(", ")", "for", "var_name", "in", "var_scope", ".", "_vars", ":", "if", "not", "scopes", "or", "var_name", ".", "startswith", "(", "scopes", "+", "\"/\"", ")", ":", "# Consume /part_ if partitioned variable.", "if", "\"/part_\"", "in", "var_name", ":", "var_name", "=", "var_name", "[", ":", "var_name", ".", "index", "(", "\"/part_\"", ")", "]", "scope_variables", ".", "add", "(", "var_name", ")", "for", "var_name", "in", "scope_variables", ":", "# Lookup name with specified prefix and suffix from current variable.", "# If tensor_name given is '/' (root), don't use it for full name.", "full_tensor_name", "=", "var_name", "[", "len", "(", "scopes", ")", ":", "]", "if", "current_var_or_name", "!=", "\"/\"", ":", "full_tensor_name", "=", "full_tensor_name", "[", "1", ":", "]", "if", "tensor_name_in_ckpt", "!=", "\"/\"", ":", "full_tensor_name", "=", "tensor_name_in_ckpt", "+", "full_tensor_name", "if", "full_tensor_name", "not", "in", "variable_map", ":", "raise", "ValueError", "(", "\"Tensor %s (%s in %s) is not found in %s checkpoint\"", "%", "(", "full_tensor_name", ",", "var_name", "[", "len", "(", "scopes", ")", "+", "1", ":", "]", ",", "tensor_name_in_ckpt", ",", "checkpoint_dir", ")", ")", "var", "=", "var_scope", ".", "_vars", ".", "get", "(", "var_name", ",", "None", ")", "if", "var", "is", "None", ":", "var", "=", "_collect_partitioned_variable", "(", "var_name", ",", "var_scope", ")", "_set_variable_or_list_initializer", "(", "var", ",", "filepattern", ",", "full_tensor_name", ")", "logging", ".", "info", "(", "\"Initialize variable %s from checkpoint %s with %s\"", "%", "(", "var_name", ",", "checkpoint_dir", ",", "full_tensor_name", ")", ")" ]

[ "Logs", "an", "error", "for", "each", "line", "containing", "bad", "characters", "." ]

[ "def", "CheckForBadCharacters", "(", "filename", ",", "lines", ",", "error", ")", ":", "for", "linenum", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "if", "u'\\ufffd'", "in", "line", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/utf8'", ",", "5", ",", "'Line contains invalid UTF-8 (or Unicode replacement character).'", ")", "if", "'\\0'", "in", "line", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/nul'", ",", "5", ",", "'Line contains NUL byte.'", ")" ]

[ "Squeeze", "last", "dim", "if", "ranks", "of", "predictions", "and", "labels", "differ", "by", "1", "." ]

[ "def", "remove_squeezable_dimensions", "(", "predictions", ",", "labels", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "'remove_squeezable_dimensions'", ",", "[", "predictions", ",", "labels", "]", ")", ":", "predictions", "=", "ops", ".", "convert_to_tensor", "(", "predictions", ")", "labels", "=", "ops", ".", "convert_to_tensor", "(", "labels", ")", "predictions_shape", "=", "predictions", ".", "get_shape", "(", ")", "predictions_rank", "=", "predictions_shape", ".", "ndims", "labels_shape", "=", "labels", ".", "get_shape", "(", ")", "labels_rank", "=", "labels_shape", ".", "ndims", "if", "(", "labels_rank", "is", "not", "None", ")", "and", "(", "predictions_rank", "is", "not", "None", ")", ":", "# Use static rank.", "rank_diff", "=", "predictions_rank", "-", "labels_rank", "if", "rank_diff", "==", "-", "1", ":", "labels", "=", "array_ops", ".", "squeeze", "(", "labels", ",", "[", "-", "1", "]", ")", "elif", "rank_diff", "==", "1", ":", "predictions", "=", "array_ops", ".", "squeeze", "(", "predictions", ",", "[", "-", "1", "]", ")", "return", "predictions", ",", "labels", "# Use dynamic rank.", "rank_diff", "=", "array_ops", ".", "rank", "(", "predictions", ")", "-", "array_ops", ".", "rank", "(", "labels", ")", "if", "(", "predictions_rank", "is", "None", ")", "or", "(", "predictions_shape", ".", "dims", "[", "-", "1", "]", ".", "is_compatible_with", "(", "1", ")", ")", ":", "predictions", "=", "control_flow_ops", ".", "cond", "(", "math_ops", ".", "equal", "(", "1", ",", "rank_diff", ")", ",", "lambda", ":", "array_ops", ".", "squeeze", "(", "predictions", ",", "[", "-", "1", "]", ")", ",", "lambda", ":", "predictions", ")", "if", "(", "labels_rank", "is", "None", ")", "or", "(", "labels_shape", ".", "dims", "[", "-", "1", "]", ".", "is_compatible_with", "(", "1", ")", ")", ":", "labels", "=", "control_flow_ops", ".", "cond", "(", "math_ops", ".", "equal", "(", "-", "1", ",", "rank_diff", ")", ",", "lambda", ":", "array_ops", ".", "squeeze", "(", "labels", ",", "[", "-", "1", "]", ")", ",", "lambda", ":", "labels", ")", "return", "predictions", ",", "labels" ]

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

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

[ "Compares", "two", "folders", "and", "all", "files", "and", "subfolders", "in", "them", ".", ":", "param", "folder1", ":", "Path", "to", "folder", "1", ".", ":", "param", "folder2", ":", "Path", "to", "folder", "2", ".", ":", "return", ":", "True", "on", "success", "else", "an", "exception", "is", "raised", "." ]

[ "def", "compare_folders", "(", "folder1", ",", "folder2", ")", ":", "global", "verbosity_level", ",", "dir_names_to_ignore", ",", "file_names_to_ignore", "cond_print", "(", "'Comparing \"{}\" to \"{}\" ...'", ".", "format", "(", "folder1", ",", "folder2", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "folder1_dir_list", "=", "[", "]", "folder1_file_list", "=", "[", "]", "folder2_dir_list", "=", "[", "]", "folder2_file_list", "=", "[", "]", "# Get all directories & files as lists for folder1", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "folder1", ")", ":", "for", "ignored_dir", "in", "dir_names_to_ignore", ":", "if", "ignored_dir", "in", "dirs", ":", "dirs", ".", "remove", "(", "ignored_dir", ")", "cond_print", "(", "'Ignoring directory \"{}\".'", ".", "format", "(", "os", ".", "path", ".", "join", "(", "root", ",", "ignored_dir", ")", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "for", "dir_", "in", "dirs", ":", "full_dir_path", "=", "os", ".", "path", ".", "join", "(", "root", ",", "dir_", ")", "clean_dir_path", "=", "full_dir_path", ".", "replace", "(", "folder1", ",", "''", ",", "1", ")", "folder1_dir_list", ".", "append", "(", "clean_dir_path", ")", "for", "file_", "in", "files", ":", "full_file_path", "=", "os", ".", "path", ".", "join", "(", "root", ",", "file_", ")", "if", "file_", "in", "file_names_to_ignore", ":", "cond_print", "(", "'Ignoring file \"{}\".'", ".", "format", "(", "full_file_path", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "continue", "clean_file_path", "=", "full_file_path", ".", "replace", "(", "folder1", ",", "''", ",", "1", ")", "folder1_file_list", ".", "append", "(", "clean_file_path", ")", "# Get all directories & files as lists for the local path", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "folder2", ")", ":", "for", "ignored_dir", "in", "dir_names_to_ignore", ":", "if", "ignored_dir", "in", "dirs", ":", "dirs", ".", "remove", "(", "ignored_dir", ")", "cond_print", "(", "'Ignoring directory \"{}\".'", ".", "format", "(", "os", ".", "path", ".", "join", "(", "root", ",", "ignored_dir", ")", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "for", "dir_", "in", "dirs", ":", "full_dir_path", "=", "os", ".", "path", ".", "join", "(", "root", ",", "dir_", ")", "clean_dir_path", "=", "full_dir_path", ".", "replace", "(", "folder2", ",", "''", ",", "1", ")", "folder2_dir_list", ".", "append", "(", "clean_dir_path", ")", "for", "file_", "in", "files", ":", "full_file_path", "=", "os", ".", "path", ".", "join", "(", "root", ",", "file_", ")", "if", "file_", "in", "file_names_to_ignore", ":", "cond_print", "(", "'Ignoring file \"{}\".'", ".", "format", "(", "full_file_path", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "continue", "clean_file_path", "=", "full_file_path", ".", "replace", "(", "folder2", ",", "''", ",", "1", ")", "folder2_file_list", ".", "append", "(", "clean_file_path", ")", "folder1_dir_list", ".", "sort", "(", ")", "folder1_file_list", ".", "sort", "(", ")", "folder2_dir_list", ".", "sort", "(", ")", "folder2_file_list", ".", "sort", "(", ")", "# Now we have four lists: One directory list per root folder, one file list per root folder, all cleaned from their", "# specific prefix and sorted alphabetically. The lists must have the same length and contain the same entries in", "# the same order, else the root folders are not the same from our logic's point of view. For files, also compare", "# the hash.", "if", "len", "(", "folder1_dir_list", ")", "!=", "len", "(", "folder2_dir_list", ")", ":", "for", "folder1_dir", "in", "folder1_dir_list", ":", "if", "folder1_dir", "not", "in", "folder2_dir_list", ":", "cond_print", "(", "'Folder 1 directory \"{}\" has no match in folder 2.'", ".", "format", "(", "folder1_dir", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "for", "folder2_dir", "in", "folder2_dir_list", ":", "if", "folder2_dir", "not", "in", "folder1_dir_list", ":", "cond_print", "(", "'Folder 2 directory \"{}\" has no match in folder 1.'", ".", "format", "(", "folder2_dir", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_SILENT", ")", "raise", "RuntimeError", "(", "'Directory structure is not equal. Aborting.'", ")", "for", "folder1_dir", ",", "folder2_dir", "in", "zip", "(", "folder1_dir_list", ",", "folder2_dir_list", ")", ":", "if", "folder1_dir", "!=", "folder2_dir", ":", "raise", "RuntimeError", "(", "'Directory name not equal: \"{}\" in folder 1, \"{}\" on folder 2. Aborting'", ".", "format", "(", "folder1_dir", ",", "folder2_dir", ")", ")", "cond_print", "(", "'Comparison passed: \"{}\" and \"{}\".'", ".", "format", "(", "folder1_dir", ",", "folder2_dir", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_NORMAL", ")", "# Compare files via name & hash", "if", "len", "(", "folder1_file_list", ")", "!=", "len", "(", "folder2_file_list", ")", ":", "for", "folder1_file", "in", "folder1_file_list", ":", "if", "folder1_file", "not", "in", "folder2_file_list", ":", "print", "(", "'folder1 file \"{}\" has no match on folder2.'", ".", "format", "(", "folder1_file", ")", ")", "for", "folder2_file", "in", "folder2_file_list", ":", "if", "folder2_file", "not", "in", "folder1_file_list", ":", "print", "(", "'folder2 file \"{}\" has no match in folder1.'", ".", "format", "(", "folder2_file", ")", ")", "raise", "RuntimeError", "(", "'File count different. Aborting.'", ")", "for", "folder1_file", ",", "folder2_file", "in", "zip", "(", "folder1_file_list", ",", "folder2_file_list", ")", ":", "if", "folder1_file", "!=", "folder2_file", ":", "raise", "RuntimeError", "(", "'File name not equal: \"{}\" in folder1, \"{}\" on folder2. Aborting'", ".", "format", "(", "folder1_file", ",", "folder2_file", ")", ")", "folder1_file_hash", "=", "get_sha512_hashdigest", "(", "os", ".", "path", ".", "join", "(", "folder1", ",", "folder1_file", ")", ")", "folder2_file_hash", "=", "get_sha512_hashdigest", "(", "os", ".", "path", ".", "join", "(", "folder2", ",", "folder2_file", ")", ")", "if", "folder1_file_hash", "!=", "folder2_file_hash", ":", "raise", "RuntimeError", "(", "'Hash mismatch: \"{}\" for folder 1 file \"{}\", \"{}\" for folder 2 file \"{}\".'", ".", "format", "(", "folder1_file_hash", ",", "folder1_file", ",", "folder2_file_hash", ",", "folder2_file", ")", ")", "cond_print", "(", "'Comparison passed: \"{}\" and \"{}\" [{}].'", ".", "format", "(", "folder1_file", ",", "folder2_file", ",", "folder1_file_hash", ")", ",", "verbosity_level", ">", "VERBOSITY_LEVEL_NORMAL", ")", "return", "True" ]