Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Check", "if", "this", "folder", "contains", "FSL", "install" ]

[ "def", "check_fsl_install", "(", "folder", ")", ":", "from", "os", "import", "path", "fsldir", "=", "'/'", ".", "join", "(", "(", "folder", ",", "'fsl'", ")", ")", "if", "path", ".", "isdir", "(", "fsldir", ")", ":", "return", "True", "return", "False" ]

[ "This", "function", "builds", "a", "dictionary", "of", "links", "going", "the", "other", "way", ".", "I", ".", "e", ".", "if", "given", "a", "dictionary", "of", "start", "to", "end", "links", "it", "will", "return", "a", "dictionary", "of", "end", "to", "start", "links", "." ]

[ "def", "build_reverse_links", "(", "links", ")", ":", "reverse_links", "=", "{", "}", "for", "start", ",", "ends", "in", "links", ".", "items", "(", ")", ":", "for", "end", "in", "ends", ":", "if", "end", "not", "in", "reverse_links", ":", "reverse_links", "[", "end", "]", "=", "[", "]", "reverse_links", "[", "end", "]", ".", "append", "(", "start", ")", "return", "reverse_links" ]

[ "Removes", "multiline", "(", "c", "-", "style", ")", "comments", "from", "lines", "." ]

[ "def", "RemoveMultiLineComments", "(", "filename", ",", "lines", ",", "error", ")", ":", "lineix", "=", "0", "while", "lineix", "<", "len", "(", "lines", ")", ":", "lineix_begin", "=", "FindNextMultiLineCommentStart", "(", "lines", ",", "lineix", ")", "if", "lineix_begin", ">=", "len", "(", "lines", ")", ":", "return", "lineix_end", "=", "FindNextMultiLineCommentEnd", "(", "lines", ",", "lineix_begin", ")", "if", "lineix_end", ">=", "len", "(", "lines", ")", ":", "error", "(", "filename", ",", "lineix_begin", "+", "1", ",", "'readability/multiline_comment'", ",", "5", ",", "'Could not find end of multi-line comment'", ")", "return", "RemoveMultiLineCommentsFromRange", "(", "lines", ",", "lineix_begin", ",", "lineix_end", "+", "1", ")", "lineix", "=", "lineix_end", "+", "1" ]

[ "Validates", "the", "correctness", "of", "algorithm", "parameters", "in", "config" ]

[ "def", "validate_algo_config", "(", "self", ")", ":", "range_estimator_parameters", "=", "{", "'preset'", ":", "None", ",", "'min'", ":", "{", "'type'", ":", "None", ",", "'outlier_prob'", ":", "None", ",", "'granularity'", ":", "None", ",", "'clipping_value'", ":", "None", "}", ",", "'max'", ":", "{", "'type'", ":", "None", ",", "'outlier_prob'", ":", "None", ",", "'granularity'", ":", "None", ",", "'clipping_value'", ":", "None", "}", "}", "weights_params", "=", "{", "'bits'", ":", "None", ",", "'mode'", ":", "None", ",", "'level_low'", ":", "None", ",", "'level_high'", ":", "None", ",", "'granularity'", ":", "None", ",", "'range_estimator'", ":", "range_estimator_parameters", "}", "activations_params", "=", "deepcopy", "(", "weights_params", ")", "activations_params", "[", "'range_estimator'", "]", "[", "'min'", "]", ".", "update", "(", "{", "'aggregator'", ":", "None", "}", ")", "activations_params", "[", "'range_estimator'", "]", "[", "'max'", "]", ".", "update", "(", "{", "'aggregator'", ":", "None", "}", ")", "ignored", "=", "{", "'ignored'", ":", "{", "}", "}", "ignored_content", "=", "{", "'skip_model'", ":", "None", ",", "'scope'", ":", "None", ",", "'operations'", ":", "None", "}", "if", "self", ".", "model", ".", "cascade", ":", "for", "model", "in", "self", ".", "model", ".", "cascade", ":", "ignored", "[", "'ignored'", "]", ".", "update", "(", "{", "model", ".", "name", ":", "ignored_content", "}", ")", "else", ":", "ignored", "[", "'ignored'", "]", "=", "ignored_content", "bias_correction_params", "=", "{", "'stat_subset_size'", ":", "None", ",", "'shuffle_data'", ":", "None", ",", "'seed'", ":", "None", ",", "'apply_for_all_nodes'", ":", "None", ",", "'threshold'", ":", "None", "}", "layerwise_finetuning_params", "=", "{", "'num_samples_for_tuning'", ":", "None", ",", "'batch_size'", ":", "None", ",", "'optimizer'", ":", "None", ",", "'loss'", ":", "None", ",", "'tuning_iterations'", ":", "None", ",", "'random_seed'", ":", "None", ",", "'use_ranking_subset'", ":", "None", ",", "'calibration_indices_pool'", ":", "None", ",", "'calculate_grads_on_loss_increase_only'", ":", "None", ",", "'weight_decay'", ":", "None", "}", "supported_params", "=", "{", "'ActivationChannelAlignment'", ":", "{", "'stat_subset_size'", ":", "None", ",", "'shuffle_data'", ":", "None", ",", "'seed'", ":", "None", "}", ",", "'MinMaxQuantization'", ":", "{", "'preset'", ":", "None", ",", "'stat_subset_size'", ":", "None", ",", "'shuffle_data'", ":", "None", ",", "'seed'", ":", "None", ",", "'range_estimator'", ":", "range_estimator_parameters", ",", "'weights'", ":", "weights_params", ",", "'activations'", ":", "activations_params", ",", "'saturation_fix'", ":", "None", "}", ",", "'FastBiasCorrection'", ":", "bias_correction_params", ",", "'BiasCorrection'", ":", "bias_correction_params", ",", "'DefaultQuantization'", ":", "{", "'use_fast_bias'", ":", "None", ",", "'use_layerwise_tuning'", ":", "None", "}", ",", "'ParamsTuningSearch'", ":", "{", "}", ",", "'DataFreeQuantization'", ":", "{", "'preset'", ":", "None", ",", "'weights'", ":", "weights_params", ",", "'activations'", ":", "activations_params", "}", ",", "'AccuracyAwareQuantization'", ":", "{", "'metric_subset_ratio'", ":", "None", ",", "'ranking_subset_size'", ":", "None", ",", "'max_iter_num'", ":", "None", ",", "'maximal_drop'", ":", "None", ",", "'drop_type'", ":", "None", ",", "'use_prev_if_drop_increase'", ":", "None", ",", "'metrics'", ":", "None", ",", "'base_algorithm'", ":", "'DefaultQuantization'", ",", "'annotation_free'", ":", "None", ",", "'tune_hyperparams'", ":", "None", ",", "'annotation_conf_threshold'", ":", "None", ",", "'convert_to_mixed_preset'", ":", "None", "}", ",", "'RangeOptimization'", ":", "{", "'stat_subset_size'", ":", "None", ",", "'result_filename'", ":", "None", ",", "'maxiter'", ":", "None", ",", "'lower_boxsize'", ":", "None", ",", "'upper_boxsize'", ":", "None", ",", "'zero_boxsize'", ":", "None", ",", "'optimization_scope'", ":", "None", ",", "'activation_ranges_to_set'", ":", "None", ",", "'metric_name'", ":", "None", ",", "'optimizer_name'", ":", "None", ",", "'stochastic'", ":", "None", ",", "'dump_model_prefix'", ":", "None", ",", "'error_function'", ":", "None", ",", "'opt_backend'", ":", "None", ",", "}", ",", "'TunableQuantization'", ":", "{", "'outlier_prob_choices'", ":", "None", "}", ",", "'MagnitudeSparsity'", ":", "{", "'sparsity_level'", ":", "None", ",", "'normed_threshold'", ":", "None", ",", "}", ",", "'BaseWeightSparsity'", ":", "{", "'use_fast_bias'", ":", "None", ",", "}", ",", "'WeightSparsity'", ":", "{", "'use_layerwise_tuning'", ":", "None", ",", "}", ",", "'OverflowCorrection'", ":", "{", "'stat_subset_size'", ":", "None", ",", "'shuffle_data'", ":", "None", ",", "'seed'", ":", "None", ",", "}", ",", "'Ranger'", ":", "{", "'stat_subset_size'", ":", "None", ",", "'shuffle_data'", ":", "None", ",", "'seed'", ":", "None", ",", "}", ",", "}", "# completing supported parameters", "for", "algo_name", "in", "supported_params", ":", "supported_params", "[", "algo_name", "]", ".", "update", "(", "ignored", ")", "for", "algo_name", "in", "[", "'DefaultQuantization'", ",", "'WeightSparsity'", "]", ":", "supported_params", "[", "algo_name", "]", ".", "update", "(", "layerwise_finetuning_params", ")", "for", "algo_name", "in", "[", "'ActivationChannelAlignment'", ",", "'MinMaxQuantization'", ",", "'FastBiasCorrection'", ",", "'BiasCorrection'", "]", ":", "supported_params", "[", "'DefaultQuantization'", "]", ".", "update", "(", "supported_params", "[", "algo_name", "]", ")", "supported_params", "[", "'ParamsTuningSearch'", "]", ".", "update", "(", "supported_params", "[", "algo_name", "]", ")", "for", "algo_name", "in", "[", "'MagnitudeSparsity'", ",", "'FastBiasCorrection'", "]", ":", "supported_params", "[", "'BaseWeightSparsity'", "]", ".", "update", "(", "supported_params", "[", "algo_name", "]", ")", "for", "algo_name", "in", "[", "'BaseWeightSparsity'", "]", ":", "supported_params", "[", "'WeightSparsity'", "]", ".", "update", "(", "supported_params", "[", "algo_name", "]", ")", "supported_params", "[", "'TunableQuantization'", "]", ".", "update", "(", "supported_params", "[", "'MinMaxQuantization'", "]", ")", "# check algorithm parameters", "for", "algo", "in", "self", "[", "'compression'", "]", "[", "'algorithms'", "]", ":", "algo_name", "=", "algo", "[", "'name'", "]", "if", "algo_name", "in", "supported_params", ":", "if", "algo_name", "==", "'AccuracyAwareQuantization'", ":", "backup", "=", "deepcopy", "(", "supported_params", "[", "'AccuracyAwareQuantization'", "]", ")", "base_algo", "=", "supported_params", "[", "'AccuracyAwareQuantization'", "]", "[", "'base_algorithm'", "]", "if", "'base_algorithm'", "in", "algo", "[", "'params'", "]", "and", "algo", "[", "'params'", "]", "[", "'base_algorithm'", "]", "in", "supported_params", ":", "base_algo", "=", "algo", "[", "'params'", "]", "[", "'base_algorithm'", "]", "supported_params", "[", "'AccuracyAwareQuantization'", "]", ".", "update", "(", "supported_params", "[", "base_algo", "]", ")", "check_params", "(", "algo_name", ",", "algo", "[", "'params'", "]", ",", "supported_params", "[", "algo_name", "]", ")", "if", "algo_name", "==", "'AccuracyAwareQuantization'", ":", "supported_params", "[", "'AccuracyAwareQuantization'", "]", "=", "backup" ]

[ "等同于", ":", "func", ":", "bigflow", ".", "transforms", ".", "aggregate", "(", "self", "aggregate_fn", "combine_fn", "*", "side_inputs", "**", "options", ")", "<bigflow", ".", "transforms", ".", "aggregate", ">" ]

[ "def", "aggregate", "(", "self", ",", "zero", ",", "aggregate_fn", ",", "combine_fn", ",", "*", "side_inputs", ",", "*", "*", "options", ")", ":", "return", "transforms", ".", "aggregate", "(", "self", ",", "zero", ",", "aggregate_fn", ",", "combine_fn", ",", "*", "side_inputs", ",", "*", "*", "options", ")" ]

[ "r", "Use", "reg", ".", "exe", "to", "read", "a", "particular", "key", "through", "_RegistryQueryBase", "." ]

[ "def", "_RegistryQuery", "(", "key", ",", "value", "=", "None", ")", ":", "text", "=", "None", "try", ":", "text", "=", "_RegistryQueryBase", "(", "'Sysnative'", ",", "key", ",", "value", ")", "except", "OSError", ",", "e", ":", "if", "e", ".", "errno", "==", "errno", ".", "ENOENT", ":", "text", "=", "_RegistryQueryBase", "(", "'System32'", ",", "key", ",", "value", ")", "else", ":", "raise", "return", "text" ]

[ "t", ".", "open_r", "(", "file", ")", "and", "t", ".", "open_w", "(", "file", ")", "implement", "t", ".", "open", "(", "file", "r", ")", "and", "t", ".", "open", "(", "file", "w", ")", "respectively", "." ]

[ "def", "open_r", "(", "self", ",", "file", ")", ":", "if", "not", "self", ".", "steps", ":", "return", "open", "(", "file", ",", "'r'", ")", "if", "self", ".", "steps", "[", "-", "1", "]", "[", "1", "]", "==", "SINK", ":", "raise", "ValueError", ",", "'Template.open_r: pipeline ends width SINK'", "cmd", "=", "self", ".", "makepipeline", "(", "file", ",", "''", ")", "return", "os", ".", "popen", "(", "cmd", ",", "'r'", ")" ]

[ "Return", "statistics", "for", "the", "last", "check", "." ]

[ "def", "statistics", "(", "self", ")", ":", "return", "Statistics", "(", "Z3_optimize_get_statistics", "(", "self", ".", "ctx", ".", "ref", "(", ")", ",", "self", ".", "optimize", ")", ",", "self", ".", "ctx", ")" ]

[ "Returns", "opaque", "params", "size", "for", "specific", "Cudnn", "config", "." ]

