Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Attempt", "to", "upload", "files", "to", "Gold", ".", "This", "module", "assumes", "setup", "has", "occurred", "for", "the", "vars", "and", "flavor", "modules", "." ]

[ "def", "upload", "(", "self", ")", ":", "revision", "=", "self", ".", "m", ".", "properties", "[", "'revision'", "]", "results_dir", "=", "self", ".", "m", ".", "flavor", ".", "host_dirs", ".", "dm_dir", "# Upload the images. It is preferred that the images are uploaded first", "# so they exist whenever the json is processed.", "image_dest_path", "=", "'gs://%s/dm-images-v1'", "%", "self", ".", "m", ".", "properties", "[", "'gs_bucket'", "]", "for", "ext", "in", "[", "'.png'", "]", ":", "files_to_upload", "=", "self", ".", "m", ".", "file", ".", "glob_paths", "(", "'find %s images'", "%", "ext", ",", "results_dir", ",", "'*%s'", "%", "ext", ",", "test_data", "=", "[", "'someimage.png'", "]", ")", "# For some reason, glob returns results_dir when it should return nothing.", "files_to_upload", "=", "[", "f", "for", "f", "in", "files_to_upload", "if", "str", "(", "f", ")", ".", "endswith", "(", "ext", ")", "]", "if", "len", "(", "files_to_upload", ")", ">", "0", ":", "self", ".", "m", ".", "gsutil", ".", "cp", "(", "'%s images'", "%", "ext", ",", "results_dir", ".", "join", "(", "'*%s'", "%", "ext", ")", ",", "image_dest_path", ",", "multithread", "=", "True", ")", "summary_dest_path", "=", "'gs://%s'", "%", "self", ".", "m", ".", "properties", "[", "'gs_bucket'", "]", "ref", "=", "revision", "# Trybot results are siloed by issue/patchset.", "if", "self", ".", "m", ".", "vars", ".", "is_trybot", ":", "summary_dest_path", "=", "'/'", ".", "join", "(", "[", "summary_dest_path", ",", "'trybot'", "]", ")", "ref", "=", "'%s_%s'", "%", "(", "str", "(", "self", ".", "m", ".", "vars", ".", "issue", ")", ",", "str", "(", "self", ".", "m", ".", "vars", ".", "patchset", ")", ")", "# Compute the directory to upload results to", "now", "=", "self", ".", "m", ".", "time", ".", "utcnow", "(", ")", "summary_dest_path", "=", "'/'", ".", "join", "(", "[", "summary_dest_path", ",", "'dm-json-v1'", ",", "str", "(", "now", ".", "year", ")", ".", "zfill", "(", "4", ")", ",", "str", "(", "now", ".", "month", ")", ".", "zfill", "(", "2", ")", ",", "str", "(", "now", ".", "day", ")", ".", "zfill", "(", "2", ")", ",", "str", "(", "now", ".", "hour", ")", ".", "zfill", "(", "2", ")", ",", "ref", ",", "self", ".", "m", ".", "vars", ".", "builder_name", ",", "str", "(", "int", "(", "calendar", ".", "timegm", "(", "now", ".", "utctimetuple", "(", ")", ")", ")", ")", "]", ")", "# Directly upload dm.json if it exists.", "json_file", "=", "results_dir", ".", "join", "(", "DM_JSON", ")", "# -Z compresses the json file at rest with gzip.", "self", ".", "m", ".", "gsutil", ".", "cp", "(", "'dm.json'", ",", "json_file", ",", "summary_dest_path", "+", "'/'", "+", "DM_JSON", ",", "extra_args", "=", "[", "'-Z'", "]", ")" ]

[ "This", "calls", "write", "()", "for", "each", "element", "in", "the", "sequence", "." ]

[ "def", "writelines", "(", "self", ",", "sequence", ")", ":", "for", "s", "in", "sequence", ":", "self", ".", "send", "(", "s", ")" ]

[ "SetFunctionCode", "(", "self", "str", "data", ")" ]

[ "def", "SetFunctionCode", "(", "self", ",", "*", "args", ")", ":", "return", "_lldb", ".", "SBTypeSummary_SetFunctionCode", "(", "self", ",", "*", "args", ")" ]

[ "Build", "the", "filter", "part" ]

[ "def", "_build_filter_part", "(", "self", ",", "cls", ",", "filters", ",", "order_by", "=", "None", ",", "select", "=", "None", ")", ":", "import", "types", "query_parts", "=", "[", "]", "order_by_filtered", "=", "False", "if", "order_by", ":", "if", "order_by", "[", "0", "]", "==", "\"-\"", ":", "order_by_method", "=", "\"DESC\"", "order_by", "=", "order_by", "[", "1", ":", "]", "else", ":", "order_by_method", "=", "\"ASC\"", "if", "select", ":", "if", "order_by", "and", "order_by", "in", "select", ":", "order_by_filtered", "=", "True", "query_parts", ".", "append", "(", "\"(%s)\"", "%", "select", ")", "if", "isinstance", "(", "filters", ",", "six", ".", "string_types", ")", ":", "query", "=", "\"WHERE %s AND `__type__` = '%s'\"", "%", "(", "filters", ",", "cls", ".", "__name__", ")", "if", "order_by", "in", "[", "\"__id__\"", ",", "\"itemName()\"", "]", ":", "query", "+=", "\" ORDER BY itemName() %s\"", "%", "order_by_method", "elif", "order_by", "is", "not", "None", ":", "query", "+=", "\" ORDER BY `%s` %s\"", "%", "(", "order_by", ",", "order_by_method", ")", "return", "query", "for", "filter", "in", "filters", ":", "filter_parts", "=", "[", "]", "filter_props", "=", "filter", "[", "0", "]", "if", "not", "isinstance", "(", "filter_props", ",", "list", ")", ":", "filter_props", "=", "[", "filter_props", "]", "for", "filter_prop", "in", "filter_props", ":", "(", "name", ",", "op", ")", "=", "filter_prop", ".", "strip", "(", ")", ".", "split", "(", "\" \"", ",", "1", ")", "value", "=", "filter", "[", "1", "]", "property", "=", "cls", ".", "find_property", "(", "name", ")", "if", "name", "==", "order_by", ":", "order_by_filtered", "=", "True", "if", "types", ".", "TypeType", "(", "value", ")", "==", "list", ":", "filter_parts_sub", "=", "[", "]", "for", "val", "in", "value", ":", "val", "=", "self", ".", "encode_value", "(", "property", ",", "val", ")", "if", "isinstance", "(", "val", ",", "list", ")", ":", "for", "v", "in", "val", ":", "filter_parts_sub", ".", "append", "(", "self", ".", "_build_filter", "(", "property", ",", "name", ",", "op", ",", "v", ")", ")", "else", ":", "filter_parts_sub", ".", "append", "(", "self", ".", "_build_filter", "(", "property", ",", "name", ",", "op", ",", "val", ")", ")", "filter_parts", ".", "append", "(", "\"(%s)\"", "%", "(", "\" OR \"", ".", "join", "(", "filter_parts_sub", ")", ")", ")", "else", ":", "val", "=", "self", ".", "encode_value", "(", "property", ",", "value", ")", "if", "isinstance", "(", "val", ",", "list", ")", ":", "for", "v", "in", "val", ":", "filter_parts", ".", "append", "(", "self", ".", "_build_filter", "(", "property", ",", "name", ",", "op", ",", "v", ")", ")", "else", ":", "filter_parts", ".", "append", "(", "self", ".", "_build_filter", "(", "property", ",", "name", ",", "op", ",", "val", ")", ")", "query_parts", ".", "append", "(", "\"(%s)\"", "%", "(", "\" or \"", ".", "join", "(", "filter_parts", ")", ")", ")", "type_query", "=", "\"(`__type__` = '%s'\"", "%", "cls", ".", "__name__", "for", "subclass", "in", "self", ".", "_get_all_decendents", "(", "cls", ")", ".", "keys", "(", ")", ":", "type_query", "+=", "\" or `__type__` = '%s'\"", "%", "subclass", "type_query", "+=", "\")\"", "query_parts", ".", "append", "(", "type_query", ")", "order_by_query", "=", "\"\"", "if", "order_by", ":", "if", "not", "order_by_filtered", ":", "query_parts", ".", "append", "(", "\"`%s` LIKE '%%'\"", "%", "order_by", ")", "if", "order_by", "in", "[", "\"__id__\"", ",", "\"itemName()\"", "]", ":", "order_by_query", "=", "\" ORDER BY itemName() %s\"", "%", "order_by_method", "else", ":", "order_by_query", "=", "\" ORDER BY `%s` %s\"", "%", "(", "order_by", ",", "order_by_method", ")", "if", "len", "(", "query_parts", ")", ">", "0", ":", "return", "\"WHERE %s %s\"", "%", "(", "\" AND \"", ".", "join", "(", "query_parts", ")", ",", "order_by_query", ")", "else", ":", "return", "\"\"" ]

[ "Transform", "numeric", "labels", "into", "onehot_labels", "using", "tf", ".", "one_hot", "." ]

[ "def", "one_hot_encoding", "(", "labels", ",", "num_classes", ",", "on_value", "=", "1.0", ",", "off_value", "=", "0.0", ",", "outputs_collections", "=", "None", ",", "scope", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "scope", ",", "'OneHotEncoding'", ",", "[", "labels", ",", "num_classes", "]", ")", "as", "sc", ":", "labels", "=", "ops", ".", "convert_to_tensor", "(", "labels", ")", "if", "labels", ".", "dtype", "==", "dtypes", ".", "int32", ":", "labels", "=", "standard_ops", ".", "to_int64", "(", "labels", ")", "outputs", "=", "standard_ops", ".", "one_hot", "(", "labels", ",", "num_classes", ",", "on_value", "=", "on_value", ",", "off_value", "=", "off_value", ")", "return", "utils", ".", "collect_named_outputs", "(", "outputs_collections", ",", "sc", ",", "outputs", ")" ]

[ "Return", "an", "SSL", ".", "Context", "from", "self", "attributes", "." ]

[ "def", "get_context", "(", "self", ")", ":", "# See http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/442473", "c", "=", "SSL", ".", "Context", "(", "SSL", ".", "SSLv23_METHOD", ")", "c", ".", "use_privatekey_file", "(", "self", ".", "private_key", ")", "if", "self", ".", "certificate_chain", ":", "c", ".", "load_verify_locations", "(", "self", ".", "certificate_chain", ")", "c", ".", "use_certificate_file", "(", "self", ".", "certificate", ")", "return", "c" ]

[ "Returns", "the", "arrays", "of", "capabilities", "." ]

[ "def", "generate_capability_arrays", "(", "caps", ")", ":", "caps", "=", "sorted", "(", "set", "(", "[", "tuple", "(", "c", ")", "for", "c", "in", "caps", "if", "c", "]", ")", ")", "arrays", "=", "[", "'static const SpvCapability {}[] = {};'", ".", "format", "(", "get_capability_array_name", "(", "c", ")", ",", "compose_capability_list", "(", "c", ")", ")", "for", "c", "in", "caps", "]", "return", "'\\n'", ".", "join", "(", "arrays", ")" ]

[ "ProcessEventLocally", "(", "self", "Event", "event", ")", "-", ">", "bool" ]

