Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

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

[ "def", "gt_roidb", "(", "self", ")", ":", "cache_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "cache_path", ",", "self", ".", "name", "+", "'_gt_roidb.pkl'", ")", "if", "os", ".", "path", ".", "exists", "(", "cache_file", ")", ":", "with", "open", "(", "cache_file", ",", "'rb'", ")", "as", "fid", ":", "roidb", "=", "cPickle", ".", "load", "(", "fid", ")", "print", "'{} gt roidb loaded from {}'", ".", "format", "(", "self", ".", "name", ",", "cache_file", ")", "print", "'class weights: '", ",", "roidb", "[", "0", "]", "[", "'class_weights'", "]", "return", "roidb", "# self.compute_class_weights()", "gt_roidb", "=", "[", "self", ".", "_load_yumi_annotation", "(", "index", ")", "for", "index", "in", "self", ".", "image_index", "]", "if", "not", "cfg", ".", "TRAIN", ".", "SEGMENTATION", ":", "# print out recall", "for", "i", "in", "xrange", "(", "1", ",", "self", ".", "num_classes", ")", ":", "print", "'{}: Total number of boxes {:d}'", ".", "format", "(", "self", ".", "classes", "[", "i", "]", ",", "self", ".", "_num_boxes_all", "[", "i", "]", ")", "print", "'{}: Number of boxes covered {:d}'", ".", "format", "(", "self", ".", "classes", "[", "i", "]", ",", "self", ".", "_num_boxes_covered", "[", "i", "]", ")", "if", "self", ".", "_num_boxes_all", "[", "i", "]", ">", "0", ":", "print", "'{}: Recall {:f}'", ".", "format", "(", "self", ".", "classes", "[", "i", "]", ",", "float", "(", "self", ".", "_num_boxes_covered", "[", "i", "]", ")", "/", "float", "(", "self", ".", "_num_boxes_all", "[", "i", "]", ")", ")", "with", "open", "(", "cache_file", ",", "'wb'", ")", "as", "fid", ":", "cPickle", ".", "dump", "(", "gt_roidb", ",", "fid", ",", "cPickle", ".", "HIGHEST_PROTOCOL", ")", "print", "'wrote gt roidb to {}'", ".", "format", "(", "cache_file", ")", "return", "gt_roidb" ]

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

[ "def", "CanIncreaseTextSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_webkit", ".", "WebKitCtrl_CanIncreaseTextSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Defines", "the", "default", "ResNet", "arg", "scope", "." ]

[ "def", "resnet_arg_scope", "(", "weight_decay", "=", "0.0001", ",", "batch_norm_decay", "=", "0.997", ",", "batch_norm_epsilon", "=", "1e-5", ",", "batch_norm_scale", "=", "True", ")", ":", "batch_norm_params", "=", "{", "'decay'", ":", "batch_norm_decay", ",", "'epsilon'", ":", "batch_norm_epsilon", ",", "'scale'", ":", "batch_norm_scale", ",", "'updates_collections'", ":", "tf", ".", "GraphKeys", ".", "UPDATE_OPS", ",", "}", "with", "slim", ".", "arg_scope", "(", "[", "slim", ".", "conv2d", "]", ",", "weights_regularizer", "=", "slim", ".", "l2_regularizer", "(", "weight_decay", ")", ",", "weights_initializer", "=", "slim", ".", "variance_scaling_initializer", "(", ")", ",", "activation_fn", "=", "tf", ".", "nn", ".", "relu", ",", "normalizer_fn", "=", "slim", ".", "batch_norm", ",", "normalizer_params", "=", "batch_norm_params", ")", ":", "with", "slim", ".", "arg_scope", "(", "[", "slim", ".", "batch_norm", "]", ",", "*", "*", "batch_norm_params", ")", ":", "# The following implies padding='SAME' for pool1, which makes feature", "# alignment easier for dense prediction tasks. This is also used in", "# https://github.com/facebook/fb.resnet.torch. However the accompanying", "# code of 'Deep Residual Learning for Image Recognition' uses", "# padding='VALID' for pool1. You can switch to that choice by setting", "# slim.arg_scope([slim.max_pool2d], padding='VALID').", "with", "slim", ".", "arg_scope", "(", "[", "slim", ".", "max_pool2d", "]", ",", "padding", "=", "'SAME'", ")", "as", "arg_sc", ":", "return", "arg_sc" ]

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

[ "def", "evaluate", "(", ")", ":", "with", "tf", ".", "Graph", "(", ")", ".", "as_default", "(", ")", "as", "g", ":", "# Get images and labels for CIFAR-10.", "eval_data", "=", "FLAGS", ".", "eval_data", "==", "'test'", "images", ",", "labels", "=", "cifar10", ".", "inputs", "(", "eval_data", "=", "eval_data", ")", "# Build a Graph that computes the logits predictions from the", "# inference model.", "logits", "=", "cifar10", ".", "inference", "(", "images", ")", "# Calculate predictions.", "top_k_op", "=", "tf", ".", "nn", ".", "in_top_k", "(", "logits", ",", "labels", ",", "1", ")", "# Restore the moving average version of the learned variables for eval.", "variable_averages", "=", "tf", ".", "train", ".", "ExponentialMovingAverage", "(", "cifar10", ".", "MOVING_AVERAGE_DECAY", ")", "variables_to_restore", "=", "variable_averages", ".", "variables_to_restore", "(", ")", "saver", "=", "tf", ".", "train", ".", "Saver", "(", "variables_to_restore", ")", "# Build the summary operation based on the TF collection of Summaries.", "summary_op", "=", "tf", ".", "merge_all_summaries", "(", ")", "summary_writer", "=", "tf", ".", "train", ".", "SummaryWriter", "(", "FLAGS", ".", "eval_dir", ",", "g", ")", "while", "True", ":", "eval_once", "(", "saver", ",", "summary_writer", ",", "top_k_op", ",", "summary_op", ")", "if", "FLAGS", ".", "run_once", ":", "break", "time", ".", "sleep", "(", "FLAGS", ".", "eval_interval_secs", ")" ]

[ "StyleGetSizeFractional", "(", "self", "int", "style", ")", "-", ">", "int" ]