[ "def", "cudnn_rnn_opaque_params_size", "(", "rnn_mode", ",", "num_layers", ",", "num_units", ",", "input_size", ",", "input_mode", "=", "CUDNN_INPUT_LINEAR_MODE", ",", "direction", "=", "CUDNN_RNN_UNIDIRECTION", ",", "dtype", "=", "dtypes", ".", "float32", ",", "dropout", "=", "0", ",", "seed", "=", "0", ",", "num_proj", "=", "None", ",", "name", "=", "None", ")", ":", "_check_rnn_mode", "(", "rnn_mode", ")", "check_direction", "(", "direction", ")", "check_input_mode", "(", "input_mode", ")", "seed", ",", "seed2", "=", "random_seed", ".", "get_seed", "(", "seed", ")", "return", "gen_cudnn_rnn_ops", ".", "cudnn_rnn_params_size", "(", "rnn_mode", "=", "rnn_mode", ",", "num_layers", "=", "num_layers", ",", "num_units", "=", "num_units", ",", "input_size", "=", "input_size", ",", "num_proj", "=", "num_proj", ",", "T", "=", "dtype", ",", "S", "=", "dtypes", ".", "int32", ",", "dropout", "=", "dropout", ",", "seed", "=", "seed", ",", "seed2", "=", "seed2", ",", "input_mode", "=", "input_mode", ",", "direction", "=", "direction", ",", "name", "=", "name", ")", "[", "0", "]" ]

[ "SetPropertyHelpString", "(", "self", "PGPropArg", "id", "String", "helpString", ")" ]

[ "def", "SetPropertyHelpString", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridInterface_SetPropertyHelpString", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Round", "down", "unless", "digit", "prec", "-", "1", "is", "0", "or", "5", "." ]

[ "def", "_round_05up", "(", "self", ",", "prec", ")", ":", "if", "prec", "and", "self", ".", "_int", "[", "prec", "-", "1", "]", "not", "in", "'05'", ":", "return", "self", ".", "_round_down", "(", "prec", ")", "else", ":", "return", "-", "self", ".", "_round_down", "(", "prec", ")" ]

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

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

[ "Lists", "the", "Availability", "Zones", "that", "have", "available", "AWS", "CloudHSM", "capacity", "." ]

[ "def", "list_available_zones", "(", "self", ")", ":", "params", "=", "{", "}", "return", "self", ".", "make_request", "(", "action", "=", "'ListAvailableZones'", ",", "body", "=", "json", ".", "dumps", "(", "params", ")", ")" ]

[ "For", "all", "signature", "files", "create", "a", "single", "windows", "def", "file", "." ]

[ "def", "CreateWindowsDefForSigFiles", "(", "sig_files", ",", "out_dir", ",", "module_name", ")", ":", "signatures", "=", "[", "]", "for", "input_path", "in", "sig_files", ":", "infile", "=", "open", "(", "input_path", ",", "'r'", ")", "try", ":", "signatures", "+=", "ParseSignatures", "(", "infile", ")", "finally", ":", "infile", ".", "close", "(", ")", "def_file_path", "=", "os", ".", "path", ".", "join", "(", "out_dir", ",", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "module_name", ")", ")", "[", "0", "]", "+", "'.def'", ")", "outfile", "=", "open", "(", "def_file_path", ",", "'w'", ")", "try", ":", "WriteWindowsDefFile", "(", "module_name", ",", "signatures", ",", "outfile", ")", "finally", ":", "outfile", ".", "close", "(", ")" ]

[ "Set", "the", "mean", "to", "subtract", "for", "centering", "the", "data", "." ]

[ "def", "set_mean", "(", "self", ",", "in_", ",", "mean", ")", ":", "self", ".", "__check_input", "(", "in_", ")", "ms", "=", "mean", ".", "shape", "if", "mean", ".", "ndim", "==", "1", ":", "# broadcast channels", "if", "ms", "[", "0", "]", "!=", "self", ".", "inputs", "[", "in_", "]", "[", "1", "]", ":", "raise", "ValueError", "(", "'Mean channels incompatible with input.'", ")", "mean", "=", "mean", "[", ":", ",", "np", ".", "newaxis", ",", "np", ".", "newaxis", "]", "else", ":", "# elementwise mean", "if", "len", "(", "ms", ")", "==", "2", ":", "ms", "=", "(", "1", ",", ")", "+", "ms", "if", "len", "(", "ms", ")", "!=", "3", ":", "raise", "ValueError", "(", "'Mean shape invalid'", ")", "if", "ms", "!=", "self", ".", "inputs", "[", "in_", "]", "[", "1", ":", "]", ":", "raise", "ValueError", "(", "'Mean shape incompatible with input shape.'", ")", "self", ".", "mean", "[", "in_", "]", "=", "mean" ]

[ "If", "a", "cell", "imports", "matplotlib", "split", "the", "cell", "to", "keep", "the", "import", "statement", "separate", "from", "the", "code", "that", "uses", "matplotlib", ".", "This", "prevents", "a", "known", "bug", "in", "the", "Jupyter", "backend", "which", "causes", "the", "plot", "object", "to", "be", "represented", "as", "a", "string", "instead", "of", "a", "canvas", "when", "created", "in", "the", "cell", "where", "matplotlib", "is", "imported", "for", "the", "first", "time", "(", "https", ":", "//", "github", ".", "com", "/", "jupyter", "/", "notebook", "/", "issues", "/", "3523", ")", "." ]

[ "def", "split_matplotlib_cells", "(", "nb", ")", ":", "for", "i", "in", "range", "(", "len", "(", "nb", "[", "'cells'", "]", ")", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "cell", "=", "nb", "[", "'cells'", "]", "[", "i", "]", "if", "cell", "[", "'cell_type'", "]", "==", "'code'", "and", "'matplotlib'", "in", "cell", "[", "'source'", "]", ":", "code", "=", "iw", ".", "protect_ipython_magics", "(", "cell", "[", "'source'", "]", ")", "# split cells after matplotlib imports", "mapping", "=", "iw", ".", "delimit_statements", "(", "code", ")", "tree", "=", "ast", ".", "parse", "(", "code", ")", "visitor", "=", "iw", ".", "GetMatplotlibPyplot", "(", ")", "visitor", ".", "visit", "(", "tree", ")", "if", "visitor", ".", "matplotlib_first", ":", "code", "=", "iw", ".", "deprotect_ipython_magics", "(", "code", ")", "lines", "=", "code", ".", "split", "(", "'\\n'", ")", "lineno_end", "=", "mapping", "[", "visitor", ".", "matplotlib_first", "]", "split_code", "=", "'\\n'", ".", "join", "(", "lines", "[", "lineno_end", ":", "]", ")", ".", "lstrip", "(", "'\\n'", ")", "if", "split_code", ":", "new_cell", "=", "nbformat", ".", "v4", ".", "new_code_cell", "(", "source", "=", "split_code", ")", "nb", "[", "'cells'", "]", ".", "insert", "(", "i", "+", "1", ",", "new_cell", ")", "lines", "=", "lines", "[", ":", "lineno_end", "]", "nb", "[", "'cells'", "]", "[", "i", "]", "[", "'source'", "]", "=", "'\\n'", ".", "join", "(", "lines", ")", ".", "rstrip", "(", "'\\n'", ")" ]

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

[ "def", "WriteImmediateCmdSetHeader", "(", "self", ",", "func", ",", "file", ")", ":", "file", ".", "Write", "(", "\" void SetHeader(GLsizei count) {\\n\"", ")", "file", ".", "Write", "(", "\" header.SetCmdByTotalSize<ValueType>(ComputeSize(count));\\n\"", ")", "file", ".", "Write", "(", "\" }\\n\"", ")", "file", ".", "Write", "(", "\"\\n\"", ")" ]

[ "By", "default", "libxml", "submits", "HTTP", "output", "requests", "using", "the", "PUT", "method", ".", "Calling", "this", "method", "changes", "the", "HTTP", "output", "method", "to", "use", "the", "POST", "method", "instead", "." ]

[ "def", "registerHTTPPostCallbacks", "(", ")", ":", "libxml2mod", ".", "xmlRegisterHTTPPostCallbacks", "(", ")" ]

[ "Determine", "the", "boundedness", "of", "a", "single", "row", "with", "topdown", "metrics" ]

[ "def", "determine_boundedness", "(", "row", ")", ":", "boundedness", "=", "[", "]", "level_1", "=", "max_column", "(", "row", ",", "[", "'retiring'", ",", "'bad_speculation'", ",", "'frontend_bound'", ",", "'backend_bound'", "]", ")", "if", "str", "(", "row", "[", "level_1", "]", ")", "!=", "'nan'", "and", "str", "(", "row", "[", "level_1", "]", ")", "!=", "'inf'", ":", "boundedness", ".", "append", "(", "level_1", "+", "' '", "+", "percentage_string", "(", "row", "[", "level_1", "]", ")", ")", "if", "level_1", "==", "'bad_speculation'", ":", "level_2", "=", "max_column", "(", "row", ",", "[", "'branch_mispredict'", ",", "'machine_clear'", "]", ")", "boundedness", ".", "append", "(", "level_2", "+", "' '", "+", "percentage_string", "(", "row", "[", "level_2", "]", ")", ")", "elif", "level_1", "==", "'frontend_bound'", ":", "level_2", "=", "max_column", "(", "row", ",", "[", "'frontend_latency'", ",", "'frontend_bandwidth'", "]", ")", "boundedness", ".", "append", "(", "level_2", "+", "' '", "+", "percentage_string", "(", "row", "[", "level_2", "]", ")", ")", "elif", "level_1", "==", "'backend_bound'", ":", "level_2", "=", "max_column", "(", "row", ",", "[", "'core_bound'", ",", "'memory_bound'", "]", ")", "boundedness", ".", "append", "(", "level_2", "+", "' '", "+", "percentage_string", "(", "row", "[", "level_2", "]", ")", ")", "if", "level_2", "==", "'memory_bound'", ":", "level_3", "=", "max_column", "(", "row", ",", "[", "'l1_bound'", ",", "'l2_bound'", ",", "'l3_bound'", ",", "'mem_bound'", ",", "'uncore_bound'", "]", ")", "boundedness", ".", "append", "(", "level_3", "+", "' '", "+", "percentage_string", "(", "row", "[", "level_3", "]", ")", ")", "if", "len", "(", "boundedness", ")", "==", "0", ":", "boundedness", ".", "append", "(", "'undetermined'", ")", "return", "boundedness" ]

[ "Return", "the", "database", "of", "ground", "-", "truth", "regions", "of", "interest", "." ]

[ "def", "gt_roidb", "(", "self", ")", ":", "cache_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "cache_path", ",", "self", ".", "name", "+", "'_gt_roidb.pkl'", ")", "if", "os", ".", "path", ".", "exists", "(", "cache_file", ")", ":", "with", "open", "(", "cache_file", ",", "'rb'", ")", "as", "fid", ":", "roidb", "=", "cPickle", ".", "load", "(", "fid", ")", "print", "'{} gt roidb loaded from {}'", ".", "format", "(", "self", ".", "name", ",", "cache_file", ")", "return", "roidb", "gt_roidb", "=", "[", "self", ".", "_load_rgbd_scene_annotation", "(", "index", ")", "for", "index", "in", "self", ".", "image_index", "]", "with", "open", "(", "cache_file", ",", "'wb'", ")", "as", "fid", ":", "cPickle", ".", "dump", "(", "gt_roidb", ",", "fid", ",", "cPickle", ".", "HIGHEST_PROTOCOL", ")", "print", "'wrote gt roidb to {}'", ".", "format", "(", "cache_file", ")", "return", "gt_roidb" ]

[ "Adds", "a", "Sum", "-", "of", "-", "Squares", "loss", "to", "the", "training", "procedure", "." ]

[ "def", "mean_squared_error", "(", "labels", ",", "predictions", ",", "weights", "=", "1.0", ",", "scope", "=", "None", ",", "loss_collection", "=", "ops", ".", "GraphKeys", ".", "LOSSES", ",", "reduction", "=", "Reduction", ".", "SUM_BY_NONZERO_WEIGHTS", ")", ":", "if", "labels", "is", "None", ":", "raise", "ValueError", "(", "\"labels must not be None.\"", ")", "if", "predictions", "is", "None", ":", "raise", "ValueError", "(", "\"predictions must not be None.\"", ")", "with", "ops", ".", "name_scope", "(", "scope", ",", "\"mean_squared_error\"", ",", "(", "predictions", ",", "labels", ",", "weights", ")", ")", "as", "scope", ":", "predictions", "=", "math_ops", ".", "to_float", "(", "predictions", ")", "labels", "=", "math_ops", ".", "to_float", "(", "labels", ")", "predictions", ".", "get_shape", "(", ")", ".", "assert_is_compatible_with", "(", "labels", ".", "get_shape", "(", ")", ")", "losses", "=", "math_ops", ".", "squared_difference", "(", "predictions", ",", "labels", ")", "return", "compute_weighted_loss", "(", "losses", ",", "weights", ",", "scope", ",", "loss_collection", ",", "reduction", "=", "reduction", ")" ]

[ "Return", "a", "subprocess", "object", "producing", "the", "diff", "from", "commit", "." ]

[ "def", "compute_diff", "(", "commit", ",", "files", ")", ":", "cmd", "=", "[", "'git'", ",", "'diff-index'", ",", "'-p'", ",", "'-U0'", ",", "commit", ",", "'--'", "]", "cmd", ".", "extend", "(", "files", ")", "p", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "stdin", "=", "subprocess", ".", "PIPE", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "encoding", "=", "'utf8'", ")", "p", ".", "stdin", ".", "close", "(", ")", "return", "p" ]

[ "Get", "the", "size", "of", "a", "Finder", "window", "for", "folder", "Specify", "by", "path", "." ]

[ "def", "_getwindowposition", "(", "folder_alias", ")", ":", "finder", "=", "_getfinder", "(", ")", "args", "=", "{", "}", "attrs", "=", "{", "}", "aeobj_0", "=", "aetypes", ".", "ObjectSpecifier", "(", "want", "=", "aetypes", ".", "Type", "(", "'cfol'", ")", ",", "form", "=", "\"alis\"", ",", "seld", "=", "folder_alias", ",", "fr", "=", "None", ")", "aeobj_1", "=", "aetypes", ".", "ObjectSpecifier", "(", "want", "=", "aetypes", ".", "Type", "(", "'prop'", ")", ",", "form", "=", "\"prop\"", ",", "seld", "=", "aetypes", ".", "Type", "(", "'cwnd'", ")", ",", "fr", "=", "aeobj_0", ")", "aeobj_2", "=", "aetypes", ".", "ObjectSpecifier", "(", "want", "=", "aetypes", ".", "Type", "(", "'prop'", ")", ",", "form", "=", "\"prop\"", ",", "seld", "=", "aetypes", ".", "Type", "(", "'ptsz'", ")", ",", "fr", "=", "aeobj_1", ")", "args", "[", "'----'", "]", "=", "aeobj_2", "_reply", ",", "args", ",", "attrs", "=", "finder", ".", "send", "(", "'core'", ",", "'getd'", ",", "args", ",", "attrs", ")", "if", "'errn'", "in", "args", ":", "raise", "Error", ",", "aetools", ".", "decodeerror", "(", "args", ")", "if", "'----'", "in", "args", ":", "return", "args", "[", "'----'", "]" ]