[ "def", "ProcessEventLocally", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "EvtHandler_ProcessEventLocally", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Function", "which", "don", "t", "have", "special", "handlers", "are", "parsed", "here", "." ]

[ "def", "parse_func_default", "(", "self", ",", "line", ")", ":", "print_dbg", "(", "\"\\tdefault_func: \"", "+", "line", ")", "params", ",", "line", "=", "self", ".", "parse_func_params", "(", "line", ")", "return", "line" ]

[ "FindItemById", "(", "self", "int", "id", ")", "-", ">", "MenuItem" ]

[ "def", "FindItemById", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "MenuBar_FindItemById", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Run", "one", "step", "of", "LSTM", "." ]

[ "def", "call", "(", "self", ",", "inputs", ",", "state", ")", ":", "num_proj", "=", "self", ".", "_num_units", "if", "self", ".", "_num_proj", "is", "None", "else", "self", ".", "_num_proj", "sigmoid", "=", "math_ops", ".", "sigmoid", "if", "self", ".", "_state_is_tuple", ":", "(", "c_prev", ",", "m_prev", ")", "=", "state", "else", ":", "c_prev", "=", "array_ops", ".", "slice", "(", "state", ",", "[", "0", ",", "0", "]", ",", "[", "-", "1", ",", "self", ".", "_num_units", "]", ")", "m_prev", "=", "array_ops", ".", "slice", "(", "state", ",", "[", "0", ",", "self", ".", "_num_units", "]", ",", "[", "-", "1", ",", "num_proj", "]", ")", "input_size", "=", "inputs", ".", "get_shape", "(", ")", ".", "with_rank", "(", "2", ")", ".", "dims", "[", "1", "]", "if", "input_size", ".", "value", "is", "None", ":", "raise", "ValueError", "(", "\"Could not infer input size from inputs.get_shape()[-1]\"", ")", "# i = input_gate, j = new_input, f = forget_gate, o = output_gate", "lstm_matrix", "=", "math_ops", ".", "matmul", "(", "array_ops", ".", "concat", "(", "[", "inputs", ",", "m_prev", "]", ",", "1", ")", ",", "self", ".", "_masked_kernel", ")", "lstm_matrix", "=", "nn_ops", ".", "bias_add", "(", "lstm_matrix", ",", "self", ".", "_bias", ")", "i", ",", "j", ",", "f", ",", "o", "=", "array_ops", ".", "split", "(", "value", "=", "lstm_matrix", ",", "num_or_size_splits", "=", "4", ",", "axis", "=", "1", ")", "# Diagonal connections", "if", "self", ".", "_use_peepholes", ":", "c", "=", "(", "sigmoid", "(", "f", "+", "self", ".", "_forget_bias", "+", "self", ".", "_w_f_diag", "*", "c_prev", ")", "*", "c_prev", "+", "sigmoid", "(", "i", "+", "self", ".", "_w_i_diag", "*", "c_prev", ")", "*", "self", ".", "_activation", "(", "j", ")", ")", "else", ":", "c", "=", "(", "sigmoid", "(", "f", "+", "self", ".", "_forget_bias", ")", "*", "c_prev", "+", "sigmoid", "(", "i", ")", "*", "self", ".", "_activation", "(", "j", ")", ")", "if", "self", ".", "_cell_clip", "is", "not", "None", ":", "# pylint: disable=invalid-unary-operand-type", "c", "=", "clip_ops", ".", "clip_by_value", "(", "c", ",", "-", "self", ".", "_cell_clip", ",", "self", ".", "_cell_clip", ")", "# pylint: enable=invalid-unary-operand-type", "if", "self", ".", "_use_peepholes", ":", "m", "=", "sigmoid", "(", "o", "+", "self", ".", "_w_o_diag", "*", "c", ")", "*", "self", ".", "_activation", "(", "c", ")", "else", ":", "m", "=", "sigmoid", "(", "o", ")", "*", "self", ".", "_activation", "(", "c", ")", "if", "self", ".", "_num_proj", "is", "not", "None", ":", "m", "=", "math_ops", ".", "matmul", "(", "m", ",", "self", ".", "_proj_kernel", ")", "if", "self", ".", "_proj_clip", "is", "not", "None", ":", "# pylint: disable=invalid-unary-operand-type", "m", "=", "clip_ops", ".", "clip_by_value", "(", "m", ",", "-", "self", ".", "_proj_clip", ",", "self", ".", "_proj_clip", ")", "# pylint: enable=invalid-unary-operand-type", "new_state", "=", "(", "tf_rnn", ".", "LSTMStateTuple", "(", "c", ",", "m", ")", "if", "self", ".", "_state_is_tuple", "else", "array_ops", ".", "concat", "(", "[", "c", ",", "m", "]", ",", "1", ")", ")", "return", "m", ",", "new_state" ]

[ ":", "param", "value", ":", "input", "value", ":", "return", ":", "16", "-", "bit", "big", "endian", "bytearray", "representation", "of", "the", "input", "value" ]

[ "def", "pack_be16", "(", "value", ")", ":", "_check_input_value", "(", "value", ",", "16", ")", "return", "bytearray", "(", "[", "(", "value", ">>", "8", ")", "&", "0xFF", ",", "value", "&", "0xFF", "]", ")" ]

[ "Creates", "a", "1D", "tensor", "containing", "a", "sequence", "of", "integers", "." ]

[ "def", "arange", "(", "start", ",", "stop", "=", "None", ",", "step", "=", "1", ",", "dtype", "=", "'int32'", ")", ":", "# Match the behavior of numpy and Theano by returning an empty sequence.", "if", "stop", "is", "None", "and", "start", "<", "0", ":", "start", "=", "0", "result", "=", "math_ops", ".", "range", "(", "start", ",", "limit", "=", "stop", ",", "delta", "=", "step", ",", "name", "=", "'arange'", ")", "if", "dtype", "!=", "'int32'", ":", "result", "=", "cast", "(", "result", ",", "dtype", ")", "return", "result" ]

[ "Return", "DXF", "string", "of", "the", "object", ".", "DEPRECATED", ".", "Use", "get_dxf", "." ]

[ "def", "getDXF", "(", "obj", ",", "direction", "=", "None", ")", ":", "utils", ".", "use_instead", "(", "\"get_dxf\"", ")", "return", "get_dxf", "(", "obj", ",", "direction", "=", "direction", ")" ]

[ "Creates", "a", "normal", "token", "." ]

[ "def", "__CreateNormalToken", "(", "self", ",", "mode", ",", "string", ",", "line", ",", "line_number", ")", ":", "type", "=", "Type", ".", "NORMAL", "if", "mode", "in", "self", ".", "default_types", ":", "type", "=", "self", ".", "default_types", "[", "mode", "]", "return", "self", ".", "_CreateToken", "(", "string", ",", "type", ",", "line", ",", "line_number", ")" ]

[ "Train", "CIFAR", "-", "10", "for", "a", "number", "of", "steps", "." ]

[ "def", "train", "(", ")", ":", "with", "tf", ".", "Graph", "(", ")", ".", "as_default", "(", ")", ",", "tf", ".", "device", "(", "'/cpu:0'", ")", ":", "# Create a variable to count the number of train() calls. This equals the", "# number of batches processed * FLAGS.num_gpus.", "global_step", "=", "tf", ".", "get_variable", "(", "'global_step'", ",", "[", "]", ",", "initializer", "=", "tf", ".", "constant_initializer", "(", "0", ")", ",", "trainable", "=", "False", ")", "# Calculate the learning rate schedule.", "num_batches_per_epoch", "=", "(", "cifar10", ".", "NUM_EXAMPLES_PER_EPOCH_FOR_TRAIN", "/", "FLAGS", ".", "batch_size", ")", "decay_steps", "=", "int", "(", "num_batches_per_epoch", "*", "cifar10", ".", "NUM_EPOCHS_PER_DECAY", ")", "# Decay the learning rate exponentially based on the number of steps.", "lr", "=", "tf", ".", "train", ".", "exponential_decay", "(", "cifar10", ".", "INITIAL_LEARNING_RATE", ",", "global_step", ",", "decay_steps", ",", "cifar10", ".", "LEARNING_RATE_DECAY_FACTOR", ",", "staircase", "=", "True", ")", "# Create an optimizer that performs gradient descent.", "opt", "=", "tf", ".", "train", ".", "GradientDescentOptimizer", "(", "lr", ")", "# Calculate the gradients for each model tower.", "tower_grads", "=", "[", "]", "for", "i", "in", "xrange", "(", "FLAGS", ".", "num_gpus", ")", ":", "with", "tf", ".", "device", "(", "'/gpu:%d'", "%", "i", ")", ":", "with", "tf", ".", "name_scope", "(", "'%s_%d'", "%", "(", "cifar10", ".", "TOWER_NAME", ",", "i", ")", ")", "as", "scope", ":", "# Calculate the loss for one tower of the CIFAR model. This function", "# constructs the entire CIFAR model but shares the variables across", "# all towers.", "loss", "=", "tower_loss", "(", "scope", ")", "# Reuse variables for the next tower.", "tf", ".", "get_variable_scope", "(", ")", ".", "reuse_variables", "(", ")", "# Retain the summaries from the final tower.", "summaries", "=", "tf", ".", "get_collection", "(", "tf", ".", "GraphKeys", ".", "SUMMARIES", ",", "scope", ")", "# Calculate the gradients for the batch of data on this CIFAR tower.", "grads", "=", "opt", ".", "compute_gradients", "(", "loss", ")", "# Keep track of the gradients across all towers.", "tower_grads", ".", "append", "(", "grads", ")", "# We must calculate the mean of each gradient. Note that this is the", "# synchronization point across all towers.", "grads", "=", "average_gradients", "(", "tower_grads", ")", "# Add a summary to track the learning rate.", "summaries", ".", "append", "(", "tf", ".", "scalar_summary", "(", "'learning_rate'", ",", "lr", ")", ")", "# Add histograms for gradients.", "for", "grad", ",", "var", "in", "grads", ":", "if", "grad", "is", "not", "None", ":", "summaries", ".", "append", "(", "tf", ".", "histogram_summary", "(", "var", ".", "op", ".", "name", "+", "'/gradients'", ",", "grad", ")", ")", "# Apply the gradients to adjust the shared variables.", "apply_gradient_op", "=", "opt", ".", "apply_gradients", "(", "grads", ",", "global_step", "=", "global_step", ")", "# Add histograms for trainable variables.", "for", "var", "in", "tf", ".", "trainable_variables", "(", ")", ":", "summaries", ".", "append", "(", "tf", ".", "histogram_summary", "(", "var", ".", "op", ".", "name", ",", "var", ")", ")", "# Track the moving averages of all trainable variables.", "variable_averages", "=", "tf", ".", "train", ".", "ExponentialMovingAverage", "(", "cifar10", ".", "MOVING_AVERAGE_DECAY", ",", "global_step", ")", "variables_averages_op", "=", "variable_averages", ".", "apply", "(", "tf", ".", "trainable_variables", "(", ")", ")", "# Group all updates to into a single train op.", "train_op", "=", "tf", ".", "group", "(", "apply_gradient_op", ",", "variables_averages_op", ")", "# Create a saver.", "saver", "=", "tf", ".", "train", ".", "Saver", "(", "tf", ".", "all_variables", "(", ")", ")", "# Build the summary operation from the last tower summaries.", "summary_op", "=", "tf", ".", "merge_summary", "(", "summaries", ")", "# Build an initialization operation to run below.", "init", "=", "tf", ".", "initialize_all_variables", "(", ")", "# Start running operations on the Graph. allow_soft_placement must be set to", "# True to build towers on GPU, as some of the ops do not have GPU", "# implementations.", "sess", "=", "tf", ".", "Session", "(", "config", "=", "tf", ".", "ConfigProto", "(", "allow_soft_placement", "=", "True", ",", "log_device_placement", "=", "FLAGS", ".", "log_device_placement", ")", ")", "sess", ".", "run", "(", "init", ")", "# Start the queue runners.", "tf", ".", "train", ".", "start_queue_runners", "(", "sess", "=", "sess", ")", "summary_writer", "=", "tf", ".", "train", ".", "SummaryWriter", "(", "FLAGS", ".", "train_dir", ",", "sess", ".", "graph", ")", "for", "step", "in", "xrange", "(", "FLAGS", ".", "max_steps", ")", ":", "start_time", "=", "time", ".", "time", "(", ")", "_", ",", "loss_value", "=", "sess", ".", "run", "(", "[", "train_op", ",", "loss", "]", ")", "duration", "=", "time", ".", "time", "(", ")", "-", "start_time", "assert", "not", "np", ".", "isnan", "(", "loss_value", ")", ",", "'Model diverged with loss = NaN'", "if", "step", "%", "10", "==", "0", ":", "num_examples_per_step", "=", "FLAGS", ".", "batch_size", "*", "FLAGS", ".", "num_gpus", "examples_per_sec", "=", "num_examples_per_step", "/", "duration", "sec_per_batch", "=", "duration", "/", "FLAGS", ".", "num_gpus", "format_str", "=", "(", "'%s: step %d, loss = %.2f (%.1f examples/sec; %.3f '", "'sec/batch)'", ")", "print", "(", "format_str", "%", "(", "datetime", ".", "now", "(", ")", ",", "step", ",", "loss_value", ",", "examples_per_sec", ",", "sec_per_batch", ")", ")", "if", "step", "%", "100", "==", "0", ":", "summary_str", "=", "sess", ".", "run", "(", "summary_op", ")", "summary_writer", ".", "add_summary", "(", "summary_str", ",", "step", ")", "# Save the model checkpoint periodically.", "if", "step", "%", "1000", "==", "0", "or", "(", "step", "+", "1", ")", "==", "FLAGS", ".", "max_steps", ":", "checkpoint_path", "=", "os", ".", "path", ".", "join", "(", "FLAGS", ".", "train_dir", ",", "'model.ckpt'", ")", "saver", ".", "save", "(", "sess", ",", "checkpoint_path", ",", "global_step", "=", "step", ")" ]

[ "Mark", "the", "object", "as", "expired", "to", "prevent", "future", "API", "accesses", "." ]

[ "def", "expire", "(", "self", ")", ":", "self", ".", "expired", "=", "True" ]

[ "Draw", "random", "samples", "from", "a", "Wishart", "distribution", "." ]

[ "def", "rvs", "(", "self", ",", "df", ",", "scale", ",", "size", "=", "1", ",", "random_state", "=", "None", ")", ":", "n", ",", "shape", "=", "self", ".", "_process_size", "(", "size", ")", "dim", ",", "df", ",", "scale", "=", "self", ".", "_process_parameters", "(", "df", ",", "scale", ")", "# Cholesky decomposition of scale", "C", "=", "scipy", ".", "linalg", ".", "cholesky", "(", "scale", ",", "lower", "=", "True", ")", "out", "=", "self", ".", "_rvs", "(", "n", ",", "shape", ",", "dim", ",", "df", ",", "C", ",", "random_state", ")", "return", "_squeeze_output", "(", "out", ")" ]

[ "Check", "whether", "the", "character", "is", "part", "of", "YiSyllables", "UCS", "Block" ]

[ "def", "uCSIsYiSyllables", "(", "code", ")", ":", "ret", "=", "libxml2mod", ".", "xmlUCSIsYiSyllables", "(", "code", ")", "return", "ret" ]

[ "Updates", "the", "global", "list", "of", "error", "-", "suppressions", "." ]

[ "def", "ParseNolintSuppressions", "(", "filename", ",", "raw_line", ",", "linenum", ",", "error", ")", ":", "# FIXME(adonovan): \"NOLINT(\" is misparsed as NOLINT(*).", "matched", "=", "_RE_SUPPRESSION", ".", "search", "(", "raw_line", ")", "if", "matched", ":", "if", "matched", ".", "group", "(", "1", ")", "==", "'_NEXT_LINE'", ":", "linenum", "+=", "1", "category", "=", "matched", ".", "group", "(", "2", ")", "if", "category", "in", "(", "None", ",", "'(*)'", ")", ":", "# => \"suppress all\"", "_error_suppressions", ".", "setdefault", "(", "None", ",", "set", "(", ")", ")", ".", "add", "(", "linenum", ")", "else", ":", "if", "category", ".", "startswith", "(", "'('", ")", "and", "category", ".", "endswith", "(", "')'", ")", ":", "category", "=", "category", "[", "1", ":", "-", "1", "]", "if", "category", "in", "_ERROR_CATEGORIES", ":", "_error_suppressions", ".", "setdefault", "(", "category", ",", "set", "(", ")", ")", ".", "add", "(", "linenum", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/nolint'", ",", "5", ",", "'Unknown NOLINT error category: %s'", "%", "category", ")" ]

[ "Return", "a", "constructor", "for", "an", "encoder", "for", "a", "fixed", "-", "width", "field", "." ]

[ "def", "_StructPackEncoder", "(", "wire_type", ",", "format", ")", ":", "value_size", "=", "struct", ".", "calcsize", "(", "format", ")", "def", "SpecificEncoder", "(", "field_number", ",", "is_repeated", ",", "is_packed", ")", ":", "local_struct_pack", "=", "struct", ".", "pack", "if", "is_packed", ":", "tag_bytes", "=", "TagBytes", "(", "field_number", ",", "wire_format", ".", "WIRETYPE_LENGTH_DELIMITED", ")", "local_EncodeVarint", "=", "_EncodeVarint", "def", "EncodePackedField", "(", "write", ",", "value", ",", "deterministic", ")", ":", "write", "(", "tag_bytes", ")", "local_EncodeVarint", "(", "write", ",", "len", "(", "value", ")", "*", "value_size", ",", "deterministic", ")", "for", "element", "in", "value", ":", "write", "(", "local_struct_pack", "(", "format", ",", "element", ")", ")", "return", "EncodePackedField", "elif", "is_repeated", ":", "tag_bytes", "=", "TagBytes", "(", "field_number", ",", "wire_type", ")", "def", "EncodeRepeatedField", "(", "write", ",", "value", ",", "unused_deterministic", "=", "None", ")", ":", "for", "element", "in", "value", ":", "write", "(", "tag_bytes", ")", "write", "(", "local_struct_pack", "(", "format", ",", "element", ")", ")", "return", "EncodeRepeatedField", "else", ":", "tag_bytes", "=", "TagBytes", "(", "field_number", ",", "wire_type", ")", "def", "EncodeField", "(", "write", ",", "value", ",", "unused_deterministic", "=", "None", ")", ":", "write", "(", "tag_bytes", ")", "return", "write", "(", "local_struct_pack", "(", "format", ",", "value", ")", ")", "return", "EncodeField", "return", "SpecificEncoder" ]

[ "Add", "Builders", "and", "construction", "variables", "for", "g", "++", "to", "an", "Environment", "." ]

[ "def", "generate", "(", "env", ")", ":", "static_obj", ",", "shared_obj", "=", "SCons", ".", "Tool", ".", "createObjBuilders", "(", "env", ")", "if", "'CXX'", "not", "in", "env", ":", "env", "[", "'CXX'", "]", "=", "env", ".", "Detect", "(", "compilers", ")", "or", "compilers", "[", "0", "]", "cxx", ".", "generate", "(", "env", ")", "# platform specific settings", "if", "env", "[", "'PLATFORM'", "]", "==", "'aix'", ":", "env", "[", "'SHCXXFLAGS'", "]", "=", "SCons", ".", "Util", ".", "CLVar", "(", "'$CXXFLAGS -mminimal-toc'", ")", "env", "[", "'STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'", "]", "=", "1", "env", "[", "'SHOBJSUFFIX'", "]", "=", "'$OBJSUFFIX'", "elif", "env", "[", "'PLATFORM'", "]", "==", "'hpux'", ":", "env", "[", "'SHOBJSUFFIX'", "]", "=", "'.pic.o'", "elif", "env", "[", "'PLATFORM'", "]", "==", "'sunos'", ":", "env", "[", "'SHOBJSUFFIX'", "]", "=", "'.pic.o'", "# determine compiler version", "version", "=", "gcc", ".", "detect_version", "(", "env", ",", "env", "[", "'CXX'", "]", ")", "if", "version", ":", "env", "[", "'CXXVERSION'", "]", "=", "version" ]

[ "pickle", "support" ]

[ "def", "__getinitargs__", "(", "self", ")", ":", "if", "self", ".", "_name", "is", "None", ":", "return", "(", "self", ".", "_offset", ",", ")", "return", "(", "self", ".", "_offset", ",", "self", ".", "_name", ")" ]

[ "RichTextBuffer_GetFloatingLayoutMode", "()", "-", ">", "bool" ]

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

[ "Returns", "an", "instance", "of", "APIType", "corresponding", "to", "the", "described", "class", "." ]

[ "def", "as_type", "(", "self", ")", ":", "return", "APIType", "(", "self", ".", "name", "(", ")", ",", "self", ".", "api", ")" ]

[ "r", "SetOS", "(", "SpatialReference", "self", "double", "dfOriginLat", "double", "dfCMeridian", "double", "scale", "double", "fe", "double", "fn", ")", "-", ">", "OGRErr" ]

[ "def", "SetOS", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_osr", ".", "SpatialReference_SetOS", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Initialization", "." ]

[ "def", "__init__", "(", "self", ",", "opname", ",", "caps", ",", "exts", ",", "operands", ",", "version", ",", "lastVersion", ")", ":", "assert", "opname", ".", "startswith", "(", "'Op'", ")", "self", ".", "opname", "=", "opname", "[", "2", ":", "]", "# Remove the \"Op\" prefix.", "self", ".", "num_caps", "=", "len", "(", "caps", ")", "self", ".", "caps_mask", "=", "get_capability_array_name", "(", "caps", ")", "self", ".", "num_exts", "=", "len", "(", "exts", ")", "self", ".", "exts", "=", "get_extension_array_name", "(", "exts", ")", "self", ".", "operands", "=", "[", "convert_operand_kind", "(", "o", ")", "for", "o", "in", "operands", "]", "self", ".", "fix_syntax", "(", ")", "operands", "=", "[", "o", "[", "0", "]", "for", "o", "in", "operands", "]", "self", ".", "ref_type_id", "=", "'IdResultType'", "in", "operands", "self", ".", "def_result_id", "=", "'IdResult'", "in", "operands", "self", ".", "version", "=", "convert_min_required_version", "(", "version", ")", "self", ".", "lastVersion", "=", "convert_max_required_version", "(", "lastVersion", ")" ]

[ "Bind", "fun", "to", "mouse", "-", "button", "-", "release", "event", "on", "this", "turtle", "on", "canvas", "." ]

[ "def", "onrelease", "(", "self", ",", "fun", ",", "btn", "=", "1", ",", "add", "=", "None", ")", ":", "self", ".", "screen", ".", "_onrelease", "(", "self", ".", "turtle", ".", "_item", ",", "fun", ",", "btn", ",", "add", ")", "self", ".", "_update", "(", ")" ]

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

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

[ "Prove", "a", "single", "-", "goal", "task", "." ]

[ "def", "prove_one", "(", "self", ",", "search_tree", ":", "proof_search_tree", ".", "ProofSearchTree", ",", "task", ":", "proof_assistant_pb2", ".", "ProverTask", ")", "->", "Optional", "[", "Text", "]", ":", "raise", "NotImplementedError", "(", "'Must define this.'", ")" ]

[ "str", "(", "self", ")" ]

[ "def", "__str__", "(", "self", ")", ":", "if", "self", ".", "_denominator", "==", "1", ":", "return", "str", "(", "self", ".", "_numerator", ")", "else", ":", "return", "'%s/%s'", "%", "(", "self", ".", "_numerator", ",", "self", ".", "_denominator", ")" ]

[ "Inserts", "a", "new", "key", "<Key", ">", "with", "value", "1", ".", "Or", "increments", "an", "existing", "key", "by", "1", ".", ":", "type", "key", ":", "str", ":", "rtype", ":", "void" ]

[ "def", "inc", "(", "self", ",", "key", ",", "n", "=", "1", ")", ":", "if", "key", "in", "self", ":", "self", "[", "key", "]", "+=", "n", "else", ":", "self", "[", "key", "]", "=", "n", "for", "i", "in", "range", "(", "n", ")", ":", "self", ".", "dll", ".", "incTo", "(", "key", ",", "self", "[", "key", "]", ")" ]

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

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

[ "Get", "the", "type", "of", "a", "field", "." ]

[ "def", "typeof", "(", "self", ",", "key", ")", ":", "return", "self", ".", "fields", "[", "key", "]", ".", "type" ]

[ "Return", "True", "if", "self", "is", "subnormal", ";", "otherwise", "return", "False", "." ]

[ "def", "is_subnormal", "(", "self", ",", "context", "=", "None", ")", ":", "if", "self", ".", "_is_special", "or", "not", "self", ":", "return", "False", "if", "context", "is", "None", ":", "context", "=", "getcontext", "(", ")", "return", "self", ".", "adjusted", "(", ")", "<", "context", ".", "Emin" ]

[ "C", "++", "does", "not", "expose", "this", "endpoint", "." ]

[ "def", "optimize", "(", "self", ",", "*", "*", "kwargs", ")", ":", "raise", "NotImplementedError", "(", "\"C++ wrapper currently does not support optimization member functions.\"", ")" ]

[ "weight_variable", "generates", "a", "weight", "variable", "of", "a", "given", "shape", "." ]

[ "def", "weight_variable", "(", "shape", ",", "name", ")", ":", "weight_var", "=", "tf", ".", "compat", ".", "v1", ".", "get_variable", "(", "name", ",", "shape", ")", "return", "weight_var" ]

[ "Solves", "a", "dictionary", "learning", "matrix", "factorization", "problem", "online", "." ]

[ "def", "dict_learning_online", "(", "X", ",", "n_components", "=", "2", ",", "alpha", "=", "1", ",", "n_iter", "=", "100", ",", "return_code", "=", "True", ",", "dict_init", "=", "None", ",", "callback", "=", "None", ",", "batch_size", "=", "3", ",", "verbose", "=", "False", ",", "shuffle", "=", "True", ",", "n_jobs", "=", "None", ",", "method", "=", "'lars'", ",", "iter_offset", "=", "0", ",", "random_state", "=", "None", ",", "return_inner_stats", "=", "False", ",", "inner_stats", "=", "None", ",", "return_n_iter", "=", "False", ",", "positive_dict", "=", "False", ",", "positive_code", "=", "False", ",", "method_max_iter", "=", "1000", ")", ":", "if", "n_components", "is", "None", ":", "n_components", "=", "X", ".", "shape", "[", "1", "]", "if", "method", "not", "in", "(", "'lars'", ",", "'cd'", ")", ":", "raise", "ValueError", "(", "'Coding method not supported as a fit algorithm.'", ")", "_check_positive_coding", "(", "method", ",", "positive_code", ")", "method", "=", "'lasso_'", "+", "method", "t0", "=", "time", ".", "time", "(", ")", "n_samples", ",", "n_features", "=", "X", ".", "shape", "# Avoid integer division problems", "alpha", "=", "float", "(", "alpha", ")", "random_state", "=", "check_random_state", "(", "random_state", ")", "# Init V with SVD of X", "if", "dict_init", "is", "not", "None", ":", "dictionary", "=", "dict_init", "else", ":", "_", ",", "S", ",", "dictionary", "=", "randomized_svd", "(", "X", ",", "n_components", ",", "random_state", "=", "random_state", ")", "dictionary", "=", "S", "[", ":", ",", "np", ".", "newaxis", "]", "*", "dictionary", "r", "=", "len", "(", "dictionary", ")", "if", "n_components", "<=", "r", ":", "dictionary", "=", "dictionary", "[", ":", "n_components", ",", ":", "]", "else", ":", "dictionary", "=", "np", ".", "r_", "[", "dictionary", ",", "np", ".", "zeros", "(", "(", "n_components", "-", "r", ",", "dictionary", ".", "shape", "[", "1", "]", ")", ")", "]", "if", "verbose", "==", "1", ":", "print", "(", "'[dict_learning]'", ",", "end", "=", "' '", ")", "if", "shuffle", ":", "X_train", "=", "X", ".", "copy", "(", ")", "random_state", ".", "shuffle", "(", "X_train", ")", "else", ":", "X_train", "=", "X", "dictionary", "=", "check_array", "(", "dictionary", ".", "T", ",", "order", "=", "'F'", ",", "dtype", "=", "np", ".", "float64", ",", "copy", "=", "False", ")", "dictionary", "=", "np", ".", "require", "(", "dictionary", ",", "requirements", "=", "'W'", ")", "X_train", "=", "check_array", "(", "X_train", ",", "order", "=", "'C'", ",", "dtype", "=", "np", ".", "float64", ",", "copy", "=", "False", ")", "batches", "=", "gen_batches", "(", "n_samples", ",", "batch_size", ")", "batches", "=", "itertools", ".", "cycle", "(", "batches", ")", "# The covariance of the dictionary", "if", "inner_stats", "is", "None", ":", "A", "=", "np", ".", "zeros", "(", "(", "n_components", ",", "n_components", ")", ")", "# The data approximation", "B", "=", "np", ".", "zeros", "(", "(", "n_features", ",", "n_components", ")", ")", "else", ":", "A", "=", "inner_stats", "[", "0", "]", ".", "copy", "(", ")", "B", "=", "inner_stats", "[", "1", "]", ".", "copy", "(", ")", "# If n_iter is zero, we need to return zero.", "ii", "=", "iter_offset", "-", "1", "for", "ii", ",", "batch", "in", "zip", "(", "range", "(", "iter_offset", ",", "iter_offset", "+", "n_iter", ")", ",", "batches", ")", ":", "this_X", "=", "X_train", "[", "batch", "]", "dt", "=", "(", "time", ".", "time", "(", ")", "-", "t0", ")", "if", "verbose", "==", "1", ":", "sys", ".", "stdout", ".", "write", "(", "\".\"", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "elif", "verbose", ":", "if", "verbose", ">", "10", "or", "ii", "%", "ceil", "(", "100.", "/", "verbose", ")", "==", "0", ":", "print", "(", "\"Iteration % 3i (elapsed time: % 3is, % 4.1fmn)\"", "%", "(", "ii", ",", "dt", ",", "dt", "/", "60", ")", ")", "this_code", "=", "sparse_encode", "(", "this_X", ",", "dictionary", ".", "T", ",", "algorithm", "=", "method", ",", "alpha", "=", "alpha", ",", "n_jobs", "=", "n_jobs", ",", "check_input", "=", "False", ",", "positive", "=", "positive_code", ",", "max_iter", "=", "method_max_iter", ",", "verbose", "=", "verbose", ")", ".", "T", "# Update the auxiliary variables", "if", "ii", "<", "batch_size", "-", "1", ":", "theta", "=", "float", "(", "(", "ii", "+", "1", ")", "*", "batch_size", ")", "else", ":", "theta", "=", "float", "(", "batch_size", "**", "2", "+", "ii", "+", "1", "-", "batch_size", ")", "beta", "=", "(", "theta", "+", "1", "-", "batch_size", ")", "/", "(", "theta", "+", "1", ")", "A", "*=", "beta", "A", "+=", "np", ".", "dot", "(", "this_code", ",", "this_code", ".", "T", ")", "B", "*=", "beta", "B", "+=", "np", ".", "dot", "(", "this_X", ".", "T", ",", "this_code", ".", "T", ")", "# Update dictionary", "dictionary", "=", "_update_dict", "(", "dictionary", ",", "B", ",", "A", ",", "verbose", "=", "verbose", ",", "random_state", "=", "random_state", ",", "positive", "=", "positive_dict", ")", "# XXX: Can the residuals be of any use?", "# Maybe we need a stopping criteria based on the amount of", "# modification in the dictionary", "if", "callback", "is", "not", "None", ":", "callback", "(", "locals", "(", ")", ")", "if", "return_inner_stats", ":", "if", "return_n_iter", ":", "return", "dictionary", ".", "T", ",", "(", "A", ",", "B", ")", ",", "ii", "-", "iter_offset", "+", "1", "else", ":", "return", "dictionary", ".", "T", ",", "(", "A", ",", "B", ")", "if", "return_code", ":", "if", "verbose", ">", "1", ":", "print", "(", "'Learning code...'", ",", "end", "=", "' '", ")", "elif", "verbose", "==", "1", ":", "print", "(", "'|'", ",", "end", "=", "' '", ")", "code", "=", "sparse_encode", "(", "X", ",", "dictionary", ".", "T", ",", "algorithm", "=", "method", ",", "alpha", "=", "alpha", ",", "n_jobs", "=", "n_jobs", ",", "check_input", "=", "False", ",", "positive", "=", "positive_code", ",", "max_iter", "=", "method_max_iter", ",", "verbose", "=", "verbose", ")", "if", "verbose", ">", "1", ":", "dt", "=", "(", "time", ".", "time", "(", ")", "-", "t0", ")", "print", "(", "'done (total time: % 3is, % 4.1fmn)'", "%", "(", "dt", ",", "dt", "/", "60", ")", ")", "if", "return_n_iter", ":", "return", "code", ",", "dictionary", ".", "T", ",", "ii", "-", "iter_offset", "+", "1", "else", ":", "return", "code", ",", "dictionary", ".", "T", "if", "return_n_iter", ":", "return", "dictionary", ".", "T", ",", "ii", "-", "iter_offset", "+", "1", "else", ":", "return", "dictionary", ".", "T" ]

[ "The", "year", "of", "the", "datetime", "." ]

[ "def", "year", "(", "self", ")", ":", "# noqa: E501", "return", "self", ".", "_get_dt_field", "(", "\"year\"", ")" ]

[ "Find", "best", "-", "matching", "BLAS", "/", "LAPACK", "type", "." ]

[ "def", "find_best_blas_type", "(", "arrays", "=", "(", ")", ",", "dtype", "=", "None", ")", ":", "dtype", "=", "_np", ".", "dtype", "(", "dtype", ")", "prefer_fortran", "=", "False", "if", "arrays", ":", "# use the most generic type in arrays", "dtypes", "=", "[", "ar", ".", "dtype", "for", "ar", "in", "arrays", "]", "dtype", "=", "_np", ".", "find_common_type", "(", "dtypes", ",", "(", ")", ")", "try", ":", "index", "=", "dtypes", ".", "index", "(", "dtype", ")", "except", "ValueError", ":", "index", "=", "0", "if", "arrays", "[", "index", "]", ".", "flags", "[", "'FORTRAN'", "]", ":", "# prefer Fortran for leading array with column major order", "prefer_fortran", "=", "True", "prefix", "=", "_type_conv", ".", "get", "(", "dtype", ".", "char", ",", "'d'", ")", "if", "dtype", ".", "char", "==", "'G'", ":", "# complex256 -> complex128 (i.e., C long double -> C double)", "dtype", "=", "_np", ".", "dtype", "(", "'D'", ")", "elif", "dtype", ".", "char", "not", "in", "'fdFD'", ":", "dtype", "=", "_np", ".", "dtype", "(", "'d'", ")", "return", "prefix", ",", "dtype", ",", "prefer_fortran" ]

[ "Returns", "the", "currently", "active", "variant" ]

[ "def", "variant", "(", ")", ":", "return", "getattr", "(", "_tls", ",", "'variant'", ",", "None", ")" ]

[ "__init__", "(", "self", "int", "language", "=", "-", "1", "int", "flags", "=", "LOCALE_LOAD_DEFAULT", ")", "-", ">", "PyLocale" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_gdi_", ".", "PyLocale_swiginit", "(", "self", ",", "_gdi_", ".", "new_PyLocale", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "PyLocale", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "PyLocale", ")" ]

[ "__init__", "(", "self", ")", "-", ">", "NotificationMessage", "__init__", "(", "self", "String", "title", "String", "message", "=", "wxEmptyString", "Window", "parent", "=", "None", ")", "-", ">", "NotificationMessage" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ")", ":", "_misc_", ".", "NotificationMessage_swiginit", "(", "self", ",", "_misc_", ".", "new_NotificationMessage", "(", "*", "args", ")", ")" ]

[ "Get", "successors", "of", "a", "node", "in", "graph" ]

[ "def", "children", "(", "self", ",", "node", ")", ":" ]

[ "Fetch", "a", "time", "stamp", "for", "this", "Executor", ".", "We", "don", "t", "have", "one", "of", "course", "(", "only", "files", "do", ")", "but", "this", "is", "the", "interface", "used", "by", "the", "timestamp", "module", "." ]

[ "def", "get_timestamp", "(", "self", ")", ":", "return", "0" ]

[ "Returns", "search", "symbol", "being", "used", "." ]

[ "def", "get_symbol", "(", "self", ")", ":", "return", "clib", ".", "get_str", "(", "self", ".", "_abi", "(", "'GetSymbol'", ")", ",", "self", ".", "_obj", ")" ]

[ "deletes", "the", "path", "entirely" ]

[ "def", "deleteDir", "(", "path", ")", ":", "cmd", "=", "\"rm -rf \"", "+", "path", "result", "=", "getstatusoutput", "(", "cmd", ")", "if", "(", "result", "[", "0", "]", "!=", "0", ")", ":", "raise", "RuntimeError", "(", "result", "[", "1", "]", ")" ]

[ "pkg", "/", "typeName", "-", ">", "pkg", "typeName", "-", ">", "None" ]

[ "def", "resource_name_package", "(", "name", ")", ":", "if", "not", "PRN_SEPARATOR", "in", "name", ":", "return", "None", "return", "name", "[", ":", "name", ".", "find", "(", "PRN_SEPARATOR", ")", "]" ]

[ "Returns", "the", "element", "-", "wise", "max", "of", "two", "SparseTensors", "." ]

[ "def", "sparse_maximum", "(", "sp_a", ",", "sp_b", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"SparseSparseMaximum\"", ",", "[", "sp_a", ".", "indices", ",", "sp_a", ".", "values", ",", "sp_b", ".", "indices", ",", "sp_b", ".", "values", "]", ")", "as", "name", ":", "out_indices", ",", "out_values", "=", "gen_sparse_ops", ".", "sparse_sparse_maximum", "(", "sp_a", ".", "indices", ",", "sp_a", ".", "values", ",", "sp_a", ".", "dense_shape", ",", "sp_b", ".", "indices", ",", "sp_b", ".", "values", ",", "sp_b", ".", "dense_shape", ",", "name", "=", "name", ")", "return", "sparse_tensor", ".", "SparseTensor", "(", "out_indices", ",", "out_values", ",", "sp_a", ".", "dense_shape", ")" ]

[ "Tries", "to", "find", "executable", "in", "the", "directories", "listed", "in", "path", "." ]

[ "def", "_find_executable", "(", "executable", ",", "path", "=", "None", ")", ":", "if", "path", "is", "None", ":", "path", "=", "os", ".", "environ", "[", "'PATH'", "]", "paths", "=", "path", ".", "split", "(", "os", ".", "pathsep", ")", "base", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "executable", ")", "if", "(", "sys", ".", "platform", "==", "'win32'", "or", "os", ".", "name", "==", "'os2'", ")", "and", "(", "ext", "!=", "'.exe'", ")", ":", "executable", "=", "executable", "+", "'.exe'", "if", "not", "os", ".", "path", ".", "isfile", "(", "executable", ")", ":", "for", "p", "in", "paths", ":", "f", "=", "os", ".", "path", ".", "join", "(", "p", ",", "executable", ")", "if", "os", ".", "path", ".", "isfile", "(", "f", ")", ":", "# the file exists, we have a shot at spawn working", "return", "f", "return", "None", "else", ":", "return", "executable" ]

[ "Reads", "the", "args", ".", "json", "file", "in", "a", "results", "directory", "copies", "it", "to", "an", "appropriate", "location", "in", "the", "current", "results", "directory", "and", "returns", "the", "link", "speed", "range", "and", "a", "list", "of", "RemyCC", "files", "." ]

[ "def", "process_replot_argument", "(", "replot_dir", ",", "results_dir", ")", ":", "argsfilename", "=", "os", ".", "path", ".", "join", "(", "replot_dir", ",", "\"args.json\"", ")", "argsfile", "=", "open", "(", "argsfilename", ")", "jsondict", "=", "json", ".", "load", "(", "argsfile", ")", "argsfile", ".", "close", "(", ")", "args", "=", "jsondict", "[", "\"args\"", "]", "remyccs", "=", "args", "[", "\"remycc\"", "]", "link_ppt_range", "=", "np", ".", "logspace", "(", "np", ".", "log10", "(", "args", "[", "\"link_ppt\"", "]", "[", "0", "]", ")", ",", "np", ".", "log10", "(", "args", "[", "\"link_ppt\"", "]", "[", "1", "]", ")", ",", "args", "[", "\"num_points\"", "]", ")", "console_dir", "=", "os", ".", "path", ".", "join", "(", "replot_dir", ",", "\"outputs\"", ")", "replots_dirname", "=", "os", ".", "path", ".", "join", "(", "results_dir", ",", "\"replots\"", ",", "os", ".", "path", ".", "basename", "(", "replot_dir", ")", ")", "os", ".", "makedirs", "(", "replots_dirname", ",", "exist_ok", "=", "True", ")", "target_filename", "=", "os", ".", "path", ".", "join", "(", "replots_dirname", ",", "\"args.json\"", ")", "shutil", ".", "copy", "(", "argsfilename", ",", "target_filename", ")", "return", "remyccs", ",", "link_ppt_range", ",", "console_dir" ]

[ "FileTypeInfoSequence", "(", "wxArrayString", "sArray", ")", "-", ">", "FileTypeInfo" ]

[ "def", "FileTypeInfoSequence", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_misc_", ".", "new_FileTypeInfoSequence", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Creates", "a", "client", "for", "the", "Google", "Base", "service", "." ]

[ "def", "__init__", "(", "self", ",", "email", "=", "None", ",", "password", "=", "None", ",", "source", "=", "None", ",", "server", "=", "'base.google.com'", ",", "api_key", "=", "None", ",", "additional_headers", "=", "None", ",", "handler", "=", "None", ",", "*", "*", "kwargs", ")", ":", "gdata", ".", "service", ".", "GDataService", ".", "__init__", "(", "self", ",", "email", "=", "email", ",", "password", "=", "password", ",", "service", "=", "'gbase'", ",", "source", "=", "source", ",", "server", "=", "server", ",", "additional_headers", "=", "additional_headers", ",", "handler", "=", "handler", ",", "*", "*", "kwargs", ")", "self", ".", "api_key", "=", "api_key" ]

[ "Splits", "the", "file", "into", "the", "directory", "basename", "and", "extension", "." ]

[ "def", "Split", "(", "self", ")", ":", "googlename", "=", "self", ".", "RepositoryName", "(", ")", "project", ",", "rest", "=", "os", ".", "path", ".", "split", "(", "googlename", ")", "return", "(", "project", ",", ")", "+", "os", ".", "path", ".", "splitext", "(", "rest", ")" ]

[ "Return", "output", "from", "git", "." ]

[ "def", "git", "(", "self", ",", "*", "arguments", ")", ":", "process", "=", "subprocess", ".", "Popen", "(", "[", "'git'", "]", "+", "list", "(", "arguments", ")", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "cwd", "=", "self", ".", "cwd", ")", "return", "process", ".", "communicate", "(", ")", "[", "0", "]", ".", "decode", "(", "'UTF-8'", ")" ]

[ "GetFrame", "(", "self", ")", "-", ">", "Frame" ]

[ "def", "GetFrame", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PrintPreview_GetFrame", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Merges", "a", "single", "scalar", "field", "into", "a", "message", "." ]

[ "def", "_MergeMessageField", "(", "self", ",", "tokenizer", ",", "message", ",", "field", ")", ":", "is_map_entry", "=", "_IsMapEntry", "(", "field", ")", "if", "tokenizer", ".", "TryConsume", "(", "'<'", ")", ":", "end_token", "=", "'>'", "else", ":", "tokenizer", ".", "Consume", "(", "'{'", ")", "end_token", "=", "'}'", "if", "(", "field", ".", "message_type", ".", "full_name", "==", "_ANY_FULL_TYPE_NAME", "and", "tokenizer", ".", "TryConsume", "(", "'['", ")", ")", ":", "packed_type_name", "=", "self", ".", "_ConsumeAnyTypeUrl", "(", "tokenizer", ")", "tokenizer", ".", "Consume", "(", "']'", ")", "tokenizer", ".", "TryConsume", "(", "':'", ")", "if", "tokenizer", ".", "TryConsume", "(", "'<'", ")", ":", "expanded_any_end_token", "=", "'>'", "else", ":", "tokenizer", ".", "Consume", "(", "'{'", ")", "expanded_any_end_token", "=", "'}'", "if", "not", "self", ".", "descriptor_pool", ":", "raise", "ParseError", "(", "'Descriptor pool required to parse expanded Any field'", ")", "expanded_any_sub_message", "=", "_BuildMessageFromTypeName", "(", "packed_type_name", ",", "self", ".", "descriptor_pool", ")", "if", "not", "expanded_any_sub_message", ":", "raise", "ParseError", "(", "'Type %s not found in descriptor pool'", "%", "packed_type_name", ")", "while", "not", "tokenizer", ".", "TryConsume", "(", "expanded_any_end_token", ")", ":", "if", "tokenizer", ".", "AtEnd", "(", ")", ":", "raise", "tokenizer", ".", "ParseErrorPreviousToken", "(", "'Expected \"%s\".'", "%", "(", "expanded_any_end_token", ",", ")", ")", "self", ".", "_MergeField", "(", "tokenizer", ",", "expanded_any_sub_message", ")", "if", "field", ".", "label", "==", "descriptor", ".", "FieldDescriptor", ".", "LABEL_REPEATED", ":", "any_message", "=", "getattr", "(", "message", ",", "field", ".", "name", ")", ".", "add", "(", ")", "else", ":", "any_message", "=", "getattr", "(", "message", ",", "field", ".", "name", ")", "any_message", ".", "Pack", "(", "expanded_any_sub_message", ")", "elif", "field", ".", "label", "==", "descriptor", ".", "FieldDescriptor", ".", "LABEL_REPEATED", ":", "if", "field", ".", "is_extension", ":", "sub_message", "=", "message", ".", "Extensions", "[", "field", "]", ".", "add", "(", ")", "elif", "is_map_entry", ":", "sub_message", "=", "getattr", "(", "message", ",", "field", ".", "name", ")", ".", "GetEntryClass", "(", ")", "(", ")", "else", ":", "sub_message", "=", "getattr", "(", "message", ",", "field", ".", "name", ")", ".", "add", "(", ")", "else", ":", "if", "field", ".", "is_extension", ":", "sub_message", "=", "message", ".", "Extensions", "[", "field", "]", "else", ":", "sub_message", "=", "getattr", "(", "message", ",", "field", ".", "name", ")", "sub_message", ".", "SetInParent", "(", ")", "while", "not", "tokenizer", ".", "TryConsume", "(", "end_token", ")", ":", "if", "tokenizer", ".", "AtEnd", "(", ")", ":", "raise", "tokenizer", ".", "ParseErrorPreviousToken", "(", "'Expected \"%s\".'", "%", "(", "end_token", ",", ")", ")", "self", ".", "_MergeField", "(", "tokenizer", ",", "sub_message", ")", "if", "is_map_entry", ":", "value_cpptype", "=", "field", ".", "message_type", ".", "fields_by_name", "[", "'value'", "]", ".", "cpp_type", "if", "value_cpptype", "==", "descriptor", ".", "FieldDescriptor", ".", "CPPTYPE_MESSAGE", ":", "value", "=", "getattr", "(", "message", ",", "field", ".", "name", ")", "[", "sub_message", ".", "key", "]", "value", ".", "MergeFrom", "(", "sub_message", ".", "value", ")", "else", ":", "getattr", "(", "message", ",", "field", ".", "name", ")", "[", "sub_message", ".", "key", "]", "=", "sub_message", ".", "value" ]

[ "Remove", "an", "item", "from", "the", "cache", "dict", ".", "Raise", "a", "KeyError", "if", "it", "does", "not", "exist", "." ]

[ "def", "__delitem__", "(", "self", ",", "key", ")", ":", "self", ".", "_wlock", ".", "acquire", "(", ")", "try", ":", "del", "self", ".", "_mapping", "[", "key", "]", "try", ":", "self", ".", "_remove", "(", "key", ")", "except", "ValueError", ":", "# __getitem__ is not locked, it might happen", "pass", "finally", ":", "self", ".", "_wlock", ".", "release", "(", ")" ]

[ "Resend", "fragments", "requires", "a", "ping", "done", "first", "to", "find", "missing", "fragments" ]

[ "def", "resend_message", "(", "self", ",", "msg_id", ")", ":", "if", "self", ".", "pending_msg_id", "==", "msg_id", "and", "msg_id", "in", "self", ".", "pending_messages", ".", "keys", "(", ")", ":", "print", "\"[+] Found saved message, only resending missing fragments\"", "for", "i", "in", "self", ".", "pending_messages", "[", "msg_id", "]", ".", "keys", "(", ")", ":", "if", "not", "self", ".", "pending_fragments", "[", "i", "-", "1", "]", ":", "# fragments starts at offset 0", "self", ".", "send_data", "(", "CMD_EXECUTE", ",", "self", ".", "pending_messages", "[", "msg_id", "]", "[", "i", "]", ",", "msg_id", ",", "i", ",", "len", "(", "self", ".", "pending_messages", "[", "msg_id", "]", ".", "keys", "(", ")", ")", ")", "else", ":", "print", "\"Skipping\"", ",", "i", "elif", "msg_id", "in", "self", ".", "pending_messages", ".", "keys", "(", ")", ":", "print", "\"[+] Found saved message, but couldn't find ping or missing fragments, resending everything\"", "frag_count", "=", "len", "(", "self", ".", "pending_messages", "[", "msg_id", "]", ".", "keys", "(", ")", ")", "for", "i", "in", "self", ".", "pending_messages", "[", "msg_id", "]", ".", "keys", "(", ")", ":", "self", ".", "send_data", "(", "CMD_EXECUTE", ",", "self", ".", "pending_messages", "[", "msg_id", "]", "[", "i", "]", ",", "msg_id", ",", "i", ",", "frag_count", ")", "else", ":", "raise", "Exception", "(", "\"Couldn't find pending message, did you ping? \"", "+", "repr", "(", "msg_id", ")", "+", "\" not in \"", "+", "str", "(", "self", ".", "pending_messages", ".", "keys", "(", ")", ")", ")" ]

[ "Check", "if", "we", "are", "currently", "one", "level", "inside", "a", "namespace", "body", "." ]

[ "def", "InNamespaceBody", "(", "self", ")", ":", "return", "self", ".", "stack", "and", "isinstance", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "_NamespaceInfo", ")" ]

[ "Publish", "message", "to", "MQTT", "server", "and", "data", "store", "." ]

[ "def", "log", "(", "event", ")", ":", "message", "=", "\"{0} {1}\"", ".", "format", "(", "datetime", ".", "utcnow", "(", ")", ".", "isoformat", "(", ")", ",", "event", ")", "payload", "=", "{", "\"value\"", ":", "message", "}", "print", "(", "message", ")", "send", "(", "payload", ")" ]

[ "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", ")" ]

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

[ "def", "GetAlignment", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewRenderer_GetAlignment", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Create", "a", "new", "empty", "Counter", "object", ".", "And", "if", "given", "count", "elements", "from", "an", "input", "iterable", ".", "Or", "initialize", "the", "count", "from", "another", "mapping", "of", "elements", "to", "their", "counts", "." ]

[ "def", "__init__", "(", "self", ",", "iterable", "=", "None", ",", "*", "*", "kwds", ")", ":", "super", "(", "Counter", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "update", "(", "iterable", ",", "*", "*", "kwds", ")" ]

[ "Get", "all", "the", "header", "values", "for", "a", "particular", "field", "name", "as", "a", "list" ]

[ "def", "get_list", "(", "self", ",", "key", ",", "default", "=", "missing", ")", ":", "try", ":", "return", "dict", ".", "__getitem__", "(", "self", ",", "key", ".", "lower", "(", ")", ")", "except", "KeyError", ":", "if", "default", "is", "not", "missing", ":", "return", "default", "else", ":", "raise" ]

[ "Load", "the", "pyproject", ".", "toml", "file", "." ]

[ "def", "load_pyproject_toml", "(", "use_pep517", ",", "# type: Optional[bool]", "pyproject_toml", ",", "# type: str", "setup_py", ",", "# type: str", "req_name", "# type: str", ")", ":", "# type: (...) -> Optional[Tuple[List[str], str, List[str]]]", "has_pyproject", "=", "os", ".", "path", ".", "isfile", "(", "pyproject_toml", ")", "has_setup", "=", "os", ".", "path", ".", "isfile", "(", "setup_py", ")", "if", "has_pyproject", ":", "with", "io", ".", "open", "(", "pyproject_toml", ",", "encoding", "=", "\"utf-8\"", ")", "as", "f", ":", "pp_toml", "=", "pytoml", ".", "load", "(", "f", ")", "build_system", "=", "pp_toml", ".", "get", "(", "\"build-system\"", ")", "else", ":", "build_system", "=", "None", "# The following cases must use PEP 517", "# We check for use_pep517 being non-None and falsey because that means", "# the user explicitly requested --no-use-pep517. The value 0 as", "# opposed to False can occur when the value is provided via an", "# environment variable or config file option (due to the quirk of", "# strtobool() returning an integer in pip's configuration code).", "if", "has_pyproject", "and", "not", "has_setup", ":", "if", "use_pep517", "is", "not", "None", "and", "not", "use_pep517", ":", "raise", "InstallationError", "(", "\"Disabling PEP 517 processing is invalid: \"", "\"project does not have a setup.py\"", ")", "use_pep517", "=", "True", "elif", "build_system", "and", "\"build-backend\"", "in", "build_system", ":", "if", "use_pep517", "is", "not", "None", "and", "not", "use_pep517", ":", "raise", "InstallationError", "(", "\"Disabling PEP 517 processing is invalid: \"", "\"project specifies a build backend of {} \"", "\"in pyproject.toml\"", ".", "format", "(", "build_system", "[", "\"build-backend\"", "]", ")", ")", "use_pep517", "=", "True", "# If we haven't worked out whether to use PEP 517 yet,", "# and the user hasn't explicitly stated a preference,", "# we do so if the project has a pyproject.toml file.", "elif", "use_pep517", "is", "None", ":", "use_pep517", "=", "has_pyproject", "# At this point, we know whether we're going to use PEP 517.", "assert", "use_pep517", "is", "not", "None", "# If we're using the legacy code path, there is nothing further", "# for us to do here.", "if", "not", "use_pep517", ":", "return", "None", "if", "build_system", "is", "None", ":", "# Either the user has a pyproject.toml with no build-system", "# section, or the user has no pyproject.toml, but has opted in", "# explicitly via --use-pep517.", "# In the absence of any explicit backend specification, we", "# assume the setuptools backend that most closely emulates the", "# traditional direct setup.py execution, and require wheel and", "# a version of setuptools that supports that backend.", "build_system", "=", "{", "\"requires\"", ":", "[", "\"setuptools>=40.8.0\"", ",", "\"wheel\"", "]", ",", "\"build-backend\"", ":", "\"setuptools.build_meta:__legacy__\"", ",", "}", "# If we're using PEP 517, we have build system information (either", "# from pyproject.toml, or defaulted by the code above).", "# Note that at this point, we do not know if the user has actually", "# specified a backend, though.", "assert", "build_system", "is", "not", "None", "# Ensure that the build-system section in pyproject.toml conforms", "# to PEP 518.", "error_template", "=", "(", "\"{package} has a pyproject.toml file that does not comply \"", "\"with PEP 518: {reason}\"", ")", "# Specifying the build-system table but not the requires key is invalid", "if", "\"requires\"", "not", "in", "build_system", ":", "raise", "InstallationError", "(", "error_template", ".", "format", "(", "package", "=", "req_name", ",", "reason", "=", "(", "\"it has a 'build-system' table but not \"", "\"'build-system.requires' which is mandatory in the table\"", ")", ")", ")", "# Error out if requires is not a list of strings", "requires", "=", "build_system", "[", "\"requires\"", "]", "if", "not", "_is_list_of_str", "(", "requires", ")", ":", "raise", "InstallationError", "(", "error_template", ".", "format", "(", "package", "=", "req_name", ",", "reason", "=", "\"'build-system.requires' is not a list of strings.\"", ",", ")", ")", "backend", "=", "build_system", ".", "get", "(", "\"build-backend\"", ")", "check", "=", "[", "]", "# type: List[str]", "if", "backend", "is", "None", ":", "# If the user didn't specify a backend, we assume they want to use", "# the setuptools backend. But we can't be sure they have included", "# a version of setuptools which supplies the backend, or wheel", "# (which is needed by the backend) in their requirements. So we", "# make a note to check that those requirements are present once", "# we have set up the environment.", "# This is quite a lot of work to check for a very specific case. But", "# the problem is, that case is potentially quite common - projects that", "# adopted PEP 518 early for the ability to specify requirements to", "# execute setup.py, but never considered needing to mention the build", "# tools themselves. The original PEP 518 code had a similar check (but", "# implemented in a different way).", "backend", "=", "\"setuptools.build_meta:__legacy__\"", "check", "=", "[", "\"setuptools>=40.8.0\"", ",", "\"wheel\"", "]", "return", "(", "requires", ",", "backend", ",", "check", ")" ]

[ "GetCursor", "(", "int", "item", ")", "-", ">", "Cursor" ]

[ "def", "GetCursor", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "StockGDI_GetCursor", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Execute", "the", "specified", "command", "and", "return", "the", "result", "." ]

[ "def", "exec_cmd", "(", "cmd", ",", "path", ",", "input_string", "=", "None", ")", ":", "out", "=", "''", "err", "=", "''", "ret", "=", "-", "1", "parts", "=", "cmd", ".", "split", "(", ")", "try", ":", "if", "input_string", "is", "None", ":", "process", "=", "Popen", "(", "parts", ",", "cwd", "=", "path", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ",", "shell", "=", "(", "sys", ".", "platform", "==", "'win32'", ")", ")", "out", ",", "err", "=", "process", ".", "communicate", "(", ")", "ret", "=", "process", ".", "returncode", "else", ":", "process", "=", "Popen", "(", "parts", ",", "cwd", "=", "path", ",", "stdin", "=", "PIPE", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ",", "shell", "=", "(", "sys", ".", "platform", "==", "'win32'", ")", ")", "out", ",", "err", "=", "process", ".", "communicate", "(", "input", "=", "input_string", ")", "ret", "=", "process", ".", "returncode", "except", "IOError", "as", "e", ":", "(", "errno", ",", "strerror", ")", "=", "e", ".", "args", "raise", "except", ":", "raise", "return", "{", "'out'", ":", "out", ".", "decode", "(", "'utf-8'", ")", ",", "'err'", ":", "err", ".", "decode", "(", "'utf-8'", ")", ",", "'ret'", ":", "ret", "}" ]

[ "Return", "the", "uri", "to", "the", "AlbumEntry", "containing", "this", "tag" ]

[ "def", "GetAlbumUri", "(", "self", ")", ":", "href", "=", "self", ".", "GetSelfLink", "(", ")", ".", "href", "pos", "=", "href", ".", "find", "(", "'/photoid'", ")", "if", "pos", "==", "-", "1", ":", "return", "None", "return", "href", "[", ":", "pos", "]" ]

[ "Generate", "some", "lorem", "impsum", "for", "the", "template", "." ]

[ "def", "generate_lorem_ipsum", "(", "n", "=", "5", ",", "html", "=", "True", ",", "min", "=", "20", ",", "max", "=", "100", ")", ":", "from", "jinja2", ".", "constants", "import", "LOREM_IPSUM_WORDS", "from", "random", "import", "choice", ",", "randrange", "words", "=", "LOREM_IPSUM_WORDS", ".", "split", "(", ")", "result", "=", "[", "]", "for", "_", "in", "range", "(", "n", ")", ":", "next_capitalized", "=", "True", "last_comma", "=", "last_fullstop", "=", "0", "word", "=", "None", "last", "=", "None", "p", "=", "[", "]", "# each paragraph contains out of 20 to 100 words.", "for", "idx", ",", "_", "in", "enumerate", "(", "range", "(", "randrange", "(", "min", ",", "max", ")", ")", ")", ":", "while", "True", ":", "word", "=", "choice", "(", "words", ")", "if", "word", "!=", "last", ":", "last", "=", "word", "break", "if", "next_capitalized", ":", "word", "=", "word", ".", "capitalize", "(", ")", "next_capitalized", "=", "False", "# add commas", "if", "idx", "-", "randrange", "(", "3", ",", "8", ")", ">", "last_comma", ":", "last_comma", "=", "idx", "last_fullstop", "+=", "2", "word", "+=", "','", "# add end of sentences", "if", "idx", "-", "randrange", "(", "10", ",", "20", ")", ">", "last_fullstop", ":", "last_comma", "=", "last_fullstop", "=", "idx", "word", "+=", "'.'", "next_capitalized", "=", "True", "p", ".", "append", "(", "word", ")", "# ensure that the paragraph ends with a dot.", "p", "=", "u' '", ".", "join", "(", "p", ")", "if", "p", ".", "endswith", "(", "','", ")", ":", "p", "=", "p", "[", ":", "-", "1", "]", "+", "'.'", "elif", "not", "p", ".", "endswith", "(", "'.'", ")", ":", "p", "+=", "'.'", "result", ".", "append", "(", "p", ")", "if", "not", "html", ":", "return", "u'\\n\\n'", ".", "join", "(", "result", ")", "return", "Markup", "(", "u'\\n'", ".", "join", "(", "u'<p>%s</p>'", "%", "escape", "(", "x", ")", "for", "x", "in", "result", ")", ")" ]

[ "Recursively", "looks", "at", "the", "parents", "of", "a", "node", "and", "returns", "the", "first", "found", "node", "that", "matches", "node_types", ".", "Returns", "None", "if", "no", "matching", "node", "is", "found", "." ]

[ "def", "search_ancestor", "(", "node", ":", "'NodeOrLeaf'", ",", "*", "node_types", ":", "str", ")", "->", "'Optional[BaseNode]'", ":", "n", "=", "node", ".", "parent", "while", "n", "is", "not", "None", ":", "if", "n", ".", "type", "in", "node_types", ":", "return", "n", "n", "=", "n", ".", "parent", "return", "None" ]

[ "Returns", "a", ":", "class", ":", "pyalgotrade", ".", "dataseries", ".", "DataSeries", "with", "the", "high", "prices", "." ]

[ "def", "getHighDataSeries", "(", "self", ")", ":", "return", "self", ".", "__highDS" ]

[ "Convert", "the", "MSVS", "macros", "found", "in", "the", "string", "to", "the", "MSBuild", "equivalent", "." ]

[ "def", "ConvertVCMacrosToMSBuild", "(", "s", ")", ":", "if", "\"$\"", "in", "s", ":", "replace_map", "=", "{", "\"$(ConfigurationName)\"", ":", "\"$(Configuration)\"", ",", "\"$(InputDir)\"", ":", "\"%(RelativeDir)\"", ",", "\"$(InputExt)\"", ":", "\"%(Extension)\"", ",", "\"$(InputFileName)\"", ":", "\"%(Filename)%(Extension)\"", ",", "\"$(InputName)\"", ":", "\"%(Filename)\"", ",", "\"$(InputPath)\"", ":", "\"%(Identity)\"", ",", "\"$(ParentName)\"", ":", "\"$(ProjectFileName)\"", ",", "\"$(PlatformName)\"", ":", "\"$(Platform)\"", ",", "\"$(SafeInputName)\"", ":", "\"%(Filename)\"", ",", "}", "for", "old", ",", "new", "in", "replace_map", ".", "items", "(", ")", ":", "s", "=", "s", ".", "replace", "(", "old", ",", "new", ")", "s", "=", "FixVCMacroSlashes", "(", "s", ")", "return", "s" ]

[ "Increase", "the", "number", "of", "pgs", "in", "a", "pool" ]

[ "def", "expand_pool", "(", "self", ",", "pool_name", ",", "by", ",", "max_pgs", ")", ":", "with", "self", ".", "lock", ":", "assert", "isinstance", "(", "pool_name", ",", "str", ")", "assert", "isinstance", "(", "by", ",", "int", ")", "assert", "pool_name", "in", "self", ".", "pools", "if", "self", ".", "get_num_creating", "(", ")", ">", "0", ":", "return", "False", "if", "(", "self", ".", "pools", "[", "pool_name", "]", "+", "by", ")", ">", "max_pgs", ":", "return", "False", "self", ".", "log", "(", "\"increase pool size by %d\"", "%", "(", "by", ",", ")", ")", "new_pg_num", "=", "self", ".", "pools", "[", "pool_name", "]", "+", "by", "self", ".", "set_pool_property", "(", "pool_name", ",", "\"pg_num\"", ",", "new_pg_num", ")", "self", ".", "pools", "[", "pool_name", "]", "=", "new_pg_num", "return", "True" ]

[ "Creates", "a", "wx", ".", "Bitmap", "from", "the", "data", "in", "dataBuffer", ".", "The", "dataBuffer", "parameter", "must", "be", "a", "Python", "object", "that", "implements", "the", "buffer", "interface", "such", "as", "a", "string", "array", "etc", ".", "The", "dataBuffer", "object", "is", "expected", "to", "contain", "a", "series", "of", "RGB", "bytes", "and", "be", "width", "*", "height", "*", "3", "bytes", "long", ".", "A", "buffer", "object", "can", "optionally", "be", "supplied", "for", "the", "image", "s", "alpha", "channel", "data", "and", "it", "is", "expected", "to", "be", "width", "*", "height", "bytes", "long", ".", "On", "Windows", "and", "Mac", "the", "RGB", "values", "are", "premultiplied", "by", "the", "alpha", "values", ".", "(", "The", "other", "platforms", "do", "the", "multiplication", "themselves", ".", ")" ]

[ "def", "BitmapFromBuffer", "(", "width", ",", "height", ",", "dataBuffer", ",", "alphaBuffer", "=", "None", ")", ":", "if", "alphaBuffer", "is", "not", "None", ":", "return", "_gdi_", ".", "_BitmapFromBufferAlpha", "(", "width", ",", "height", ",", "dataBuffer", ",", "alphaBuffer", ")", "else", ":", "return", "_gdi_", ".", "_BitmapFromBuffer", "(", "width", ",", "height", ",", "dataBuffer", ")" ]

[ "SetJoin", "(", "self", "int", "join_style", ")" ]

[ "def", "SetJoin", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "Pen_SetJoin", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Resets", "the", "RpcController", "to", "its", "initial", "state", "." ]

[ "def", "Reset", "(", "self", ")", ":", "raise", "NotImplementedError" ]

[ ":", "param", "vehicle", ":", "actor", "to", "apply", "to", "local", "planner", "logic", "onto", ":", "param", "opt_dict", ":", "dictionary", "of", "arguments", "with", "different", "parameters", ":", "dt", ":", "time", "between", "simulation", "steps", "target_speed", ":", "desired", "cruise", "speed", "in", "Km", "/", "h", "sampling_radius", ":", "distance", "between", "the", "waypoints", "part", "of", "the", "plan", "lateral_control_dict", ":", "values", "of", "the", "lateral", "PID", "controller", "longitudinal_control_dict", ":", "values", "of", "the", "longitudinal", "PID", "controller", "max_throttle", ":", "maximum", "throttle", "applied", "to", "the", "vehicle", "max_brake", ":", "maximum", "brake", "applied", "to", "the", "vehicle", "max_steering", ":", "maximum", "steering", "applied", "to", "the", "vehicle", "offset", ":", "distance", "between", "the", "route", "waypoints", "and", "the", "center", "of", "the", "lane" ]

[ "def", "__init__", "(", "self", ",", "vehicle", ",", "opt_dict", "=", "{", "}", ")", ":", "self", ".", "_vehicle", "=", "vehicle", "self", ".", "_world", "=", "self", ".", "_vehicle", ".", "get_world", "(", ")", "self", ".", "_map", "=", "self", ".", "_world", ".", "get_map", "(", ")", "self", ".", "_vehicle_controller", "=", "None", "self", ".", "target_waypoint", "=", "None", "self", ".", "target_road_option", "=", "None", "self", ".", "_waypoints_queue", "=", "deque", "(", "maxlen", "=", "10000", ")", "self", ".", "_min_waypoint_queue_length", "=", "100", "self", ".", "_stop_waypoint_creation", "=", "False", "# Base parameters", "self", ".", "_dt", "=", "1.0", "/", "20.0", "self", ".", "_target_speed", "=", "20.0", "# Km/h", "self", ".", "_sampling_radius", "=", "2.0", "self", ".", "_args_lateral_dict", "=", "{", "'K_P'", ":", "1.95", ",", "'K_I'", ":", "0.05", ",", "'K_D'", ":", "0.2", ",", "'dt'", ":", "self", ".", "_dt", "}", "self", ".", "_args_longitudinal_dict", "=", "{", "'K_P'", ":", "1.0", ",", "'K_I'", ":", "0.05", ",", "'K_D'", ":", "0", ",", "'dt'", ":", "self", ".", "_dt", "}", "self", ".", "_max_throt", "=", "0.75", "self", ".", "_max_brake", "=", "0.3", "self", ".", "_max_steer", "=", "0.8", "self", ".", "_offset", "=", "0", "self", ".", "_base_min_distance", "=", "3.0", "self", ".", "_follow_speed_limits", "=", "False", "# Overload parameters", "if", "opt_dict", ":", "if", "'dt'", "in", "opt_dict", ":", "self", ".", "_dt", "=", "opt_dict", "[", "'dt'", "]", "if", "'target_speed'", "in", "opt_dict", ":", "self", ".", "_target_speed", "=", "opt_dict", "[", "'target_speed'", "]", "if", "'sampling_radius'", "in", "opt_dict", ":", "self", ".", "_sampling_radius", "=", "opt_dict", "[", "'sampling_radius'", "]", "if", "'lateral_control_dict'", "in", "opt_dict", ":", "self", ".", "_args_lateral_dict", "=", "opt_dict", "[", "'lateral_control_dict'", "]", "if", "'longitudinal_control_dict'", "in", "opt_dict", ":", "self", ".", "_args_longitudinal_dict", "=", "opt_dict", "[", "'longitudinal_control_dict'", "]", "if", "'max_throttle'", "in", "opt_dict", ":", "self", ".", "_max_throt", "=", "opt_dict", "[", "'max_throttle'", "]", "if", "'max_brake'", "in", "opt_dict", ":", "self", ".", "_max_brake", "=", "opt_dict", "[", "'max_brake'", "]", "if", "'max_steering'", "in", "opt_dict", ":", "self", ".", "_max_steer", "=", "opt_dict", "[", "'max_steering'", "]", "if", "'offset'", "in", "opt_dict", ":", "self", ".", "_offset", "=", "opt_dict", "[", "'offset'", "]", "if", "'base_min_distance'", "in", "opt_dict", ":", "self", ".", "_base_min_distance", "=", "opt_dict", "[", "'base_min_distance'", "]", "if", "'follow_speed_limits'", "in", "opt_dict", ":", "self", ".", "_follow_speed_limits", "=", "opt_dict", "[", "'follow_speed_limits'", "]", "# initializing controller", "self", ".", "_init_controller", "(", ")" ]

[ "Extends", "by", "appending", "the", "given", "sequence", ".", "Similar", "to", "list", ".", "extend", "()", "." ]

[ "def", "extend", "(", "self", ",", "elem_seq", ")", ":", "if", "not", "elem_seq", ":", "return", "new_values", "=", "[", "]", "for", "elem", "in", "elem_seq", ":", "self", ".", "_type_checker", ".", "CheckValue", "(", "elem", ")", "new_values", ".", "append", "(", "elem", ")", "self", ".", "_values", ".", "extend", "(", "new_values", ")", "self", ".", "_message_listener", ".", "Modified", "(", ")" ]

[ "Validate", "arguments", "for", "traitlet", "link", "functions" ]

[ "def", "_validate_link", "(", "*", "tuples", ")", ":", "for", "t", "in", "tuples", ":", "if", "not", "len", "(", "t", ")", "==", "2", ":", "raise", "TypeError", "(", "\"Each linked traitlet must be specified as (HasTraits, 'trait_name'), not %r\"", "%", "t", ")", "obj", ",", "trait_name", "=", "t", "if", "not", "isinstance", "(", "obj", ",", "HasTraits", ")", ":", "raise", "TypeError", "(", "\"Each object must be HasTraits, not %r\"", "%", "type", "(", "obj", ")", ")", "if", "not", "trait_name", "in", "obj", ".", "traits", "(", ")", ":", "raise", "TypeError", "(", "\"%r has no trait %r\"", "%", "(", "obj", ",", "trait_name", ")", ")" ]

[ "copy", "source", "content", "(", "local", "or", "remote", ")", "to", "local", "file" ]

[ "def", "copy_to", "(", "src", ",", "dst", ")", ":", "local", "=", "None", "if", "is_remote_path", "(", "src", ")", ":", "local", "=", "tempfile", ".", "NamedTemporaryFile", "(", "delete", "=", "False", ")", "download_remote_file", "(", "src", ",", "local", ".", "name", ")", "src", "=", "local", ".", "name", "shutil", ".", "copy", "(", "src", ",", "dst", ")", "if", "local", "is", "not", "None", ":", "os", ".", "remove", "(", "local", ".", "name", ")" ]

[ "Find", "all", "matching", "subelements", "by", "tag", "name", "or", "path", "." ]

[ "def", "iterfind", "(", "self", ",", "path", ",", "namespaces", "=", "None", ")", ":", "return", "ElementPath", ".", "iterfind", "(", "self", ",", "path", ",", "namespaces", ")" ]

[ "Walks", "over", "all", "the", "names", "imported", "in", "a", "dotted_as_names", "node", "." ]

[ "def", "traverse_imports", "(", "names", ")", ":", "pending", "=", "[", "names", "]", "while", "pending", ":", "node", "=", "pending", ".", "pop", "(", ")", "if", "node", ".", "type", "==", "token", ".", "NAME", ":", "yield", "node", ".", "value", "elif", "node", ".", "type", "==", "syms", ".", "dotted_name", ":", "yield", "\"\"", ".", "join", "(", "[", "ch", ".", "value", "for", "ch", "in", "node", ".", "children", "]", ")", "elif", "node", ".", "type", "==", "syms", ".", "dotted_as_name", ":", "pending", ".", "append", "(", "node", ".", "children", "[", "0", "]", ")", "elif", "node", ".", "type", "==", "syms", ".", "dotted_as_names", ":", "pending", ".", "extend", "(", "node", ".", "children", "[", ":", ":", "-", "2", "]", ")", "else", ":", "raise", "AssertionError", "(", "\"unknown node type\"", ")" ]

[ "Open", "video", "options", "window" ]

[ "def", "OpenVideoOptionsWindow", "(", ")", ":", "global", "HelpTextArea", "#GemRB.GetView(\"SUB_WIN\", 0).Close()", "Window", "=", "GemRB", ".", "LoadWindow", "(", "6", ",", "\"GUIOPT\"", ")", "Window", ".", "AddAlias", "(", "\"SUB_WIN\"", ",", "0", ")", "Window", ".", "SetFlags", "(", "WF_BORDERLESS", ",", "OP_OR", ")", "HelpTextArea", "=", "GUIOPTControls", ".", "OptHelpText", "(", "'VideoOptions'", ",", "Window", ",", "33", ",", "18038", ")", "GUIOPTControls", ".", "OptDone", "(", "CloseVideoOptionsWindow", ",", "Window", ",", "21", ")", "GUIOPTControls", ".", "OptCancel", "(", "CloseVideoOptionsWindow", ",", "Window", ",", "32", ")", "GUIOPTControls", ".", "OptSlider", "(", "18038", ",", "17203", ",", "HelpTextArea", ",", "Window", ",", "3", ",", "35", ",", "17129", ",", "'Brightness Correction'", ",", "DisplayHelpBrightness", ",", "4", ")", "GUIOPTControls", ".", "OptSlider", "(", "18038", ",", "17204", ",", "HelpTextArea", ",", "Window", ",", "22", ",", "36", ",", "17128", ",", "'Gamma Correction'", ",", "DisplayHelpContrast", ")", "GUIOPTControls", ".", "OptRadio", "(", "DisplayHelpBPP", ",", "Window", ",", "5", ",", "37", ",", "'BitsPerPixel'", ",", "16", ")", "GUIOPTControls", ".", "OptRadio", "(", "DisplayHelpBPP", ",", "Window", ",", "6", ",", "37", ",", "'BitsPerPixel'", ",", "24", ")", "GUIOPTControls", ".", "OptRadio", "(", "DisplayHelpBPP", ",", "Window", ",", "7", ",", "37", ",", "'BitsPerPixel'", ",", "32", ")", "GUIOPTControls", ".", "OptCheckbox", "(", "18038", ",", "18000", ",", "HelpTextArea", ",", "Window", ",", "9", ",", "38", ",", "17131", ",", "'Full Screen'", ",", "DisplayHelpFullScreen", ")", "GUIOPTControls", ".", "OptCheckbox", "(", "18038", ",", "20620", ",", "HelpTextArea", ",", "Window", ",", "51", ",", "50", ",", "20617", ",", "'Translucent Shadows'", ")", "GUIOPTControls", ".", "OptCheckbox", "(", "18038", ",", "18004", ",", "HelpTextArea", ",", "Window", ",", "40", ",", "44", ",", "17134", ",", "'SoftMirrorBlt'", ")", "GUIOPTControls", ".", "OptCheckbox", "(", "18038", ",", "18006", ",", "HelpTextArea", ",", "Window", ",", "41", ",", "46", ",", "17136", ",", "'SoftSrcKeyBlt'", ")", "# software standard blit", "GUIOPTControls", ".", "OptCheckbox", "(", "18038", ",", "18007", ",", "HelpTextArea", ",", "Window", ",", "42", ",", "48", ",", "17135", ",", "'SoftBltFast'", ")", "# software transparent blit", "Window", ".", "ShowModal", "(", "MODAL_SHADOW_GRAY", ")", "return" ]

[ "r", "Loads", "a", "custom", "op", "into", "the", "Scanner", "runtime", "." ]

[ "def", "load_op", "(", "self", ",", "so_path", ":", "str", ",", "proto_path", ":", "str", "=", "None", ")", ":", "if", "proto_path", "is", "not", "None", ":", "protobufs", ".", "add_module", "(", "proto_path", ")", "op_path", "=", "protobufs", ".", "OpPath", "(", ")", "op_path", ".", "path", "=", "so_path", "self", ".", "_try_rpc", "(", "lambda", ":", "self", ".", "_master", ".", "LoadOp", "(", "op_path", ",", "timeout", "=", "self", ".", "_grpc_timeout", ")", ")", "self", ".", "_modules", ".", "add", "(", "(", "so_path", ",", "proto_path", ")", ")" ]

[ "Wait", "until", "notified", "." ]

[ "async", "def", "wait", "(", "self", ")", ":", "if", "not", "self", ".", "locked", "(", ")", ":", "raise", "RuntimeError", "(", "'cannot wait on un-acquired lock'", ")", "self", ".", "release", "(", ")", "try", ":", "fut", "=", "self", ".", "_loop", ".", "create_future", "(", ")", "self", ".", "_waiters", ".", "append", "(", "fut", ")", "try", ":", "await", "fut", "return", "True", "finally", ":", "self", ".", "_waiters", ".", "remove", "(", "fut", ")", "finally", ":", "# Must reacquire lock even if wait is cancelled", "cancelled", "=", "False", "while", "True", ":", "try", ":", "await", "self", ".", "acquire", "(", ")", "break", "except", "futures", ".", "CancelledError", ":", "cancelled", "=", "True", "if", "cancelled", ":", "raise", "futures", ".", "CancelledError" ]

[ "Given", "the", "value", "of", "environment", "variable", "CXX", "or", "HOST_CXX", "find", "the", "version", "of", "the", "libstdc", "++", "it", "uses", "." ]

[ "def", "find_version", "(", "e", ")", ":", "args", "=", "e", ".", "split", "(", ")", "args", "+=", "[", "'-shared'", ",", "'-Wl,-t'", "]", "p", "=", "subprocess", ".", "Popen", "(", "args", ",", "stderr", "=", "subprocess", ".", "STDOUT", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "candidates", "=", "[", "x", "for", "x", "in", "p", ".", "stdout", "if", "'libstdc++.so'", "in", "x", "]", "if", "not", "candidates", ":", "return", "''", "assert", "len", "(", "candidates", ")", "==", "1", "libstdcxx", "=", "parse_ld_line", "(", "candidates", "[", "-", "1", "]", ")", "p", "=", "subprocess", ".", "Popen", "(", "[", "'readelf'", ",", "'-V'", ",", "libstdcxx", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "versions", "=", "[", "parse_readelf_line", "(", "x", ")", "for", "x", "in", "p", ".", "stdout", ".", "readlines", "(", ")", "if", "'Name: GLIBCXX'", "in", "x", "]", "last_version", "=", "sorted", "(", "versions", ",", "cmp", "=", "cmp_ver", ")", "[", "-", "1", "]", "return", "encode_ver", "(", "last_version", ")" ]

[ "Find", "the", "installed", "debugger", "." ]

[ "def", "_find_debugger", "(", "self", ",", "debugger", ")", ":", "raise", "NotImplementedError", "(", "\"_find_debugger must be implemented in OS-specific subclasses\"", ")" ]

[ "This", "method", "does", "things", "based", "on", "the", "type", "of", "key", "." ]

[ "def", "__getitem__", "(", "self", ",", "key", ")", ":", "if", "type", "(", "key", ")", "is", "SArray", ":", "return", "self", ".", "_row_selector", "(", "key", ")", "elif", "type", "(", "key", ")", "is", "str", ":", "return", "self", ".", "select_column", "(", "key", ")", "elif", "type", "(", "key", ")", "is", "type", ":", "return", "self", ".", "select_columns", "(", "[", "key", "]", ")", "elif", "_is_non_string_iterable", "(", "key", ")", ":", "return", "self", ".", "select_columns", "(", "key", ")", "elif", "isinstance", "(", "key", ",", "numbers", ".", "Integral", ")", ":", "sf_len", "=", "len", "(", "self", ")", "if", "key", "<", "0", ":", "key", "=", "sf_len", "+", "key", "if", "key", ">=", "sf_len", ":", "raise", "IndexError", "(", "\"SFrame index out of range\"", ")", "if", "not", "hasattr", "(", "self", ",", "'_cache'", ")", "or", "self", ".", "_cache", "is", "None", ":", "self", ".", "_cache", "=", "{", "}", "try", ":", "lb", ",", "ub", ",", "value_list", "=", "self", ".", "_cache", "[", "\"getitem_cache\"", "]", "if", "lb", "<=", "key", "<", "ub", ":", "return", "value_list", "[", "int", "(", "key", "-", "lb", ")", "]", "except", "KeyError", ":", "pass", "# Not in cache, need to grab it. Smaller here than with sarray", "# Do we have a good block size that won't cause memory to blow up?", "if", "not", "\"getitem_cache_blocksize\"", "in", "self", ".", "_cache", ":", "block_size", "=", "(", "8", "*", "1024", ")", "//", "sum", "(", "(", "2", "if", "dt", "in", "[", "int", ",", "long", ",", "float", "]", "else", "8", ")", "for", "dt", "in", "self", ".", "column_types", "(", ")", ")", "block_size", "=", "max", "(", "16", ",", "block_size", ")", "self", ".", "_cache", "[", "\"getitem_cache_blocksize\"", "]", "=", "block_size", "else", ":", "block_size", "=", "self", ".", "_cache", "[", "\"getitem_cache_blocksize\"", "]", "block_num", "=", "int", "(", "key", "//", "block_size", ")", "lb", "=", "block_num", "*", "block_size", "ub", "=", "min", "(", "sf_len", ",", "lb", "+", "block_size", ")", "val_list", "=", "list", "(", "SFrame", "(", "_proxy", "=", "self", ".", "__proxy__", ".", "copy_range", "(", "lb", ",", "1", ",", "ub", ")", ")", ")", "self", ".", "_cache", "[", "\"getitem_cache\"", "]", "=", "(", "lb", ",", "ub", ",", "val_list", ")", "return", "val_list", "[", "int", "(", "key", "-", "lb", ")", "]", "elif", "type", "(", "key", ")", "is", "slice", ":", "start", "=", "key", ".", "start", "stop", "=", "key", ".", "stop", "step", "=", "key", ".", "step", "if", "start", "is", "None", ":", "start", "=", "0", "if", "stop", "is", "None", ":", "stop", "=", "len", "(", "self", ")", "if", "step", "is", "None", ":", "step", "=", "1", "# handle negative indices", "if", "start", "<", "0", ":", "start", "=", "len", "(", "self", ")", "+", "start", "if", "stop", "<", "0", ":", "stop", "=", "len", "(", "self", ")", "+", "stop", "return", "SFrame", "(", "_proxy", "=", "self", ".", "__proxy__", ".", "copy_range", "(", "start", ",", "step", ",", "stop", ")", ")", "else", ":", "raise", "TypeError", "(", "\"Invalid index type: must be SArray, list, int, or str\"", ")" ]

[ "Exports", "inference", "graph", "into", "given", "dir", "." ]

[ "def", "export", "(", "self", ",", "export_dir", ",", "signature_fn", "=", "None", ",", "input_fn", "=", "None", ",", "default_batch_size", "=", "1", ",", "exports_to_keep", "=", "None", ")", ":", "def", "default_input_fn", "(", "unused_estimator", ",", "examples", ")", ":", "return", "layers", ".", "parse_feature_columns_from_examples", "(", "examples", ",", "self", ".", "_feature_columns", ")", "return", "self", ".", "_estimator", ".", "export", "(", "export_dir", "=", "export_dir", ",", "signature_fn", "=", "signature_fn", ",", "input_fn", "=", "input_fn", "or", "default_input_fn", ",", "default_batch_size", "=", "default_batch_size", ",", "exports_to_keep", "=", "exports_to_keep", ")" ]

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

[ "def", "GetRowStride", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "PixelDataBase_GetRowStride", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "the", "high_price", "of", "this", "Instrument", "." ]

[ "def", "high_price", "(", "self", ",", "high_price", ")", ":", "self", ".", "_high_price", "=", "high_price" ]

[ "Sets", "the", "button", "as", "toggled", "/", "not", "toggled", "." ]

[ "def", "SetToggle", "(", "self", ",", "flag", ")", ":", "self", ".", "up", "=", "not", "flag", "self", ".", "Refresh", "(", ")" ]

[ "For", "all", "subtrees", "that", "match", "the", "pattern", "execute", "the", "visit", "action", "." ]

[ "def", "_visitPattern", "(", "self", ",", "tree", ",", "pattern", ",", "visitor", ")", ":", "# Create a TreePattern from the pattern", "tokenizer", "=", "TreePatternLexer", "(", "pattern", ")", "parser", "=", "TreePatternParser", "(", "tokenizer", ",", "self", ",", "TreePatternTreeAdaptor", "(", ")", ")", "tpattern", "=", "parser", ".", "pattern", "(", ")", "# don't allow invalid patterns", "if", "(", "tpattern", "is", "None", "or", "tpattern", ".", "isNil", "(", ")", "or", "isinstance", "(", "tpattern", ",", "WildcardTreePattern", ")", ")", ":", "return", "rootTokenType", "=", "tpattern", ".", "getType", "(", ")", "def", "rootvisitor", "(", "tree", ",", "parent", ",", "childIndex", ",", "labels", ")", ":", "labels", "=", "{", "}", "if", "self", ".", "_parse", "(", "tree", ",", "tpattern", ",", "labels", ")", ":", "visitor", "(", "tree", ",", "parent", ",", "childIndex", ",", "labels", ")", "self", ".", "visit", "(", "tree", ",", "rootTokenType", ",", "rootvisitor", ")" ]

[ "Add", "id", "for", "gather", "feature", "for", "inference", "." ]

[ "def", "add_id", "(", "pos_list", ",", "image_id", "=", "0", ")", ":", "new_list", "=", "[", "]", "for", "item", "in", "pos_list", ":", "new_list", ".", "append", "(", "(", "image_id", ",", "item", "[", "0", "]", ",", "item", "[", "1", "]", ")", ")", "return", "new_list" ]

[ "Returns", "flags", "that", "need", "to", "be", "passed", "to", "the", "linker", "." ]

[ "def", "GetLdflags", "(", "self", ",", "configname", ",", "product_dir", ",", "gyp_to_build_path", ",", "arch", "=", "None", ")", ":", "self", ".", "configname", "=", "configname", "ldflags", "=", "[", "]", "# The xcode build is relative to a gyp file's directory, and OTHER_LDFLAGS", "# can contain entries that depend on this. Explicitly absolutify these.", "for", "ldflag", "in", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'OTHER_LDFLAGS'", ",", "[", "]", ")", ":", "ldflags", ".", "append", "(", "self", ".", "_MapLinkerFlagFilename", "(", "ldflag", ",", "gyp_to_build_path", ")", ")", "if", "self", ".", "_Test", "(", "'DEAD_CODE_STRIPPING'", ",", "'YES'", ",", "default", "=", "'NO'", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-dead_strip'", ")", "if", "self", ".", "_Test", "(", "'PREBINDING'", ",", "'YES'", ",", "default", "=", "'NO'", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-prebind'", ")", "self", ".", "_Appendf", "(", "ldflags", ",", "'DYLIB_COMPATIBILITY_VERSION'", ",", "'-compatibility_version %s'", ")", "self", ".", "_Appendf", "(", "ldflags", ",", "'DYLIB_CURRENT_VERSION'", ",", "'-current_version %s'", ")", "self", ".", "_AppendPlatformVersionMinFlags", "(", "ldflags", ")", "if", "'SDKROOT'", "in", "self", ".", "_Settings", "(", ")", "and", "self", ".", "_SdkPath", "(", ")", ":", "ldflags", ".", "append", "(", "'-isysroot '", "+", "self", ".", "_SdkPath", "(", ")", ")", "for", "library_path", "in", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'LIBRARY_SEARCH_PATHS'", ",", "[", "]", ")", ":", "ldflags", ".", "append", "(", "'-L'", "+", "gyp_to_build_path", "(", "library_path", ")", ")", "if", "'ORDER_FILE'", "in", "self", ".", "_Settings", "(", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-order_file '", "+", "'-Wl,'", "+", "gyp_to_build_path", "(", "self", ".", "_Settings", "(", ")", "[", "'ORDER_FILE'", "]", ")", ")", "if", "arch", "is", "not", "None", ":", "archs", "=", "[", "arch", "]", "else", ":", "assert", "self", ".", "configname", "archs", "=", "self", ".", "GetActiveArchs", "(", "self", ".", "configname", ")", "if", "len", "(", "archs", ")", "!=", "1", ":", "# TODO: Supporting fat binaries will be annoying.", "self", ".", "_WarnUnimplemented", "(", "'ARCHS'", ")", "archs", "=", "[", "'i386'", "]", "ldflags", ".", "append", "(", "'-arch '", "+", "archs", "[", "0", "]", ")", "# Xcode adds the product directory by default.", "# Rewrite -L. to -L./ to work around http://www.openradar.me/25313838", "ldflags", ".", "append", "(", "'-L'", "+", "(", "product_dir", "if", "product_dir", "!=", "'.'", "else", "'./'", ")", ")", "install_name", "=", "self", ".", "GetInstallName", "(", ")", "if", "install_name", "and", "self", ".", "spec", "[", "'type'", "]", "!=", "'loadable_module'", ":", "ldflags", ".", "append", "(", "'-install_name '", "+", "install_name", ".", "replace", "(", "' '", ",", "r'\\ '", ")", ")", "for", "rpath", "in", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'LD_RUNPATH_SEARCH_PATHS'", ",", "[", "]", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-rpath,'", "+", "rpath", ")", "sdk_root", "=", "self", ".", "_SdkPath", "(", ")", "if", "not", "sdk_root", ":", "sdk_root", "=", "''", "config", "=", "self", ".", "spec", "[", "'configurations'", "]", "[", "self", ".", "configname", "]", "framework_dirs", "=", "config", ".", "get", "(", "'mac_framework_dirs'", ",", "[", "]", ")", "for", "directory", "in", "framework_dirs", ":", "ldflags", ".", "append", "(", "'-F'", "+", "directory", ".", "replace", "(", "'$(SDKROOT)'", ",", "sdk_root", ")", ")", "if", "self", ".", "_IsXCTest", "(", ")", ":", "platform_root", "=", "self", ".", "_XcodePlatformPath", "(", "configname", ")", "if", "sdk_root", "and", "platform_root", ":", "ldflags", ".", "append", "(", "'-F'", "+", "platform_root", "+", "'/Developer/Library/Frameworks/'", ")", "ldflags", ".", "append", "(", "'-framework XCTest'", ")", "is_extension", "=", "self", ".", "_IsIosAppExtension", "(", ")", "or", "self", ".", "_IsIosWatchKitExtension", "(", ")", "if", "sdk_root", "and", "is_extension", ":", "# Adds the link flags for extensions. These flags are common for all", "# extensions and provide loader and main function.", "# These flags reflect the compilation options used by xcode to compile", "# extensions.", "if", "XcodeVersion", "(", ")", "<", "'0900'", ":", "ldflags", ".", "append", "(", "'-lpkstart'", ")", "ldflags", ".", "append", "(", "sdk_root", "+", "'/System/Library/PrivateFrameworks/PlugInKit.framework/PlugInKit'", ")", "else", ":", "ldflags", ".", "append", "(", "'-e _NSExtensionMain'", ")", "ldflags", ".", "append", "(", "'-fapplication-extension'", ")", "self", ".", "_Appendf", "(", "ldflags", ",", "'CLANG_CXX_LIBRARY'", ",", "'-stdlib=%s'", ")", "self", ".", "configname", "=", "None", "return", "ldflags" ]

[ "Check", "for", "use", "of", "stack", "canary" ]

[ "def", "check_ELF_Canary", "(", "executable", ")", ":", "p", "=", "subprocess", ".", "Popen", "(", "[", "READELF_CMD", ",", "'--dyn-syms'", ",", "'-W'", ",", "executable", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "stdin", "=", "subprocess", ".", "PIPE", ",", "universal_newlines", "=", "True", ")", "(", "stdout", ",", "stderr", ")", "=", "p", ".", "communicate", "(", ")", "if", "p", ".", "returncode", ":", "raise", "IOError", "(", "'Error opening file'", ")", "ok", "=", "False", "for", "line", "in", "stdout", ".", "splitlines", "(", ")", ":", "if", "'__stack_chk_fail'", "in", "line", ":", "ok", "=", "True", "return", "ok" ]

[ "Creates", "a", "Session", "recovering", "if", "possible", "." ]

[ "def", "recover_session", "(", "self", ",", "master", ",", "saver", "=", "None", ",", "checkpoint_dir", "=", "None", ",", "wait_for_checkpoint", "=", "False", ",", "max_wait_secs", "=", "7200", ",", "config", "=", "None", ")", ":", "self", ".", "_target", "=", "master", "sess", "=", "session", ".", "Session", "(", "self", ".", "_target", ",", "graph", "=", "self", ".", "_graph", ",", "config", "=", "config", ")", "if", "self", ".", "_local_init_op", ":", "sess", ".", "run", "(", "[", "self", ".", "_local_init_op", "]", ")", "# If either saver or checkpoint_dir is not specified, cannot restore. Just", "# return.", "if", "not", "saver", "or", "not", "checkpoint_dir", ":", "not_ready", "=", "self", ".", "_model_not_ready", "(", "sess", ")", "return", "sess", ",", "not_ready", "is", "None", "# Waits up until max_wait_secs for checkpoint to become available.", "wait_time", "=", "0", "ckpt", "=", "saver_mod", ".", "get_checkpoint_state", "(", "checkpoint_dir", ")", "while", "not", "ckpt", "or", "not", "ckpt", ".", "model_checkpoint_path", ":", "if", "wait_for_checkpoint", "and", "wait_time", "<", "max_wait_secs", ":", "logging", ".", "info", "(", "\"Waiting for checkpoint to be available.\"", ")", "time", ".", "sleep", "(", "self", ".", "_recovery_wait_secs", ")", "wait_time", "+=", "self", ".", "_recovery_wait_secs", "ckpt", "=", "saver_mod", ".", "get_checkpoint_state", "(", "checkpoint_dir", ")", "else", ":", "return", "sess", ",", "False", "# Loads the checkpoint and verifies that it makes the model ready.", "saver", ".", "restore", "(", "sess", ",", "ckpt", ".", "model_checkpoint_path", ")", "last_checkpoints", "=", "[", "]", "for", "fname", "in", "ckpt", ".", "all_model_checkpoint_paths", ":", "fnames", "=", "gfile", ".", "Glob", "(", "fname", ")", "if", "fnames", ":", "mtime", "=", "gfile", ".", "Stat", "(", "fnames", "[", "0", "]", ")", ".", "mtime", "last_checkpoints", ".", "append", "(", "(", "fname", ",", "mtime", ")", ")", "saver", ".", "set_last_checkpoints_with_time", "(", "last_checkpoints", ")", "not_ready", "=", "self", ".", "_model_not_ready", "(", "sess", ")", "if", "not_ready", ":", "logging", ".", "info", "(", "\"Restoring model from %s did not make model ready: %s\"", ",", "ckpt", ".", "model_checkpoint_path", ",", "not_ready", ")", "return", "sess", ",", "False", "else", ":", "logging", ".", "info", "(", "\"Restored model from %s\"", ",", "ckpt", ".", "model_checkpoint_path", ")", "return", "sess", ",", "True" ]

[ "Convert", "any", "negative", "measurements", "in", "the", "current", "box", "to", "positive", "and", "adjust", "the", "origin", "." ]

[ "def", "normalizeBox", "(", "box", ")", ":", "x", ",", "y", ",", "w", ",", "h", "=", "box", "if", "w", "<", "0", ":", "x", "+=", "(", "w", "+", "1", ")", "w", "*=", "-", "1", "if", "h", "<", "0", ":", "y", "+=", "(", "h", "+", "1", ")", "h", "*=", "-", "1", "return", "(", "x", ",", "y", ",", "w", ",", "h", ")" ]

[ "IsBefore", "(", "self", "HtmlCell", "cell", ")", "-", ">", "bool" ]

[ "def", "IsBefore", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html", ".", "HtmlCell_IsBefore", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]