[ "def", "StyleGetSizeFractional", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_StyleGetSizeFractional", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "The", "derivatives", "for", "deconvolution", "." ]

[ "def", "_Conv2DBackpropInputGrad", "(", "op", ",", "grad", ")", ":", "return", "[", "None", ",", "nn_ops", ".", "conv2d_backprop_filter", "(", "grad", ",", "array_ops", ".", "shape", "(", "op", ".", "inputs", "[", "1", "]", ")", ",", "op", ".", "inputs", "[", "2", "]", ",", "op", ".", "get_attr", "(", "\"strides\"", ")", ",", "op", ".", "get_attr", "(", "\"padding\"", ")", ",", "op", ".", "get_attr", "(", "\"use_cudnn_on_gpu\"", ")", ",", "op", ".", "get_attr", "(", "\"data_format\"", ")", ")", ",", "nn_ops", ".", "conv2d", "(", "grad", ",", "op", ".", "inputs", "[", "1", "]", ",", "op", ".", "get_attr", "(", "\"strides\"", ")", ",", "op", ".", "get_attr", "(", "\"padding\"", ")", ",", "op", ".", "get_attr", "(", "\"use_cudnn_on_gpu\"", ")", ",", "op", ".", "get_attr", "(", "\"data_format\"", ")", ")", "]" ]

[ "Function", "to", "run", "the", "IHT", "routine", "on", "FastObj" ]

[ "def", "runHardThrsd", "(", "self", ",", "sess", ")", ":", "self", ".", "thrsdParams", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "self", ".", "numMatrices", "[", "0", "]", ")", ":", "self", ".", "thrsdParams", ".", "append", "(", "utils", ".", "hardThreshold", "(", "self", ".", "FastParams", "[", "i", "]", ".", "eval", "(", ")", ",", "self", ".", "sW", ")", ")", "for", "i", "in", "range", "(", "self", ".", "numMatrices", "[", "0", "]", ",", "self", ".", "totalMatrices", ")", ":", "self", ".", "thrsdParams", ".", "append", "(", "utils", ".", "hardThreshold", "(", "self", ".", "FastParams", "[", "i", "]", ".", "eval", "(", ")", ",", "self", ".", "sU", ")", ")", "fd_thrsd", "=", "{", "}", "for", "i", "in", "range", "(", "0", ",", "self", ".", "totalMatrices", ")", ":", "fd_thrsd", "[", "self", ".", "paramPlaceholders", "[", "i", "]", "]", "=", "self", ".", "thrsdParams", "[", "i", "]", "sess", ".", "run", "(", "self", ".", "hardThresholdGroup", ",", "feed_dict", "=", "fd_thrsd", ")" ]

[ "Free", "a", "parameter", "from", "tie", "or", "constraint" ]

[ "def", "free", "(", "self", ",", "name", ")", ":", "self", ".", "fun", ".", "removeTie", "(", "name", ")", "self", ".", "fun", ".", "removeConstraint", "(", "name", ")" ]

[ "Encountered", "the", "end", "of", "a", "tag" ]

[ "def", "handle_endtag", "(", "self", ",", "tag", ")", ":", "if", "tag", "==", "\"head\"", "and", "self", ".", "steps", "==", "4", ":", "self", ".", "steps", "=", "5", "elif", "tag", "==", "\"body\"", "and", "self", ".", "steps", "==", "6", ":", "self", ".", "steps", "=", "7", "if", "tag", "==", "\"html\"", "and", "self", ".", "steps", "==", "7", ":", "self", ".", "steps", "=", "8" ]

[ "Process", "selector", "events", "." ]

[ "def", "_process_events", "(", "self", ",", "event_list", ")", ":", "raise", "NotImplementedError" ]

[ ":", "math", ":", "J_", "{", "bu", "}", "-", "matrix", "coefficient", "for", "bounds", "on", "u", "at", "shooting", "nodes", "(", "0", "to", "N", "-", "1", ")", ".", "Translated", "internally", "to", ":", "py", ":", "attr", ":", "idxbu", "." ]

[ "def", "Jbu", "(", "self", ")", ":", "print_J_to_idx_note", "(", ")", "return", "self", ".", "__idxbu" ]

[ "Construct", "an", "image", "path", "from", "the", "image", "s", "index", "identifier", "." ]

[ "def", "image_path_from_index", "(", "self", ",", "index", ")", ":", "image_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_data_path", ",", "index", "+", "'-color'", "+", "self", ".", "_image_ext", ")", "assert", "os", ".", "path", ".", "exists", "(", "image_path", ")", ",", "'Path does not exist: {}'", ".", "format", "(", "image_path", ")", "return", "image_path" ]

[ "Return", "pathname", "with", "new_root", "prepended", ".", "If", "pathname", "is", "relative", "this", "is", "equivalent", "to", "os", ".", "path", ".", "join", "(", "new_root", "pathname", ")", ".", "Otherwise", "it", "requires", "making", "pathname", "relative", "and", "then", "joining", "the", "two", "which", "is", "tricky", "on", "DOS", "/", "Windows", "and", "Mac", "OS", "." ]

[ "def", "change_root", "(", "new_root", ",", "pathname", ")", ":", "if", "os", ".", "name", "==", "'posix'", ":", "if", "not", "os", ".", "path", ".", "isabs", "(", "pathname", ")", ":", "return", "os", ".", "path", ".", "join", "(", "new_root", ",", "pathname", ")", "else", ":", "return", "os", ".", "path", ".", "join", "(", "new_root", ",", "pathname", "[", "1", ":", "]", ")", "elif", "os", ".", "name", "==", "'nt'", ":", "(", "drive", ",", "path", ")", "=", "os", ".", "path", ".", "splitdrive", "(", "pathname", ")", "if", "path", "[", "0", "]", "==", "'\\\\'", ":", "path", "=", "path", "[", "1", ":", "]", "return", "os", ".", "path", ".", "join", "(", "new_root", ",", "path", ")", "else", ":", "raise", "DistutilsPlatformError", "(", "\"nothing known about platform '%s'\"", "%", "os", ".", "name", ")" ]

[ ":", "type", "s", ":", "int", ":", "type", "nums", ":", "List", "[", "int", "]", ":", "rtype", ":", "int" ]

[ "def", "minSubArrayLen", "(", "self", ",", "s", ",", "nums", ")", ":", "i", ",", "j", ",", "size", ",", "sum", ",", "min_len", "=", "0", ",", "0", ",", "len", "(", "nums", ")", ",", "0", ",", "len", "(", "nums", ")", "if", "size", "==", "0", ":", "return", "0", "while", "j", "<", "size", ":", "sum", "+=", "nums", "[", "j", "]", "while", "sum", ">=", "s", ":", "sum", "-=", "nums", "[", "i", "]", "i", "+=", "1", "min_len", "=", "min", "(", "min_len", ",", "j", "-", "i", "+", "2", ")", "j", "+=", "1", "return", "min_len", "if", "i", "!=", "0", "else", "0" ]

[ "Register", "an", "error", "handler", "that", "will", "be", "called", "back", "as", "f", "(", "arg", "msg", "severity", "locator", ")", "." ]

[ "def", "SetErrorHandler", "(", "self", ",", "f", ",", "arg", ")", ":", "if", "f", "is", "None", ":", "libxml2mod", ".", "xmlTextReaderSetErrorHandler", "(", "self", ".", "_o", ",", "None", ",", "None", ")", "else", ":", "libxml2mod", ".", "xmlTextReaderSetErrorHandler", "(", "self", ".", "_o", ",", "_xmlTextReaderErrorFunc", ",", "(", "f", ",", "arg", ")", ")" ]

[ "Get", "completed", "and", "available", "for", "use", "techs", "." ]

[ "def", "get_completed_techs", "(", ")", ":", "return", "[", "tech", "for", "tech", "in", "fo", ".", "techs", "(", ")", "if", "tech_is_complete", "(", "tech", ")", "]" ]

[ "Determine", "if", "we", "have", "any", "encoding", "information", "in", "our", "headers", "." ]

[ "def", "_get_encoding_from_headers", "(", "headers", ")", ":", "# type: (ResponseHeaders) -> Optional[str]", "if", "headers", "and", "\"Content-Type\"", "in", "headers", ":", "content_type", ",", "params", "=", "cgi", ".", "parse_header", "(", "headers", "[", "\"Content-Type\"", "]", ")", "if", "\"charset\"", "in", "params", ":", "return", "params", "[", "'charset'", "]", "return", "None" ]

[ "Get", "the", "duration", "of", "the", "operator", "execution", "." ]

[ "def", "duration", "(", "self", ")", ":", "return", "self", ".", "_duration" ]

[ "Reconstruct", "3D", "pose", "given", "a", "2D", "pose" ]

[ "def", "create_rec", "(", "self", ",", "w2", ",", "weights", ",", "res_weight", "=", "1", ")", ":", "_SIGMA_SCALING", "=", "5.2", "res", ",", "e", ",", "a", ",", "r", ",", "scale", "=", "self", ".", "affine_estimate", "(", "w2", ",", "scale", "=", "_SIGMA_SCALING", ",", "weights", "=", "weights", ",", "depth_reg", "=", "0", ",", "cap_scale", "=", "-", "0.001", ",", "scale_mean", "=", "-", "0.003", ")", "remaining_dims", "=", "3", "*", "w2", ".", "shape", "[", "2", "]", "-", "e", ".", "shape", "[", "1", "]", "assert", "(", "remaining_dims", ">=", "0", ")", "llambda", "=", "-", "np", ".", "log", "(", "self", ".", "sigma", ")", "lgdet", "=", "np", ".", "sum", "(", "llambda", "[", ":", ",", ":", "-", "1", "]", ",", "1", ")", "+", "llambda", "[", ":", ",", "-", "1", "]", "*", "remaining_dims", "score", "=", "(", "res", "*", "res_weight", "+", "lgdet", "[", ":", ",", "np", ".", "newaxis", "]", "*", "(", "scale", "**", "2", ")", ")", "best", "=", "np", ".", "argmin", "(", "score", ",", "0", ")", "index", "=", "np", ".", "arange", "(", "best", ".", "shape", "[", "0", "]", ")", "a2", "=", "a", "[", "best", ",", "index", "]", "r2", "=", "r", "[", "best", ",", ":", ",", "index", "]", ".", "T", "rec", "=", "Prob3dPose", ".", "build_and_rot_model", "(", "a2", ",", "e", "[", "best", "]", ",", "self", ".", "mu", "[", "best", "]", ",", "r2", ")", "rec", "*=", "-", "np", ".", "abs", "(", "scale", "[", "best", ",", "index", "]", ")", "[", ":", ",", "np", ".", "newaxis", ",", "np", ".", "newaxis", "]", "rec", "=", "self", ".", "better_rec", "(", "w2", ",", "rec", ",", "1", ",", "1.55", "*", "weights", ",", "1", ")", "*", "-", "1", "rec", "=", "Prob3dPose", ".", "renorm_gt", "(", "rec", ")", "rec", "*=", "0.97", "return", "rec" ]

[ "r", "Return", "a", "sample", "(", "or", "samples", ")", "from", "the", "standard", "normal", "distribution", ".", "If", "positive", "int_like", "or", "int", "-", "convertible", "arguments", "are", "provided", "randn", "generates", "an", "array", "of", "shape", "(", "d0", "d1", "...", "dn", ")", "filled", "with", "random", "floats", "sampled", "from", "a", "univariate", "normal", "(", "Gaussian", ")", "distribution", "of", "mean", "0", "and", "variance", "1", "(", "if", "any", "of", "the", ":", "math", ":", "d_i", "are", "floats", "they", "are", "first", "converted", "to", "integers", "by", "truncation", ")", ".", "A", "single", "float", "randomly", "sampled", "from", "the", "distribution", "is", "returned", "if", "no", "argument", "is", "provided", ".", "This", "is", "a", "convenience", "function", ".", "If", "you", "want", "an", "interface", "that", "takes", "a", "tuple", "as", "the", "first", "argument", "use", "numpy", ".", "random", ".", "standard_normal", "instead", ".", "Parameters", "----------", "d0", "d1", "...", "dn", ":", "int", "optional", "The", "dimensions", "of", "the", "returned", "array", "should", "be", "all", "positive", ".", "If", "no", "argument", "is", "given", "a", "single", "Python", "float", "is", "returned", ".", "Returns", "-------", "Z", ":", "ndarray", "A", "(", "d0", "d1", "...", "dn", ")", "-", "shaped", "array", "of", "floating", "-", "point", "samples", "from", "the", "standard", "normal", "distribution", "or", "a", "single", "such", "float", "if", "no", "parameters", "were", "supplied", ".", "Notes", "-----", "For", "random", "samples", "from", ":", "math", ":", "N", "(", "\\", "mu", "\\", "sigma^2", ")", "use", ":", "sigma", "*", "np", ".", "random", ".", "randn", "(", "...", ")", "+", "mu", "Examples", "--------", ">>>", "np", ".", "random", ".", "randn", "()", "2", ".", "1923875335537315", "#random", "Two", "-", "by", "-", "four", "array", "of", "samples", "from", "N", "(", "3", "6", ".", "25", ")", ":", ">>>", "2", ".", "5", "*", "np", ".", "random", ".", "randn", "(", "2", "4", ")", "+", "3", "array", "(", "[[", "-", "4", ".", "49401501", "4", ".", "00950034", "-", "1", ".", "81814867", "7", ".", "29718677", "]", "#random", "[", "0", ".", "39924804", "4", ".", "68456316", "4", ".", "99394529", "4", ".", "84057254", "]]", ")", "#random" ]

[ "def", "randn", "(", "*", "size", ",", "*", "*", "kwargs", ")", ":", "output_shape", "=", "(", ")", "for", "s", "in", "size", ":", "output_shape", "+=", "(", "s", ",", ")", "return", "_mx_nd_np", ".", "random", ".", "normal", "(", "0", ",", "1", ",", "size", "=", "output_shape", ",", "*", "*", "kwargs", ")" ]

[ "SetPosition", "(", "self", "Point", "pos", ")" ]

[ "def", "SetPosition", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "MoveEvent_SetPosition", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Call", "to", "schedule", "current", "learning", "rate" ]

[ "def", "__call__", "(", "self", ",", "iteration", ")", ":", "if", "self", ".", "init", "==", "False", ":", "self", ".", "init", "=", "True", "self", ".", "old_lr", "=", "self", ".", "base_lr", "lr", "=", "self", ".", "base_lr", "*", "math", ".", "pow", "(", "self", ".", "factor", ",", "int", "(", "iteration", "/", "self", ".", "step", ")", ")", "if", "lr", "!=", "self", ".", "old_lr", ":", "self", ".", "old_lr", "=", "lr", "logging", ".", "info", "(", "\"At Iteration [%d]: Swith to new learning rate %.5f\"", ",", "iteration", ",", "lr", ")", "return", "lr" ]

[ "Gets", "the", "list", "of", "revision", "numbers", "between", "self", ".", "good_revision", "and", "self", ".", "bad_revision", "." ]

[ "def", "GetRevList", "(", "self", ")", ":", "cache", "=", "{", "}", "# The cache is stored in the same directory as bisect-builds.py", "cache_filename", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ")", ",", "'.bisect-builds-cache.json'", ")", "cache_dict_key", "=", "self", ".", "GetListingURL", "(", ")", "def", "_LoadBucketFromCache", "(", ")", ":", "if", "self", ".", "use_local_cache", ":", "try", ":", "with", "open", "(", "cache_filename", ")", "as", "cache_file", ":", "for", "(", "key", ",", "value", ")", "in", "json", ".", "load", "(", "cache_file", ")", ".", "items", "(", ")", ":", "cache", "[", "key", "]", "=", "value", "revisions", "=", "cache", ".", "get", "(", "cache_dict_key", ",", "[", "]", ")", "githash_svn_dict", "=", "cache", ".", "get", "(", "'githash_svn_dict'", ",", "{", "}", ")", "if", "revisions", ":", "print", "'Loaded revisions %d-%d from %s'", "%", "(", "revisions", "[", "0", "]", ",", "revisions", "[", "-", "1", "]", ",", "cache_filename", ")", "return", "(", "revisions", ",", "githash_svn_dict", ")", "except", "(", "EnvironmentError", ",", "ValueError", ")", ":", "pass", "return", "(", "[", "]", ",", "{", "}", ")", "def", "_SaveBucketToCache", "(", ")", ":", "\"\"\"Save the list of revisions and the git-svn mappings to a file.\n The list of revisions is assumed to be sorted.\"\"\"", "if", "self", ".", "use_local_cache", ":", "cache", "[", "cache_dict_key", "]", "=", "revlist_all", "cache", "[", "'githash_svn_dict'", "]", "=", "self", ".", "githash_svn_dict", "try", ":", "with", "open", "(", "cache_filename", ",", "'w'", ")", "as", "cache_file", ":", "json", ".", "dump", "(", "cache", ",", "cache_file", ")", "print", "'Saved revisions %d-%d to %s'", "%", "(", "revlist_all", "[", "0", "]", ",", "revlist_all", "[", "-", "1", "]", ",", "cache_filename", ")", "except", "EnvironmentError", ":", "pass", "# Download the revlist and filter for just the range between good and bad.", "minrev", "=", "min", "(", "self", ".", "good_revision", ",", "self", ".", "bad_revision", ")", "maxrev", "=", "max", "(", "self", ".", "good_revision", ",", "self", ".", "bad_revision", ")", "(", "revlist_all", ",", "self", ".", "githash_svn_dict", ")", "=", "_LoadBucketFromCache", "(", ")", "last_known_rev", "=", "revlist_all", "[", "-", "1", "]", "if", "revlist_all", "else", "0", "if", "last_known_rev", "<", "maxrev", ":", "revlist_all", ".", "extend", "(", "map", "(", "int", ",", "self", ".", "ParseDirectoryIndex", "(", "last_known_rev", ")", ")", ")", "revlist_all", "=", "list", "(", "set", "(", "revlist_all", ")", ")", "revlist_all", ".", "sort", "(", ")", "_SaveBucketToCache", "(", ")", "revlist", "=", "[", "x", "for", "x", "in", "revlist_all", "if", "x", ">=", "int", "(", "minrev", ")", "and", "x", "<=", "int", "(", "maxrev", ")", "]", "# Set good and bad revisions to be legit revisions.", "if", "revlist", ":", "if", "self", ".", "good_revision", "<", "self", ".", "bad_revision", ":", "self", ".", "good_revision", "=", "revlist", "[", "0", "]", "self", ".", "bad_revision", "=", "revlist", "[", "-", "1", "]", "else", ":", "self", ".", "bad_revision", "=", "revlist", "[", "0", "]", "self", ".", "good_revision", "=", "revlist", "[", "-", "1", "]", "# Fix chromium rev so that the deps blink revision matches REVISIONS file.", "if", "self", ".", "base_url", "==", "WEBKIT_BASE_URL", ":", "revlist_all", ".", "sort", "(", ")", "self", ".", "good_revision", "=", "FixChromiumRevForBlink", "(", "revlist", ",", "revlist_all", ",", "self", ",", "self", ".", "good_revision", ")", "self", ".", "bad_revision", "=", "FixChromiumRevForBlink", "(", "revlist", ",", "revlist_all", ",", "self", ",", "self", ".", "bad_revision", ")", "return", "revlist" ]

[ "Does", "the", "node", "represent", "a", "list", "literal?" ]

[ "def", "is_list", "(", "node", ")", ":", "return", "(", "isinstance", "(", "node", ",", "Node", ")", "and", "len", "(", "node", ".", "children", ")", ">", "1", "and", "isinstance", "(", "node", ".", "children", "[", "0", "]", ",", "Leaf", ")", "and", "isinstance", "(", "node", ".", "children", "[", "-", "1", "]", ",", "Leaf", ")", "and", "node", ".", "children", "[", "0", "]", ".", "value", "==", "\"[\"", "and", "node", ".", "children", "[", "-", "1", "]", ".", "value", "==", "\"]\"", ")" ]

[ "Return", "the", "database", "of", "selective", "search", "regions", "of", "interest", ".", "Ground", "-", "truth", "ROIs", "are", "also", "included", "." ]

[ "def", "selective_search_roidb", "(", "self", ")", ":", "cache_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "cache_path", ",", "self", ".", "name", "+", "'_selective_search_roidb.pkl'", ")", "if", "os", ".", "path", ".", "exists", "(", "cache_file", ")", ":", "with", "open", "(", "cache_file", ",", "'rb'", ")", "as", "fid", ":", "roidb", "=", "cPickle", ".", "load", "(", "fid", ")", "print", "'{} ss roidb loaded from {}'", ".", "format", "(", "self", ".", "name", ",", "cache_file", ")", "return", "roidb", "if", "int", "(", "self", ".", "_year", ")", "==", "2007", "or", "self", ".", "_image_set", "!=", "'test'", ":", "gt_roidb", "=", "self", ".", "gt_roidb", "(", ")", "ss_roidb", "=", "self", ".", "_load_selective_search_roidb", "(", "gt_roidb", ")", "roidb", "=", "imdb", ".", "merge_roidbs", "(", "gt_roidb", ",", "ss_roidb", ")", "else", ":", "roidb", "=", "self", ".", "_load_selective_search_roidb", "(", "None", ")", "with", "open", "(", "cache_file", ",", "'wb'", ")", "as", "fid", ":", "cPickle", ".", "dump", "(", "roidb", ",", "fid", ",", "cPickle", ".", "HIGHEST_PROTOCOL", ")", "print", "'wrote ss roidb to {}'", ".", "format", "(", "cache_file", ")", "return", "roidb" ]

[ "Escapes", "a", "CPP", "define", "so", "that", "it", "will", "reach", "the", "compiler", "unaltered", "." ]

[ "def", "_EscapeCppDefineForMSBuild", "(", "s", ")", ":", "s", "=", "_EscapeEnvironmentVariableExpansion", "(", "s", ")", "s", "=", "_EscapeCommandLineArgumentForMSBuild", "(", "s", ")", "s", "=", "_EscapeMSBuildSpecialCharacters", "(", "s", ")", "# cl.exe replaces literal # characters with = in preprocesor definitions for", "# some reason. Octal-encode to work around that.", "s", "=", "s", ".", "replace", "(", "'#'", ",", "'\\\\%03o'", "%", "ord", "(", "'#'", ")", ")", "return", "s" ]

[ "Returns", "the", "@extension", "method", "to", "call", "for", "a", "Node", "of", "a", "particular", "extension", "." ]

[ "def", "get_hook", "(", "self", ",", "node", ")", ":", "name", "=", "node", ".", "name", "for", "k", "in", "self", ".", "mappings", ":", "try", ":", "if", "name", ".", "endswith", "(", "k", ")", ":", "return", "self", ".", "mappings", "[", "k", "]", "except", "TypeError", ":", "# regexps objects", "if", "k", ".", "match", "(", "name", ")", ":", "return", "self", ".", "mappings", "[", "k", "]", "keys", "=", "list", "(", "self", ".", "mappings", ".", "keys", "(", ")", ")", "raise", "Errors", ".", "WafError", "(", "\"File %r has no mapping in %r (load a waf tool?)\"", "%", "(", "node", ",", "keys", ")", ")" ]

[ "Set", "the", "ordered", "attribute", "to", "the", "boolean", "value", "." ]

[ "def", "set_ordered", "(", "self", ",", "value", ",", "inplace", "=", "False", ")", ":", "inplace", "=", "validate_bool_kwarg", "(", "inplace", ",", "\"inplace\"", ")", "new_dtype", "=", "CategoricalDtype", "(", "self", ".", "categories", ",", "ordered", "=", "value", ")", "cat", "=", "self", "if", "inplace", "else", "self", ".", "copy", "(", ")", "cat", ".", "_dtype", "=", "new_dtype", "if", "not", "inplace", ":", "return", "cat" ]

[ "Given", "a", "scenario", "returns", "a", "yaml", "-", "formatted", "str", "for", "it", "." ]

[ "def", "save_scenario", "(", "*", ",", "scenario", ")", ":", "# For a known list of scenario-specific items, convert numpy arrays into", "# lists for serialization purposes.", "scrubbed", "=", "dict", "(", "scenario", ")", "for", "key", "in", "[", "\"controller_params\"", ",", "\"initial_state\"", "]", ":", "if", "isinstance", "(", "scenario", "[", "key", "]", ",", "dict", ")", ":", "for", "subkey", "in", "[", "\"min\"", ",", "\"max\"", "]", ":", "scrubbed", "[", "key", "]", "[", "subkey", "]", "=", "[", "float", "(", "x", ")", "for", "x", "in", "scenario", "[", "key", "]", "[", "subkey", "]", "]", "else", ":", "scrubbed", "[", "key", "]", "=", "[", "float", "(", "x", ")", "for", "x", "in", "scenario", "[", "key", "]", "]", "return", "yaml_dump", "(", "scrubbed", ")" ]

[ "If", "input", "points", "to", ")", "or", "}", "or", "]", "or", ">", "finds", "the", "position", "that", "opens", "it", "." ]

[ "def", "ReverseCloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "endchar", "=", "line", "[", "pos", "]", "if", "endchar", "not", "in", "')}]>'", ":", "return", "(", "line", ",", "0", ",", "-", "1", ")", "if", "endchar", "==", "')'", ":", "startchar", "=", "'('", "if", "endchar", "==", "']'", ":", "startchar", "=", "'['", "if", "endchar", "==", "'}'", ":", "startchar", "=", "'{'", "if", "endchar", "==", "'>'", ":", "startchar", "=", "'<'", "# Check last line", "(", "start_pos", ",", "num_open", ")", "=", "FindStartOfExpressionInLine", "(", "line", ",", "pos", ",", "0", ",", "startchar", ",", "endchar", ")", "if", "start_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "start_pos", ")", "# Continue scanning backward", "while", "linenum", ">", "0", ":", "linenum", "-=", "1", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "(", "start_pos", ",", "num_open", ")", "=", "FindStartOfExpressionInLine", "(", "line", ",", "len", "(", "line", ")", "-", "1", ",", "num_open", ",", "startchar", ",", "endchar", ")", "if", "start_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "start_pos", ")", "# Did not find startchar before beginning of file, give up", "return", "(", "line", ",", "0", ",", "-", "1", ")" ]

[ "Change", "position", "." ]

[ "def", "seek", "(", "self", ",", "offset", ",", "whence", "=", "0", ")", ":", "if", "whence", "==", "1", ":", "self", ".", "_file", ".", "seek", "(", "self", ".", "_pos", ")", "self", ".", "_file", ".", "seek", "(", "offset", ",", "whence", ")", "self", ".", "_pos", "=", "self", ".", "_file", ".", "tell", "(", ")" ]

[ "Return", "True", "if", "obj", "is", "a", "coroutine", "object", "." ]

[ "def", "iscoroutine", "(", "obj", ")", ":", "if", "type", "(", "obj", ")", "in", "_iscoroutine_typecache", ":", "return", "True", "if", "isinstance", "(", "obj", ",", "_COROUTINE_TYPES", ")", ":", "# Just in case we don't want to cache more than 100", "# positive types. That shouldn't ever happen, unless", "# someone stressing the system on purpose.", "if", "len", "(", "_iscoroutine_typecache", ")", "<", "100", ":", "_iscoroutine_typecache", ".", "add", "(", "type", "(", "obj", ")", ")", "return", "True", "else", ":", "return", "False" ]

[ "Generates", "the", "edges", "described", "in", "custom_edges", "for", "all", "unit", "cells", "." ]

[ "def", "get_custom_edges", "(", "basis_vectors", ",", "extent", ",", "site_offsets", ",", "pbc", ",", "atol", ",", "custom_edges", ":", "Sequence", "[", "CustomEdgeT", "]", ")", ":", "if", "not", "all", "(", "[", "len", "(", "desc", ")", "in", "(", "3", ",", "4", ")", "for", "desc", "in", "custom_edges", "]", ")", ":", "raise", "ValueError", "(", "dedent", "(", "\"\"\"\n custom_edges must be a list of tuples of length 3 or 4.\n Every tuple must contain two sublattice indices (integers), a distance vector\n and can optionally include an integer to represent the color of that edge.\n \n Check the docstring of `nk.graph.Lattice` for more informations.\n \"\"\"", ")", ")", "def", "translated_edges", "(", "sl1", ",", "sl2", ",", "distance", ",", "color", ")", ":", "# get distance in terms of unit cells", "d_cell", "=", "(", "distance", "+", "site_offsets", "[", "sl1", "]", "-", "site_offsets", "[", "sl2", "]", ")", "@", "np", ".", "linalg", ".", "inv", "(", "basis_vectors", ")", "if", "not", "np", ".", "all", "(", "is_approx_int", "(", "d_cell", ",", "atol", "=", "atol", ")", ")", ":", "# error out", "msg", "=", "f\"{distance} is invalid distance vector between sublattices {sl1}->{sl2}\"", "# see if the user flipped the vector accidentally", "d_cell", "=", "(", "distance", "+", "site_offsets", "[", "sl2", "]", "-", "site_offsets", "[", "sl1", "]", ")", "@", "np", ".", "linalg", ".", "inv", "(", "basis_vectors", ")", "if", "np", ".", "all", "(", "is_approx_int", "(", "d_cell", ",", "atol", "=", "atol", ")", ")", ":", "msg", "+=", "f\" (but valid {sl2}->{sl1})\"", "raise", "ValueError", "(", "msg", ")", "d_cell", "=", "np", ".", "asarray", "(", "np", ".", "rint", "(", "d_cell", ")", ",", "dtype", "=", "int", ")", "# catches self-referential and other unrealisably long edges", "if", "not", "np", ".", "all", "(", "d_cell", "<", "extent", ")", ":", "raise", "ValueError", "(", "f\"Distance vector {distance} does not fit into the lattice\"", ")", "# Unit cells of starting points", "start_min", "=", "np", ".", "where", "(", "pbc", ",", "0", ",", "np", ".", "maximum", "(", "0", ",", "-", "d_cell", ")", ")", "start_max", "=", "np", ".", "where", "(", "pbc", ",", "extent", ",", "extent", "-", "np", ".", "maximum", "(", "0", ",", "d_cell", ")", ")", "start_ranges", "=", "[", "slice", "(", "lo", ",", "hi", ")", "for", "lo", ",", "hi", "in", "zip", "(", "start_min", ",", "start_max", ")", "]", "start", "=", "np", ".", "mgrid", "[", "start_ranges", "]", ".", "reshape", "(", "len", "(", "extent", ")", ",", "-", "1", ")", ".", "T", "end", "=", "(", "start", "+", "d_cell", ")", "%", "extent", "# Convert to site indices", "start", "=", "site_to_idx", "(", "(", "start", ",", "sl1", ")", ",", "extent", ",", "site_offsets", ")", "end", "=", "site_to_idx", "(", "(", "end", ",", "sl2", ")", ",", "extent", ",", "site_offsets", ")", "return", "[", "(", "*", "edge", ",", "color", ")", "for", "edge", "in", "zip", "(", "start", ",", "end", ")", "]", "colored_edges", "=", "[", "]", "for", "i", ",", "desc", "in", "enumerate", "(", "custom_edges", ")", ":", "edge_data", "=", "desc", "[", ":", "3", "]", "edge_color", "=", "desc", "[", "3", "]", "if", "len", "(", "desc", ")", "==", "4", "else", "i", "colored_edges", "+=", "translated_edges", "(", "*", "edge_data", ",", "edge_color", ")", "return", "colored_edges" ]

[ "Generator", "for", "paths", "that", "were", "added", "." ]

[ "def", "IterAddedPaths", "(", "self", ")", ":", "for", "path", "in", "self", ".", "new_metadata", ".", "IterPaths", "(", ")", ":", "if", "self", ".", "_GetOldTag", "(", "path", ")", "is", "None", ":", "yield", "path" ]

[ "Creates", "a", "pdf", "graph", "of", "|snapshots|", "(", "a", "list", "of", "DeviceSnapshots", ")", "at", "|file_path|", ".", "This", "currently", "only", "shows", "memory", "stats", "and", "no", "network", "stats", "." ]

[ "def", "PrettyGraph", "(", "self", ",", "file_path", ",", "snapshots", ")", ":", "# Import these here so the rest of the functionality doesn't rely on", "# matplotlib", "from", "matplotlib", "import", "pyplot", "from", "matplotlib", ".", "backends", ".", "backend_pdf", "import", "PdfPages", "if", "not", "file_path", "or", "not", "snapshots", ":", "return", "pids", "=", "self", ".", "__FindPidsForSnapshotList", "(", "snapshots", ")", "pp", "=", "PdfPages", "(", "file_path", ")", "for", "(", "userid", ",", "pid", ",", "name", ")", "in", "pids", ":", "figure", "=", "pyplot", ".", "figure", "(", ")", "ax", "=", "figure", ".", "add_subplot", "(", "1", ",", "1", ",", "1", ")", "ax", ".", "set_xlabel", "(", "'Time (s)'", ")", "ax", ".", "set_ylabel", "(", "'MB'", ")", "ax", ".", "set_title", "(", "name", "+", "' ('", "+", "pid", "+", "')'", ")", "mem_list", "=", "[", "[", "]", "for", "x", "in", "range", "(", "len", "(", "self", ".", "__MEMORY_COLUMN_TITLES", ")", ")", "]", "timestamps", "=", "[", "]", "for", "snapshot", "in", "snapshots", ":", "results", "=", "snapshot", ".", "GetMemoryResults", "(", "pid", ")", "if", "not", "results", ":", "continue", "timestamps", ".", "append", "(", "round", "(", "snapshot", ".", "GetTimestamp", "(", ")", ",", "2", ")", ")", "assert", "len", "(", "results", ")", "==", "len", "(", "self", ".", "__MEMORY_COLUMN_TITLES", ")", "for", "idx", ",", "result", "in", "enumerate", "(", "results", ")", ":", "mem_list", "[", "idx", "]", ".", "append", "(", "result", ")", "colors", "=", "[", "]", "for", "data", "in", "mem_list", ":", "colors", ".", "append", "(", "ax", ".", "plot", "(", "timestamps", ",", "data", ")", "[", "0", "]", ")", "for", "i", "in", "xrange", "(", "len", "(", "timestamps", ")", ")", ":", "ax", ".", "annotate", "(", "data", "[", "i", "]", ",", "xy", "=", "(", "timestamps", "[", "i", "]", ",", "data", "[", "i", "]", ")", ")", "figure", ".", "legend", "(", "colors", ",", "self", ".", "__MEMORY_COLUMN_TITLES", ")", "pp", ".", "savefig", "(", ")", "pp", ".", "close", "(", ")" ]

[ "Return", "all", "sub_graphs", "included", "in", "the", "main", "graph", "as", "a", "set", "." ]

[ "def", "all_sub_graphs", "(", "self", ",", "for_test", "=", "False", ")", ":", "return", "[", "IrGraph", "(", "self", ".", "graph", ".", "get_sub_graph", "(", "i", ")", ",", "for_test", "=", "for_test", ")", "for", "i", "in", "range", "(", "self", ".", "graph", ".", "sub_graph_size", "(", ")", ")", "]" ]

[ "Get", "the", "enumeration", "name", "of", "this", "cursor", "kind", "." ]

[ "def", "name", "(", "self", ")", ":", "if", "self", ".", "_name_map", "is", "None", ":", "self", ".", "_name_map", "=", "{", "}", "for", "key", ",", "value", "in", "TypeKind", ".", "__dict__", ".", "items", "(", ")", ":", "if", "isinstance", "(", "value", ",", "TypeKind", ")", ":", "self", ".", "_name_map", "[", "value", "]", "=", "key", "return", "self", ".", "_name_map", "[", "self", "]" ]

[ "SetupOperation", "(", "name", "objFactory", "opPageClass", "pixmap", "menuText", "toolTip", "setupProperties", "=", "None", ")", "Creates", "an", "instance", "of", "CommandPathOp", "with", "the", "given", "parameters", "and", "registers", "the", "command", "with", "FreeCAD", ".", "When", "activated", "it", "creates", "a", "model", "with", "proxy", "(", "by", "invoking", "objFactory", ")", "assigns", "a", "view", "provider", "to", "it", "(", "see", "ViewProvider", "in", "this", "module", ")", "and", "starts", "the", "editor", "specifically", "for", "this", "operation", "(", "driven", "by", "opPageClass", ")", ".", "This", "is", "an", "internal", "function", "that", "is", "automatically", "called", "by", "the", "initialisation", "code", "for", "each", "operation", ".", "It", "is", "not", "expected", "to", "be", "called", "manually", "." ]

[ "def", "SetupOperation", "(", "name", ",", "objFactory", ",", "opPageClass", ",", "pixmap", ",", "menuText", ",", "toolTip", ",", "setupProperties", "=", "None", ")", ":", "res", "=", "CommandResources", "(", "name", ",", "objFactory", ",", "opPageClass", ",", "pixmap", ",", "menuText", ",", "None", ",", "toolTip", ")", "command", "=", "CommandPathOp", "(", "res", ")", "FreeCADGui", ".", "addCommand", "(", "\"Path_%s\"", "%", "name", ".", "replace", "(", "\" \"", ",", "\"_\"", ")", ",", "command", ")", "if", "setupProperties", "is", "not", "None", ":", "PathSetupSheet", ".", "RegisterOperation", "(", "name", ",", "objFactory", ",", "setupProperties", ")", "return", "command" ]

[ "Generates", "a", "new", "TTF", "program", "for", "the", "node", "." ]

[ "def", "_Handler_assembly", "(", "self", ",", "path", ",", "node", ")", ":", "if", "\"fpgm\"", "in", "path", ":", "# We want the \"fpgm\" (Font Program) section empty, as it should only contain instruction/function definitions.", "node", ".", "text", "=", "\"\"", "else", ":", "program", "=", "TTProgram", "(", "self", ".", "_twilight_points", ",", "self", ".", "_contours_in_glyph", ",", "self", ".", "_points_in_glyph", ")", "if", "\"prep\"", "in", "path", ":", "# Insert a constant number of initialization instructions into the \"prep\" table.", "node", ".", "text", "=", "program", ".", "GenerateProgram", "(", "self", ".", "PREP_INSTRUCTIONS", ")", "else", ":", "# Generate a regular TrueType program with length depending on the number of glyphs in font.", "node", ".", "text", "=", "program", ".", "GenerateProgram", "(", "min", "(", "self", ".", "_num_instructions", "//", "self", ".", "_num_glyphs", ",", "self", ".", "MAX_INSTRUCTIONS_PER_GLYPH", ")", ")" ]

[ "GetHScrollBar", "(", "self", "Window", "child", ")", "-", ">", "ScrollBar" ]

[ "def", "GetHScrollBar", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "DynamicSashWindow_GetHScrollBar", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "True", "if", "the", "keyed", "message", "exists", "False", "otherwise", "." ]

[ "def", "__contains__", "(", "self", ",", "key", ")", ":", "self", ".", "_refresh", "(", ")", "return", "key", "in", "self", ".", "_toc" ]

[ "Compile", "a", "set", "of", "source", "modules", "into", "C", "/", "C", "++", "files", "and", "return", "a", "list", "of", "distutils", "Extension", "objects", "for", "them", "." ]

[ "def", "cythonize", "(", "module_list", ",", "exclude", "=", "None", ",", "nthreads", "=", "0", ",", "aliases", "=", "None", ",", "quiet", "=", "False", ",", "force", "=", "False", ",", "language", "=", "None", ",", "exclude_failures", "=", "False", ",", "*", "*", "options", ")", ":", "if", "exclude", "is", "None", ":", "exclude", "=", "[", "]", "if", "'include_path'", "not", "in", "options", ":", "options", "[", "'include_path'", "]", "=", "[", "'.'", "]", "if", "'common_utility_include_dir'", "in", "options", ":", "safe_makedirs", "(", "options", "[", "'common_utility_include_dir'", "]", ")", "depfile", "=", "options", ".", "pop", "(", "'depfile'", ",", "None", ")", "if", "pythran", "is", "None", ":", "pythran_options", "=", "None", "else", ":", "pythran_options", "=", "CompilationOptions", "(", "*", "*", "options", ")", "pythran_options", ".", "cplus", "=", "True", "pythran_options", ".", "np_pythran", "=", "True", "c_options", "=", "CompilationOptions", "(", "*", "*", "options", ")", "cpp_options", "=", "CompilationOptions", "(", "*", "*", "options", ")", "cpp_options", ".", "cplus", "=", "True", "ctx", "=", "c_options", ".", "create_context", "(", ")", "options", "=", "c_options", "module_list", ",", "module_metadata", "=", "create_extension_list", "(", "module_list", ",", "exclude", "=", "exclude", ",", "ctx", "=", "ctx", ",", "quiet", "=", "quiet", ",", "exclude_failures", "=", "exclude_failures", ",", "language", "=", "language", ",", "aliases", "=", "aliases", ")", "deps", "=", "create_dependency_tree", "(", "ctx", ",", "quiet", "=", "quiet", ")", "build_dir", "=", "getattr", "(", "options", ",", "'build_dir'", ",", "None", ")", "def", "copy_to_build_dir", "(", "filepath", ",", "root", "=", "os", ".", "getcwd", "(", ")", ")", ":", "filepath_abs", "=", "os", ".", "path", ".", "abspath", "(", "filepath", ")", "if", "os", ".", "path", ".", "isabs", "(", "filepath", ")", ":", "filepath", "=", "filepath_abs", "if", "filepath_abs", ".", "startswith", "(", "root", ")", ":", "# distutil extension depends are relative to cwd", "mod_dir", "=", "join_path", "(", "build_dir", ",", "os", ".", "path", ".", "dirname", "(", "_relpath", "(", "filepath", ",", "root", ")", ")", ")", "copy_once_if_newer", "(", "filepath_abs", ",", "mod_dir", ")", "modules_by_cfile", "=", "collections", ".", "defaultdict", "(", "list", ")", "to_compile", "=", "[", "]", "for", "m", "in", "module_list", ":", "if", "build_dir", ":", "for", "dep", "in", "m", ".", "depends", ":", "copy_to_build_dir", "(", "dep", ")", "cy_sources", "=", "[", "source", "for", "source", "in", "m", ".", "sources", "if", "os", ".", "path", ".", "splitext", "(", "source", ")", "[", "1", "]", "in", "(", "'.pyx'", ",", "'.py'", ")", "]", "if", "len", "(", "cy_sources", ")", "==", "1", ":", "# normal \"special\" case: believe the Extension module name to allow user overrides", "full_module_name", "=", "m", ".", "name", "else", ":", "# infer FQMN from source files", "full_module_name", "=", "None", "new_sources", "=", "[", "]", "for", "source", "in", "m", ".", "sources", ":", "base", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "source", ")", "if", "ext", "in", "(", "'.pyx'", ",", "'.py'", ")", ":", "if", "m", ".", "np_pythran", ":", "c_file", "=", "base", "+", "'.cpp'", "options", "=", "pythran_options", "elif", "m", ".", "language", "==", "'c++'", ":", "c_file", "=", "base", "+", "'.cpp'", "options", "=", "cpp_options", "else", ":", "c_file", "=", "base", "+", "'.c'", "options", "=", "c_options", "# setup for out of place build directory if enabled", "if", "build_dir", ":", "if", "os", ".", "path", ".", "isabs", "(", "c_file", ")", ":", "warnings", ".", "warn", "(", "\"build_dir has no effect for absolute source paths\"", ")", "c_file", "=", "os", ".", "path", ".", "join", "(", "build_dir", ",", "c_file", ")", "dir", "=", "os", ".", "path", ".", "dirname", "(", "c_file", ")", "safe_makedirs_once", "(", "dir", ")", "# write out the depfile, if requested", "if", "depfile", ":", "dependencies", "=", "deps", ".", "all_dependencies", "(", "source", ")", "src_base_dir", ",", "_", "=", "os", ".", "path", ".", "split", "(", "source", ")", "if", "not", "src_base_dir", ".", "endswith", "(", "os", ".", "sep", ")", ":", "src_base_dir", "+=", "os", ".", "sep", "# paths below the base_dir are relative, otherwise absolute", "paths", "=", "[", "]", "for", "fname", "in", "dependencies", ":", "if", "(", "fname", ".", "startswith", "(", "src_base_dir", ")", "or", "fname", ".", "startswith", "(", "'.'", "+", "os", ".", "path", ".", "sep", ")", ")", ":", "paths", ".", "append", "(", "os", ".", "path", ".", "relpath", "(", "fname", ",", "src_base_dir", ")", ")", "else", ":", "paths", ".", "append", "(", "os", ".", "path", ".", "abspath", "(", "fname", ")", ")", "depline", "=", "os", ".", "path", ".", "split", "(", "c_file", ")", "[", "1", "]", "+", "\": \\\\\\n \"", "depline", "+=", "\" \\\\\\n \"", ".", "join", "(", "paths", ")", "+", "\"\\n\"", "with", "open", "(", "c_file", "+", "'.dep'", ",", "'w'", ")", "as", "outfile", ":", "outfile", ".", "write", "(", "depline", ")", "if", "os", ".", "path", ".", "exists", "(", "c_file", ")", ":", "c_timestamp", "=", "os", ".", "path", ".", "getmtime", "(", "c_file", ")", "else", ":", "c_timestamp", "=", "-", "1", "# Priority goes first to modified files, second to direct", "# dependents, and finally to indirect dependents.", "if", "c_timestamp", "<", "deps", ".", "timestamp", "(", "source", ")", ":", "dep_timestamp", ",", "dep", "=", "deps", ".", "timestamp", "(", "source", ")", ",", "source", "priority", "=", "0", "else", ":", "dep_timestamp", ",", "dep", "=", "deps", ".", "newest_dependency", "(", "source", ")", "priority", "=", "2", "-", "(", "dep", "in", "deps", ".", "immediate_dependencies", "(", "source", ")", ")", "if", "force", "or", "c_timestamp", "<", "dep_timestamp", ":", "if", "not", "quiet", "and", "not", "force", ":", "if", "source", "==", "dep", ":", "print", "(", "\"Compiling %s because it changed.\"", "%", "source", ")", "else", ":", "print", "(", "\"Compiling %s because it depends on %s.\"", "%", "(", "source", ",", "dep", ")", ")", "if", "not", "force", "and", "options", ".", "cache", ":", "fingerprint", "=", "deps", ".", "transitive_fingerprint", "(", "source", ",", "m", ",", "options", ")", "else", ":", "fingerprint", "=", "None", "to_compile", ".", "append", "(", "(", "priority", ",", "source", ",", "c_file", ",", "fingerprint", ",", "quiet", ",", "options", ",", "not", "exclude_failures", ",", "module_metadata", ".", "get", "(", "m", ".", "name", ")", ",", "full_module_name", ")", ")", "new_sources", ".", "append", "(", "c_file", ")", "modules_by_cfile", "[", "c_file", "]", ".", "append", "(", "m", ")", "else", ":", "new_sources", ".", "append", "(", "source", ")", "if", "build_dir", ":", "copy_to_build_dir", "(", "source", ")", "m", ".", "sources", "=", "new_sources", "if", "options", ".", "cache", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "options", ".", "cache", ")", ":", "os", ".", "makedirs", "(", "options", ".", "cache", ")", "to_compile", ".", "sort", "(", ")", "# Drop \"priority\" component of \"to_compile\" entries and add a", "# simple progress indicator.", "N", "=", "len", "(", "to_compile", ")", "progress_fmt", "=", "\"[{0:%d}/{1}] \"", "%", "len", "(", "str", "(", "N", ")", ")", "for", "i", "in", "range", "(", "N", ")", ":", "progress", "=", "progress_fmt", ".", "format", "(", "i", "+", "1", ",", "N", ")", "to_compile", "[", "i", "]", "=", "to_compile", "[", "i", "]", "[", "1", ":", "]", "+", "(", "progress", ",", ")", "if", "N", "<=", "1", ":", "nthreads", "=", "0", "if", "nthreads", ":", "# Requires multiprocessing (or Python >= 2.6)", "try", ":", "import", "multiprocessing", "pool", "=", "multiprocessing", ".", "Pool", "(", "nthreads", ",", "initializer", "=", "_init_multiprocessing_helper", ")", "except", "(", "ImportError", ",", "OSError", ")", ":", "print", "(", "\"multiprocessing required for parallel cythonization\"", ")", "nthreads", "=", "0", "else", ":", "# This is a bit more involved than it should be, because KeyboardInterrupts", "# break the multiprocessing workers when using a normal pool.map().", "# See, for example:", "# http://noswap.com/blog/python-multiprocessing-keyboardinterrupt", "try", ":", "result", "=", "pool", ".", "map_async", "(", "cythonize_one_helper", ",", "to_compile", ",", "chunksize", "=", "1", ")", "pool", ".", "close", "(", ")", "while", "not", "result", ".", "ready", "(", ")", ":", "try", ":", "result", ".", "get", "(", "99999", ")", "# seconds", "except", "multiprocessing", ".", "TimeoutError", ":", "pass", "except", "KeyboardInterrupt", ":", "pool", ".", "terminate", "(", ")", "raise", "pool", ".", "join", "(", ")", "if", "not", "nthreads", ":", "for", "args", "in", "to_compile", ":", "cythonize_one", "(", "*", "args", ")", "if", "exclude_failures", ":", "failed_modules", "=", "set", "(", ")", "for", "c_file", ",", "modules", "in", "modules_by_cfile", ".", "items", "(", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "c_file", ")", ":", "failed_modules", ".", "update", "(", "modules", ")", "elif", "os", ".", "path", ".", "getsize", "(", "c_file", ")", "<", "200", ":", "f", "=", "io_open", "(", "c_file", ",", "'r'", ",", "encoding", "=", "'iso8859-1'", ")", "try", ":", "if", "f", ".", "read", "(", "len", "(", "'#error '", ")", ")", "==", "'#error '", ":", "# dead compilation result", "failed_modules", ".", "update", "(", "modules", ")", "finally", ":", "f", ".", "close", "(", ")", "if", "failed_modules", ":", "for", "module", "in", "failed_modules", ":", "module_list", ".", "remove", "(", "module", ")", "print", "(", "\"Failed compilations: %s\"", "%", "', '", ".", "join", "(", "sorted", "(", "[", "module", ".", "name", "for", "module", "in", "failed_modules", "]", ")", ")", ")", "if", "options", ".", "cache", ":", "cleanup_cache", "(", "options", ".", "cache", ",", "getattr", "(", "options", ",", "'cache_size'", ",", "1024", "*", "1024", "*", "100", ")", ")", "# cythonize() is often followed by the (non-Python-buffered)", "# compiler output, flush now to avoid interleaving output.", "sys", ".", "stdout", ".", "flush", "(", ")", "return", "module_list" ]

[ "Return", "1", "if", "the", "actor", "has", "LODs", "0", "otherwise" ]

[ "def", "hasLOD", "(", "self", ")", ":", "return", "self", ".", "__hasLOD" ]

[ "Calculate", "next", "level", "boundary", "for", "qtnode", "." ]

[ "def", "GetNextQtnodeBounds", "(", "qtnode", ",", "x", ",", "y", ",", "size", ")", ":", "if", "qtnode", ":", "size", "/=", "2", "if", "qtnode", "[", "0", "]", "==", "\"3\"", ":", "return", "GetNextQtnodeBounds", "(", "qtnode", "[", "1", ":", "]", ",", "x", ",", "y", "+", "size", ",", "size", ")", "elif", "qtnode", "[", "0", "]", "==", "\"2\"", ":", "return", "GetNextQtnodeBounds", "(", "qtnode", "[", "1", ":", "]", ",", "x", "+", "size", ",", "y", "+", "size", ",", "size", ")", "elif", "qtnode", "[", "0", "]", "==", "\"1\"", ":", "return", "GetNextQtnodeBounds", "(", "qtnode", "[", "1", ":", "]", ",", "x", "+", "size", ",", "y", ",", "size", ")", "elif", "qtnode", "[", "0", "]", "==", "\"0\"", ":", "return", "GetNextQtnodeBounds", "(", "qtnode", "[", "1", ":", "]", ",", "x", ",", "y", ",", "size", ")", "else", ":", "raise", "Exception", "(", "\"Error: unexpected qtnode value %s\"", "%", "qtnode", "[", "0", "]", ")", "else", ":", "return", "[", "x", ",", "y", ",", "x", "+", "size", ",", "y", "+", "size", "]" ]

[ "Initialize", "the", "Estimator", "." ]

[ "def", "__init__", "(", "self", ",", "periodicities", ",", "input_window_size", ",", "output_window_size", ",", "num_features", ",", "num_time_buckets", "=", "10", ",", "loss", "=", "ar_model", ".", "ARModel", ".", "NORMAL_LIKELIHOOD_LOSS", ",", "hidden_layer_sizes", "=", "None", ",", "anomaly_prior_probability", "=", "None", ",", "anomaly_distribution", "=", "None", ",", "optimizer", "=", "None", ",", "model_dir", "=", "None", ",", "config", "=", "None", ")", ":", "if", "optimizer", "is", "None", ":", "optimizer", "=", "train", ".", "AdagradOptimizer", "(", "0.1", ")", "if", "anomaly_prior_probability", "is", "None", "and", "anomaly_distribution", "is", "not", "None", ":", "raise", "ValueError", "(", "\"anomaly_prior_probability is required if \"", "\"anomaly_distribution is specified.\"", ")", "if", "anomaly_prior_probability", "is", "None", ":", "if", "anomaly_distribution", "is", "None", ":", "anomaly_distribution", "=", "ar_model", ".", "AnomalyMixtureARModel", ".", "GAUSSIAN_ANOMALY", "model", "=", "ar_model", ".", "ARModel", "(", "periodicities", "=", "periodicities", ",", "num_features", "=", "num_features", ",", "num_time_buckets", "=", "num_time_buckets", ",", "input_window_size", "=", "input_window_size", ",", "output_window_size", "=", "output_window_size", ",", "loss", "=", "loss", ",", "hidden_layer_sizes", "=", "hidden_layer_sizes", ")", "else", ":", "if", "loss", "!=", "ar_model", ".", "ARModel", ".", "NORMAL_LIKELIHOOD_LOSS", ":", "raise", "ValueError", "(", "\"AnomalyMixtureARModel only supports \"", "\"ar_model.ARModel.NORMAL_LIKELIHOOD_LOSS for its loss argument.\"", ")", "model", "=", "ar_model", ".", "AnomalyMixtureARModel", "(", "periodicities", "=", "periodicities", ",", "input_window_size", "=", "input_window_size", ",", "output_window_size", "=", "output_window_size", ",", "num_features", "=", "num_features", ",", "num_time_buckets", "=", "num_time_buckets", ",", "hidden_layer_sizes", "=", "hidden_layer_sizes", ",", "anomaly_prior_probability", "=", "anomaly_prior_probability", ",", "anomaly_distribution", "=", "anomaly_distribution", ")", "state_manager", "=", "state_management", ".", "FilteringOnlyStateManager", "(", ")", "super", "(", "ARRegressor", ",", "self", ")", ".", "__init__", "(", "model", "=", "model", ",", "state_manager", "=", "state_manager", ",", "optimizer", "=", "optimizer", ",", "model_dir", "=", "model_dir", ",", "config", "=", "config", ")" ]

[ "This", "function", "is", "used", "to", "reduce", "the", "calculated", "metrics", "for", "each", "class", "of", "each", "example", "." ]

[ "def", "_decrease_metric", "(", "chart", ",", "decrease", "=", "\"mean\"", ")", ":", "nans", "=", "np", ".", "isnan", "(", "chart", ")", "not_nans", "=", "(", "~", "nans", ")", ".", "astype", "(", "float", ")", "chart", "[", "nans", "]", "=", "0", "decrease_dict", "=", "{", "\"mean\"", ":", "_decrease_mean", "(", "not_nans", ",", "chart", ")", ",", "\"sum\"", ":", "_decrease_sum", "(", "not_nans", ",", "chart", ")", ",", "\"mean_batch\"", ":", "_decrease_mean_batch", ",", "\"sum_batch\"", ":", "_decrease_sum_batch", "(", "not_nans", ",", "chart", ")", ",", "\"mean_channel\"", ":", "_decrease_mean_channel", "(", "not_nans", ",", "chart", ")", ",", "\"sum_channel\"", ":", "_decrease_sum_channel", "(", "not_nans", ",", "chart", ")", ",", "\"none\"", ":", "_decrease_none", "(", "not_nans", ",", "chart", ")", "}", "not_nans", ",", "chart", "=", "decrease_dict", ".", "get", "(", "decrease", ")", "return", "chart", ",", "not_nans" ]

[ "Get", "the", "option", "value", "for", "cell", "at", "(", "x", "y", ")" ]

[ "def", "entrycget", "(", "self", ",", "x", ",", "y", ",", "option", ")", ":", "if", "option", "and", "option", "[", "0", "]", "!=", "'-'", ":", "option", "=", "'-'", "+", "option", "return", "self", ".", "tk", ".", "call", "(", "self", ",", "'entrycget'", ",", "x", ",", "y", ",", "option", ")" ]

[ "Returns", "a", "generator", "for", "all", "subpaths", "in", "the", "given", "zip", "." ]

[ "def", "IterSubpaths", "(", "self", ",", "path", ")", ":", "outer_entry", "=", "self", ".", "_GetEntry", "(", "path", ")", "if", "not", "outer_entry", ":", "return", "(", ")", "subentries", "=", "outer_entry", ".", "get", "(", "'entries'", ",", "[", "]", ")", "return", "(", "entry", "[", "'path'", "]", "for", "entry", "in", "subentries", ")" ]

[ "Add", "a", "visitor", "to", "the", "list", "of", "visitors", "." ]

[ "def", "addVisitor", "(", "self", ",", "visitor", ")", ":", "if", "issubclass", "(", "visitor", ".", "__class__", ",", "AbstractVisitor", ".", "AbstractVisitor", ")", ":", "self", ".", "__visitor_list", ".", "append", "(", "visitor", ")", "else", ":", "DEBUG", ".", "error", "(", "\"MdStartPage.addVisitor(v) - the given visitor is not a subclass of AbstractVisitor!\"", ")", "raise", "Exception", "(", "\"MdStartPage.addVisitor(v) - the given visitor is not a subclass of AbstractVisitor!\"", ")" ]

[ "Clears", "all", "data", "written", "to", "the", "output", "stream", "so", "that", "it", "is", "empty", "." ]

[ "def", "clear", "(", "self", ")", ":", "self", ".", "body", "=", "''" ]

[ "Ask", "the", "function", "attached", "to", "the", "task", "to", "process", "it" ]

[ "def", "action_process_file_func", "(", "tsk", ")", ":", "if", "not", "tsk", ".", "fun", ":", "raise", "Errors", ".", "WafError", "(", "'task must have a function attached to it for copy_func to work!'", ")", "return", "tsk", ".", "fun", "(", "tsk", ")" ]

[ "Return", "the", "normalized", "path", "as", "a", "list", "of", "its", "components", ".", "split", "(", "foo", "/", "bar", "/", "baz", ")", "returns", "[", "foo", "bar", "baz", "]" ]

[ "def", "split", "(", "path", ")", ":", "return", "normsep", "(", "path", ")", ".", "split", "(", "'/'", ")" ]

[ "Get", "a", "helper", "object", "to", "access", "the", "*", "typ", "*", "s", "members", "for", "the", "given", "value", "or", "reference", "." ]

[ "def", "make_helper", "(", "self", ",", "builder", ",", "typ", ",", "value", "=", "None", ",", "ref", "=", "None", ")", ":", "return", "self", ".", "_make_helper", "(", "builder", ",", "typ", ",", "value", ",", "ref", ",", "kind", "=", "'value'", ")" ]

[ "Unregisters", "a", "previously", "registered", "domain", "." ]

[ "def", "UnregisterDomain", "(", "self", ",", "domain_name", ")", ":", "assert", "domain_name", "in", "self", ".", "_domain_handlers", "self", ".", "_domain_handlers", ".", "pop", "(", "domain_name", ")" ]

[ "Returns", "the", "matrix", "product", "of", "two", "blocks", "." ]

[ "def", "dot", "(", "input", ",", "other", ",", "allow_tf32", "=", "True", ",", "_builder", "=", "None", ")", ":", "return", "frontend", ".", "dot", "(", "input", ",", "other", ",", "allow_tf32", ",", "_builder", ")" ]

[ "Checks", "that", "the", "file", "contains", "a", "header", "guard", "." ]

[ "def", "CheckForHeaderGuard", "(", "filename", ",", "lines", ",", "error", ")", ":", "cppvar", "=", "GetHeaderGuardCPPVariable", "(", "filename", ")", "ifndef", "=", "None", "ifndef_linenum", "=", "0", "define", "=", "None", "endif", "=", "None", "endif_linenum", "=", "0", "for", "linenum", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "# Already been well guarded, no need for further checking.", "if", "line", ".", "strip", "(", ")", "==", "\"#pragma once\"", ":", "return", "linesplit", "=", "line", ".", "split", "(", ")", "if", "len", "(", "linesplit", ")", ">=", "2", ":", "# find the first occurrence of #ifndef and #define, save arg", "if", "not", "ifndef", "and", "linesplit", "[", "0", "]", "==", "'#ifndef'", ":", "# set ifndef to the header guard presented on the #ifndef line.", "ifndef", "=", "linesplit", "[", "1", "]", "ifndef_linenum", "=", "linenum", "if", "not", "define", "and", "linesplit", "[", "0", "]", "==", "'#define'", ":", "define", "=", "linesplit", "[", "1", "]", "# find the last occurrence of #endif, save entire line", "if", "line", ".", "startswith", "(", "'#endif'", ")", ":", "endif", "=", "line", "endif_linenum", "=", "linenum", "if", "not", "ifndef", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'No #ifndef header guard found, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "if", "not", "define", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'No #define header guard found, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "# The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__", "# for backward compatibility.", "if", "ifndef", "!=", "cppvar", ":", "error_level", "=", "0", "if", "ifndef", "!=", "cppvar", "+", "'_'", ":", "error_level", "=", "5", "ParseNolintSuppressions", "(", "filename", ",", "lines", "[", "ifndef_linenum", "]", ",", "ifndef_linenum", ",", "error", ")", "error", "(", "filename", ",", "ifndef_linenum", ",", "'build/header_guard'", ",", "error_level", ",", "'#ifndef header guard has wrong style, please use: %s'", "%", "cppvar", ")", "if", "define", "!=", "ifndef", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'#ifndef and #define don\\'t match, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "if", "endif", "!=", "(", "'#endif // %s'", "%", "cppvar", ")", ":", "error_level", "=", "0", "if", "endif", "!=", "(", "'#endif // %s'", "%", "(", "cppvar", "+", "'_'", ")", ")", ":", "error_level", "=", "5", "ParseNolintSuppressions", "(", "filename", ",", "lines", "[", "endif_linenum", "]", ",", "endif_linenum", ",", "error", ")", "error", "(", "filename", ",", "endif_linenum", ",", "'build/header_guard'", ",", "error_level", ",", "'#endif line should be \"#endif // %s\"'", "%", "cppvar", ")" ]

[ "SetFoldLevelPrev", "(", "self", "int", "val", ")" ]

[ "def", "SetFoldLevelPrev", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextEvent_SetFoldLevelPrev", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Send", "a", "DNS", "message", "." ]

[ "def", "send", "(", "self", ",", "data", ")", ":", "if", "self", ".", "__sock", "is", "None", ":", "raise", "DNSTCPContextError", "(", "'send() called after close'", ")", "if", "self", ".", "__send_buffer", "is", "not", "None", ":", "raise", "DNSTCPContextError", "(", "'duplicate send()'", ")", "self", ".", "__send_buffer", "=", "DNSTCPSendBuffer", "(", "data", ")", "self", ".", "__send_marker", "=", "0", "return", "self", ".", "__do_send", "(", ")" ]

[ "Adjusts", "the", "limits", "of", "variadic", "sequence", "MPL", "-", "containers", "." ]

[ "def", "adjust_container_limits_for_variadic_sequences", "(", "headerDir", ",", "containers", ",", "maxElements", ")", ":", "for", "container", "in", "containers", ":", "headerFile", "=", "os", ".", "path", ".", "join", "(", "headerDir", ",", "\"limits\"", ",", "container", "+", "\".hpp\"", ")", "regexMatch", "=", "r'(define\\s+BOOST_MPL_LIMIT_'", "+", "container", ".", "upper", "(", ")", "+", "r'_SIZE\\s+)[0-9]+'", "regexReplace", "=", "r'\\g<1>'", "+", "re", ".", "escape", "(", "str", "(", "maxElements", ")", ")", "for", "line", "in", "fileinput", ".", "input", "(", "headerFile", ",", "inplace", "=", "1", ",", "mode", "=", "\"rU\"", ")", ":", "line", "=", "re", ".", "sub", "(", "regexMatch", ",", "regexReplace", ",", "line", ".", "rstrip", "(", ")", ")", "print", "(", "line", ")" ]

[ "Move", "this", "method", "into", "group", "of", "calls", "which", "may", "be", "called", "multiple", "times", "." ]

[ "def", "MultipleTimes", "(", "self", ",", "group_name", "=", "\"default\"", ")", ":", "return", "self", ".", "_CheckAndCreateNewGroup", "(", "group_name", ",", "MultipleTimesGroup", ")" ]

[ "TimeSpan_Minutes", "(", "long", "min", ")", "-", ">", "TimeSpan" ]

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

[ "Converts", "a", "N", "-", "dimensional", "array", "to", "blob", "proto", ".", "If", "diff", "is", "given", "also", "convert", "the", "diff", ".", "You", "need", "to", "make", "sure", "that", "arr", "and", "diff", "have", "the", "same", "shape", "and", "this", "function", "does", "not", "do", "sanity", "check", "." ]

[ "def", "array_to_blobproto", "(", "arr", ",", "diff", "=", "None", ")", ":", "blob", "=", "caffe_pb2", ".", "BlobProto", "(", ")", "blob", ".", "shape", ".", "dim", ".", "extend", "(", "arr", ".", "shape", ")", "blob", ".", "data", ".", "extend", "(", "arr", ".", "astype", "(", "float", ")", ".", "flat", ")", "if", "diff", "is", "not", "None", ":", "blob", ".", "diff", ".", "extend", "(", "diff", ".", "astype", "(", "float", ")", ".", "flat", ")", "return", "blob" ]

[ "GetSDL", "is", "used", "to", "get", "the", "value", "of", "an", "Age", "SDL", "variable", "by", "name", ".", "Expects", "one", "argument", ":", "(", "string", ")", "VariableName" ]

[ "def", "GetSDL", "(", "varName", ")", ":", "import", "Plasma", "if", "not", "varName", ":", "print", "(", "\"xCheat.GetSDL(): GetSDL takes one argument: SDL variable name is required.\\n Use 'all' to list all variables for the current Age.\"", ")", "return", "ageName", "=", "Plasma", ".", "PtGetAgeName", "(", ")", "try", ":", "ageSDL", "=", "Plasma", ".", "PtGetAgeSDL", "(", ")", "except", ":", "print", "(", "(", "\"xCheat.GetSDL(): Unable to retrieve SDL for '{}'.\"", ".", "format", "(", "ageName", ")", ")", ")", "return", "varList", "=", "[", "]", "if", "varName", "==", "\"all\"", ":", "if", "ageName", "==", "\"Personal\"", ":", "varRecord", "=", "Plasma", ".", "ptVault", "(", ")", ".", "getPsnlAgeSDL", "(", ")", "if", "varRecord", ":", "varList", "=", "varRecord", ".", "getVarList", "(", ")", "else", ":", "vault", "=", "Plasma", ".", "ptAgeVault", "(", ")", "if", "vault", ":", "varRecord", "=", "vault", ".", "getAgeSDL", "(", ")", "if", "varRecord", ":", "varList", "=", "varRecord", ".", "getVarList", "(", ")", "if", "not", "varList", ":", "print", "(", "\"xCheat.GetSDL(): Couldn't retrieve SDL list.\"", ")", "return", "maxlen", "=", "len", "(", "max", "(", "varList", ",", "key", "=", "len", ")", ")", "for", "var", "in", "varList", ":", "try", ":", "if", "len", "(", "ageSDL", "[", "var", "]", ")", "==", "0", ":", "val", "=", "\"\"", "else", ":", "val", "=", "ageSDL", "[", "var", "]", "[", "0", "]", "print", "(", "(", "\"xCheat.GetSDL(): {:>{width}} = {}\"", ".", "format", "(", "var", ",", "val", ",", "width", "=", "maxlen", ")", ")", ")", "except", ":", "print", "(", "(", "\"xCheat.GetSDL(): Error retrieving value for '{}'.\"", ".", "format", "(", "var", ")", ")", ")", "else", ":", "try", ":", "if", "len", "(", "ageSDL", "[", "varName", "]", ")", "==", "0", ":", "print", "(", "(", "\"xCheat.GetSDL(): SDL variable '{}' is not set.\"", ".", "format", "(", "varName", ")", ")", ")", "else", ":", "print", "(", "(", "\"xCheat.GetSDL(): {} = {}\"", ".", "format", "(", "varName", ",", "ageSDL", "[", "varName", "]", "[", "0", "]", ")", ")", ")", "except", ":", "print", "(", "(", "\"xCheat.GetSDL(): SDL variable '{}' not found.\"", ".", "format", "(", "varName", ")", ")", ")", "return" ]

[ "Encode", "bytes", "using", "the", "URL", "-", "and", "filesystem", "-", "safe", "Base64", "alphabet", "." ]

[ "def", "urlsafe_b64encode", "(", "s", ")", ":", "return", "b64encode", "(", "s", ")", ".", "translate", "(", "_urlsafe_encode_translation", ")" ]

[ "Execute", "docker", "-", "compose", "builds", "." ]

[ "def", "docker_build", "(", "obj", ",", "image", ",", "*", ",", "force_pull", ",", "using_docker_cli", ",", "using_docker_buildx", ",", "use_cache", ",", "use_leaf_cache", ")", ":", "compose", "=", "obj", "[", "'compose'", "]", "using_docker_cli", "|=", "using_docker_buildx", "try", ":", "if", "force_pull", ":", "compose", ".", "pull", "(", "image", ",", "pull_leaf", "=", "use_leaf_cache", ",", "using_docker", "=", "using_docker_cli", ")", "compose", ".", "build", "(", "image", ",", "use_cache", "=", "use_cache", ",", "use_leaf_cache", "=", "use_leaf_cache", ",", "using_docker", "=", "using_docker_cli", ",", "using_buildx", "=", "using_docker_buildx", ",", "pull_parents", "=", "force_pull", ")", "except", "UndefinedImage", "as", "e", ":", "raise", "click", ".", "ClickException", "(", "\"There is no service/image defined in docker-compose.yml with \"", "\"name: {}\"", ".", "format", "(", "str", "(", "e", ")", ")", ")", "except", "RuntimeError", "as", "e", ":", "raise", "click", ".", "ClickException", "(", "str", "(", "e", ")", ")" ]

[ "See", "grpc", ".", "Future", ".", "running", "." ]

[ "def", "running", "(", "self", ")", ":", "return", "False" ]

[ ":", "type", "costs", ":", "List", "[", "List", "[", "int", "]]", ":", "rtype", ":", "int" ]

[ "def", "minCost", "(", "self", ",", "costs", ")", ":", "if", "costs", "is", "None", "or", "len", "(", "costs", ")", "==", "0", ":", "return", "0", "size", "=", "len", "(", "costs", ")", "color_size", "=", "len", "(", "costs", "[", "0", "]", ")", "table", "=", "[", "[", "0", "for", "_", "in", "range", "(", "color_size", ")", "]", "for", "i", "in", "range", "(", "size", "+", "1", ")", "]", "for", "i", "in", "range", "(", "1", ",", "size", "+", "1", ")", ":", "for", "j", "in", "range", "(", "color_size", ")", ":", "cost", "=", "float", "(", "'inf'", ")", "for", "p", "in", "range", "(", "color_size", ")", ":", "if", "j", "!=", "p", ":", "cost", "=", "min", "(", "cost", ",", "table", "[", "i", "-", "1", "]", "[", "p", "]", "+", "costs", "[", "i", "-", "1", "]", "[", "j", "]", ")", "table", "[", "i", "]", "[", "j", "]", "=", "cost", "return", "min", "(", "table", "[", "-", "1", "]", ")" ]

[ "SecureTransport", "cannot", "have", "its", "hostname", "checking", "disabled", ".", "For", "more", "see", "the", "comment", "on", "getpeercert", "()", "in", "this", "file", "." ]

[ "def", "check_hostname", "(", "self", ",", "value", ")", ":", "pass" ]

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

[ "def", "HasTabs", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "TextAttr_HasTabs", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Fetch", "metadata", "using", "lazy", "wheel", "if", "possible", "." ]

[ "def", "_fetch_metadata_using_lazy_wheel", "(", "self", ",", "link", ")", ":", "# type: (Link) -> Optional[Distribution]", "if", "not", "self", ".", "use_lazy_wheel", ":", "return", "None", "if", "self", ".", "require_hashes", ":", "logger", ".", "debug", "(", "'Lazy wheel is not used as hash checking is required'", ")", "return", "None", "if", "link", ".", "is_file", "or", "not", "link", ".", "is_wheel", ":", "logger", ".", "debug", "(", "'Lazy wheel is not used as '", "'%r does not points to a remote wheel'", ",", "link", ",", ")", "return", "None", "wheel", "=", "Wheel", "(", "link", ".", "filename", ")", "name", "=", "canonicalize_name", "(", "wheel", ".", "name", ")", "logger", ".", "info", "(", "'Obtaining dependency information from %s %s'", ",", "name", ",", "wheel", ".", "version", ",", ")", "url", "=", "link", ".", "url", ".", "split", "(", "'#'", ",", "1", ")", "[", "0", "]", "try", ":", "return", "dist_from_wheel_url", "(", "name", ",", "url", ",", "self", ".", "_session", ")", "except", "HTTPRangeRequestUnsupported", ":", "logger", ".", "debug", "(", "'%s does not support range requests'", ",", "url", ")", "return", "None" ]

[ "suffixes", "are", "fortran", "source", "files", "and", "ppsuffixes", "the", "ones", "to", "be", "pre", "-", "processed", ".", "Both", "should", "be", "sequences", "not", "strings", "." ]

[ "def", "ComputeFortranSuffixes", "(", "suffixes", ",", "ppsuffixes", ")", ":", "assert", "len", "(", "suffixes", ")", ">", "0", "s", "=", "suffixes", "[", "0", "]", "sup", "=", "s", ".", "upper", "(", ")", "upper_suffixes", "=", "[", "_", ".", "upper", "(", ")", "for", "_", "in", "suffixes", "]", "if", "SCons", ".", "Util", ".", "case_sensitive_suffixes", "(", "s", ",", "sup", ")", ":", "ppsuffixes", ".", "extend", "(", "upper_suffixes", ")", "else", ":", "suffixes", ".", "extend", "(", "upper_suffixes", ")" ]

[ "Rewrites", "a", "source", "object", "to", "a", "destination", "object", ".", "Optionally", "overrides", "metadata", "." ]

[ "def", "RunWithArgs", "(", "self", ",", "sourceBucket", ",", "sourceObject", ",", "destinationBucket", ",", "destinationObject", ")", ":", "client", "=", "GetClientFromFlags", "(", ")", "global_params", "=", "GetGlobalParamsFromFlags", "(", ")", "request", "=", "messages", ".", "StorageObjectsRewriteRequest", "(", "sourceBucket", "=", "sourceBucket", ".", "decode", "(", "'utf8'", ")", ",", "sourceObject", "=", "sourceObject", ".", "decode", "(", "'utf8'", ")", ",", "destinationBucket", "=", "destinationBucket", ".", "decode", "(", "'utf8'", ")", ",", "destinationObject", "=", "destinationObject", ".", "decode", "(", "'utf8'", ")", ",", ")", "if", "FLAGS", "[", "'destinationPredefinedAcl'", "]", ".", "present", ":", "request", ".", "destinationPredefinedAcl", "=", "messages", ".", "StorageObjectsRewriteRequest", ".", "DestinationPredefinedAclValueValuesEnum", "(", "FLAGS", ".", "destinationPredefinedAcl", ")", "if", "FLAGS", "[", "'ifGenerationMatch'", "]", ".", "present", ":", "request", ".", "ifGenerationMatch", "=", "int", "(", "FLAGS", ".", "ifGenerationMatch", ")", "if", "FLAGS", "[", "'ifGenerationNotMatch'", "]", ".", "present", ":", "request", ".", "ifGenerationNotMatch", "=", "int", "(", "FLAGS", ".", "ifGenerationNotMatch", ")", "if", "FLAGS", "[", "'ifMetagenerationMatch'", "]", ".", "present", ":", "request", ".", "ifMetagenerationMatch", "=", "int", "(", "FLAGS", ".", "ifMetagenerationMatch", ")", "if", "FLAGS", "[", "'ifMetagenerationNotMatch'", "]", ".", "present", ":", "request", ".", "ifMetagenerationNotMatch", "=", "int", "(", "FLAGS", ".", "ifMetagenerationNotMatch", ")", "if", "FLAGS", "[", "'ifSourceGenerationMatch'", "]", ".", "present", ":", "request", ".", "ifSourceGenerationMatch", "=", "int", "(", "FLAGS", ".", "ifSourceGenerationMatch", ")", "if", "FLAGS", "[", "'ifSourceGenerationNotMatch'", "]", ".", "present", ":", "request", ".", "ifSourceGenerationNotMatch", "=", "int", "(", "FLAGS", ".", "ifSourceGenerationNotMatch", ")", "if", "FLAGS", "[", "'ifSourceMetagenerationMatch'", "]", ".", "present", ":", "request", ".", "ifSourceMetagenerationMatch", "=", "int", "(", "FLAGS", ".", "ifSourceMetagenerationMatch", ")", "if", "FLAGS", "[", "'ifSourceMetagenerationNotMatch'", "]", ".", "present", ":", "request", ".", "ifSourceMetagenerationNotMatch", "=", "int", "(", "FLAGS", ".", "ifSourceMetagenerationNotMatch", ")", "if", "FLAGS", "[", "'maxBytesRewrittenPerCall'", "]", ".", "present", ":", "request", ".", "maxBytesRewrittenPerCall", "=", "int", "(", "FLAGS", ".", "maxBytesRewrittenPerCall", ")", "if", "FLAGS", "[", "'object'", "]", ".", "present", ":", "request", ".", "object", "=", "apitools_base", ".", "JsonToMessage", "(", "messages", ".", "Object", ",", "FLAGS", ".", "object", ")", "if", "FLAGS", "[", "'projection'", "]", ".", "present", ":", "request", ".", "projection", "=", "messages", ".", "StorageObjectsRewriteRequest", ".", "ProjectionValueValuesEnum", "(", "FLAGS", ".", "projection", ")", "if", "FLAGS", "[", "'rewriteToken'", "]", ".", "present", ":", "request", ".", "rewriteToken", "=", "FLAGS", ".", "rewriteToken", ".", "decode", "(", "'utf8'", ")", "if", "FLAGS", "[", "'sourceGeneration'", "]", ".", "present", ":", "request", ".", "sourceGeneration", "=", "int", "(", "FLAGS", ".", "sourceGeneration", ")", "result", "=", "client", ".", "objects", ".", "Rewrite", "(", "request", ",", "global_params", "=", "global_params", ")", "print", "apitools_base_cli", ".", "FormatOutput", "(", "result", ")" ]

[ "deletes", "a", "node", "at", "the", "given", "position" ]

[ "def", "deleteNodeByPosition", "(", "self", ",", "pos", ")", ":", "if", "self", ".", "head", "is", "None", ":", "return", "False", "elif", "pos", "==", "0", ":", "self", ".", "head", "=", "self", ".", "head", ".", "next", "return", "True", "else", ":", "CurrentNode", "=", "self", ".", "head", "while", "pos", ">", "1", ":", "CurrentNode", "=", "CurrentNode", ".", "next", "pos", "-=", "1", "CurrentNode", ".", "next", "=", "CurrentNode", ".", "next", ".", "next", "return", "True" ]

[ "SetEnvironmentEntries", "(", "self", "list", "envp", "bool", "append", ")" ]

[ "def", "SetEnvironmentEntries", "(", "self", ",", "*", "args", ")", ":", "return", "_lldb", ".", "SBLaunchInfo_SetEnvironmentEntries", "(", "self", ",", "*", "args", ")" ]

[ "__init__", "(", "self", ")", "-", ">", "PyGridTableBase" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_grid", ".", "PyGridTableBase_swiginit", "(", "self", ",", "_grid", ".", "new_PyGridTableBase", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "self", ".", "_setOORInfo", "(", "self", ")", "PyGridTableBase", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "PyGridTableBase", ")" ]

[ "Callback", "to", "checkpoint", "Module", "to", "prefix", "every", "epoch", "." ]

[ "def", "module_checkpoint", "(", "mod", ",", "prefix", ",", "period", "=", "1", ",", "save_optimizer_states", "=", "False", ")", ":", "period", "=", "int", "(", "max", "(", "1", ",", "period", ")", ")", "# pylint: disable=unused-argument", "def", "_callback", "(", "iter_no", ",", "sym", "=", "None", ",", "arg", "=", "None", ",", "aux", "=", "None", ")", ":", "\"\"\"The checkpoint function.\"\"\"", "if", "(", "iter_no", "+", "1", ")", "%", "period", "==", "0", ":", "mod", ".", "save_checkpoint", "(", "prefix", ",", "iter_no", "+", "1", ",", "save_optimizer_states", ")", "return", "_callback" ]

[ "If", "we", "have", "bytes", "decode", "them", "to", "unicode", "." ]

[ "def", "_ensure_decoded", "(", "s", ")", ":", "if", "isinstance", "(", "s", ",", "(", "np", ".", "bytes_", ",", "bytes", ")", ")", ":", "s", "=", "s", ".", "decode", "(", "get_option", "(", "\"display.encoding\"", ")", ")", "return", "s" ]

[ "SetDisabledBitmap", "(", "self", "Bitmap", "bmp", ")" ]

[ "def", "SetDisabledBitmap", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBarItem_SetDisabledBitmap", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "r", "GetSemiMajor", "(", "SpatialReference", "self", ")", "-", ">", "double" ]

[ "def", "GetSemiMajor", "(", "self", ",", "*", "args", ")", ":", "return", "_osr", ".", "SpatialReference_GetSemiMajor", "(", "self", ",", "*", "args", ")" ]

[ "Create", "bind", "and", "connect", "one", "socket", "." ]

[ "async", "def", "_connect_sock", "(", "self", ",", "exceptions", ",", "addr_info", ",", "local_addr_infos", "=", "None", ")", ":", "my_exceptions", "=", "[", "]", "exceptions", ".", "append", "(", "my_exceptions", ")", "family", ",", "type_", ",", "proto", ",", "_", ",", "address", "=", "addr_info", "sock", "=", "None", "try", ":", "sock", "=", "socket", ".", "socket", "(", "family", "=", "family", ",", "type", "=", "type_", ",", "proto", "=", "proto", ")", "sock", ".", "setblocking", "(", "False", ")", "if", "local_addr_infos", "is", "not", "None", ":", "for", "_", ",", "_", ",", "_", ",", "_", ",", "laddr", "in", "local_addr_infos", ":", "try", ":", "sock", ".", "bind", "(", "laddr", ")", "break", "except", "OSError", "as", "exc", ":", "msg", "=", "(", "f'error while attempting to bind on '", "f'address {laddr!r}: '", "f'{exc.strerror.lower()}'", ")", "exc", "=", "OSError", "(", "exc", ".", "errno", ",", "msg", ")", "my_exceptions", ".", "append", "(", "exc", ")", "else", ":", "# all bind attempts failed", "raise", "my_exceptions", ".", "pop", "(", ")", "await", "self", ".", "sock_connect", "(", "sock", ",", "address", ")", "return", "sock", "except", "OSError", "as", "exc", ":", "my_exceptions", ".", "append", "(", "exc", ")", "if", "sock", "is", "not", "None", ":", "sock", ".", "close", "(", ")", "raise", "except", ":", "if", "sock", "is", "not", "None", ":", "sock", ".", "close", "(", ")", "raise" ]

[ "Deletes", "the", "item", "at", "the", "specified", "position", "." ]

[ "def", "__delitem__", "(", "self", ",", "key", ")", ":", "del", "self", ".", "_values", "[", "key", "]", "self", ".", "_message_listener", ".", "Modified", "(", ")" ]

[ "Parses", "Name_Alias", "from", "NameAliases", ".", "txt", ".", "A", "character", "can", "have", "multiple", "aliases", "." ]

[ "def", "ParseNameAliases", "(", "in_file", ")", ":", "for", "data", "in", "ReadUCDLines", "(", "in_file", ")", ":", "start", "=", "data", "[", "2", "]", "end", "=", "data", "[", "3", "]", "if", "start", "!=", "end", ":", "raise", "ValueError", "(", "\"NameAliases.txt has an alias for a range %04lX..%04lX\"", "%", "(", "start", ",", "end", ")", ")", "fields", "=", "data", "[", "4", "]", "if", "len", "(", "fields", ")", "==", "2", ":", "alias", "=", "\"correction=\"", "+", "fields", "[", "1", "]", "else", ":", "alias", "=", "fields", "[", "2", "]", "+", "'='", "+", "fields", "[", "1", "]", "update", "=", "(", "NeedToSetAlways", ",", "DoSetNameAlias", ",", "alias", ")", "UpdateProps", "(", "start", ",", "end", ",", "update", ")" ]

[ "Provide", "an", "candidate", "iterable", "for", "get_preference", "()" ]

[ "def", "for_preference", "(", "self", ")", ":", "return", "self", ".", "_sequence" ]

[ "Convert", "a", "term", "or", "a", "sort", "to", "a", "Z3", "object", "." ]

[ "def", "_to_z3", "(", "x", ")", ":", "if", "x", "in", "_z3_interpreted", ":", "return", "_z3_interpreted", "[", "x", "]", "elif", "type", "(", "x", ")", "is", "UninterpretedSort", ":", "if", "x", "not", "in", "_z3_uninterpreted_sorts", ":", "_z3_uninterpreted_sorts", "[", "x", "]", "=", "z3", ".", "DeclareSort", "(", "x", ".", "name", ")", "return", "_z3_uninterpreted_sorts", "[", "x", "]", "elif", "type", "(", "x", ")", "is", "FunctionSort", ":", "assert", "False", ",", "\"FunctionSort's aren't converted to Z3\"", "elif", "type", "(", "x", ")", "in", "(", "Var", ",", "Const", ")", "and", "first_order_sort", "(", "x", ".", "sort", ")", ":", "return", "z3", ".", "Const", "(", "x", ".", "name", "+", "':'", "+", "str", "(", "x", ".", "sort", ")", ",", "to_z3", "(", "x", ".", "sort", ")", ")", "elif", "type", "(", "x", ")", "in", "(", "Var", ",", "Const", ")", "and", "type", "(", "x", ".", "sort", ")", "is", "FunctionSort", "and", "len", "(", "x", ".", "sort", ".", "sorts", ")", "==", "1", ":", "# convert to first order", "s", "=", "x", ".", "sort", ".", "sorts", "[", "0", "]", "return", "z3", ".", "Const", "(", "x", ".", "name", "+", "':'", "+", "str", "(", "s", ")", ",", "to_z3", "(", "s", ")", ")", "elif", "type", "(", "x", ")", "in", "(", "Var", ",", "Const", ")", "and", "type", "(", "x", ".", "sort", ")", "is", "FunctionSort", ":", "assert", "type", "(", "x", ")", "is", "Const", ",", "\"Cannot convert high-order variables to Z3, only constants\"", "return", "z3", ".", "Function", "(", "x", ".", "name", ",", "*", "(", "to_z3", "(", "s", ")", "for", "s", "in", "x", ".", "sort", ")", ")", "elif", "type", "(", "x", ")", "is", "Apply", "and", "len", "(", "x", ".", "terms", ")", "==", "0", ":", "# convert application to use of first order symbol", "return", "to_z3", "(", "x", ".", "func", ")", "elif", "type", "(", "x", ")", "is", "Apply", ":", "return", "to_z3", "(", "x", ".", "func", ")", "(", "*", "(", "to_z3", "(", "t", ")", "for", "t", "in", "x", ".", "terms", ")", ")", "elif", "type", "(", "x", ")", "in", "_z3_operators", ":", "return", "_z3_operators", "[", "type", "(", "x", ")", "]", "(", "*", "(", "to_z3", "(", "y", ")", "for", "y", "in", "x", ")", ")", "elif", "type", "(", "x", ")", "in", "_z3_quantifiers", ":", "if", "len", "(", "x", ".", "variables", ")", "==", "0", ":", "return", "to_z3", "(", "x", ".", "body", ")", "else", ":", "return", "_z3_quantifiers", "[", "type", "(", "x", ")", "]", "(", "[", "to_z3", "(", "v", ")", "for", "v", "in", "x", ".", "variables", "]", ",", "to_z3", "(", "x", ".", "body", ")", ",", ")", "else", ":", "assert", "False", ",", "type", "(", "x", ")" ]

[ "Stop", "serving", ".", "This", "leaves", "existing", "connections", "open", "." ]

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

[ "Dynamically", "add", "trait", "attributes", "to", "the", "HasTraits", "instance", "." ]

[ "def", "add_traits", "(", "self", ",", "*", "*", "traits", ")", ":", "self", ".", "__class__", "=", "type", "(", "self", ".", "__class__", ".", "__name__", ",", "(", "self", ".", "__class__", ",", ")", ",", "traits", ")", "for", "trait", "in", "traits", ".", "values", "(", ")", ":", "trait", ".", "instance_init", "(", "self", ")" ]

[ "PGTextCtrlEditor_GetTextCtrlValueFromControl", "(", "wxVariant", "variant", "PGProperty", "property", "Window", "ctrl", ")", "-", ">", "bool" ]

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

[ "Get", "a", "list", "of", "commands", "in", "a", "given", "API", "version", "by", "calling", "listCommands", "." ]

[ "def", "list_commands_for_api", "(", "api_version", ":", "str", ",", "mongod_or_mongos", ":", "str", ",", "install_dir", ":", "str", ")", "->", "Set", "[", "str", "]", ":", "assert", "mongod_or_mongos", "in", "(", "\"mongod\"", ",", "\"mongos\"", ")", "logging", ".", "info", "(", "\"Calling listCommands on %s\"", ",", "mongod_or_mongos", ")", "dbpath", "=", "TemporaryDirectory", "(", ")", "fixturelib", "=", "FixtureLib", "(", ")", "mongod_executable", "=", "os", ".", "path", ".", "join", "(", "install_dir", ",", "\"mongod\"", ")", "mongos_executable", "=", "os", ".", "path", ".", "join", "(", "install_dir", ",", "\"mongos\"", ")", "if", "mongod_or_mongos", "==", "\"mongod\"", ":", "logger", "=", "loggers", ".", "new_fixture_logger", "(", "\"MongoDFixture\"", ",", "0", ")", "logger", ".", "parent", "=", "LOGGER", "fixture", ":", "interface", ".", "Fixture", "=", "fixturelib", ".", "make_fixture", "(", "\"MongoDFixture\"", ",", "logger", ",", "0", ",", "dbpath_prefix", "=", "dbpath", ".", "name", ",", "mongod_executable", "=", "mongod_executable", ")", "else", ":", "logger", "=", "loggers", ".", "new_fixture_logger", "(", "\"ShardedClusterFixture\"", ",", "0", ")", "logger", ".", "parent", "=", "LOGGER", "fixture", "=", "fixturelib", ".", "make_fixture", "(", "\"ShardedClusterFixture\"", ",", "logger", ",", "0", ",", "dbpath_prefix", "=", "dbpath", ".", "name", ",", "mongos_executable", "=", "mongos_executable", ",", "mongod_executable", "=", "mongod_executable", ",", "mongod_options", "=", "{", "}", ")", "fixture", ".", "setup", "(", ")", "fixture", ".", "await_ready", "(", ")", "try", ":", "client", "=", "MongoClient", "(", "fixture", ".", "get_driver_connection_url", "(", ")", ")", "reply", "=", "client", ".", "admin", ".", "command", "(", "'listCommands'", ")", "commands", "=", "{", "name", "for", "name", ",", "info", "in", "reply", "[", "'commands'", "]", ".", "items", "(", ")", "if", "api_version", "in", "info", "[", "'apiVersions'", "]", "}", "logging", ".", "info", "(", "\"Found %s commands in API Version %s on %s\"", ",", "len", "(", "commands", ")", ",", "api_version", ",", "mongod_or_mongos", ")", "return", "commands", "finally", ":", "fixture", ".", "teardown", "(", ")" ]

[ "Standardizes", "a", "batch", "output", "by", "a", "generator", "." ]

[ "def", "_standardize_batch", "(", "self", ",", "data", ")", ":", "# Removes `None`s.", "x", ",", "y", ",", "sample_weight", "=", "unpack_x_y_sample_weight", "(", "data", ")", "data", "=", "pack_x_y_sample_weight", "(", "x", ",", "y", ",", "sample_weight", ")", "data", "=", "nest", ".", "list_to_tuple", "(", "data", ")", "def", "_convert_dtype", "(", "t", ")", ":", "if", "(", "isinstance", "(", "t", ",", "np", ".", "ndarray", ")", "and", "issubclass", "(", "t", ".", "dtype", ".", "type", ",", "np", ".", "floating", ")", ")", ":", "return", "np", ".", "array", "(", "t", ",", "dtype", "=", "backend", ".", "floatx", "(", ")", ")", "return", "t", "data", "=", "nest", ".", "map_structure", "(", "_convert_dtype", ",", "data", ")", "return", "data" ]

[ "EndPage", "(", "self", ")" ]

[ "def", "EndPage", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "DC_EndPage", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parameters", "----------", "dagman_config", "A", "mapping", "of", "DAGMan", "configuration", "options", ".", "dagman_job_attributes", "A", "mapping", "that", "describes", "additional", "HTCondor", "JobAd", "attributes", "for", "the", "DAGMan", "job", "itself", ".", "max_jobs_by_category", "A", "mapping", "that", "describes", "the", "maximum", "number", "of", "jobs", "(", "values", ")", "that", "should", "be", "run", "simultaneously", "from", "each", "category", "(", "keys", ")", ".", "dot_config", "Configuration", "options", "for", "writing", "a", "DOT", "file", "as", "a", ":", "class", ":", "DotConfig", ".", "jobstate_log", "The", "path", "to", "the", "jobstate", "log", ".", "If", "not", "given", "the", "jobstate", "log", "will", "not", "be", "written", ".", "node_status_file", "Configuration", "options", "for", "the", "node", "status", "file", "as", "a", ":", "class", ":", "NodeStatusFile", "." ]

[ "def", "__init__", "(", "self", ",", "dagman_config", ":", "Optional", "[", "Mapping", "[", "str", ",", "Any", "]", "]", "=", "None", ",", "dagman_job_attributes", ":", "Optional", "[", "Mapping", "[", "str", ",", "Any", "]", "]", "=", "None", ",", "max_jobs_by_category", ":", "Optional", "[", "Mapping", "[", "str", ",", "int", "]", "]", "=", "None", ",", "dot_config", ":", "Optional", "[", "DotConfig", "]", "=", "None", ",", "jobstate_log", ":", "Optional", "[", "Path", "]", "=", "None", ",", "node_status_file", ":", "Optional", "[", "NodeStatusFile", "]", "=", "None", ",", ")", ":", "self", ".", "_nodes", "=", "NodeStore", "(", ")", "self", ".", "_edges", "=", "EdgeStore", "(", ")", "self", ".", "_final_node", "=", "None", "self", ".", "jobstate_log", "=", "jobstate_log", "if", "jobstate_log", "is", "None", "else", "Path", "(", "jobstate_log", ")", "self", ".", "max_jobs_per_category", "=", "max_jobs_by_category", "or", "{", "}", "self", ".", "dagman_config", "=", "dagman_config", "or", "{", "}", "self", ".", "dagman_job_attrs", "=", "dagman_job_attributes", "or", "{", "}", "self", ".", "dot_config", "=", "dot_config", "self", ".", "node_status_file", "=", "node_status_file" ]

[ "Yield", "the", "index", "of", "each", "item", "in", "*", "iterable", "*", "for", "which", "*", "pred", "*", "returns", "True", "starting", "from", "the", "right", "and", "moving", "left", "." ]

[ "def", "rlocate", "(", "iterable", ",", "pred", "=", "bool", ",", "window_size", "=", "None", ")", ":", "if", "window_size", "is", "None", ":", "try", ":", "len_iter", "=", "len", "(", "iterable", ")", "return", "(", "len_iter", "-", "i", "-", "1", "for", "i", "in", "locate", "(", "reversed", "(", "iterable", ")", ",", "pred", ")", ")", "except", "TypeError", ":", "pass", "return", "reversed", "(", "list", "(", "locate", "(", "iterable", ",", "pred", ",", "window_size", ")", ")", ")" ]

[ "plot", "topology", "graph" ]

[ "def", "plot_all", "(", "graph", ",", "plot_id", "=", "''", ")", ":", "plt", ".", "close", "(", ")", "fig", "=", "plt", ".", "figure", "(", ")", "fig", ".", "canvas", ".", "mpl_connect", "(", "'button_press_event'", ",", "util", ".", "onclick", ")", "lane_middle_point_map", "=", "{", "}", "for", "i", ",", "(", "nd", ",", "color", ")", "in", "enumerate", "(", "zip", "(", "graph", ".", "node", ",", "color_iter", ")", ")", ":", "nd_mid_pt", "=", "plot_node", "(", "nd", ",", "plot_id", ",", "color", ")", "lane_middle_point_map", "[", "nd", ".", "lane_id", "]", "=", "nd_mid_pt", "for", "i", ",", "eg", "in", "enumerate", "(", "graph", ".", "edge", ")", ":", "plot_edge", "(", "eg", ",", "lane_middle_point_map", ")", "plt", ".", "gca", "(", ")", ".", "set_aspect", "(", "1", ")", "plt", ".", "title", "(", "'Routing topology graph'", ")", "plt", ".", "xlabel", "(", "'x'", ")", "plt", ".", "ylabel", "(", "'y'", ")", "plt", ".", "legend", "(", ")", "plt", ".", "draw", "(", ")" ]

[ "Decorator" ]

[ "def", "__call__", "(", "self", ",", "func", ")", ":", "_file", "=", "FILE", "(", "3", ")", "_line", "=", "LINE", "(", "2", ")", "@", "wraps", "(", "func", ")", "def", "function_wrapper", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "self", ".", "parse_wrapped", "(", "func", ",", "args", ",", "kwargs", ")", "self", ".", "determine_signature", "(", "is_decorator", "=", "True", ",", "is_context_manager", "=", "False", ")", "_frame", "=", "FRAME", "(", "1", ")", "_func", "=", "func", ".", "__name__", "_key", "=", "\"\"", "_args", "=", "self", ".", "arg_string", "(", "_frame", ")", "if", "self", ".", "signature", "==", "context", ".", "blank", ":", "_key", "=", "\"{}{}\"", ".", "format", "(", "self", ".", "key", ",", "_args", ")", "elif", "self", ".", "signature", "==", "context", ".", "basic", ":", "_key", "=", "\"{}{}/{}\"", ".", "format", "(", "_func", ",", "_args", ",", "self", ".", "key", ")", "elif", "self", ".", "signature", "==", "context", ".", "full", ":", "_key", "=", "\"{}{}@{}:{}/{}\"", ".", "format", "(", "_func", ",", "_args", ",", "_file", ",", "_line", ",", "self", ".", "key", ")", "_key", "=", "_key", ".", "strip", "(", "\"/\"", ")", "self", ".", "_self_obj", "=", "_rss_usage", "(", "_key", ")", "self", ".", "_self_dif", "=", "_rss_usage", "(", "_key", ")", "self", ".", "_self_dif", ".", "record", "(", ")", "# run function", "ret", "=", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "# record", "self", ".", "_self_obj", ".", "record", "(", ")", "self", ".", "_self_obj", "-=", "self", ".", "_self_dif", "print", "(", "\"{}\"", ".", "format", "(", "self", ".", "_self_obj", ")", ")", "return", "ret", "return", "function_wrapper" ]

[ "Convert", "each", "input", "to", "appropriate", "for", "table", "outplot" ]

[ "def", "_conv", "(", "self", ",", "data", ")", ":", "if", "isinstance", "(", "data", ",", "pd", ".", "Series", ")", ":", "if", "data", ".", "name", "is", "None", ":", "data", "=", "data", ".", "to_frame", "(", "name", "=", "''", ")", "else", ":", "data", "=", "data", ".", "to_frame", "(", ")", "data", "=", "data", ".", "fillna", "(", "'NaN'", ")", "return", "data" ]

[ "Find", "out", "the", "correspondence", "between", "layer", "names", "and", "parameter", "names", "." ]

[ "def", "param_name_dict", "(", ")", ":", "layer", "=", "caffe_pb2", ".", "LayerParameter", "(", ")", "# get all parameter names (typically underscore case) and corresponding", "# type names (typically camel case), which contain the layer names", "# (note that not all parameters correspond to layers, but we'll ignore that)", "param_names", "=", "[", "f", ".", "name", "for", "f", "in", "layer", ".", "DESCRIPTOR", ".", "fields", "if", "f", ".", "name", ".", "endswith", "(", "'_param'", ")", "]", "param_type_names", "=", "[", "type", "(", "getattr", "(", "layer", ",", "s", ")", ")", ".", "__name__", "for", "s", "in", "param_names", "]", "# strip the final '_param' or 'Parameter'", "param_names", "=", "[", "s", "[", ":", "-", "len", "(", "'_param'", ")", "]", "for", "s", "in", "param_names", "]", "param_type_names", "=", "[", "s", "[", ":", "-", "len", "(", "'Parameter'", ")", "]", "for", "s", "in", "param_type_names", "]", "return", "dict", "(", "zip", "(", "param_type_names", ",", "param_names", ")", ")" ]

[ "Accumulate", "histograms", "in", "new", "variables", "." ]

[ "def", "_auc_hist_accumulate", "(", "hist_true", ",", "hist_false", ",", "nbins", ",", "collections", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "None", ",", "'hist_accumulate'", ",", "[", "hist_true", ",", "hist_false", "]", ")", ":", "# Holds running total histogram of scores for records labeled True.", "hist_true_acc", "=", "variable_scope", ".", "get_variable", "(", "'hist_true_acc'", ",", "shape", "=", "[", "nbins", "]", ",", "dtype", "=", "hist_true", ".", "dtype", ",", "initializer", "=", "init_ops", ".", "zeros_initializer", "(", ")", ",", "collections", "=", "collections", ",", "trainable", "=", "False", ")", "# Holds running total histogram of scores for records labeled False.", "hist_false_acc", "=", "variable_scope", ".", "get_variable", "(", "'hist_false_acc'", ",", "shape", "=", "[", "nbins", "]", ",", "dtype", "=", "hist_true", ".", "dtype", ",", "initializer", "=", "init_ops", ".", "zeros_initializer", "(", ")", ",", "collections", "=", "collections", ",", "trainable", "=", "False", ")", "update_op", "=", "control_flow_ops", ".", "group", "(", "hist_true_acc", ".", "assign_add", "(", "hist_true", ")", ",", "hist_false_acc", ".", "assign_add", "(", "hist_false", ")", ",", "name", "=", "'update_op'", ")", "return", "hist_true_acc", ",", "hist_false_acc", ",", "update_op" ]

[ "Standardize", "an", "input", "TeX", "-", "file", "contents", "." ]

[ "def", "canonical_text", "(", "self", ",", "text", ")", ":", "out", "=", "[", "]", "line_continues_a_comment", "=", "False", "for", "line", "in", "text", ".", "splitlines", "(", ")", ":", "line", ",", "comment", "=", "self", ".", "comment_re", ".", "findall", "(", "line", ")", "[", "0", "]", "if", "line_continues_a_comment", "==", "True", ":", "out", "[", "-", "1", "]", "=", "out", "[", "-", "1", "]", "+", "line", ".", "lstrip", "(", ")", "else", ":", "out", ".", "append", "(", "line", ")", "line_continues_a_comment", "=", "len", "(", "comment", ")", ">", "0", "return", "'\\n'", ".", "join", "(", "out", ")", ".", "rstrip", "(", ")", "+", "'\\n'" ]

[ "get_embedding_var_name", "." ]

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

[ "Process", "a", "line", "in", "the", "[", "moleculetypes", "]", "category", "." ]

[ "def", "_processMoleculeType", "(", "self", ",", "line", ")", ":", "fields", "=", "line", ".", "split", "(", ")", "if", "len", "(", "fields", ")", "<", "1", ":", "raise", "ValueError", "(", "'Too few fields in [ moleculetypes ] line: '", "+", "line", ")", "type", "=", "GromacsTopFile", ".", "_MoleculeType", "(", ")", "self", ".", "_moleculeTypes", "[", "fields", "[", "0", "]", "]", "=", "type", "self", ".", "_currentMoleculeType", "=", "type" ]