[ "Loads", "MegEngine", "serialized", "object", "from", "the", "given", "URL", "." ]

[ "def", "load_serialized_obj_from_url", "(", "url", ":", "str", ",", "model_dir", "=", "None", ")", "->", "Any", ":", "if", "model_dir", "is", "None", ":", "model_dir", "=", "os", ".", "path", ".", "join", "(", "_get_megengine_home", "(", ")", ",", "\"serialized\"", ")", "os", ".", "makedirs", "(", "model_dir", ",", "exist_ok", "=", "True", ")", "parts", "=", "urlparse", "(", "url", ")", "filename", "=", "os", ".", "path", ".", "basename", "(", "parts", ".", "path", ")", "# use hash as prefix to avoid filename conflict from different urls", "sha256", "=", "hashlib", ".", "sha256", "(", ")", "sha256", ".", "update", "(", "url", ".", "encode", "(", ")", ")", "digest", "=", "sha256", ".", "hexdigest", "(", ")", "[", ":", "6", "]", "filename", "=", "digest", "+", "\"_\"", "+", "filename", "cached_file", "=", "os", ".", "path", ".", "join", "(", "model_dir", ",", "filename", ")", "logger", ".", "info", "(", "\"load_serialized_obj_from_url: download to or using cached %s\"", ",", "cached_file", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "cached_file", ")", ":", "if", "is_distributed", "(", ")", ":", "logger", ".", "warning", "(", "\"Downloading serialized object in DISTRIBUTED mode\\n\"", "\" File may be downloaded multiple times. We recommend\\n\"", "\" users to download in single process first.\"", ")", "download_from_url", "(", "url", ",", "cached_file", ")", "state_dict", "=", "_mge_load_serialized", "(", "cached_file", ")", "return", "state_dict" ]

[ "We", "are", "inside", "a", "comment", "find", "the", "end", "marker", "." ]

[ "def", "FindNextMultiLineCommentEnd", "(", "lines", ",", "lineix", ")", ":", "while", "lineix", "<", "len", "(", "lines", ")", ":", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "endswith", "(", "'*/'", ")", ":", "return", "lineix", "lineix", "+=", "1", "return", "len", "(", "lines", ")" ]

[ "Overload", "method", "triggered", "when", "we", "detect", "a", "compressed", "tiff", "Calls", "out", "to", "libtiff" ]

[ "def", "_load_libtiff", "(", "self", ")", ":", "pixel", "=", "Image", ".", "Image", ".", "load", "(", "self", ")", "if", "self", ".", "tile", "is", "None", ":", "raise", "OSError", "(", "\"cannot load this image\"", ")", "if", "not", "self", ".", "tile", ":", "return", "pixel", "self", ".", "load_prepare", "(", ")", "if", "not", "len", "(", "self", ".", "tile", ")", "==", "1", ":", "raise", "OSError", "(", "\"Not exactly one tile\"", ")", "# (self._compression, (extents tuple),", "# 0, (rawmode, self._compression, fp))", "extents", "=", "self", ".", "tile", "[", "0", "]", "[", "1", "]", "args", "=", "list", "(", "self", ".", "tile", "[", "0", "]", "[", "3", "]", ")", "# To be nice on memory footprint, if there's a", "# file descriptor, use that instead of reading", "# into a string in python.", "# libtiff closes the file descriptor, so pass in a dup.", "try", ":", "fp", "=", "hasattr", "(", "self", ".", "fp", ",", "\"fileno\"", ")", "and", "os", ".", "dup", "(", "self", ".", "fp", ".", "fileno", "(", ")", ")", "# flush the file descriptor, prevents error on pypy 2.4+", "# should also eliminate the need for fp.tell", "# in _seek", "if", "hasattr", "(", "self", ".", "fp", ",", "\"flush\"", ")", ":", "self", ".", "fp", ".", "flush", "(", ")", "except", "OSError", ":", "# io.BytesIO have a fileno, but returns an IOError if", "# it doesn't use a file descriptor.", "fp", "=", "False", "if", "fp", ":", "args", "[", "2", "]", "=", "fp", "decoder", "=", "Image", ".", "_getdecoder", "(", "self", ".", "mode", ",", "\"libtiff\"", ",", "tuple", "(", "args", ")", ",", "self", ".", "decoderconfig", ")", "try", ":", "decoder", ".", "setimage", "(", "self", ".", "im", ",", "extents", ")", "except", "ValueError", ":", "raise", "OSError", "(", "\"Couldn't set the image\"", ")", "close_self_fp", "=", "self", ".", "_exclusive_fp", "and", "not", "self", ".", "_is_animated", "if", "hasattr", "(", "self", ".", "fp", ",", "\"getvalue\"", ")", ":", "# We've got a stringio like thing passed in. Yay for all in memory.", "# The decoder needs the entire file in one shot, so there's not", "# a lot we can do here other than give it the entire file.", "# unless we could do something like get the address of the", "# underlying string for stringio.", "#", "# Rearranging for supporting byteio items, since they have a fileno", "# that returns an IOError if there's no underlying fp. Easier to", "# deal with here by reordering.", "if", "DEBUG", ":", "print", "(", "\"have getvalue. just sending in a string from getvalue\"", ")", "n", ",", "err", "=", "decoder", ".", "decode", "(", "self", ".", "fp", ".", "getvalue", "(", ")", ")", "elif", "fp", ":", "# we've got a actual file on disk, pass in the fp.", "if", "DEBUG", ":", "print", "(", "\"have fileno, calling fileno version of the decoder.\"", ")", "if", "not", "close_self_fp", ":", "self", ".", "fp", ".", "seek", "(", "0", ")", "# 4 bytes, otherwise the trace might error out", "n", ",", "err", "=", "decoder", ".", "decode", "(", "b\"fpfp\"", ")", "else", ":", "# we have something else.", "if", "DEBUG", ":", "print", "(", "\"don't have fileno or getvalue. just reading\"", ")", "self", ".", "fp", ".", "seek", "(", "0", ")", "# UNDONE -- so much for that buffer size thing.", "n", ",", "err", "=", "decoder", ".", "decode", "(", "self", ".", "fp", ".", "read", "(", ")", ")", "self", ".", "tile", "=", "[", "]", "self", ".", "readonly", "=", "0", "self", ".", "load_end", "(", ")", "# libtiff closed the fp in a, we need to close self.fp, if possible", "if", "close_self_fp", ":", "self", ".", "fp", ".", "close", "(", ")", "self", ".", "fp", "=", "None", "# might be shared", "if", "err", "<", "0", ":", "raise", "OSError", "(", "err", ")", "return", "Image", ".", "Image", ".", "load", "(", "self", ")" ]

[ "SetVerticalAlignment", "(", "self", "int", "verticalAlignment", ")" ]

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

[ "A", "utility", "function", "which", "prompts", "the", "user", "to", "press", "the", "enter", "key", "so", "that", "the", "exploration", "session", "can", "shift", "back", "to", "the", "enclosing", "type", ".", "Useful", "when", "exploring", "types", "." ]

[ "def", "return_to_enclosing_type_prompt", "(", ")", ":", "raw_input", "(", "\"\\nPress enter to return to enclosing type: \"", ")" ]

[ "reconstruct", "labels", "from", "observed", "group", "ids" ]

[ "def", "decons_obs_group_ids", "(", "comp_ids", ",", "obs_ids", ",", "shape", ",", "labels", ",", "xnull", ")", ":", "if", "not", "xnull", ":", "lift", "=", "np", ".", "fromiter", "(", "(", "(", "a", "==", "-", "1", ")", ".", "any", "(", ")", "for", "a", "in", "labels", ")", ",", "dtype", "=", "'i8'", ")", "shape", "=", "np", ".", "asarray", "(", "shape", ",", "dtype", "=", "'i8'", ")", "+", "lift", "if", "not", "is_int64_overflow_possible", "(", "shape", ")", ":", "# obs ids are deconstructable! take the fast route!", "out", "=", "decons_group_index", "(", "obs_ids", ",", "shape", ")", "return", "out", "if", "xnull", "or", "not", "lift", ".", "any", "(", ")", "else", "[", "x", "-", "y", "for", "x", ",", "y", "in", "zip", "(", "out", ",", "lift", ")", "]", "i", "=", "unique_label_indices", "(", "comp_ids", ")", "i8copy", "=", "lambda", "a", ":", "a", ".", "astype", "(", "'i8'", ",", "subok", "=", "False", ",", "copy", "=", "True", ")", "return", "[", "i8copy", "(", "lab", "[", "i", "]", ")", "for", "lab", "in", "labels", "]" ]

[ "Abstract", "method", "to", "loop", "over", "some", "data", "in", "batches", "." ]

[ "def", "_test_loop", "(", "self", ",", "f", ",", "ins", ",", "batch_size", "=", "None", ",", "verbose", "=", "0", ",", "steps", "=", "None", ")", ":", "num_samples", "=", "self", ".", "_check_num_samples", "(", "ins", ",", "batch_size", ",", "steps", ",", "'steps'", ")", "outs", "=", "[", "]", "if", "steps", "is", "not", "None", ":", "if", "verbose", "==", "1", ":", "progbar", "=", "Progbar", "(", "target", "=", "steps", ")", "for", "step", "in", "range", "(", "steps", ")", ":", "batch_outs", "=", "f", "(", "ins", ")", "if", "isinstance", "(", "batch_outs", ",", "list", ")", ":", "if", "step", "==", "0", ":", "for", "_", "in", "enumerate", "(", "batch_outs", ")", ":", "outs", ".", "append", "(", "0.", ")", "for", "i", ",", "batch_out", "in", "enumerate", "(", "batch_outs", ")", ":", "outs", "[", "i", "]", "+=", "batch_out", "else", ":", "if", "step", "==", "0", ":", "outs", ".", "append", "(", "0.", ")", "outs", "[", "0", "]", "+=", "batch_outs", "if", "verbose", "==", "1", ":", "progbar", ".", "update", "(", "step", ")", "for", "i", "in", "range", "(", "len", "(", "outs", ")", ")", ":", "outs", "[", "i", "]", "/=", "steps", "else", ":", "if", "verbose", "==", "1", ":", "progbar", "=", "Progbar", "(", "target", "=", "num_samples", ")", "batches", "=", "_make_batches", "(", "num_samples", ",", "batch_size", ")", "index_array", "=", "np", ".", "arange", "(", "num_samples", ")", "for", "batch_index", ",", "(", "batch_start", ",", "batch_end", ")", "in", "enumerate", "(", "batches", ")", ":", "batch_ids", "=", "index_array", "[", "batch_start", ":", "batch_end", "]", "if", "isinstance", "(", "ins", "[", "-", "1", "]", ",", "float", ")", ":", "# Do not slice the training phase flag.", "ins_batch", "=", "_slice_arrays", "(", "ins", "[", ":", "-", "1", "]", ",", "batch_ids", ")", "+", "[", "ins", "[", "-", "1", "]", "]", "else", ":", "ins_batch", "=", "_slice_arrays", "(", "ins", ",", "batch_ids", ")", "batch_outs", "=", "f", "(", "ins_batch", ")", "if", "isinstance", "(", "batch_outs", ",", "list", ")", ":", "if", "batch_index", "==", "0", ":", "for", "batch_out", "in", "enumerate", "(", "batch_outs", ")", ":", "outs", ".", "append", "(", "0.", ")", "for", "i", ",", "batch_out", "in", "enumerate", "(", "batch_outs", ")", ":", "outs", "[", "i", "]", "+=", "batch_out", "*", "len", "(", "batch_ids", ")", "else", ":", "if", "batch_index", "==", "0", ":", "outs", ".", "append", "(", "0.", ")", "outs", "[", "0", "]", "+=", "batch_outs", "*", "len", "(", "batch_ids", ")", "if", "verbose", "==", "1", ":", "progbar", ".", "update", "(", "batch_end", ")", "for", "i", "in", "range", "(", "len", "(", "outs", ")", ")", ":", "outs", "[", "i", "]", "/=", "num_samples", "if", "len", "(", "outs", ")", "==", "1", ":", "return", "outs", "[", "0", "]", "return", "outs" ]

[ "Return", "the", "obj_id", "of", "the", "first", "unit", "in", "the", "line", "." ]

[ "def", "get_head_unit_id", "(", "self", ")", ":", "head_unit", "=", "self", ".", "get_head_unit", "(", ")", "return", "head_unit", "[", "\"id0\"", "]", ".", "get_value", "(", ")" ]

[ "Validates", "that", "default", "values", "for", "definitions", "are", "of", "the", "property", "type", ".", "Enforces", "presence", "of", "type", "in", "case", "of", "default", "presence", "." ]

[ "def", "validate_property_default", "(", "property_spec", ",", "deref", ")", ":", "deref_property_spec", "=", "deref", "(", "property_spec", ")", "if", "'default'", "in", "deref_property_spec", ":", "if", "deref_property_spec", "[", "'default'", "]", "is", "None", "and", "deref_property_spec", ".", "get", "(", "'x-nullable'", ",", "False", ")", "is", "True", ":", "# In case x-nullable property is set to true, null is a valid default", "return", "validate_value_type", "(", "schema", "=", "property_spec", ",", "value", "=", "deref_property_spec", "[", "'default'", "]", ",", "deref", "=", "deref", ")" ]

[ "Checks", "whether", "a", "type", "is", "a", "scalar", "type", ".", "A", "type", "is", "a", "scalar", "type", "of", "its", "type", "is", "gdb", ".", "TYPE_CODE_CHAR", "or", "gdb", ".", "TYPE_CODE_INT", "or", "gdb", ".", "TYPE_CODE_BOOL", "or", "gdb", ".", "TYPE_CODE_FLT", "or", "gdb", ".", "TYPE_CODE_VOID", "or", "gdb", ".", "TYPE_CODE_ENUM", "." ]

[ "def", "is_scalar_type", "(", "type", ")", ":", "return", "type", ".", "code", "in", "Explorer", ".", "_SCALAR_TYPE_LIST" ]

[ "Applies", "sparse", "assignment", "to", "individual", "values", "or", "slices", "in", "a", "Variable", "." ]

[ "def", "scatter_nd_update", "(", "self", ",", "indices", ",", "updates", ",", "name", "=", "None", ")", ":", "return", "self", ".", "_lazy_read", "(", "gen_state_ops", ".", "resource_scatter_nd_update", "(", "self", ".", "handle", ",", "indices", ",", "ops", ".", "convert_to_tensor", "(", "updates", ",", "self", ".", "dtype", ")", ",", "name", "=", "name", ")", ")" ]

[ "IsDeleted", "(", "TNEANetAFltI", "self", ")", "-", ">", "bool" ]

[ "def", "IsDeleted", "(", "self", ")", ":", "return", "_snap", ".", "TNEANetAFltI_IsDeleted", "(", "self", ")" ]

[ "Get", "a", "list", "of", "files", "to", "check", "from", "the", "working", "tree", "." ]

[ "def", "get_files_to_check_working_tree", "(", "filter_function", ")", ":", "# type: (Callable[[str], bool]) -> List[str]", "repos", "=", "get_repos", "(", ")", "valid_files", "=", "list", "(", "itertools", ".", "chain", ".", "from_iterable", "(", "[", "r", ".", "get_working_tree_candidates", "(", "filter_function", ")", "for", "r", "in", "repos", "]", ")", ")", "return", "valid_files" ]

[ "This", "function", "is", "the", "inverse", "of", ":", "func", ":", "itertools", ".", "accumulate", ".", "By", "default", "it", "will", "compute", "the", "first", "difference", "of", "*", "iterable", "*", "using", ":", "func", ":", "operator", ".", "sub", ":" ]

[ "def", "difference", "(", "iterable", ",", "func", "=", "sub", ",", "*", ",", "initial", "=", "None", ")", ":", "a", ",", "b", "=", "tee", "(", "iterable", ")", "try", ":", "first", "=", "[", "next", "(", "b", ")", "]", "except", "StopIteration", ":", "return", "iter", "(", "[", "]", ")", "if", "initial", "is", "not", "None", ":", "first", "=", "[", "]", "return", "chain", "(", "first", ",", "starmap", "(", "func", ",", "zip", "(", "b", ",", "a", ")", ")", ")" ]

[ "Returns", "the", "offsetof", "the", "FIELD_DECL", "pointed", "by", "this", "Cursor", "." ]

[ "def", "get_field_offsetof", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_Cursor_getOffsetOfField", "(", "self", ")" ]

[ "Reports", "if", "the", "app", "is", "running", "in", "the", "first", "generation", "sandbox", "." ]

[ "def", "is_appengine_sandbox", "(", ")", ":", "return", "is_appengine", "(", ")", "and", "os", ".", "environ", "[", "\"APPENGINE_RUNTIME\"", "]", "==", "\"python27\"" ]

[ "input_variable", "(", "shape", "dtype", "=", "np", ".", "float32", "needs_gradient", "=", "False", "is_sparse", "=", "False", "sequence_axis", "=", "Axis", ".", "default_dynamic_axis", "()", "name", "=", ")" ]

[ "def", "input_variable", "(", "shape", ",", "dtype", "=", "default_override_or", "(", "np", ".", "float32", ")", ",", "needs_gradient", "=", "False", ",", "is_sparse", "=", "False", ",", "sequence_axis", "=", "Axis", ".", "default_dynamic_axis", "(", ")", ",", "name", "=", "''", ")", ":", "from", ".", ".", ".", "import", "input_variable", "return", "input_variable", "(", "shape", "=", "shape", ",", "dtype", "=", "dtype", ",", "needs_gradient", "=", "needs_gradient", ",", "is_sparse", "=", "is_sparse", ",", "dynamic_axes", "=", "[", "Axis", ".", "default_batch_axis", "(", ")", ",", "sequence_axis", "]", ",", "name", "=", "name", ")" ]

[ "Returns", "predictions", "for", "given", "features", "." ]

[ "def", "predict", "(", "self", ",", "x", "=", "None", ",", "input_fn", "=", "None", ",", "batch_size", "=", "None", ",", "outputs", "=", "None", ",", "as_iterable", "=", "True", ")", ":", "if", "not", "outputs", ":", "return", "self", ".", "predict_scores", "(", "x", "=", "x", ",", "input_fn", "=", "input_fn", ",", "batch_size", "=", "batch_size", ",", "as_iterable", "=", "as_iterable", ")", "return", "super", "(", "DNNRegressor", ",", "self", ")", ".", "predict", "(", "x", "=", "x", ",", "input_fn", "=", "input_fn", ",", "batch_size", "=", "batch_size", ",", "outputs", "=", "outputs", ",", "as_iterable", "=", "as_iterable", ")" ]

[ "Attempts", "to", "find", "an", "executable", "in", "the", "path" ]

[ "def", "find_in_path", "(", "file", ",", "path", "=", "None", ")", ":", "if", "platform", ".", "system", "(", ")", "==", "'Windows'", ":", "file", "+=", "'.exe'", "if", "path", "is", "None", ":", "path", "=", "os", ".", "environ", ".", "get", "(", "'PATH'", ",", "''", ")", "if", "type", "(", "path", ")", "is", "type", "(", "''", ")", ":", "path", "=", "path", ".", "split", "(", "os", ".", "pathsep", ")", "return", "list", "(", "filter", "(", "os", ".", "path", ".", "exists", ",", "map", "(", "lambda", "dir", ",", "file", "=", "file", ":", "os", ".", "path", ".", "join", "(", "dir", ",", "file", ")", ",", "path", ")", ")", ")" ]

[ "Test", "if", "this", "is", "an", "expression", "kind", "." ]

[ "def", "is_expression", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_isExpression", "(", "self", ")" ]

[ "Entry", "point", "." ]

[ "def", "main", "(", "filenames", ",", "add_if_missing", ")", ":", "errors", "=", "[", "]", "for", "filename", "in", "filenames", ":", "if", "os", ".", "path", ".", "isdir", "(", "filename", ")", ":", "continue", "checker", "=", "File", ".", "parse", "(", "filename", ")", "if", "not", "checker", ":", "# TODO: Consider printing a warning here in verbose mode.", "continue", "if", "not", "checker", ".", "check_license_header", "(", ")", ":", "errors", ".", "extend", "(", "checker", ".", "errors", ")", "if", "add_if_missing", "and", "not", "checker", ".", "has_license_header", "(", ")", ":", "checker", ".", "add_license_header", "(", ")", "for", "err", "in", "errors", ":", "print", "(", "err", ")", "return", "len", "(", "errors", ")" ]

[ "SetActiveChild", "(", "self", "AuiMDIChildFrame", "pChildFrame", ")" ]

[ "def", "SetActiveChild", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiMDIClientWindow_SetActiveChild", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Predict", "for", "a", "2", "-", "D", "numpy", "matrix", "." ]

[ "def", "__pred_for_np2d", "(", "self", ",", "mat", ",", "num_iteration", ",", "predict_type", ")", ":", "if", "len", "(", "mat", ".", "shape", ")", "!=", "2", ":", "raise", "ValueError", "(", "'Input numpy.ndarray or list must be 2 dimensional'", ")", "if", "mat", ".", "dtype", "==", "np", ".", "float32", "or", "mat", ".", "dtype", "==", "np", ".", "float64", ":", "data", "=", "np", ".", "array", "(", "mat", ".", "reshape", "(", "mat", ".", "size", ")", ",", "dtype", "=", "mat", ".", "dtype", ",", "copy", "=", "False", ")", "else", ":", "\"\"\"change non-float data to float data, need to copy\"\"\"", "data", "=", "np", ".", "array", "(", "mat", ".", "reshape", "(", "mat", ".", "size", ")", ",", "dtype", "=", "np", ".", "float32", ")", "ptr_data", ",", "type_ptr_data", ",", "_", "=", "c_float_array", "(", "data", ")", "n_preds", "=", "self", ".", "__get_num_preds", "(", "num_iteration", ",", "mat", ".", "shape", "[", "0", "]", ",", "predict_type", ")", "preds", "=", "np", ".", "zeros", "(", "n_preds", ",", "dtype", "=", "np", ".", "float64", ")", "out_num_preds", "=", "ctypes", ".", "c_int64", "(", "0", ")", "_safe_call", "(", "_LIB", ".", "LGBM_BoosterPredictForMat", "(", "self", ".", "handle", ",", "ptr_data", ",", "ctypes", ".", "c_int", "(", "type_ptr_data", ")", ",", "ctypes", ".", "c_int", "(", "mat", ".", "shape", "[", "0", "]", ")", ",", "ctypes", ".", "c_int", "(", "mat", ".", "shape", "[", "1", "]", ")", ",", "ctypes", ".", "c_int", "(", "C_API_IS_ROW_MAJOR", ")", ",", "ctypes", ".", "c_int", "(", "predict_type", ")", ",", "ctypes", ".", "c_int", "(", "num_iteration", ")", ",", "c_str", "(", "self", ".", "pred_parameter", ")", ",", "ctypes", ".", "byref", "(", "out_num_preds", ")", ",", "preds", ".", "ctypes", ".", "data_as", "(", "ctypes", ".", "POINTER", "(", "ctypes", ".", "c_double", ")", ")", ")", ")", "if", "n_preds", "!=", "out_num_preds", ".", "value", ":", "raise", "ValueError", "(", "\"Wrong length for predict results\"", ")", "return", "preds", ",", "mat", ".", "shape", "[", "0", "]" ]

[ "Dump", "an", "HTML", "document", "to", "a", "file", ".", "If" ]

[ "def", "htmlSaveFile", "(", "self", ",", "filename", ")", ":", "ret", "=", "libxml2mod", ".", "htmlSaveFile", "(", "filename", ",", "self", ".", "_o", ")", "return", "ret" ]

[ "Call", "method", "." ]

[ "def", "__call__", "(", "self", ",", "img", ")", ":", "return", "util", ".", "center_crop", "(", "img", ",", "self", ".", "size", ")" ]

[ "Return", "the", "Android", "module", "name", "used", "for", "a", "gyp", "spec", "." ]

[ "def", "ComputeAndroidModule", "(", "self", ",", "spec", ")", ":", "if", "self", ".", "type", "==", "'shared_library'", ":", "# For reasons of convention, the Android build system requires that all", "# shared library modules are named 'libfoo' when generating -l flags.", "prefix", "=", "'lib_'", "else", ":", "prefix", "=", "''", "if", "spec", "[", "'toolset'", "]", "==", "'host'", ":", "suffix", "=", "'_host_gyp'", "else", ":", "suffix", "=", "'_gyp'", "if", "self", ".", "path", ":", "name", "=", "'%s%s_%s%s'", "%", "(", "prefix", ",", "self", ".", "path", ",", "self", ".", "target", ",", "suffix", ")", "else", ":", "name", "=", "'%s%s%s'", "%", "(", "prefix", ",", "self", ".", "target", ",", "suffix", ")", "return", "make", ".", "StringToMakefileVariable", "(", "name", ")" ]

[ "Leaves", "non", "-", "list", "values", "untouched", ".", "Raises", "an", "Exception", "in", "case", "the", "input", "list", "does", "not", "have", "exactly", "one", "element", "." ]

[ "def", "singleton_list_to_value", "(", "value_or_values", ")", ":", "if", "isinstance", "(", "value_or_values", ",", "list", ")", ":", "assert", "len", "(", "value_or_values", ")", "==", "1", "return", "value_or_values", "[", "0", "]", "return", "value_or_values" ]

[ ":", "api_attr", ":", "Static", "Graph" ]

[ "def", "sequence_unpad", "(", "x", ",", "length", ",", "name", "=", "None", ")", ":", "assert", "not", "in_dygraph_mode", "(", ")", ",", "(", "\"sequence layer is not supported in dygraph mode yet.\"", ")", "helper", "=", "LayerHelper", "(", "'sequence_unpad'", ",", "*", "*", "locals", "(", ")", ")", "check_variable_and_dtype", "(", "x", ",", "'x'", ",", "[", "'float32'", ",", "'float64'", ",", "'int32'", ",", "'int64'", "]", ",", "'fluid.layers.sequence_unpad'", ")", "check_variable_and_dtype", "(", "length", ",", "'length'", ",", "[", "'int64'", "]", ",", "'fluid.layers.sequence_unpad'", ")", "dtype", "=", "helper", ".", "input_dtype", "(", "input_param_name", "=", "'x'", ")", "out", "=", "helper", ".", "create_variable_for_type_inference", "(", "dtype", ")", "length", ".", "stop_gradient", "=", "True", "helper", ".", "append_op", "(", "type", "=", "'sequence_unpad'", ",", "inputs", "=", "{", "'X'", ":", "x", ",", "'Length'", ":", "length", "}", ",", "outputs", "=", "{", "'Out'", ":", "out", "}", ")", "return", "out" ]

[ "Return", "system", "-", "wide", "CPU", "times", "as", "a", "named", "tuple" ]

[ "def", "cpu_times", "(", ")", ":", "ret", "=", "cext", ".", "per_cpu_times", "(", ")", "return", "scputimes", "(", "*", "[", "sum", "(", "x", ")", "for", "x", "in", "zip", "(", "*", "ret", ")", "]", ")" ]

[ "Write", "the", "changelog", "to", "the", "specified", "file", "." ]

[ "def", "write", "(", "self", ",", "filename", ")", ":", "with", "open", "(", "filename", ",", "'wb'", ")", "as", "out", ":", "out", ".", "write", "(", "self", ".", "header", ")", "out", ".", "write", "(", "self", ".", "top_version_title", ")", "for", "title", ",", "body", "in", "self", ".", "categories", ".", "items", "(", ")", ":", "if", "not", "body", ":", "continue", "out", ".", "write", "(", "self", ".", "format", ".", "format_category", "(", "title", ",", "body", ")", ")", "out", ".", "write", "(", "self", ".", "trailer", ")" ]

[ "Check", "if", "our", "OmniSharp", "server", "is", "ready", "(", "loaded", "solution", "file", ")", "." ]

[ "def", "ServerIsReady", "(", "self", ")", ":", "return", "self", ".", "_CheckAllRunning", "(", "lambda", "i", ":", "i", ".", "ServerIsReady", "(", ")", ")" ]

[ "select", "coordinates", "(", "row", "numbers", ")", "from", "a", "table", ";", "return", "the", "coordinates", "object" ]

[ "def", "read_coordinates", "(", "self", ",", "where", "=", "None", ",", "start", "=", "None", ",", "stop", "=", "None", ",", "*", "*", "kwargs", ")", ":", "# validate the version", "self", ".", "validate_version", "(", "where", ")", "# infer the data kind", "if", "not", "self", ".", "infer_axes", "(", ")", ":", "return", "False", "# create the selection", "self", ".", "selection", "=", "Selection", "(", "self", ",", "where", "=", "where", ",", "start", "=", "start", ",", "stop", "=", "stop", ",", "*", "*", "kwargs", ")", "coords", "=", "self", ".", "selection", ".", "select_coords", "(", ")", "if", "self", ".", "selection", ".", "filter", "is", "not", "None", ":", "for", "field", ",", "op", ",", "filt", "in", "self", ".", "selection", ".", "filter", ".", "format", "(", ")", ":", "data", "=", "self", ".", "read_column", "(", "field", ",", "start", "=", "coords", ".", "min", "(", ")", ",", "stop", "=", "coords", ".", "max", "(", ")", "+", "1", ")", "coords", "=", "coords", "[", "op", "(", "data", ".", "iloc", "[", "coords", "-", "coords", ".", "min", "(", ")", "]", ",", "filt", ")", ".", "values", "]", "return", "Index", "(", "coords", ")" ]

[ "Disable", "the", "GPU", "backend", "in", "the", "current", "runtime", "stack" ]

[ "def", "gpu_disable", "(", ")", ":", "return", "msg", "(", "\"GPU: disable\"", ")" ]

[ "process_entry" ]

[ "def", "process_entry", "(", "data", ",", "name", ")", ":", "if", "data", "[", "\"type\"", "]", "==", "\"record\"", ":", "return", "process_record", "(", "data", ",", "name", ")", "if", "data", "[", "\"type\"", "]", "==", "\"enum\"", ":", "assert", "False", "if", "data", "[", "\"type\"", "]", "==", "\"array\"", ":", "assert", "False", "if", "data", "[", "\"type\"", "]", "==", "\"map\"", ":", "assert", "False", "if", "data", "[", "\"type\"", "]", "==", "\"fixed\"", ":", "assert", "False", "if", "isinstance", "(", "data", "[", "\"type\"", "]", ",", "list", ")", ":", "return", "process_union", "(", "data", ",", "name", ")", "return", "process_primitive", "(", "data", "[", "\"type\"", "]", ",", "name", ")" ]

[ "(", "c_intp", "*", "self", ".", "ndim", ")", ":", "A", "ctypes", "array", "of", "length", "self", ".", "ndim", "where", "the", "basetype", "is", "the", "same", "as", "for", "the", "shape", "attribute", ".", "This", "ctypes", "array", "contains", "the", "strides", "information", "from", "the", "underlying", "array", ".", "This", "strides", "information", "is", "important", "for", "showing", "how", "many", "bytes", "must", "be", "jumped", "to", "get", "to", "the", "next", "element", "in", "the", "array", "." ]

[ "def", "strides", "(", "self", ")", ":", "return", "self", ".", "strides_as", "(", "_getintp_ctype", "(", ")", ")" ]

[ "get", "subprotocol" ]

[ "def", "getsubprotocol", "(", "self", ")", ":", "if", "self", ".", "handshake_response", ":", "return", "self", ".", "handshake_response", ".", "subprotocol", "else", ":", "return", "None" ]

[ "returns", "a", "string", "containing", "an", "HTML", "<tag", ">" ]

[ "def", "formHTMLTag", "(", "self", ",", "tagName", ",", "attributes", "=", "{", "}", ")", ":", "tagTxt", "=", "[", "'<'", ",", "tagName", ".", "lower", "(", ")", "]", "for", "name", ",", "val", "in", "attributes", ".", "items", "(", ")", ":", "tagTxt", "+=", "[", "' '", ",", "name", ".", "lower", "(", ")", ",", "'=\"'", ",", "str", "(", "val", ")", ",", "'\"'", "]", "tagTxt", ".", "append", "(", "'>'", ")", "return", "''", ".", "join", "(", "tagTxt", ")" ]

[ "PreDataViewListCtrl", "()", "-", ">", "DataViewListCtrl" ]

[ "def", "PreDataViewListCtrl", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_dataview", ".", "new_PreDataViewListCtrl", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "This", "attempts", "to", "convert", "a", "deprecated", "starting", "token", "into", "the", "new", "style", "." ]

[ "def", "_convert_deprecated_starting_token", "(", "self", ",", "deprecated_token", ")", ":", "len_deprecated_token", "=", "len", "(", "deprecated_token", ")", "len_input_token", "=", "len", "(", "self", ".", "_input_token", ")", "if", "len_deprecated_token", ">", "len_input_token", ":", "raise", "ValueError", "(", "\"Bad starting token: %s\"", "%", "self", ".", "_starting_token", ")", "elif", "len_deprecated_token", "<", "len_input_token", ":", "log", ".", "debug", "(", "\"Old format starting token does not contain all input \"", "\"tokens. Setting the rest, in order, as None.\"", ")", "for", "i", "in", "range", "(", "len_input_token", "-", "len_deprecated_token", ")", ":", "deprecated_token", ".", "append", "(", "None", ")", "return", "dict", "(", "zip", "(", "self", ".", "_input_token", ",", "deprecated_token", ")", ")" ]

[ "Shift", "the", "time", "index", "using", "the", "index", "s", "frequency", "if", "available", "." ]

[ "def", "tshift", "(", "self", ":", "FrameOrSeries", ",", "periods", ":", "int", "=", "1", ",", "freq", "=", "None", ",", "axis", "=", "0", ")", "->", "FrameOrSeries", ":", "index", "=", "self", ".", "_get_axis", "(", "axis", ")", "if", "freq", "is", "None", ":", "freq", "=", "getattr", "(", "index", ",", "\"freq\"", ",", "None", ")", "if", "freq", "is", "None", ":", "freq", "=", "getattr", "(", "index", ",", "\"inferred_freq\"", ",", "None", ")", "if", "freq", "is", "None", ":", "msg", "=", "\"Freq was not given and was not set in the index\"", "raise", "ValueError", "(", "msg", ")", "if", "periods", "==", "0", ":", "return", "self", "if", "isinstance", "(", "freq", ",", "str", ")", ":", "freq", "=", "to_offset", "(", "freq", ")", "block_axis", "=", "self", ".", "_get_block_manager_axis", "(", "axis", ")", "if", "isinstance", "(", "index", ",", "PeriodIndex", ")", ":", "orig_freq", "=", "to_offset", "(", "index", ".", "freq", ")", "if", "freq", "==", "orig_freq", ":", "new_data", "=", "self", ".", "_data", ".", "copy", "(", ")", "new_data", ".", "axes", "[", "block_axis", "]", "=", "index", ".", "shift", "(", "periods", ")", "elif", "orig_freq", "is", "not", "None", ":", "msg", "=", "(", "f\"Given freq {freq.rule_code} does not match\"", "f\" PeriodIndex freq {orig_freq.rule_code}\"", ")", "raise", "ValueError", "(", "msg", ")", "else", ":", "new_data", "=", "self", ".", "_data", ".", "copy", "(", ")", "new_data", ".", "axes", "[", "block_axis", "]", "=", "index", ".", "shift", "(", "periods", ",", "freq", ")", "return", "self", ".", "_constructor", "(", "new_data", ")", ".", "__finalize__", "(", "self", ")" ]

[ "Return", "the", "cursor", "for", "the", "declaration", "of", "the", "given", "type", "." ]

[ "def", "get_declaration", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_getTypeDeclaration", "(", "self", ")" ]

[ "unload", "the", "dialog", "that", "we", "loaded" ]

[ "def", "__del__", "(", "self", ")", ":", "PtUnloadDialog", "(", "Vignette", ".", "value", ")" ]

[ "ScrollToColumn", "(", "self", "int", "column", ")" ]

[ "def", "ScrollToColumn", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_ScrollToColumn", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "converts", "a", "layer", "to", "vtkImageData", "." ]

[ "def", "layer2img", "(", "layer", ")", ":", "if", "not", "layer", ":", "return", "None", "img", "=", "vtk", ".", "vtkImageData", "(", ")", "dims", "=", "[", "0", ",", "0", ",", "0", "]", "if", "layer", ".", "hasValueArray", "(", ")", ":", "nvalues", "=", "layer", ".", "getValueArray", "(", ")", "# now, the numpy array's shape matches the 2D image", "dims", "[", "0", "]", "=", "nvalues", ".", "shape", "[", "1", "]", "dims", "[", "1", "]", "=", "nvalues", ".", "shape", "[", "0", "]", "img", ".", "SetDimensions", "(", "dims", "[", "0", "]", ",", "dims", "[", "1", "]", ",", "1", ")", "nvalues", "=", "nvalues", ".", "reshape", "(", "dims", "[", "0", "]", "*", "dims", "[", "1", "]", ")", "vvalues", "=", "dsa", ".", "numpyTovtkDataArray", "(", "nvalues", ",", "\"Values\"", ")", "img", ".", "GetPointData", "(", ")", ".", "SetScalars", "(", "vvalues", ")", "elif", "layer", ".", "hasColorArray", "(", ")", ":", "ncolors", "=", "layer", ".", "getColorArray", "(", ")", "# now, the numpy array's shape matches the 2D image", "dims", "[", "0", "]", "=", "ncolors", ".", "shape", "[", "1", "]", "dims", "[", "1", "]", "=", "ncolors", ".", "shape", "[", "0", "]", "img", ".", "SetDimensions", "(", "dims", "[", "0", "]", ",", "dims", "[", "1", "]", ",", "1", ")", "ncolors", "=", "ncolors", ".", "reshape", "(", "(", "dims", "[", "0", "]", "*", "dims", "[", "1", "]", ",", "-", "1", ")", ")", "vcolors", "=", "dsa", ".", "numpyTovtkDataArray", "(", "ncolors", ",", "\"Colors\"", ")", "img", ".", "GetPointData", "(", ")", ".", "SetScalars", "(", "vcolors", ")", "ndepth", "=", "layer", ".", "getDepth", "(", ")", "if", "ndepth", "is", "None", ":", "raise", "RuntimeError", "(", "\"Missing 'depth'\"", ")", "ndepth", "=", "ndepth", ".", "reshape", "(", "dims", "[", "0", "]", "*", "dims", "[", "1", "]", ")", "vdepth", "=", "dsa", ".", "numpyTovtkDataArray", "(", "ndepth", ",", "\"Depth\"", ")", "img", ".", "GetPointData", "(", ")", ".", "AddArray", "(", "vdepth", ")", "nluminance", "=", "layer", ".", "getLuminance", "(", ")", "if", "nluminance", "is", "not", "None", ":", "nluminance", "=", "nluminance", ".", "reshape", "(", "(", "dims", "[", "0", "]", "*", "dims", "[", "1", "]", ",", "-", "1", ")", ")", "vluminance", "=", "dsa", ".", "numpyTovtkDataArray", "(", "nluminance", ",", "\"Luminance\"", ")", "img", ".", "GetPointData", "(", ")", ".", "AddArray", "(", "vluminance", ")", "# from paraview.vtk.vtkIOLegacy import vtkDataSetWriter", "# writer = vtkDataSetWriter()", "# writer.SetInputDataObject(img)", "# writer.SetFileName(\"/tmp/layer.vtk\")", "# writer.Update()", "# del writer", "return", "img" ]

[ "GetHitCount", "(", "self", ")", "-", ">", "uint32_t" ]

[ "def", "GetHitCount", "(", "self", ")", ":", "return", "_lldb", ".", "SBBreakpoint_GetHitCount", "(", "self", ")" ]

[ "Performs", "lint", "checks", "and", "reports", "any", "errors", "to", "the", "given", "error", "function", "." ]

[ "def", "ProcessFileData", "(", "filename", ",", "file_extension", ",", "lines", ",", "error", ",", "extra_check_functions", "=", "[", "]", ")", ":", "lines", "=", "(", "[", "'// marker so line numbers and indices both start at 1'", "]", "+", "lines", "+", "[", "'// marker so line numbers end in a known way'", "]", ")", "include_state", "=", "_IncludeState", "(", ")", "function_state", "=", "_FunctionState", "(", ")", "nesting_state", "=", "_NestingState", "(", ")", "ResetNolintSuppressions", "(", ")", "CheckForCopyright", "(", "filename", ",", "lines", ",", "error", ")", "if", "file_extension", "==", "'h'", ":", "CheckForHeaderGuard", "(", "filename", ",", "lines", ",", "error", ")", "RemoveMultiLineComments", "(", "filename", ",", "lines", ",", "error", ")", "clean_lines", "=", "CleansedLines", "(", "lines", ")", "for", "line", "in", "xrange", "(", "clean_lines", ".", "NumLines", "(", ")", ")", ":", "ProcessLine", "(", "filename", ",", "file_extension", ",", "clean_lines", ",", "line", ",", "include_state", ",", "function_state", ",", "nesting_state", ",", "error", ",", "extra_check_functions", ")", "nesting_state", ".", "CheckCompletedBlocks", "(", "filename", ",", "error", ")", "CheckForIncludeWhatYouUse", "(", "filename", ",", "clean_lines", ",", "include_state", ",", "error", ")", "# We check here rather than inside ProcessLine so that we see raw", "# lines rather than \"cleaned\" lines.", "CheckForBadCharacters", "(", "filename", ",", "lines", ",", "error", ")", "CheckForNewlineAtEOF", "(", "filename", ",", "lines", ",", "error", ")" ]

[ "Args", ":" ]

[ "def", "__init__", "(", "self", ",", "message_listener", ",", "type_checker", ")", ":", "super", "(", "RepeatedScalarFieldContainer", ",", "self", ")", ".", "__init__", "(", "message_listener", ")", "self", ".", "_type_checker", "=", "type_checker" ]

[ "Add", "prefix", "to", "version", "/", "tag", "like", "v1", ".", "2", ".", "3" ]

[ "def", "to_ref", "(", "version", ")", ":", "return", "cfg_ref_prefix", "+", "version" ]

[ "Returns", "a", "generator", "of", "tuples", "like", "dict", ".", "items", "()", "where", "the", "key", "is", "resolved", "(", "as", "a", "string", ")", "and", "the", "values", "are", "still", "lazy", "contexts", "." ]

[ "def", "exact_key_items", "(", "self", ")", ":", "for", "key_node", ",", "value", "in", "self", ".", "_items", "(", ")", ":", "for", "key", "in", "self", ".", "_defining_context", ".", "eval_node", "(", "key_node", ")", ":", "if", "is_string", "(", "key", ")", ":", "yield", "key", ".", "get_safe_value", "(", ")", ",", "LazyTreeContext", "(", "self", ".", "_defining_context", ",", "value", ")" ]

[ "Returns", "a", "PyShell", "Panel" ]

[ "def", "CreateItem", "(", "self", ",", "parent", ")", ":", "util", ".", "Log", "(", "\"[PyShell][info] Creating PyShell instance for Shelf\"", ")", "return", "EdPyShellBox", "(", "parent", ")" ]

[ "Convert", "bytes", "to", "GB" ]

[ "def", "byte_to_gb", "(", "byte", ")", ":", "return", "byte", "/", "(", "1024.0", "*", "1024", "*", "1024", ")" ]

[ "Executed", "by", "msvs", "-", "ninja", "projects", "when", "the", "ClCompile", "target", "is", "used", "to", "build", "selected", "C", "/", "C", "++", "files", "." ]

[ "def", "ExecClCompile", "(", "self", ",", "project_dir", ",", "selected_files", ")", ":", "project_dir", "=", "os", ".", "path", ".", "relpath", "(", "project_dir", ",", "BASE_DIR", ")", "selected_files", "=", "selected_files", ".", "split", "(", "';'", ")", "ninja_targets", "=", "[", "os", ".", "path", ".", "join", "(", "project_dir", ",", "filename", ")", "+", "'^^'", "for", "filename", "in", "selected_files", "]", "cmd", "=", "[", "'ninja.exe'", "]", "cmd", ".", "extend", "(", "ninja_targets", ")", "return", "subprocess", ".", "call", "(", "cmd", ",", "shell", "=", "True", ",", "cwd", "=", "BASE_DIR", ")" ]

[ "Initializes", "the", "handler", "with", "a", "specific", "host", "address", "and", "port", "." ]

[ "def", "__init__", "(", "self", ",", "host", ",", "port", ")", ":", "logging", ".", "Handler", ".", "__init__", "(", "self", ")", "self", ".", "host", "=", "host", "self", ".", "port", "=", "port", "self", ".", "sock", "=", "None", "self", ".", "closeOnError", "=", "0", "self", ".", "retryTime", "=", "None", "#", "# Exponential backoff parameters.", "#", "self", ".", "retryStart", "=", "1.0", "self", ".", "retryMax", "=", "30.0", "self", ".", "retryFactor", "=", "2.0" ]

[ "Returns", "a", "function", "that", "can", "be", "used", "to", "apply", "L1", "L2", "regularizations", "." ]

[ "def", "l1_l2_regularizer", "(", "scale_l1", "=", "1.0", ",", "scale_l2", "=", "1.0", ",", "scope", "=", "None", ")", ":", "scope", "=", "scope", "or", "'l1_l2_regularizer'", "return", "sum_regularizer", "(", "[", "l1_regularizer", "(", "scale_l1", ")", ",", "l2_regularizer", "(", "scale_l2", ")", "]", ",", "scope", "=", "scope", ")" ]

[ "Used", "for", "playing", "a", "single", "game", "." ]

[ "def", "suggest_move", "(", "self", ",", "position", ")", ":", "start", "=", "time", ".", "time", "(", ")", "if", "self", ".", "timed_match", ":", "while", "time", ".", "time", "(", ")", "-", "start", "<", "self", ".", "seconds_per_move", ":", "self", ".", "tree_search", "(", ")", "else", ":", "current_readouts", "=", "self", ".", "root", ".", "N", "while", "self", ".", "root", ".", "N", "<", "current_readouts", "+", "self", ".", "num_readouts", ":", "self", ".", "tree_search", "(", ")", "if", "self", ".", "verbosity", ">", "0", ":", "dbg", "(", "\"%d: Searched %d times in %.2f seconds\\n\\n\"", "%", "(", "position", ".", "n", ",", "self", ".", "num_readouts", ",", "time", ".", "time", "(", ")", "-", "start", ")", ")", "# print some stats on moves considered.", "if", "self", ".", "verbosity", ">", "2", ":", "dbg", "(", "self", ".", "root", ".", "describe", "(", ")", ")", "dbg", "(", "'\\n\\n'", ")", "if", "self", ".", "verbosity", ">", "3", ":", "dbg", "(", "self", ".", "root", ".", "position", ")", "return", "self", ".", "pick_move", "(", ")" ]

[ "Get", "the", "bounding", "box", "(", "bottom", "left", "and", "top", "right", "coordinates", ")", "for", "a", "net", ";", "Coordinates", "are", "in", "X", "and", "Y", "(", "not", "Lat", "and", "Lon", ")" ]

[ "def", "getBBoxXY", "(", "self", ")", ":", "return", "[", "(", "self", ".", "_ranges", "[", "0", "]", "[", "0", "]", ",", "self", ".", "_ranges", "[", "1", "]", "[", "0", "]", ")", ",", "(", "self", ".", "_ranges", "[", "0", "]", "[", "1", "]", ",", "self", ".", "_ranges", "[", "1", "]", "[", "1", "]", ")", "]" ]

[ "Construct", "a", "source", "file", "(", "just", "like", "try_cpp", "()", ")", "run", "it", "through", "the", "preprocessor", "and", "return", "true", "if", "any", "line", "of", "the", "output", "matches", "pattern", ".", "pattern", "should", "either", "be", "a", "compiled", "regex", "object", "or", "a", "string", "containing", "a", "regex", ".", "If", "both", "body", "and", "headers", "are", "None", "preprocesses", "an", "empty", "file", "--", "which", "can", "be", "useful", "to", "determine", "the", "symbols", "the", "preprocessor", "and", "compiler", "set", "by", "default", "." ]

[ "def", "search_cpp", "(", "self", ",", "pattern", ",", "body", "=", "None", ",", "headers", "=", "None", ",", "include_dirs", "=", "None", ",", "lang", "=", "\"c\"", ")", ":", "self", ".", "_check_compiler", "(", ")", "src", ",", "out", "=", "self", ".", "_preprocess", "(", "body", ",", "headers", ",", "include_dirs", ",", "lang", ")", "if", "isinstance", "(", "pattern", ",", "str", ")", ":", "pattern", "=", "re", ".", "compile", "(", "pattern", ")", "file", "=", "open", "(", "out", ")", "match", "=", "0", "while", "1", ":", "line", "=", "file", ".", "readline", "(", ")", "if", "line", "==", "''", ":", "break", "if", "pattern", ".", "search", "(", "line", ")", ":", "match", "=", "1", "break", "file", ".", "close", "(", ")", "self", ".", "_clean", "(", ")", "return", "match" ]

[ "Internal", "function", ".", "Used", "to", "populate", "an", "array", "of", "selected", "items", "when", "the", "style", "TR_MULTIPLE", "is", "used", "." ]

[ "def", "FillArray", "(", "self", ",", "item", ",", "array", "=", "[", "]", ")", ":", "if", "not", "array", ":", "array", "=", "[", "]", "if", "item", ".", "IsSelected", "(", ")", ":", "array", ".", "append", "(", "item", ")", "if", "item", ".", "HasChildren", "(", ")", "and", "item", ".", "IsExpanded", "(", ")", ":", "for", "child", "in", "item", ".", "GetChildren", "(", ")", ":", "array", "=", "self", ".", "FillArray", "(", "child", ",", "array", ")", "return", "array" ]

[ "SetMiddleDown", "(", "self", "bool", "down", ")" ]

[ "def", "SetMiddleDown", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "MouseState_SetMiddleDown", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Recursively", "interpolates", "construction", "variables", "from", "the", "Environment", "into", "the", "specified", "string", "returning", "the", "expanded", "result", ".", "Construction", "variables", "are", "specified", "by", "a", "$", "prefix", "in", "the", "string", "and", "begin", "with", "an", "initial", "underscore", "or", "alphabetic", "character", "followed", "by", "any", "number", "of", "underscores", "or", "alphanumeric", "characters", ".", "The", "construction", "variable", "names", "may", "be", "surrounded", "by", "curly", "braces", "to", "separate", "the", "name", "from", "trailing", "characters", "." ]

[ "def", "subst", "(", "self", ",", "string", ",", "raw", "=", "0", ",", "target", "=", "None", ",", "source", "=", "None", ",", "conv", "=", "None", ",", "executor", "=", "None", ")", ":", "gvars", "=", "self", ".", "gvars", "(", ")", "lvars", "=", "self", ".", "lvars", "(", ")", "lvars", "[", "'__env__'", "]", "=", "self", "if", "executor", ":", "lvars", ".", "update", "(", "executor", ".", "get_lvars", "(", ")", ")", "return", "SCons", ".", "Subst", ".", "scons_subst", "(", "string", ",", "self", ",", "raw", ",", "target", ",", "source", ",", "gvars", ",", "lvars", ",", "conv", ")" ]

[ "Returns", "True", "if", "message_or_descriptor", "is", "type", "or", "a", "profile", "of", "Patient", "." ]

[ "def", "is_type_or_profile_of_patient", "(", "message_or_descriptor", ":", "annotation_utils", ".", "MessageOrDescriptorBase", ")", "->", "bool", ":", "return", "is_type_or_profile_of", "(", "_PATIENT_STRUCTURE_DEFINITION_URL", ",", "message_or_descriptor", ")" ]

[ "Implements", "tf", ".", "Variable", ".", "scatter_mul", "." ]

[ "def", "scatter_mul", "(", "self", ",", "sparse_delta", ",", "use_locking", "=", "False", ",", "name", "=", "None", ")", ":", "per_var_sparse_delta", "=", "self", ".", "_decompose_indexed_slices", "(", "sparse_delta", ")", "for", "i", ",", "v", "in", "enumerate", "(", "self", ".", "_variables", ")", ":", "new_name", "=", "None", "if", "name", "is", "not", "None", ":", "new_name", "=", "'{}/part_{}'", ".", "format", "(", "name", ",", "i", ")", "v", ".", "scatter_mul", "(", "per_var_sparse_delta", "[", "i", "]", ",", "name", "=", "new_name", ")", "return", "self" ]

[ "go", "on", "parsing", "inside", "the", "body", "of", "a", "class" ]

[ "def", "inside_class_definition", "(", "self", ",", "toktreelist", ",", "classname", ")", ":", "pub_priv_prot_re", "=", "re", ".", "compile", "(", "'public|private|protected'", ")", "stream", "=", "TokenStream", "(", "toktreelist", ")", "attr_cls_re", "=", "re", ".", "compile", "(", "'^(Dyn|)Attribute(Proxy|)_$'", ")", "attribute_", "=", "TokenStream", ".", "PatternArg", "(", "re", "=", "attr_cls_re", ")", "link_", "=", "TokenStream", ".", "PatternArg", "(", "re", "=", "re", ".", "compile", "(", "'^(Link_|Child_|DynChild_|ChildMember_)$'", ")", ")", "parameters", "=", "TokenStream", ".", "PatternArg", "(", "callback", "=", "lambda", "t", ":", "TokenGroup", ".", "IsTokenGroup", "(", "t", ",", "opening_token", "=", "'('", ")", ")", "def", "semicolon_or_block_callback", "(", "t", ")", ":", "return", "t", "==", "';'", "or", "TokenGroup", ".", "IsTokenGroup", "(", "t", ",", "opening_token", "=", "'{'", ")", "semicolon_or_block", "=", "TokenStream", ".", "PatternArg", "(", "callback", "=", "semicolon_or_block_callback", ")", "arg", "=", "TokenStream", ".", "PatternArg", "(", ")", "while", "not", "stream", ".", "empty", "(", ")", ":", "if", "stream", ".", "try_match", "(", "pub_priv_prot_re", ",", "':'", ")", ":", "continue", "if", "stream", ".", "try_match", "(", "re", ".", "compile", "(", "r'^(//|/\\*)'", ")", ")", ":", "# skip comments", "continue", "# whenever we reach this point, this is a new", "# member variable or member function definition", "elif", "stream", ".", "try_match", "(", "'using'", ")", ":", "semicolon_found", "=", "stream", ".", "discard_until", "(", "';'", ")", "assert", "semicolon_found", ",", "\"expected ; after 'using'\"", "elif", "stream", ".", "try_match", "(", "attribute_", ",", "'<'", ")", ":", "attr_type", "=", "self", ".", "stream_pop_class_name", "(", "stream", ")", "assert", "stream", ".", "try_match", "(", "'>'", ")", ",", "\"every 'Attribute_<' has to be closed by '>'\"", "attr_name", "=", "stream", ".", "pop", "(", "\"expect an attribute name\"", ")", "attr", "=", "self", ".", "objInfo", ".", "attribute_info", "(", "classname", ",", "attr_name", ")", "attr", ".", "type", "=", "attr_type", "attr", ".", "attribute_class", "=", "attribute_", ".", "value", "if", "stream", ".", "try_match", "(", "'='", ")", ":", "# static initialization:", "t", "=", "stream", ".", "pop", "(", ")", "assert", "TokenGroup", ".", "IsTokenGroup", "(", "t", ")", "attr", ".", "add_constructor_args", "(", "t", ".", "enclosed_tokens", ")", "if", "stream", ".", "try_match", "(", "';'", ")", ":", "# end of attribute definition", "pass", "else", ":", "# some other definition (e.g. a function)", "stream", ".", "discard_until", "(", "semicolon_or_block", ")", "elif", "stream", ".", "try_match", "(", "link_", ",", "'<'", ")", ":", "link_type", "=", "self", ".", "stream_pop_class_name", "(", "stream", ")", "stream", ".", "assert_match", "(", "'>'", ",", "msg", "=", "\"every 'Link_<' has to be enclosed by '>'\"", ")", "cpp_name", "=", "stream", ".", "pop", "(", "\"expect an attribute name\"", ")", "link", "=", "self", ".", "objInfo", ".", "child_info", "(", "classname", ",", "cpp_name", ")", "link", ".", "child_class", "=", "link_", ".", "value", "link", ".", "type", "=", "link_type", "stream", ".", "discard_until", "(", "semicolon_or_block", ")", "elif", "stream", ".", "try_match", "(", "'ByName'", ",", "arg", ")", ":", "link", "=", "self", ".", "objInfo", ".", "child_info", "(", "classname", ",", "arg", ".", "value", ")", "link", ".", "child_class", "=", "'ByName'", "link", ".", "user_name", "=", "'by-name'", "link", ".", "type", "=", "ClassName", "(", "'ByName'", ")", "stream", ".", "discard_until", "(", "semicolon_or_block", ")", "elif", "stream", ".", "try_match", "(", "classname", ",", "parameters", ",", "':'", ")", ":", "self", ".", "stream_consume_member_initializers", "(", "classname", ",", "stream", ")", "else", ":", "stream", ".", "discard_until", "(", "semicolon_or_block", ")" ]

[ "CreatePen", "(", "self", "Pen", "pen", ")", "-", ">", "GraphicsPen" ]

[ "def", "CreatePen", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "GraphicsRenderer_CreatePen", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "cmake_quote_path", "(", "value", ")", "-", ">", "str" ]

[ "def", "cmake_quote_path", "(", "value", ")", ":", "# CMake has a bug in it's Makefile generator that doesn't properly quote", "# strings it generates. So instead of using proper quoting, we just use \"/\"", "# style paths. Currently, we only handle escaping backslashes.", "value", "=", "value", ".", "replace", "(", "\"\\\\\"", ",", "\"/\"", ")", "return", "value" ]

[ "Generates", "strides", "(", "1", "-", "D", "tensor", ")", "according", "to", "dims", "(", "1", "-", "D", "tensor", ")", "." ]

[ "def", "_get_strides", "(", "dims", ",", "order", "=", "'C'", ")", ":", "if", "order", "not", "in", "[", "'C'", ",", "'F'", "]", ":", "_raise_value_error", "(", "\"invalid order. Expected 'C' or 'F'\"", ")", "tup", "=", "(", "_to_tensor", "(", "[", "1", "]", ")", ",", ")", "dims", "=", "dims", "[", "1", ":", "]", "[", ":", ":", "-", "1", "]", "if", "order", "==", "'C'", "else", "dims", "[", ":", "-", "1", "]", "for", "d", "in", "dims", ":", "tensor", "=", "tup", "[", "-", "1", "]", "*", "d", "if", "tensor", ".", "ndim", "<", "1", ":", "tensor", "=", "F", ".", "expand_dims", "(", "tensor", ",", "0", ")", "tup", "+=", "(", "tensor", ",", ")", "tup", "=", "tup", "[", ":", ":", "-", "1", "]", "if", "order", "==", "'C'", "else", "tup", "return", "P", ".", "Concat", "(", "0", ")", "(", "tup", ")" ]

[ "Writes", "the", "specified", "contents", "to", "the", "specified", "file_name", "iff", "the", "contents", "are", "different", "than", "the", "current", "contents", "." ]

[ "def", "write_if_changed", "(", "file_name", ",", "contents", ")", ":", "try", ":", "old_contents", "=", "open", "(", "file_name", ",", "'r'", ")", ".", "read", "(", ")", "except", "EnvironmentError", ":", "pass", "else", ":", "if", "contents", "==", "old_contents", ":", "return", "os", ".", "unlink", "(", "file_name", ")", "open", "(", "file_name", ",", "'w'", ")", ".", "write", "(", "contents", ")" ]

[ "Gets", "the", "previous", "comment", "s", "ID", "from", "GitHub", "." ]

[ "def", "get_previous_comment_on_pr", "(", "pr_number", ":", "str", ",", "verbose", ":", "bool", "=", "False", ")", "->", "Optional", "[", "int", "]", ":", "# Increasing per_page limit requires user authentication.", "api_token", "=", "get_required_env_var", "(", "'GITHUB_TOKEN'", ")", "headers", "=", "{", "\"Accept\"", ":", "\"application/vnd.github.v3+json\"", ",", "\"Authorization\"", ":", "f\"token {api_token}\"", ",", "}", "payload", "=", "json", ".", "dumps", "(", "{", "\"per_page\"", ":", "100", "}", ")", "api_endpoint", "=", "f\"{GITHUB_IREE_API_PREFIX}/issues/{pr_number}/comments\"", "response", "=", "requests", ".", "get", "(", "api_endpoint", ",", "data", "=", "payload", ",", "headers", "=", "headers", ")", "if", "response", ".", "status_code", "!=", "200", ":", "raise", "requests", ".", "RequestException", "(", "f\"Failed to get PR comments from GitHub; error code: {response.status_code}\"", ")", "response", "=", "response", ".", "json", "(", ")", "if", "verbose", ":", "print", "(", "f\"Previous comment query response: {response}\"", ")", "# Find the last comment from GITHUB_USER and has the ABBR_PR_COMMENT_TITILE", "# keyword.", "for", "comment", "in", "reversed", "(", "response", ")", ":", "if", "(", "comment", "[", "\"user\"", "]", "[", "\"login\"", "]", "==", "GITHUB_USER", ")", "and", "(", "ABBR_PR_COMMENT_TITLE", "in", "comment", "[", "\"body\"", "]", ")", ":", "return", "comment", "[", "\"id\"", "]", "return", "None" ]

[ "Returns", "the", "toolbar", "orientation", "." ]

[ "def", "GetOrientation", "(", "self", ")", ":", "return", "self", ".", "_orientation" ]

[ "Decimal", "division", "in", "a", "specified", "context", "." ]

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

[ "returns", "an", "absolute", "file", "url", "from", "the", "given", "urls" ]

[ "def", "absolutize", "(", "path", ",", "relativeUrl", ")", ":", "return", "pyuno", ".", "absolutize", "(", "path", ",", "relativeUrl", ")" ]

[ "Parse", "a", "chained", "type", "in", "a", "struct", "in", "the", "IDL", "file", "." ]

[ "def", "_parse_chained_type", "(", "ctxt", ",", "name", ",", "node", ")", ":", "# type: (errors.ParserContext, str, yaml.nodes.MappingNode) -> syntax.ChainedType", "chain", "=", "syntax", ".", "ChainedType", "(", "ctxt", ".", "file_name", ",", "node", ".", "start_mark", ".", "line", ",", "node", ".", "start_mark", ".", "column", ")", "chain", ".", "name", "=", "name", "_generic_parser", "(", "ctxt", ",", "node", ",", "\"chain\"", ",", "chain", ",", "{", "\"cpp_name\"", ":", "_RuleDesc", "(", "'scalar'", ")", ",", "}", ")", "return", "chain" ]

[ "Traverse", "an", "AST", "applying", "a", "set", "of", "fixers", "to", "each", "node", "." ]

[ "def", "traverse_by", "(", "self", ",", "fixers", ",", "traversal", ")", ":", "if", "not", "fixers", ":", "return", "for", "node", "in", "traversal", ":", "for", "fixer", "in", "fixers", "[", "node", ".", "type", "]", ":", "results", "=", "fixer", ".", "match", "(", "node", ")", "if", "results", ":", "new", "=", "fixer", ".", "transform", "(", "node", ",", "results", ")", "if", "new", "is", "not", "None", ":", "node", ".", "replace", "(", "new", ")", "node", "=", "new" ]

[ "Fit", "the", "CatBoost", "model", "." ]

[ "def", "fit", "(", "self", ",", "X", ",", "y", "=", "None", ",", "cat_features", "=", "None", ",", "text_features", "=", "None", ",", "embedding_features", "=", "None", ",", "pairs", "=", "None", ",", "sample_weight", "=", "None", ",", "group_id", "=", "None", ",", "group_weight", "=", "None", ",", "subgroup_id", "=", "None", ",", "pairs_weight", "=", "None", ",", "baseline", "=", "None", ",", "use_best_model", "=", "None", ",", "eval_set", "=", "None", ",", "verbose", "=", "None", ",", "logging_level", "=", "None", ",", "plot", "=", "False", ",", "column_description", "=", "None", ",", "verbose_eval", "=", "None", ",", "metric_period", "=", "None", ",", "silent", "=", "None", ",", "early_stopping_rounds", "=", "None", ",", "save_snapshot", "=", "None", ",", "snapshot_file", "=", "None", ",", "snapshot_interval", "=", "None", ",", "init_model", "=", "None", ",", "callbacks", "=", "None", ",", "log_cout", "=", "sys", ".", "stdout", ",", "log_cerr", "=", "sys", ".", "stderr", ")", ":", "return", "self", ".", "_fit", "(", "X", ",", "y", ",", "cat_features", ",", "text_features", ",", "embedding_features", ",", "pairs", ",", "sample_weight", ",", "group_id", ",", "group_weight", ",", "subgroup_id", ",", "pairs_weight", ",", "baseline", ",", "use_best_model", ",", "eval_set", ",", "verbose", ",", "logging_level", ",", "plot", ",", "column_description", ",", "verbose_eval", ",", "metric_period", ",", "silent", ",", "early_stopping_rounds", ",", "save_snapshot", ",", "snapshot_file", ",", "snapshot_interval", ",", "init_model", ",", "callbacks", ",", "log_cout", ",", "log_cerr", ")" ]

[ "Extract", "and", "return", "a", "list", "of", "symbols", "extracted", "from", "a", "static", "or", "dynamic", "library", ".", "The", "symbols", "are", "extracted", "using", "NM", "or", "readelf", ".", "They", "are", "then", "filtered", "and", "formated", ".", "Finally", "they", "symbols", "are", "made", "unique", "." ]

[ "def", "extract_symbols", "(", "lib_file", ",", "static_lib", "=", "None", ")", ":", "if", "static_lib", "is", "None", ":", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "lib_file", ")", "static_lib", "=", "True", "if", "ext", "in", "[", "'.a'", "]", "else", "False", "if", "ReadElfExtractor", ".", "find_tool", "(", ")", "and", "not", "static_lib", ":", "extractor", "=", "ReadElfExtractor", "(", "static_lib", "=", "static_lib", ")", "else", ":", "extractor", "=", "NMExtractor", "(", "static_lib", "=", "static_lib", ")", "return", "extractor", ".", "extract", "(", "lib_file", ")" ]

[ "Checks", "for", "the", "correctness", "of", "various", "spacing", "issues", "in", "the", "code", "." ]

[ "def", "CheckSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "# Don't use \"elided\" lines here, otherwise we can't check commented lines.", "# Don't want to use \"raw\" either, because we don't want to check inside C++11", "# raw strings,", "raw", "=", "clean_lines", ".", "lines_without_raw_strings", "line", "=", "raw", "[", "linenum", "]", "# Before nixing comments, check if the line is blank for no good", "# reason. This includes the first line after a block is opened, and", "# blank lines at the end of a function (ie, right before a line like '}'", "#", "# Skip all the blank line checks if we are immediately inside a", "# namespace body. In other words, don't issue blank line warnings", "# for this block:", "# namespace {", "#", "# }", "#", "# A warning about missing end of namespace comments will be issued instead.", "if", "IsBlankLine", "(", "line", ")", "and", "not", "nesting_state", ".", "InNamespaceBody", "(", ")", ":", "elided", "=", "clean_lines", ".", "elided", "prev_line", "=", "elided", "[", "linenum", "-", "1", "]", "prevbrace", "=", "prev_line", ".", "rfind", "(", "'{'", ")", "# TODO(unknown): Don't complain if line before blank line, and line after,", "# both start with alnums and are indented the same amount.", "# This ignores whitespace at the start of a namespace block", "# because those are not usually indented.", "if", "prevbrace", "!=", "-", "1", "and", "prev_line", "[", "prevbrace", ":", "]", ".", "find", "(", "'}'", ")", "==", "-", "1", ":", "# OK, we have a blank line at the start of a code block. Before we", "# complain, we check if it is an exception to the rule: The previous", "# non-empty line has the parameters of a function header that are indented", "# 4 spaces (because they did not fit in a 80 column line when placed on", "# the same line as the function name). We also check for the case where", "# the previous line is indented 6 spaces, which may happen when the", "# initializers of a constructor do not fit into a 80 column line.", "exception", "=", "False", "if", "Match", "(", "r' {6}\\w'", ",", "prev_line", ")", ":", "# Initializer list?", "# We are looking for the opening column of initializer list, which", "# should be indented 4 spaces to cause 6 space indentation afterwards.", "search_position", "=", "linenum", "-", "2", "while", "(", "search_position", ">=", "0", "and", "Match", "(", "r' {6}\\w'", ",", "elided", "[", "search_position", "]", ")", ")", ":", "search_position", "-=", "1", "exception", "=", "(", "search_position", ">=", "0", "and", "elided", "[", "search_position", "]", "[", ":", "5", "]", "==", "' :'", ")", "else", ":", "# Search for the function arguments or an initializer list. We use a", "# simple heuristic here: If the line is indented 4 spaces; and we have a", "# closing paren, without the opening paren, followed by an opening brace", "# or colon (for initializer lists) we assume that it is the last line of", "# a function header. If we have a colon indented 4 spaces, it is an", "# initializer list.", "exception", "=", "(", "Match", "(", "r' {4}\\w[^\\(]*\\)\\s*(const\\s*)?(\\{\\s*$|:)'", ",", "prev_line", ")", "or", "Match", "(", "r' {4}:'", ",", "prev_line", ")", ")", "if", "not", "exception", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/blank_line'", ",", "2", ",", "'Redundant blank line at the start of a code block '", "'should be deleted.'", ")", "# Ignore blank lines at the end of a block in a long if-else", "# chain, like this:", "# if (condition1) {", "# // Something followed by a blank line", "#", "# } else if (condition2) {", "# // Something else", "# }", "if", "linenum", "+", "1", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "next_line", "=", "raw", "[", "linenum", "+", "1", "]", "if", "(", "next_line", "and", "Match", "(", "r'\\s*}'", ",", "next_line", ")", "and", "next_line", ".", "find", "(", "'} else '", ")", "==", "-", "1", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/blank_line'", ",", "3", ",", "'Redundant blank line at the end of a code block '", "'should be deleted.'", ")", "matched", "=", "Match", "(", "r'\\s*(public|protected|private):'", ",", "prev_line", ")", "if", "matched", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/blank_line'", ",", "3", ",", "'Do not leave a blank line after \"%s:\"'", "%", "matched", ".", "group", "(", "1", ")", ")", "# Next, we complain if there's a comment too near the text", "commentpos", "=", "line", ".", "find", "(", "'//'", ")", "if", "commentpos", "!=", "-", "1", ":", "# Check if the // may be in quotes. If so, ignore it", "# Comparisons made explicit for clarity -- pylint: disable=g-explicit-bool-comparison", "if", "(", "line", ".", "count", "(", "'\"'", ",", "0", ",", "commentpos", ")", "-", "line", ".", "count", "(", "'\\\\\"'", ",", "0", ",", "commentpos", ")", ")", "%", "2", "==", "0", ":", "# not in quotes", "# Allow one space for new scopes, two spaces otherwise:", "if", "(", "not", "Match", "(", "r'^\\s*{ //'", ",", "line", ")", "and", "(", "(", "commentpos", ">=", "1", "and", "line", "[", "commentpos", "-", "1", "]", "not", "in", "string", ".", "whitespace", ")", "or", "(", "commentpos", ">=", "2", "and", "line", "[", "commentpos", "-", "2", "]", "not", "in", "string", ".", "whitespace", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/comments'", ",", "2", ",", "'At least two spaces is best between code and comments'", ")", "# There should always be a space between the // and the comment", "commentend", "=", "commentpos", "+", "2", "if", "commentend", "<", "len", "(", "line", ")", "and", "not", "line", "[", "commentend", "]", "==", "' '", ":", "# but some lines are exceptions -- e.g. if they're big", "# comment delimiters like:", "# //----------------------------------------------------------", "# or are an empty C++ style Doxygen comment, like:", "# ///", "# or C++ style Doxygen comments placed after the variable:", "# ///< Header comment", "# //!< Header comment", "# or they begin with multiple slashes followed by a space:", "# //////// Header comment", "match", "=", "(", "Search", "(", "r'[=/-]{4,}\\s*$'", ",", "line", "[", "commentend", ":", "]", ")", "or", "Search", "(", "r'^/$'", ",", "line", "[", "commentend", ":", "]", ")", "or", "Search", "(", "r'^!< '", ",", "line", "[", "commentend", ":", "]", ")", "or", "Search", "(", "r'^/< '", ",", "line", "[", "commentend", ":", "]", ")", "or", "Search", "(", "r'^/+ '", ",", "line", "[", "commentend", ":", "]", ")", ")", "if", "not", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/comments'", ",", "4", ",", "'Should have a space between // and comment'", ")", "CheckComment", "(", "line", "[", "commentpos", ":", "]", ",", "filename", ",", "linenum", ",", "error", ")", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# get rid of comments and strings", "# Don't try to do spacing checks for operator methods", "line", "=", "re", ".", "sub", "(", "r'operator(==|!=|<|<<|<=|>=|>>|>)\\('", ",", "'operator\\('", ",", "line", ")", "# We allow no-spaces around = within an if: \"if ( (a=Foo()) == 0 )\".", "# Otherwise not. Note we only check for non-spaces on *both* sides;", "# sometimes people put non-spaces on one side when aligning ='s among", "# many lines (not that this is behavior that I approve of...)", "if", "Search", "(", "r'[\\w.]=[\\w.]'", ",", "line", ")", "and", "not", "Search", "(", "r'\\b(if|while) '", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "4", ",", "'Missing spaces around ='", ")", "# It's ok not to have spaces around binary operators like + - * /, but if", "# there's too little whitespace, we get concerned. It's hard to tell,", "# though, so we punt on this one for now. TODO.", "# You should always have whitespace around binary operators.", "#", "# Check <= and >= first to avoid false positives with < and >, then", "# check non-include lines for spacing around < and >.", "match", "=", "Search", "(", "r'[^<>=!\\s](==|!=|<=|>=)[^<>=!\\s]'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "3", ",", "'Missing spaces around %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# We allow no-spaces around << when used like this: 10<<20, but", "# not otherwise (particularly, not when used as streams)", "# Also ignore using ns::operator<<;", "match", "=", "Search", "(", "r'(operator|\\S)(?:L|UL|ULL|l|ul|ull)?<<(\\S)'", ",", "line", ")", "if", "(", "match", "and", "not", "(", "match", ".", "group", "(", "1", ")", ".", "isdigit", "(", ")", "and", "match", ".", "group", "(", "2", ")", ".", "isdigit", "(", ")", ")", "and", "not", "(", "match", ".", "group", "(", "1", ")", "==", "'operator'", "and", "match", ".", "group", "(", "2", ")", "==", "';'", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "3", ",", "'Missing spaces around <<'", ")", "elif", "not", "Match", "(", "r'#.*include'", ",", "line", ")", ":", "# Avoid false positives on ->", "reduced_line", "=", "line", ".", "replace", "(", "'->'", ",", "''", ")", "# Look for < that is not surrounded by spaces. This is only", "# triggered if both sides are missing spaces, even though", "# technically should should flag if at least one side is missing a", "# space. This is done to avoid some false positives with shifts.", "match", "=", "Search", "(", "r'[^\\s<]<([^\\s=<].*)'", ",", "reduced_line", ")", "if", "(", "match", "and", "not", "FindNextMatchingAngleBracket", "(", "clean_lines", ",", "linenum", ",", "match", ".", "group", "(", "1", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "3", ",", "'Missing spaces around <'", ")", "# Look for > that is not surrounded by spaces. Similar to the", "# above, we only trigger if both sides are missing spaces to avoid", "# false positives with shifts.", "match", "=", "Search", "(", "r'^(.*[^\\s>])>[^\\s=>]'", ",", "reduced_line", ")", "if", "(", "match", "and", "not", "FindPreviousMatchingAngleBracket", "(", "clean_lines", ",", "linenum", ",", "match", ".", "group", "(", "1", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "3", ",", "'Missing spaces around >'", ")", "# We allow no-spaces around >> for almost anything. This is because", "# C++11 allows \">>\" to close nested templates, which accounts for", "# most cases when \">>\" is not followed by a space.", "#", "# We still warn on \">>\" followed by alpha character, because that is", "# likely due to \">>\" being used for right shifts, e.g.:", "# value >> alpha", "#", "# When \">>\" is used to close templates, the alphanumeric letter that", "# follows would be part of an identifier, and there should still be", "# a space separating the template type and the identifier.", "# type<type<type>> alpha", "match", "=", "Search", "(", "r'>>[a-zA-Z_]'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "3", ",", "'Missing spaces around >>'", ")", "# There shouldn't be space around unary operators", "match", "=", "Search", "(", "r'(!\\s|~\\s|[\\s]--[\\s;]|[\\s]\\+\\+[\\s;])'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/operators'", ",", "4", ",", "'Extra space for operator %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# A pet peeve of mine: no spaces after an if, while, switch, or for", "match", "=", "Search", "(", "r' (if\\(|for\\(|while\\(|switch\\()'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/parens'", ",", "5", ",", "'Missing space before ( in %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# For if/for/while/switch, the left and right parens should be", "# consistent about how many spaces are inside the parens, and", "# there should either be zero or one spaces inside the parens.", "# We don't want: \"if ( foo)\" or \"if ( foo )\".", "# Exception: \"for ( ; foo; bar)\" and \"for (foo; bar; )\" are allowed.", "match", "=", "Search", "(", "r'\\b(if|for|while|switch)\\s*'", "r'\\(([ ]*)(.).*[^ ]+([ ]*)\\)\\s*{\\s*$'", ",", "line", ")", "if", "match", ":", "if", "len", "(", "match", ".", "group", "(", "2", ")", ")", "!=", "len", "(", "match", ".", "group", "(", "4", ")", ")", ":", "if", "not", "(", "match", ".", "group", "(", "3", ")", "==", "';'", "and", "len", "(", "match", ".", "group", "(", "2", ")", ")", "==", "1", "+", "len", "(", "match", ".", "group", "(", "4", ")", ")", "or", "not", "match", ".", "group", "(", "2", ")", "and", "Search", "(", "r'\\bfor\\s*\\(.*; \\)'", ",", "line", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/parens'", ",", "5", ",", "'Mismatching spaces inside () in %s'", "%", "match", ".", "group", "(", "1", ")", ")", "if", "len", "(", "match", ".", "group", "(", "2", ")", ")", "not", "in", "[", "0", ",", "1", "]", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/parens'", ",", "5", ",", "'Should have zero or one spaces inside ( and ) in %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# You should always have a space after a comma (either as fn arg or operator)", "#", "# This does not apply when the non-space character following the", "# comma is another comma, since the only time when that happens is", "# for empty macro arguments.", "#", "# We run this check in two passes: first pass on elided lines to", "# verify that lines contain missing whitespaces, second pass on raw", "# lines to confirm that those missing whitespaces are not due to", "# elided comments.", "if", "Search", "(", "r',[^,\\s]'", ",", "line", ")", "and", "Search", "(", "r',[^,\\s]'", ",", "raw", "[", "linenum", "]", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/comma'", ",", "3", ",", "'Missing space after ,'", ")", "# You should always have a space after a semicolon", "# except for few corner cases", "# TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more", "# space after ;", "if", "Search", "(", "r';[^\\s};\\\\)/]'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/semicolon'", ",", "3", ",", "'Missing space after ;'", ")", "# Next we will look for issues with function calls.", "CheckSpacingForFunctionCall", "(", "filename", ",", "line", ",", "linenum", ",", "error", ")", "# Except after an opening paren, or after another opening brace (in case of", "# an initializer list, for instance), you should have spaces before your", "# braces. And since you should never have braces at the beginning of a line,", "# this is an easy test.", "match", "=", "Match", "(", "r'^(.*[^ ({]){'", ",", "line", ")", "if", "match", ":", "# Try a bit harder to check for brace initialization. This", "# happens in one of the following forms:", "# Constructor() : initializer_list_{} { ... }", "# Constructor{}.MemberFunction()", "# Type variable{};", "# FunctionCall(type{}, ...);", "# LastArgument(..., type{});", "# LOG(INFO) << type{} << \" ...\";", "# map_of_type[{...}] = ...;", "#", "# We check for the character following the closing brace, and", "# silence the warning if it's one of those listed above, i.e.", "# \"{.;,)<]\".", "#", "# To account for nested initializer list, we allow any number of", "# closing braces up to \"{;,)<\". We can't simply silence the", "# warning on first sight of closing brace, because that would", "# cause false negatives for things that are not initializer lists.", "# Silence this: But not this:", "# Outer{ if (...) {", "# Inner{...} if (...){ // Missing space before {", "# }; }", "#", "# There is a false negative with this approach if people inserted", "# spurious semicolons, e.g. \"if (cond){};\", but we will catch the", "# spurious semicolon with a separate check.", "(", "endline", ",", "endlinenum", ",", "endpos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "len", "(", "match", ".", "group", "(", "1", ")", ")", ")", "trailing_text", "=", "''", "if", "endpos", ">", "-", "1", ":", "trailing_text", "=", "endline", "[", "endpos", ":", "]", "for", "offset", "in", "xrange", "(", "endlinenum", "+", "1", ",", "min", "(", "endlinenum", "+", "3", ",", "clean_lines", ".", "NumLines", "(", ")", "-", "1", ")", ")", ":", "trailing_text", "+=", "clean_lines", ".", "elided", "[", "offset", "]", "if", "not", "Match", "(", "r'^[\\s}]*[{.;,)<\\]]'", ",", "trailing_text", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/braces'", ",", "5", ",", "'Missing space before {'", ")", "# Make sure '} else {' has spaces.", "if", "Search", "(", "r'}else'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/braces'", ",", "5", ",", "'Missing space before else'", ")", "# You shouldn't have spaces before your brackets, except maybe after", "# 'delete []' or 'new char * []'.", "if", "Search", "(", "r'\\w\\s+\\['", ",", "line", ")", "and", "not", "Search", "(", "r'delete\\s+\\['", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/braces'", ",", "5", ",", "'Extra space before ['", ")", "# You shouldn't have a space before a semicolon at the end of the line.", "# There's a special case for \"for\" since the style guide allows space before", "# the semicolon there.", "if", "Search", "(", "r':\\s*;\\s*$'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/semicolon'", ",", "5", ",", "'Semicolon defining empty statement. Use {} instead.'", ")", "elif", "Search", "(", "r'^\\s*;\\s*$'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/semicolon'", ",", "5", ",", "'Line contains only semicolon. If this should be an empty statement, '", "'use {} instead.'", ")", "elif", "(", "Search", "(", "r'\\s+;\\s*$'", ",", "line", ")", "and", "not", "Search", "(", "r'\\bfor\\b'", ",", "line", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/semicolon'", ",", "5", ",", "'Extra space before last semicolon. If this should be an empty '", "'statement, use {} instead.'", ")", "# In range-based for, we wanted spaces before and after the colon, but", "# not around \"::\" tokens that might appear.", "if", "(", "Search", "(", "'for *\\(.*[^:]:[^: ]'", ",", "line", ")", "or", "Search", "(", "'for *\\(.*[^: ]:[^:]'", ",", "line", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/forcolon'", ",", "2", ",", "'Missing space around colon in range-based for loop'", ")" ]

[ "a", ">", "b" ]

[ "def", "__gt__", "(", "a", ",", "b", ")", ":", "return", "a", ".", "_richcmp", "(", "b", ",", "operator", ".", "gt", ")" ]