Datasets:

sia-precision-education

/

pile_python

like 3

Follow

Sia Precision Education 5

[ "Creates", "the", "per", "-", "neuron", "shuffle", "class", "with", "initial", "RNG", "state", "." ]

[ "def", "__init__", "(", "self", ",", "init_rng", ",", "sparsity", ")", ":", "self", ".", "_rng", "=", "init_rng", "self", ".", "_sparsity", "=", "sparsity" ]

[]

[ "def", "initModel", "(", "self", ")", ":", "self", ".", "model", "=", "DCGAN", "(", "useGPU", "=", "self", ".", "useGPU", ",", "*", "*", "vars", "(", "self", ".", "modelConfig", ")", ")" ]

[ "Write", "to", "the", "handle", "." ]

[ "def", "write_file", "(", "self", ",", "qresults", ")", ":", "handle", "=", "self", ".", "handle", "qresult_counter", ",", "hit_counter", ",", "hsp_counter", ",", "frag_counter", "=", "0", ",", "0", ",", "0", ",", "0", "try", ":", "first_qresult", "=", "next", "(", "qresults", ")", "except", "StopIteration", ":", "handle", ".", "write", "(", "self", ".", "_build_header", "(", ")", ")", "else", ":", "# write header", "handle", ".", "write", "(", "self", ".", "_build_header", "(", "first_qresult", ")", ")", "# and then the qresults", "for", "qresult", "in", "chain", "(", "[", "first_qresult", "]", ",", "qresults", ")", ":", "if", "qresult", ":", "handle", ".", "write", "(", "self", ".", "_build_row", "(", "qresult", ")", ")", "qresult_counter", "+=", "1", "hit_counter", "+=", "len", "(", "qresult", ")", "hsp_counter", "+=", "sum", "(", "len", "(", "hit", ")", "for", "hit", "in", "qresult", ")", "frag_counter", "+=", "sum", "(", "len", "(", "hit", ".", "fragments", ")", "for", "hit", "in", "qresult", ")", "return", "qresult_counter", ",", "hit_counter", ",", "hsp_counter", ",", "frag_counter" ]

[ "Remove", "unwanted", "global", "metadata", "and", "escape", "special", "characters" ]

[ "def", "fix_global_metadata", "(", "self", ",", "rm_metadata", ")", ":", "metadata", "=", "remove_keys", "(", "self", ".", "dataset", ".", "GetMetadata", "(", ")", ",", "rm_metadata", ")", "# Apply escaping to metadata strings to preserve special characters (in XML/HTML format)", "metadata_escaped", "=", "{", "}", "for", "key", ",", "val", "in", "list", "(", "metadata", ".", "items", "(", ")", ")", ":", "# Keys not escaped - this may be changed if needed...", "metadata_escaped", "[", "key", "]", "=", "gdal", ".", "EscapeString", "(", "val", ",", "gdal", ".", "CPLES_XML", ")", "self", ".", "dataset", ".", "SetMetadata", "(", "metadata_escaped", ")", "self", ".", "dataset", ".", "FlushCache", "(", ")" ]

[]

[ "def", "__eq__", "(", "self", ",", "other", ")", ":", "return", "isinstance", "(", "other", ",", "self", ".", "__class__", ")" ]

[ "r", ":", "param", "LibraryId", ":", "人员库唯一标识符", ":", "type", "LibraryId", ":", "str", ":", "param", "LibraryName", ":", "人员库名称", ":", "type", "LibraryName", ":", "str", ":", "param", "RequestId", ":", "唯一请求", "ID，每次请求都会返回。定位问题时需要提供该次请求的", "RequestId。", ":", "type", "RequestId", ":", "str" ]

[ "def", "__init__", "(", "self", ")", ":", "self", ".", "LibraryId", "=", "None", "self", ".", "LibraryName", "=", "None", "self", ".", "RequestId", "=", "None" ]

[]

[ "def", "_shape_supercell_matrix", "(", "self", ",", "smat", ")", ":", "return", "shape_supercell_matrix", "(", "smat", ")" ]

[ "groups", "property", "getter" ]

[ "def", "groups", "(", "self", ")", ":", "if", "self", ".", "_groups", "is", "None", ":", "self", ".", "_groups", "=", "self", ".", "get_groups", "(", ")", "return", "self", ".", "_groups" ]

[]

[ "def", "__eq__", "(", "self", ",", "other", ")", ":", "if", "not", "isinstance", "(", "other", ",", "NormalizedVersion", ")", ":", "self", ".", "_cannot_compare", "(", "other", ")", "return", "self", ".", "parts", "==", "other", ".", "parts" ]

[ "ShuffleNet", "implementation", "for", "Keras", "2", "ShuffleNet", ":", "An", "Extremely", "Efficient", "Convolutional", "Neural", "Network", "for", "Mobile", "Devices", "Xiangyu", "Zhang", "Xinyu", "Zhou", "Mengxiao", "Lin", "Jian", "Sun", "https", ":", "//", "arxiv", ".", "org", "/", "pdf", "/", "1707", ".", "01083", ".", "pdf", "Note", "that", "only", "TensorFlow", "is", "supported", "for", "now", "therefore", "it", "only", "works", "with", "the", "data", "format", "image_data_format", "=", "channels_last", "in", "your", "Keras", "config", "at", "~", "/", ".", "keras", "/", "keras", ".", "json", ".", "Parameters", "----------", "include_top", ":", "bool", "(", "True", ")", "whether", "to", "include", "the", "fully", "-", "connected", "layer", "at", "the", "top", "of", "the", "network", ".", "input_tensor", ":", "optional", "Keras", "tensor", "(", "i", ".", "e", ".", "output", "of", "layers", ".", "Input", "()", ")", "to", "use", "as", "image", "input", "for", "the", "model", ".", "scale_factor", ":", "scales", "the", "number", "of", "output", "channels", "input_shape", ":", "pooling", ":", "Optional", "pooling", "mode", "for", "feature", "extraction", "when", "include_top", "is", "False", ".", "-", "None", "means", "that", "the", "output", "of", "the", "model", "will", "be", "the", "4D", "tensor", "output", "of", "the", "last", "convolutional", "layer", ".", "-", "avg", "means", "that", "global", "average", "pooling", "will", "be", "applied", "to", "the", "output", "of", "the", "last", "convolutional", "layer", "and", "thus", "the", "output", "of", "the", "model", "will", "be", "a", "2D", "tensor", ".", "-", "max", "means", "that", "global", "max", "pooling", "will", "be", "applied", ".", "groups", ":", "int", "number", "of", "groups", "per", "channel", "num_shuffle_units", ":", "list", "(", "[", "3", "7", "3", "]", ")", "number", "of", "stages", "(", "list", "length", ")", "and", "the", "number", "of", "shufflenet", "units", "in", "a", "stage", "beginning", "with", "stage", "2", "because", "stage", "1", "is", "fixed", "e", ".", "g", ".", "idx", "0", "contains", "3", "+", "1", "(", "first", "shuffle", "unit", "in", "each", "stage", "differs", ")", "shufflenet", "units", "for", "stage", "2", "idx", "1", "contains", "7", "+", "1", "Shufflenet", "Units", "for", "stage", "3", "and", "idx", "2", "contains", "3", "+", "1", "Shufflenet", "Units", "bottleneck_ratio", ":", "bottleneck", "ratio", "implies", "the", "ratio", "of", "bottleneck", "channels", "to", "output", "channels", ".", "For", "example", "bottleneck", "ratio", "=", "1", ":", "4", "means", "the", "output", "feature", "map", "is", "4", "times", "the", "width", "of", "the", "bottleneck", "feature", "map", ".", "classes", ":", "int", "(", "1000", ")", "number", "of", "classes", "to", "predict", "Returns", "-------", "A", "Keras", "model", "instance", "References", "----------", "-", "[", "ShuffleNet", ":", "An", "Extremely", "Efficient", "Convolutional", "Neural", "Network", "for", "Mobile", "Devices", "]", "(", "http", ":", "//", "www", ".", "arxiv", ".", "org", "/", "pdf", "/", "1707", ".", "01083", ".", "pdf", ")" ]

[ "def", "ShuffleNet", "(", "include_top", "=", "True", ",", "input_tensor", "=", "None", ",", "scale_factor", "=", "1.0", ",", "pooling", "=", "None", ",", "input_shape", "=", "None", ",", "groups", "=", "1", ",", "weights", "=", "'imagenet'", ",", "num_shuffle_units", "=", "[", "3", ",", "7", ",", "3", "]", ",", "bottleneck_ratio", "=", "0.25", ",", "classes", "=", "1000", ",", "*", "*", "kwargs", ")", ":", "if", "K", ".", "backend", "(", ")", "!=", "'tensorflow'", ":", "raise", "RuntimeError", "(", "'Only TensorFlow backend is currently supported, '", "'as other backends do not support '", ")", "name", "=", "\"ShuffleNet_%.2gX_g%d_br_%.2g_%s\"", "%", "(", "scale_factor", ",", "groups", ",", "bottleneck_ratio", ",", "\"\"", ".", "join", "(", "[", "str", "(", "x", ")", "for", "x", "in", "num_shuffle_units", "]", ")", ")", "input_shape", "=", "_obtain_input_shape", "(", "input_shape", ",", "default_size", "=", "224", ",", "min_size", "=", "28", ",", "require_flatten", "=", "include_top", ",", "data_format", "=", "K", ".", "image_data_format", "(", ")", ")", "out_dim_stage_two", "=", "{", "1", ":", "144", ",", "2", ":", "200", ",", "3", ":", "240", ",", "4", ":", "272", ",", "8", ":", "384", "}", "if", "groups", "not", "in", "out_dim_stage_two", ":", "raise", "ValueError", "(", "\"Invalid number of groups.\"", ")", "if", "pooling", "not", "in", "[", "'max'", ",", "'avg'", ",", "None", "]", ":", "raise", "ValueError", "(", "\"Invalid value for pooling.\"", ")", "if", "not", "(", "float", "(", "scale_factor", ")", "*", "4", ")", ".", "is_integer", "(", ")", ":", "raise", "ValueError", "(", "\"Invalid value for scale_factor. Should be x over 4.\"", ")", "exp", "=", "np", ".", "insert", "(", "np", ".", "arange", "(", "0", ",", "len", "(", "num_shuffle_units", ")", ",", "dtype", "=", "np", ".", "float32", ")", ",", "0", ",", "0", ")", "out_channels_in_stage", "=", "2", "**", "exp", "out_channels_in_stage", "*=", "out_dim_stage_two", "[", "groups", "]", "# calculate output channels for each stage", "out_channels_in_stage", "[", "0", "]", "=", "24", "# first stage has always 24 output channels", "out_channels_in_stage", "*=", "scale_factor", "out_channels_in_stage", "=", "out_channels_in_stage", ".", "astype", "(", "int", ")", "if", "input_tensor", "is", "None", ":", "img_input", "=", "Input", "(", "shape", "=", "input_shape", ")", "else", ":", "#if not K.is_keras_tensor(input_tensor):", "#img_input = Input(tensor=input_tensor, shape=input_shape)", "#else:", "#img_input = input_tensor", "img_input", "=", "input_tensor", "# create shufflenet architecture", "x", "=", "YoloConv2D", "(", "filters", "=", "out_channels_in_stage", "[", "0", "]", ",", "kernel_size", "=", "(", "3", ",", "3", ")", ",", "padding", "=", "'same'", ",", "use_bias", "=", "False", ",", "strides", "=", "(", "2", ",", "2", ")", ",", "activation", "=", "\"relu\"", ",", "name", "=", "\"conv1\"", ")", "(", "img_input", ")", "x", "=", "MaxPooling2D", "(", "pool_size", "=", "(", "3", ",", "3", ")", ",", "strides", "=", "(", "2", ",", "2", ")", ",", "padding", "=", "'same'", ",", "name", "=", "\"maxpool1\"", ")", "(", "x", ")", "# create stages containing shufflenet units beginning at stage 2", "for", "stage", "in", "range", "(", "0", ",", "len", "(", "num_shuffle_units", ")", ")", ":", "repeat", "=", "num_shuffle_units", "[", "stage", "]", "x", "=", "_block", "(", "x", ",", "out_channels_in_stage", ",", "repeat", "=", "repeat", ",", "bottleneck_ratio", "=", "bottleneck_ratio", ",", "groups", "=", "groups", ",", "stage", "=", "stage", "+", "2", ")", "if", "include_top", ":", "#x = Dense(units=classes, name=\"fc\")(x)", "#x = Activation('softmax', name='softmax')(x)", "x", "=", "GlobalAveragePooling2D", "(", "name", "=", "'global_avg_pool'", ")", "(", "x", ")", "x", "=", "Dense", "(", "units", "=", "classes", ",", "activation", "=", "'softmax'", ",", "use_bias", "=", "True", ",", "name", "=", "'Logits'", ")", "(", "x", ")", "else", ":", "if", "pooling", "==", "'avg'", ":", "x", "=", "GlobalAveragePooling2D", "(", "name", "=", "'global_avg_pool'", ")", "(", "x", ")", "elif", "pooling", "==", "'max'", ":", "x", "=", "GlobalMaxPooling2D", "(", "name", "=", "'global_max_pool'", ")", "(", "x", ")", "# Ensure that the model takes into account", "# any potential predecessors of `input_tensor`.", "if", "input_tensor", "is", "not", "None", ":", "inputs", "=", "get_source_inputs", "(", "input_tensor", ")", "else", ":", "inputs", "=", "img_input", "# Create model.", "model", "=", "Model", "(", "inputs", "=", "inputs", ",", "outputs", "=", "x", ",", "name", "=", "name", ")", "# Load weights.", "if", "weights", "==", "'imagenet'", ":", "if", "K", ".", "image_data_format", "(", ")", "==", "'channels_first'", ":", "raise", "ValueError", "(", "'Weights for \"channels_first\" format '", "'are not available.'", ")", "if", "include_top", ":", "model_name", "=", "(", "'shufflenet_weights_tf_dim_ordering_tf_kernels_'", "+", "str", "(", "alpha", ")", "+", "'_'", "+", "str", "(", "rows", ")", "+", "'.h5'", ")", "weigh_path", "=", "BASE_WEIGHT_PATH", "+", "model_name", "weights_path", "=", "get_file", "(", "model_name", ",", "weigh_path", ",", "cache_subdir", "=", "'models'", ")", "else", ":", "model_name", "=", "(", "'shufflenet_weights_tf_dim_ordering_tf_kernels_'", "+", "str", "(", "alpha", ")", "+", "'_'", "+", "str", "(", "rows", ")", "+", "'_no_top'", "+", "'.h5'", ")", "weigh_path", "=", "BASE_WEIGHT_PATH", "+", "model_name", "weights_path", "=", "get_file", "(", "model_name", ",", "weigh_path", ",", "cache_subdir", "=", "'models'", ")", "model", ".", "load_weights", "(", "weights_path", ")", "elif", "weights", "is", "not", "None", ":", "model", ".", "load_weights", "(", "weights", ")", "return", "model" ]

[ "Uses", "1", "-", "norm", "distance", "to", "calculate", "difference", "between", "two", "rgb", "values", "." ]

[ "def", "_color_diff", "(", "rgb1", ",", "rgb2", ")", ":", "return", "abs", "(", "rgb1", "[", "0", "]", "-", "rgb2", "[", "0", "]", ")", "+", "abs", "(", "rgb1", "[", "1", "]", "-", "rgb2", "[", "1", "]", ")", "+", "abs", "(", "rgb1", "[", "2", "]", "-", "rgb2", "[", "2", "]", ")" ]

[]

[ "def", "get_targets", "(", "self", ")", ":", "return", "[", "self", ".", "args", ".", "output", "+", "\".dgml\"", "]" ]

[]

[ "def", "do_copy", "(", "self", ",", "x", ")", ":", "return", "map", "(", "lambda", "p", ":", "p", ".", "copy", "(", ")", ",", "x", ")" ]

[ "Sets", "a", "bucket", "s", "default", "ACL", "to", "an", "XML", "string", "." ]

[ "def", "set_def_xml_acl", "(", "self", ",", "acl_str", ",", "headers", "=", "None", ")", ":", "return", "self", ".", "set_xml_acl", "(", "acl_str", ",", "''", ",", "headers", ",", "query_args", "=", "DEF_OBJ_ACL", ")" ]

[ ":", "returns", ":", "The", "URI", "of", "the", "resource", "relative", "to", "https", ":", "//", "api", ".", "twilio", ".", "com", ":", "rtype", ":", "unicode" ]

[ "def", "uri", "(", "self", ")", ":", "return", "self", ".", "_properties", "[", "'uri'", "]" ]

[ "This", "is", "a", "defense", "against", "the", "so", "called", "intersection", "attacks", "." ]

[ "def", "antiIntersectionDelay", "(", "self", ",", "initial", "=", "False", ")", ":", "# estimated time for a small object to propagate across the", "# whole network", "max_known_nodes", "=", "max", "(", "len", "(", "knownnodes", ".", "knownNodes", "[", "x", "]", ")", "for", "x", "in", "knownnodes", ".", "knownNodes", ")", "delay", "=", "math", ".", "ceil", "(", "math", ".", "log", "(", "max_known_nodes", "+", "2", ",", "20", ")", ")", "*", "(", "0.2", "+", "invQueue", ".", "queueCount", "/", "2.0", ")", "# take the stream with maximum amount of nodes", "# +2 is to avoid problems with log(0) and log(1)", "# 20 is avg connected nodes count", "# 0.2 is avg message transmission time", "if", "delay", ">", "0", ":", "if", "initial", ":", "self", ".", "skipUntil", "=", "self", ".", "connectedAt", "+", "delay", "if", "self", ".", "skipUntil", ">", "time", ".", "time", "(", ")", ":", "logger", ".", "debug", "(", "'Initial skipping processing getdata for %.2fs'", ",", "self", ".", "skipUntil", "-", "time", ".", "time", "(", ")", ")", "else", ":", "logger", ".", "debug", "(", "'Skipping processing getdata due to missing object'", "' for %.2fs'", ",", "delay", ")", "self", ".", "skipUntil", "=", "time", ".", "time", "(", ")", "+", "delay" ]

[ "Function", "to", "reclassify", "the", "strategy" ]

[ "def", "mixed_reclassifier", "(", "original_classifier", ",", "probability", ",", "m_player", ")", ":", "# If a single probability, player is passed", "if", "isinstance", "(", "probability", ",", "float", ")", "or", "isinstance", "(", "probability", ",", "int", ")", ":", "m_player", "=", "[", "m_player", "]", "probability", "=", "[", "probability", "]", "if", "min", "(", "probability", ")", "==", "max", "(", "probability", ")", "==", "0", ":", "# No probability given", "return", "original_classifier", "if", "1", "in", "probability", ":", "# If all probability given to one player", "player", "=", "m_player", "[", "probability", ".", "index", "(", "1", ")", "]", "original_classifier", "[", "\"stochastic\"", "]", "=", "player", ".", "classifier", "[", "\"stochastic\"", "]", "return", "original_classifier", "# Otherwise: stochastic.", "original_classifier", "[", "\"stochastic\"", "]", "=", "True", "return", "original_classifier" ]

[]

[ "def", "ListClientApprovals", "(", "self", ",", "args", ",", "context", "=", "None", ")", ":", "# Everybody can list their own user client approvals.", "return", "self", ".", "delegate", ".", "ListClientApprovals", "(", "args", ",", "context", "=", "context", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "capture", ",", "fps", ",", "*", "*", "kwargs", ")", ":", "super", "(", "KivyCamera", ",", "self", ")", ".", "__init__", "(", "*", "*", "kwargs", ")", "self", ".", "capture", "=", "capture", "Clock", ".", "schedule_interval", "(", "self", ".", "update", ",", "1.0", "/", "fps", ")" ]

[ "Process", "contents" ]

[ "def", "process", "(", "self", ")", ":", "self", ".", "html", "=", "[", "'<br/>\\n'", "]" ]

[ "Search", "for", "podcasts", "according", "to", "query" ]

[ "def", "search_podcasts", "(", "query", ")", ":", "if", "is_query_too_short", "(", "query", ")", ":", "logger", ".", "debug", "(", "'Found no podcasts for \"{query}\". Query is too short'", ",", "query", "=", "query", ")", "return", "Podcast", ".", "objects", ".", "none", "(", ")", "logger", ".", "debug", "(", "'Searching for \"{query}\" podcasts\"'", ",", "query", "=", "query", ")", "query", "=", "SearchQuery", "(", "query", ")", "results", "=", "(", "Podcast", ".", "objects", ".", "annotate", "(", "rank", "=", "SearchRank", "(", "F", "(", "\"search_vector\"", ")", ",", "query", ")", ")", ".", "annotate", "(", "order", "=", "ExpressionWrapper", "(", "F", "(", "\"rank\"", ")", "*", "F", "(", "\"subscribers\"", ")", ",", "output_field", "=", "FloatField", "(", ")", ")", ")", ".", "filter", "(", "rank__gte", "=", "SEARCH_CUTOFF", ")", ".", "order_by", "(", "\"-order\"", ")", "[", ":", "100", "]", ".", "prefetch_related", "(", "\"slugs\"", ")", ")", "logger", ".", "debug", "(", "'Found {count} podcasts for \"{query}\"'", ",", "count", "=", "len", "(", "results", ")", ",", "query", "=", "query", ")", "return", "results" ]

[]

[ "def", "_handle_getattr", "(", "self", ",", "oid", ",", "name", ")", ":", "return", "self", ".", "_access_attr", "(", "oid", ",", "name", ",", "(", ")", ",", "\"_rpyc_getattr\"", ",", "\"allow_getattr\"", ",", "getattr", ")" ]

[ "组装下载链接" ]

[ "def", "get_link", "(", "url", ",", "token", ")", ":", "file_name", "=", "url", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", "print", "file_name", "print", "token", "down_link", "=", "url", ".", "rstrip", "(", "file_name", ")", "+", "token", "+", "'/'", "+", "file_name", "print", "down_link", "return", "down_link" ]

[ "r", "Return", "a", "string", "tikz_pic", "consisting", "of", "a", "tikz", "picture", "of", "self", "according", "to", "a", "projection", "view", "and", "an", "angle", "angle", "obtained", "via", "Jmol", "through", "the", "current", "state", "property", "." ]

[ "def", "tikz", "(", "self", ",", "view", "=", "[", "0", ",", "0", ",", "1", "]", ",", "angle", "=", "0", ",", "scale", "=", "1", ",", "edge_color", "=", "'blue!95!black'", ",", "facet_color", "=", "'blue!95!black'", ",", "opacity", "=", "0.8", ",", "vertex_color", "=", "'green'", ",", "axis", "=", "False", ")", ":", "if", "self", ".", "polyhedron_ambient_dim", ">", "3", "or", "self", ".", "polyhedron_ambient_dim", "<", "2", ":", "raise", "NotImplementedError", "(", "\"The polytope has to live in 2 or 3 dimensions.\"", ")", "elif", "self", ".", "polyhedron_dim", "<", "2", "or", "self", ".", "polyhedron_dim", ">", "3", ":", "raise", "NotImplementedError", "(", "\"The polytope has to be 2 or 3-dimensional.\"", ")", "elif", "self", ".", "polyhedron_ambient_dim", "==", "2", ":", "# self is a polygon in 2-space", "return", "self", ".", "_tikz_2d", "(", "scale", ",", "edge_color", ",", "facet_color", ",", "opacity", ",", "vertex_color", ",", "axis", ")", "elif", "self", ".", "polyhedron_dim", "==", "2", ":", "# self is a polygon in 3-space", "return", "self", ".", "_tikz_2d_in_3d", "(", "view", ",", "angle", ",", "scale", ",", "edge_color", ",", "facet_color", ",", "opacity", ",", "vertex_color", ",", "axis", ")", "else", ":", "# self is a 3-polytope in 3-space", "return", "self", ".", "_tikz_3d_in_3d", "(", "view", ",", "angle", ",", "scale", ",", "edge_color", ",", "facet_color", ",", "opacity", ",", "vertex_color", ",", "axis", ")" ]

[ "Return", "!012_23", "=", ">", "(", "12", "23", "False", ")" ]

[ "def", "parsebit", "(", "val", ")", ":", "isset", "=", "True", "# Default is 0. Skip explicit call outs", "if", "val", "[", "0", "]", "==", "'!'", ":", "isset", "=", "False", "val", "=", "val", "[", "1", ":", "]", "# 28_05 => 28, 05", "parts", "=", "val", ".", "split", "(", "'_'", ")", "assert", "len", "(", "parts", ")", "==", "2", ",", "val", "seg_word_column", ",", "word_bit_n", "=", "parts", "return", "Bit", "(", "word_column", "=", "int", "(", "seg_word_column", ")", ",", "word_bit", "=", "int", "(", "word_bit_n", ")", ",", "isset", "=", "isset", ",", ")" ]

[ "Convenience", "fluent", "method", "for", ":", "py", ":", "func", ":", "broadcast_like", "." ]

[ "def", "broadcast_like", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "op", ".", "broadcast_like", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Accept", "the", "dialog", "." ]

[ "async", "def", "accept", "(", "self", ",", "promptText", ":", "str", "=", "''", ")", "->", "None", ":", "self", ".", "_handled", "=", "True", "await", "self", ".", "_client", ".", "send", "(", "'Page.handleJavaScriptDialog'", ",", "{", "'accept'", ":", "True", ",", "'promptText'", ":", "promptText", ",", "}", ")" ]

[]

[ "def", "normalize_2d", "(", "x", ")", ":", "exp", "=", "F", ".", "exp", "(", "x", "[", "0", "]", ")", "sums", "=", "F", ".", "sum", "(", "F", ".", "sum", "(", "exp", ",", "axis", "=", "-", "1", ")", ",", "axis", "=", "-", "1", ")", "expanded", "=", "F", ".", "expand_dims", "(", "F", ".", "expand_dims", "(", "sums", ",", "axis", "=", "-", "1", ")", ",", "axis", "=", "-", "1", ")", "denominator", "=", "F", ".", "tile", "(", "expanded", ",", "(", "1", ",", "160", ",", "210", ")", ")", "return", "exp", "/", "denominator" ]

[ "添加节点标签" ]

[ "def", "create_node_labels", "(", "self", ",", "request", ",", "project_id", ")", ":", "# 解析参数", "node_id_list", ",", "node_label_info", "=", "self", ".", "get_create_label_params", "(", "request", ")", "# 校验label中key和value", "self", ".", "label_regex", "(", "node_label_info", ")", "# 获取数据库中节点的label", "# NOTE: 节点为正常状态时，才允许设置标签", "project_node_info", "=", "self", ".", "get_node_list", "(", "request", ",", "project_id", ",", "None", ")", ".", "get", "(", "'results'", ")", "or", "[", "]", "if", "not", "project_node_info", ":", "raise", "error_codes", ".", "APIError", "(", "_", "(", "\"当前项目下节点为空，请确认\"))", "", "", "all_node_id_list", "=", "[", "]", "all_node_id_ip_map", "=", "{", "}", "for", "info", "in", "project_node_info", ":", "all_node_id_list", ".", "append", "(", "info", "[", "\"id\"", "]", ")", "all_node_id_ip_map", "[", "info", "[", "\"id\"", "]", "]", "=", "{", "\"inner_ip\"", ":", "info", "[", "\"inner_ip\"", "]", ",", "\"cluster_id\"", ":", "info", "[", "\"cluster_id\"", "]", "}", "if", "info", "[", "'id'", "]", "in", "node_id_list", "and", "info", "[", "'status'", "]", "!=", "CommonStatus", ".", "Normal", ":", "raise", "error_codes", ".", "CheckFailed", "(", "_", "(", "\"节点不是正常状态时，不允许设置标签\"))", "", "", "diff_node_id_list", "=", "set", "(", "node_id_list", ")", "-", "set", "(", "all_node_id_list", ")", "if", "diff_node_id_list", ":", "raise", "error_codes", ".", "CheckFailed", "(", "_", "(", "\"节点ID [{}] 不属于当前项目，请确认\").format(\",\".join(diff_nod", "e", "_", "id_lis", "t", ")))", "", "", "", "", "", "", "", "# 校验权限", "self", ".", "check_perm", "(", "request", ",", "project_id", ",", "all_node_id_ip_map", ",", "node_id_list", ")", "# 匹配数据", "pre_node_labels", "=", "self", ".", "get_labels_by_node", "(", "request", ",", "project_id", ",", "node_id_list", ")", "label_operation_map", "=", "self", ".", "get_label_operation", "(", "pre_node_labels", ",", "node_label_info", ",", "node_id_list", ",", "all_node_id_ip_map", ")", "# k8s 是以节点为维度", "self", ".", "create_node_label_via_k8s", "(", "request", ",", "project_id", ",", "label_operation_map", ")", "# 写入数据库", "self", ".", "create_or_update", "(", "request", ",", "project_id", ",", "label_operation_map", ")", "client", ".", "ContextActivityLogClient", "(", "project_id", "=", "project_id", ",", "user", "=", "request", ".", "user", ".", "username", ",", "resource_type", "=", "\"node\"", ",", "resource", "=", "str", "(", "node_id_list", ")", ",", "resource_id", "=", "str", "(", "node_id_list", ")", ",", "extra", "=", "json", ".", "dumps", "(", "node_label_info", ")", ",", "description", "=", "_", "(", "\"节点打标签\"),", "", "", ")", ".", "log_add", "(", "activity_status", "=", "\"succeed\"", ")", "return", "Response", "(", "{", "\"code\"", ":", "0", ",", "\"message\"", ":", "_", "(", "\"创建成功!\")})", "", "", "" ]

[ "Workaround", "for", "#516" ]

[ "def", "make_distribution", "(", "self", ")", ":", "with", "self", ".", "_remove_os_link", "(", ")", ":", "orig", ".", "sdist", ".", "make_distribution", "(", "self", ")" ]

[ "Stop", "the", "profiler", "." ]

[ "def", "stop", "(", "self", ")", ":", "self", ".", "_prof", ".", "stop", "(", ")" ]

[ "Show", "packages", "given", "as", "arguments", "in", "the", "available_pane", "If", "the", "list", "of", "packages", "is", "only", "one", "element", "long", "show", "that", "otherwise", "turn", "it", "into", "a", "comma", "seperated", "search" ]

[ "def", "show_available_packages", "(", "self", ",", "packages", ")", ":", "try", ":", "search_text", ",", "app", "=", "parse_packages_args", "(", "packages", ")", "except", "DebFileOpenError", "as", "e", ":", "LOG", ".", "exception", "(", "\"show_available_packages: can not open %r, error:\"", ",", "packages", ")", "dialogs", ".", "error", "(", "None", ",", "_", "(", "\"Error\"", ")", ",", "_", "(", "\"The file “%s” could not be opened.\") % ", "e", "p", "t", "h", ")", "", "search_text", "=", "app", "=", "None", "LOG", ".", "info", "(", "'show_available_packages: search_text is %r, app is %r.'", ",", "search_text", ",", "app", ")", "if", "search_text", ":", "self", ".", "available_pane", ".", "init_view", "(", ")", "self", ".", "available_pane", ".", "searchentry", ".", "set_text", "(", "search_text", ")", "elif", "app", "is", "not", "None", ":", "self", ".", "show_app", "(", "app", ")", "else", ":", "# normal startup, show the lobby (it will have a spinner when", "# its not ready yet) - it will also initialize the view", "self", ".", "view_manager", ".", "set_active_view", "(", "ViewPages", ".", "AVAILABLE", ")" ]

[ "Returns", ":", "A", "tuple", "unique", "to", "this", "view", "of", "the", "tensor", "." ]

[ "def", "key", "(", "self", ")", ":", "return", "self", ".", "tensor_description", ".", "parameter_key" ]

[ "Check", "if", "an", "element", "exists", "between", "the", "end", "of", "the", "active", "formatting", "elements", "and", "the", "last", "marker", ".", "If", "it", "does", "return", "it", "else", "return", "false" ]

[ "def", "elementInActiveFormattingElements", "(", "self", ",", "name", ")", ":", "for", "item", "in", "self", ".", "activeFormattingElements", "[", ":", ":", "-", "1", "]", ":", "# Check for Marker first because if it's a Marker it doesn't have a", "# name attribute.", "if", "item", "==", "Marker", ":", "break", "elif", "item", ".", "name", "==", "name", ":", "return", "item", "return", "False" ]

[ "Search", "through", "the", "issues", "applying", "filters", "." ]

[ "def", "filter", "(", "self", ",", "filters", ")", ":", "# because http.Request needs params to be a dict of strings to strings", "# (roughly) and since BitBucket wants repeated parameters to express", "# OR, we'll do the quoting by hand ourselves", "def", "flatten_conditions", "(", "filters", ")", ":", "for", "key", ",", "val", "in", "filters", ".", "items", "(", ")", ":", "if", "isinstance", "(", "val", ",", "(", "list", ",", "tuple", ")", ")", ":", "for", "v", "in", "val", ":", "yield", "(", "port", ".", "to_b", "(", "key", ")", ",", "port", ".", "to_b", "(", "v", ")", ")", "else", ":", "yield", "(", "port", ".", "to_b", "(", "key", ")", ",", "port", ".", "to_b", "(", "val", ")", ")", "to_encode", "=", "tuple", "(", "flatten_conditions", "(", "filters", ")", ")", "qs", "=", "port", ".", "urlencode", "(", "to_encode", ")", "url", "=", "'{0}/?{1}'", ".", "format", "(", "self", ".", "get_url", "(", ")", ",", "qs", ")", "return", "http", ".", "Request", "(", "'GET'", ",", "url", ")", ",", "parsers", ".", "parse_json" ]

[ "Utility", "API", "that", "formats", "WWN", "to", "insert", ":", "." ]

[ "def", "get_formatted_wwn", "(", "wwn_str", ")", ":", "if", "(", "len", "(", "wwn_str", ")", "!=", "16", ")", ":", "return", "wwn_str", ".", "lower", "(", ")", "else", ":", "return", "(", "':'", ".", "join", "(", "[", "wwn_str", "[", "i", ":", "i", "+", "2", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "wwn_str", ")", ",", "2", ")", "]", ")", ")", ".", "lower", "(", ")" ]

[ "Given", "a", "model", "recorder", "and", "return", "its", "online", "tag", "." ]

[ "def", "get_online_tag", "(", "self", ",", "recorder", ":", "Recorder", ")", "->", "str", ":", "tags", "=", "recorder", ".", "list_tags", "(", ")", "return", "tags", ".", "get", "(", "self", ".", "ONLINE_KEY", ",", "self", ".", "OFFLINE_TAG", ")" ]

[ "Compute", "the", "loss", "of", "the", "SSD", "model", "prediction", "against", "the", "ground", "truth", "." ]

[ "def", "compute_loss", "(", "self", ",", "y_true", ",", "y_pred", ")", ":", "batch_size", "=", "tf", ".", "shape", "(", "y_pred", ")", "[", "0", "]", "# Output dtype: tf.int32", "n_boxes", "=", "tf", ".", "shape", "(", "y_pred", ")", "[", "1", "]", "# Output dtype: tf.int32, note that `n_boxes` in this context denotes the total number of boxes per image, not the number of boxes per cell", "# 1: Compute the losses for class and box predictions for every box", "classification_loss", "=", "tf", ".", "cast", "(", "self", ".", "log_loss", "(", "y_true", "[", ":", ",", ":", ",", ":", "-", "12", "]", ",", "y_pred", "[", ":", ",", ":", ",", ":", "-", "12", "]", ")", ",", "dtype", "=", "tf", ".", "float32", ")", "# Output shape: (batch_size, n_boxes)", "localization_loss", "=", "tf", ".", "cast", "(", "self", ".", "smooth_L1_loss", "(", "y_true", "[", ":", ",", ":", ",", "-", "12", ":", "-", "8", "]", ",", "y_pred", "[", ":", ",", ":", ",", "-", "12", ":", "-", "8", "]", ")", ",", "dtype", "=", "tf", ".", "float32", ")", "# Output shape: (batch_size, n_boxes)", "# 2: Compute the classification losses for the positive and negative targets", "# Create masks for the positive and negative ground truth classes", "negatives", "=", "y_true", "[", ":", ",", ":", ",", "0", "]", "# Tensor of shape (batch_size, n_boxes)", "positives", "=", "tf", ".", "cast", "(", "tf", ".", "reduce_max", "(", "y_true", "[", ":", ",", ":", ",", "1", ":", "-", "12", "]", ",", "axis", "=", "-", "1", ")", ",", "dtype", "=", "tf", ".", "float32", ")", "# Tensor of shape (batch_size, n_boxes)", "# Count the number of positive boxes (classes 1 to n) in y_true across the whole batch", "n_positive", "=", "tf", ".", "reduce_sum", "(", "positives", ")", "# Now mask all negative boxes and sum up the losses for the positive boxes PER batch item", "# (Keras loss functions must output one scalar loss value PER batch item, rather than just", "# one scalar for the entire batch, that's why we're not summing across all axes)", "pos_class_loss", "=", "tf", ".", "reduce_sum", "(", "classification_loss", "*", "positives", ",", "axis", "=", "-", "1", ")", "# Tensor of shape (batch_size,)", "# Compute the classification loss for the negative default boxes (if there are any)", "# First, compute the classification loss for all negative boxes", "neg_class_loss_all", "=", "classification_loss", "*", "negatives", "# Tensor of shape (batch_size, n_boxes)", "n_neg_losses", "=", "tf", ".", "math", ".", "count_nonzero", "(", "neg_class_loss_all", ",", "dtype", "=", "tf", ".", "int32", ")", "# The number of non-zero loss entries in `neg_class_loss_all`", "# What's the point of `n_neg_losses`? For the next step, which will be to compute which negative boxes enter the classification", "# loss, we don't just want to know how many negative ground truth boxes there are, but for how many of those there actually is", "# a positive (i.e. non-zero) loss. This is necessary because `tf.nn.top-k()` in the function below will pick the top k boxes with", "# the highest losses no matter what, even if it receives a vector where all losses are zero. In the unlikely event that all negative", "# classification losses ARE actually zero though, this behavior might lead to `tf.nn.top-k()` returning the indices of positive", "# boxes, leading to an incorrect negative classification loss computation, and hence an incorrect overall loss computation.", "# We therefore need to make sure that `n_negative_keep`, which assumes the role of the `k` argument in `tf.nn.top-k()`,", "# is at most the number of negative boxes for which there is a positive classification loss.", "# Compute the number of negative examples we want to account for in the loss", "# We'll keep at most `self.neg_pos_ratio` times the number of positives in `y_true`, but at least `self.n_neg_min` (unless `n_neg_loses` is smaller)", "n_negative_keep", "=", "tf", ".", "minimum", "(", "tf", ".", "maximum", "(", "self", ".", "neg_pos_ratio", "*", "tf", ".", "cast", "(", "n_positive", ",", "dtype", "=", "tf", ".", "int32", ")", ",", "self", ".", "n_neg_min", ")", ",", "n_neg_losses", ")", "# In the unlikely case when either (1) there are no negative ground truth boxes at all", "# or (2) the classification loss for all negative boxes is zero, return zero as the `neg_class_loss`", "def", "f1", "(", ")", ":", "return", "tf", ".", "zeros", "(", "[", "batch_size", "]", ")", "# Otherwise compute the negative loss", "def", "f2", "(", ")", ":", "# Now we'll identify the top-k (where k == `n_negative_keep`) boxes with the highest confidence loss that", "# belong to the background class in the ground truth data. Note that this doesn't necessarily mean that the model", "# predicted the wrong class for those boxes, it just means that the loss for those boxes is the highest.", "# To do this, we reshape `neg_class_loss_all` to 1D...", "neg_class_loss_all_1D", "=", "tf", ".", "reshape", "(", "neg_class_loss_all", ",", "[", "-", "1", "]", ")", "# Tensor of shape (batch_size * n_boxes,)", "# ...and then we get the indices for the `n_negative_keep` boxes with the highest loss out of those...", "values", ",", "indices", "=", "tf", ".", "nn", ".", "top_k", "(", "neg_class_loss_all_1D", ",", "n_negative_keep", ",", "False", ")", "# We don't need sorting", "# ...and with these indices we'll create a mask...", "negatives_keep", "=", "tf", ".", "scatter_nd", "(", "tf", ".", "expand_dims", "(", "indices", ",", "axis", "=", "1", ")", ",", "updates", "=", "tf", ".", "ones_like", "(", "indices", ",", "dtype", "=", "tf", ".", "int32", ")", ",", "shape", "=", "tf", ".", "shape", "(", "neg_class_loss_all_1D", ")", ")", "# Tensor of shape (batch_size * n_boxes,)", "negatives_keep", "=", "tf", ".", "cast", "(", "tf", ".", "reshape", "(", "negatives_keep", ",", "[", "batch_size", ",", "n_boxes", "]", ")", ",", "dtype", "=", "tf", ".", "float32", ")", "# Tensor of shape (batch_size, n_boxes)", "# ...and use it to keep only those boxes and mask all other classification losses", "neg_class_loss", "=", "tf", ".", "reduce_sum", "(", "classification_loss", "*", "negatives_keep", ",", "axis", "=", "-", "1", ")", "# Tensor of shape (batch_size,)", "return", "neg_class_loss", "neg_class_loss", "=", "tf", ".", "cond", "(", "tf", ".", "equal", "(", "n_neg_losses", ",", "tf", ".", "constant", "(", "0", ")", ")", ",", "f1", ",", "f2", ")", "class_loss", "=", "pos_class_loss", "+", "neg_class_loss", "# Tensor of shape (batch_size,)", "# 3: Compute the localization loss for the positive targets", "# We don't penalize localization loss for negative predicted boxes (obviously: there are no ground truth boxes they would correspond to)", "loc_loss", "=", "tf", ".", "reduce_sum", "(", "localization_loss", "*", "positives", ",", "axis", "=", "-", "1", ")", "# Tensor of shape (batch_size,)", "# 4: Compute the total loss", "total_loss", "=", "(", "self", ".", "beta", "*", "class_loss", "+", "self", ".", "alpha", "*", "loc_loss", ")", "/", "tf", ".", "maximum", "(", "1.0", ",", "n_positive", ")", "# In case `n_positive == 0`", "return", "total_loss" ]

[ "Filter", "that", "checks", "if", "the", "task", "should", "be", "stored", "in", "this", "backend", "." ]

[ "def", "get_task_filter_for_backend", "(", "self", ")", ":", "def", "backend_filter", "(", "req", ",", "task", ",", "parameters", ")", ":", "\"\"\"\n Filter that checks if two tags sets intersect. It is used to check\n if a task should be stored inside a backend\n @param task: a task object\n @param tags_to_match_set: a *set* of tag names\n \"\"\"", "try", ":", "tags_to_match_set", "=", "parameters", "[", "'tags'", "]", "except", "KeyError", ":", "return", "[", "]", "all_tasks_tag", "=", "req", ".", "get_alltag_tag", "(", ")", ".", "get_name", "(", ")", "if", "all_tasks_tag", "in", "tags_to_match_set", ":", "return", "True", "task_tags", "=", "set", "(", "task", ".", "get_tags_name", "(", ")", ")", "return", "task_tags", ".", "intersection", "(", "tags_to_match_set", ")", "attached_tags", "=", "self", ".", "backend", ".", "get_attached_tags", "(", ")", "return", "lambda", "task", ":", "backend_filter", "(", "self", ".", "requester", ",", "task", ",", "{", "\"tags\"", ":", "set", "(", "attached_tags", ")", "}", ")" ]

[ "Adds", "a", "depthwise", "convolution", "block", ".", "A", "depthwise", "convolution", "block", "consists", "of", "a", "depthwise", "conv", "batch", "normalization", "relu6", "pointwise", "convolution", "batch", "normalization", "and", "relu6", "activation", ".", "#", "Arguments", "inputs", ":", "Input", "tensor", "of", "shape", "(", "rows", "cols", "channels", ")", "(", "with", "channels_last", "data", "format", ")", "or", "(", "channels", "rows", "cols", ")", "(", "with", "channels_first", "data", "format", ")", ".", "pointwise_conv_filters", ":", "Integer", "the", "dimensionality", "of", "the", "output", "space", "(", "i", ".", "e", ".", "the", "number", "output", "of", "filters", "in", "the", "pointwise", "convolution", ")", ".", "alpha", ":", "controls", "the", "width", "of", "the", "network", ".", "-", "If", "alpha", "<", "1", ".", "0", "proportionally", "decreases", "the", "number", "of", "filters", "in", "each", "layer", ".", "-", "If", "alpha", ">", "1", ".", "0", "proportionally", "increases", "the", "number", "of", "filters", "in", "each", "layer", ".", "-", "If", "alpha", "=", "1", "default", "number", "of", "filters", "from", "the", "paper", "are", "used", "at", "each", "layer", ".", "depth_multiplier", ":", "The", "number", "of", "depthwise", "convolution", "output", "channels", "for", "each", "input", "channel", ".", "The", "total", "number", "of", "depthwise", "convolution", "output", "channels", "will", "be", "equal", "to", "filters_in", "*", "depth_multiplier", ".", "strides", ":", "An", "integer", "or", "tuple", "/", "list", "of", "2", "integers", "specifying", "the", "strides", "of", "the", "convolution", "along", "the", "width", "and", "height", ".", "Can", "be", "a", "single", "integer", "to", "specify", "the", "same", "value", "for", "all", "spatial", "dimensions", ".", "Specifying", "any", "stride", "value", "!", "=", "1", "is", "incompatible", "with", "specifying", "any", "dilation_rate", "value", "!", "=", "1", ".", "block_id", ":", "Integer", "a", "unique", "identification", "designating", "the", "block", "number", ".", "#", "Input", "shape", "4D", "tensor", "with", "shape", ":", "(", "batch", "channels", "rows", "cols", ")", "if", "data_format", "=", "channels_first", "or", "4D", "tensor", "with", "shape", ":", "(", "batch", "rows", "cols", "channels", ")", "if", "data_format", "=", "channels_last", ".", "#", "Output", "shape", "4D", "tensor", "with", "shape", ":", "(", "batch", "filters", "new_rows", "new_cols", ")", "if", "data_format", "=", "channels_first", "or", "4D", "tensor", "with", "shape", ":", "(", "batch", "new_rows", "new_cols", "filters", ")", "if", "data_format", "=", "channels_last", ".", "rows", "and", "cols", "values", "might", "have", "changed", "due", "to", "stride", ".", "#", "Returns", "Output", "tensor", "of", "block", "." ]

[ "def", "_depthwise_conv_block", "(", "inputs", ",", "pointwise_conv_filters", ",", "alpha", ",", "depth_multiplier", "=", "1", ",", "strides", "=", "(", "1", ",", "1", ")", ",", "block_id", "=", "1", ",", "attention_module", "=", "None", ")", ":", "channel_axis", "=", "1", "if", "K", ".", "image_data_format", "(", ")", "==", "'channels_first'", "else", "-", "1", "pointwise_conv_filters", "=", "int", "(", "pointwise_conv_filters", "*", "alpha", ")", "x", "=", "DepthwiseConv2D", "(", "(", "3", ",", "3", ")", ",", "padding", "=", "'same'", ",", "depth_multiplier", "=", "depth_multiplier", ",", "strides", "=", "strides", ",", "use_bias", "=", "False", ",", "name", "=", "'conv_dw_%d'", "%", "block_id", ")", "(", "inputs", ")", "x", "=", "BatchNormalization", "(", "axis", "=", "channel_axis", ",", "name", "=", "'conv_dw_%d_bn'", "%", "block_id", ")", "(", "x", ")", "x", "=", "Activation", "(", "relu6", ",", "name", "=", "'conv_dw_%d_relu'", "%", "block_id", ")", "(", "x", ")", "x", "=", "Conv2D", "(", "pointwise_conv_filters", ",", "(", "1", ",", "1", ")", ",", "padding", "=", "'same'", ",", "use_bias", "=", "False", ",", "strides", "=", "(", "1", ",", "1", ")", ",", "name", "=", "'conv_pw_%d'", "%", "block_id", ")", "(", "x", ")", "x", "=", "BatchNormalization", "(", "axis", "=", "channel_axis", ",", "name", "=", "'conv_pw_%d_bn'", "%", "block_id", ")", "(", "x", ")", "x", "=", "Activation", "(", "relu6", ",", "name", "=", "'conv_pw_%d_relu'", "%", "block_id", ")", "(", "x", ")", "if", "attention_module", "==", "'se_block'", ":", "x", "=", "se_block", "(", "x", ")", "if", "attention_module", "==", "'cbam_block'", ":", "x", "=", "cbam_block", "(", "x", ")", "return", "x" ]

[ "Print", "end", "-", "of", "-", "epoch", "stats", "." ]

[ "def", "print", "(", "self", ",", "stats", ",", "tag", "=", "''", ",", "step", "=", "None", ")", ":", "postfix", "=", "self", ".", "_str_pipes", "(", "self", ".", "_format_stats", "(", "stats", ")", ")", "print", "(", "'{} | {}'", ".", "format", "(", "self", ".", "prefix", ",", "postfix", ")", ",", "flush", "=", "True", ")" ]

[ "Get", "the", "ID", "of", "the", "cluster", "our", "job", "is", "running", "on", "or", "None", "." ]

[ "def", "get_cluster_id", "(", "self", ")", ":", "return", "self", ".", "_cluster_id" ]

[ "Request", "a", "new", "channel", "to", "the", "server", ".", "Channels", "<", ".", "Channel", ">", "are", "socket", "-", "like", "objects", "used", "for", "the", "actual", "transfer", "of", "data", "across", "the", "session", ".", "You", "may", "only", "request", "a", "channel", "after", "negotiating", "encryption", "(", "using", "connect", "or", "start_client", ")", "and", "authenticating", "." ]

[ "def", "open_channel", "(", "self", ",", "kind", ",", "dest_addr", "=", "None", ",", "src_addr", "=", "None", ",", "window_size", "=", "None", ",", "max_packet_size", "=", "None", ",", "timeout", "=", "None", ")", ":", "if", "not", "self", ".", "active", ":", "raise", "SSHException", "(", "'SSH session not active'", ")", "timeout", "=", "3600", "if", "timeout", "is", "None", "else", "timeout", "self", ".", "lock", ".", "acquire", "(", ")", "try", ":", "window_size", "=", "self", ".", "_sanitize_window_size", "(", "window_size", ")", "max_packet_size", "=", "self", ".", "_sanitize_packet_size", "(", "max_packet_size", ")", "chanid", "=", "self", ".", "_next_channel", "(", ")", "m", "=", "Message", "(", ")", "m", ".", "add_byte", "(", "cMSG_CHANNEL_OPEN", ")", "m", ".", "add_string", "(", "kind", ")", "m", ".", "add_int", "(", "chanid", ")", "m", ".", "add_int", "(", "window_size", ")", "m", ".", "add_int", "(", "max_packet_size", ")", "if", "(", "kind", "==", "'forwarded-tcpip'", ")", "or", "(", "kind", "==", "'direct-tcpip'", ")", ":", "m", ".", "add_string", "(", "dest_addr", "[", "0", "]", ")", "m", ".", "add_int", "(", "dest_addr", "[", "1", "]", ")", "m", ".", "add_string", "(", "src_addr", "[", "0", "]", ")", "m", ".", "add_int", "(", "src_addr", "[", "1", "]", ")", "elif", "kind", "==", "'x11'", ":", "m", ".", "add_string", "(", "src_addr", "[", "0", "]", ")", "m", ".", "add_int", "(", "src_addr", "[", "1", "]", ")", "chan", "=", "Channel", "(", "chanid", ")", "self", ".", "_channels", ".", "put", "(", "chanid", ",", "chan", ")", "self", ".", "channel_events", "[", "chanid", "]", "=", "event", "=", "threading", ".", "Event", "(", ")", "self", ".", "channels_seen", "[", "chanid", "]", "=", "True", "chan", ".", "_set_transport", "(", "self", ")", "chan", ".", "_set_window", "(", "window_size", ",", "max_packet_size", ")", "finally", ":", "self", ".", "lock", ".", "release", "(", ")", "self", ".", "_send_user_message", "(", "m", ")", "start_ts", "=", "time", ".", "time", "(", ")", "while", "True", ":", "event", ".", "wait", "(", "0.1", ")", "if", "not", "self", ".", "active", ":", "e", "=", "self", ".", "get_exception", "(", ")", "if", "e", "is", "None", ":", "e", "=", "SSHException", "(", "'Unable to open channel.'", ")", "raise", "e", "if", "event", ".", "is_set", "(", ")", ":", "break", "elif", "start_ts", "+", "timeout", "<", "time", ".", "time", "(", ")", ":", "raise", "SSHException", "(", "'Timeout openning channel.'", ")", "chan", "=", "self", ".", "_channels", ".", "get", "(", "chanid", ")", "if", "chan", "is", "not", "None", ":", "return", "chan", "e", "=", "self", ".", "get_exception", "(", ")", "if", "e", "is", "None", ":", "e", "=", "SSHException", "(", "'Unable to open channel.'", ")", "raise", "e" ]

[ "Gets", "a", "task", "from", "the", "queue", "." ]

[ "def", "get_task", "(", "self", ",", "task", ",", "omit_payload", "=", "False", ")", ":", "if", "omit_payload", ":", "columns", "=", "[", "'task_name'", ",", "'time_enqueued'", ",", "'lease_expires'", ",", "'lease_count'", ",", "'tag'", "]", "else", ":", "columns", "=", "[", "'payload'", ",", "'task_name'", ",", "'time_enqueued'", ",", "'lease_expires'", ",", "'lease_count'", ",", "'tag'", "]", "pg_connection", "=", "pg_wrapper", ".", "get_connection", "(", ")", "with", "pg_connection", ":", "with", "pg_connection", ".", "cursor", "(", ")", "as", "pg_cursor", ":", "pg_cursor", ".", "execute", "(", "'SELECT {columns} FROM \"{tasks_table}\" '", "'WHERE task_name = %(task_name)s AND time_deleted IS NULL'", ".", "format", "(", "columns", "=", "', '", ".", "join", "(", "columns", ")", ",", "tasks_table", "=", "self", ".", "tasks_table_name", ")", ",", "vars", "=", "{", "'task_name'", ":", "task", ".", "id", ",", "}", ")", "row", "=", "pg_cursor", ".", "fetchone", "(", ")", "if", "not", "row", ":", "return", "None", "return", "self", ".", "_task_from_row", "(", "columns", ",", "row", ",", "id", "=", "task", ".", "id", ")" ]

[ "Reload", "options", ".", "1", ".", "Stop", "proxy", "2", ".", "Try", "to", "start", "proxy", "with", "new", "params", "3", ".", "If", "can", "t", "=", ">", "alert", "4", ".", "If", "everything", "is", "ok", "then", "start", "proxy", "5", ".", "Set", "Trap", "options", "6", ".", "Save", "options" ]

[ "def", "reload_options", "(", "self", ")", ":", "new_port", "=", "self", ".", "pref", ".", "get_value", "(", "'proxy'", ",", "'ipport'", ")", "if", "new_port", "!=", "self", ".", "_prev_ip_port", ":", "self", ".", "w3af", ".", "mainwin", ".", "sb", "(", "_", "(", "\"Stopping local proxy\"", ")", ")", "if", "self", ".", "proxy", ":", "self", ".", "proxy", ".", "stop", "(", ")", "try", ":", "self", ".", "_start_proxy", "(", ")", "except", "ProxyException", ":", "# Ups, port looks already used..:(", "# Let's show alert and focus Options tab", "self", ".", "w3af", ".", "mainwin", ".", "sb", "(", "_", "(", "\"Failed to start local proxy\"", ")", ")", "self", ".", "fuzzable", "=", "None", "self", ".", "waiting_requests", "=", "False", "self", ".", "keep_checking", "=", "False", "# Focus Options tab", "self", ".", "nb", ".", "set_current_page", "(", "2", ")", "return", "else", ":", "self", ".", "fuzzable", "=", "None", "self", ".", "waiting_requests", "=", "True", "self", ".", "keep_checking", "=", "True", "# Config test", "try", ":", "self", ".", "proxy", ".", "set_what_to_trap", "(", "self", ".", "pref", ".", "get_value", "(", "'proxy'", ",", "'trap'", ")", ")", "self", ".", "proxy", ".", "set_what_not_to_trap", "(", "self", ".", "pref", ".", "get_value", "(", "'proxy'", ",", "'notrap'", ")", ")", "self", ".", "proxy", ".", "set_methods_to_trap", "(", "self", ".", "pref", ".", "get_value", "(", "'proxy'", ",", "'methodtrap'", ")", ")", "except", "BaseFrameworkException", ",", "w3", ":", "self", ".", "show_alert", "(", "_", "(", "\"Invalid configuration!\\n\"", "+", "str", "(", "w3", ")", ")", ")", "self", ".", "_prev_ip_port", "=", "new_port", "httpeditor", "=", "self", ".", "reqresp", ".", "request", ".", "get_view_by_id", "(", "'HttpRawView'", ")", "httpeditor", ".", "set_show_line_numbers", "(", "self", ".", "pref", ".", "get_value", "(", "'editor'", ",", "'display_line_num'", ")", ")", "httpeditor", ".", "set_highlight_current_line", "(", "self", ".", "pref", ".", "get_value", "(", "'editor'", ",", "'highlight_current_line'", ")", ")", "httpeditor", ".", "set_highlight_syntax", "(", "self", ".", "pref", ".", "get_value", "(", "'editor'", ",", "'highlight_syntax'", ")", ")", "httpeditor", ".", "set_wrap", "(", "self", ".", "pref", ".", "get_value", "(", "'editor'", ",", "'wrap'", ")", ")", "self", ".", "pref", ".", "save", "(", ")", "if", "self", ".", "_layout", "!=", "self", ".", "pref", ".", "get_value", "(", "'proxy'", ",", "'trap_view'", ")", ":", "self", ".", "show_alert", "(", "_", "(", "'Some of options will take effect after you'", "' restart proxy tool'", ")", ")" ]

[ "Apply", "[", "f_", "expr_", "ls_", "OptionsPattern", "[", "Apply", "]]" ]

[ "def", "apply_invalidlevel", "(", "self", ",", "f", ",", "expr", ",", "ls", ",", "evaluation", ",", "options", "=", "{", "}", ")", ":", "evaluation", ".", "message", "(", "\"Apply\"", ",", "\"level\"", ",", "ls", ")" ]

[ "Checks", "that", "we", "can", "append", "the", "l0", "perturbation", "to", "the", "malware", "sample", "and", "not", "exceed", "the", "maximum", "file", "size", ".", "A", "new", "label", "vector", "with", "just", "the", "valid", "files", "indicated", "is", "created", "." ]

[ "def", "check_valid_size", "(", "self", ",", "y", ":", "np", ".", "ndarray", ",", "sample_sizes", ":", "np", ".", "ndarray", ",", "append_perturbation_size", ":", "np", ".", "ndarray", ",", ")", "->", "np", ".", "ndarray", ":", "adv_label_vector", "=", "np", ".", "zeros_like", "(", "y", ")", "for", "i", ",", "label", "in", "enumerate", "(", "y", ")", ":", "if", "label", "==", "1", ":", "if", "sample_sizes", "[", "i", "]", "+", "append_perturbation_size", "[", "i", "]", "<=", "self", ".", "param_dic", "[", "\"maxlen\"", "]", ":", "adv_label_vector", "[", "i", "]", "=", "1", "logger", ".", "info", "(", "\"size to append on sample %d is %d\"", ",", "i", ",", "append_perturbation_size", "[", "i", "]", ")", "return", "adv_label_vector" ]

[ "Get", "all", "Distribution", "instances", "in", "the", "current", "environment", "." ]

[ "def", "distributions", "(", "*", "*", "kwargs", ")", ":", "return", "Distribution", ".", "discover", "(", "*", "*", "kwargs", ")" ]

[ "Overwrites", "self", "with", "array", ".", "array", "should", "have", "a", "size", "smaller", "than", "that", "of", "the", "array", "used", "to", "initialize", "the", "EigenMatrix", ".", "The", "method", "will", "not", "throw", "an", "Exception", "just", "yet", "if", "this", "is", "not", "true", ".", "It", "will", "throw", "exceptions", "or", "behave", "in", "strange", "ways", "later", "on", "." ]

[ "def", "overwrite", "(", "self", ",", "array", ")", ":", "assert", "type", "(", "array", ")", "==", "np", ".", "ndarray", ",", "'array must be a np.ndarray.'", "array", "=", "reformat", "(", "array", ")", "self", ".", "numpy_array", "=", "array", "_eigenmat", ".", "init_from_array", "(", "self", ".", "p_mat", ",", "array", ".", "ctypes", ".", "data_as", "(", "ct", ".", "POINTER", "(", "ct", ".", "c_float", ")", ")", ",", "ct", ".", "c_int", "(", "array", ".", "shape", "[", "0", "]", ")", ",", "ct", ".", "c_int", "(", "array", ".", "shape", "[", "1", "]", ")", ")" ]

[ "Parse", "all", "the", "arguments", "provided", "from", "the", "CLI", ".", "Returns", ":", "A", "list", "of", "parsed", "arguments", "." ]

[ "def", "get_arguments", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "\"Dynamic Video Segmentation Network\"", ")", "parser", ".", "add_argument", "(", "\"--data_dir\"", ",", "type", "=", "str", ",", "default", "=", "DATA_DIRECTORY", ",", "help", "=", "\"Path to the directory containing the dataset.\"", ")", "parser", ".", "add_argument", "(", "\"--data_list\"", ",", "type", "=", "str", ",", "default", "=", "DATA_LIST_PATH", ",", "help", "=", "\"Path to the file listing the images in the dataset.\"", ")", "parser", ".", "add_argument", "(", "\"--restore_from\"", ",", "type", "=", "str", ",", "default", "=", "RESTORE_FROM", ",", "help", "=", "\"Where restore model parameters from.\"", ")", "parser", ".", "add_argument", "(", "\"--decision_from\"", ",", "type", "=", "str", ",", "default", "=", "RESTORE_FROM", ",", "help", "=", "\"Where restore decision model parameters from.\"", ")", "parser", ".", "add_argument", "(", "\"--save_dir\"", ",", "type", "=", "str", ",", "default", "=", "SAVE_DIR", ",", "help", "=", "\"Where to save segmented output.\"", ")", "parser", ".", "add_argument", "(", "\"--num_steps\"", ",", "type", "=", "int", ",", "default", "=", "NUM_STEPS", ",", "help", "=", "\"Number of images in the video.\"", ")", "parser", ".", "add_argument", "(", "\"--overlap\"", ",", "type", "=", "int", ",", "default", "=", "OVERLAP", ",", "help", "=", "\"Overlapping size.\"", ")", "parser", ".", "add_argument", "(", "\"--target\"", ",", "type", "=", "float", ",", "default", "=", "TARGET", ",", "help", "=", "\"Confidence score threshold.\"", ")", "parser", ".", "add_argument", "(", "\"--dynamic\"", ",", "action", "=", "\"store_true\"", ",", "help", "=", "\"Whether to dynamically adjust target\"", ")", "return", "parser", ".", "parse_args", "(", ")" ]

[ "Return", "the", "list", "of", "items", "for", "a", "given", "key", ".", "If", "that", "key", "is", "not", "in", "the", "MultiDict", "the", "return", "value", "will", "be", "an", "empty", "list", ".", "Just", "like", "get", "getlist", "accepts", "a", "type", "parameter", ".", "All", "items", "will", "be", "converted", "with", "the", "callable", "defined", "there", "." ]

[ "def", "getlist", "(", "self", ",", "key", ",", "type", "=", "None", ")", ":", "try", ":", "rv", "=", "dict", ".", "__getitem__", "(", "self", ",", "key", ")", "except", "KeyError", ":", "return", "[", "]", "if", "type", "is", "None", ":", "return", "list", "(", "rv", ")", "result", "=", "[", "]", "for", "item", "in", "rv", ":", "try", ":", "result", ".", "append", "(", "type", "(", "item", ")", ")", "except", "ValueError", ":", "pass", "return", "result" ]

[ "Apply", "spikes", "to", "a", "continuous", "dataset", "whose", "values", "are", "between", "0", ".", "0", "and", "1", ".", "0", "Args", ":", "data_e", ":", "nexamples", "length", "list", "of", "NxT", "trials", "dt", ":", "how", "often", "the", "data", "are", "sampled", "max_firing_rate", ":", "the", "firing", "rate", "that", "is", "associated", "with", "a", "value", "of", "1", ".", "0", "Returns", ":", "spikified_e", ":", "a", "list", "of", "length", "b", "of", "the", "data", "represented", "as", "spikes", "sampled", "from", "the", "underlying", "poisson", "process", "." ]

[ "def", "spikify_data", "(", "data_e", ",", "rng", ",", "dt", "=", "1.0", ",", "max_firing_rate", "=", "100", ")", ":", "E", "=", "len", "(", "data_e", ")", "spikes_e", "=", "[", "]", "for", "e", "in", "range", "(", "E", ")", ":", "data", "=", "data_e", "[", "e", "]", "N", ",", "T", "=", "data", ".", "shape", "data_s", "=", "np", ".", "zeros", "(", "[", "N", ",", "T", "]", ")", ".", "astype", "(", "np", ".", "int", ")", "for", "n", "in", "range", "(", "N", ")", ":", "f", "=", "data", "[", "n", ",", ":", "]", "s", "=", "rng", ".", "poisson", "(", "f", "*", "max_firing_rate", "*", "dt", ",", "size", "=", "T", ")", "data_s", "[", "n", ",", ":", "]", "=", "s", "spikes_e", ".", "append", "(", "data_s", ")", "return", "spikes_e" ]

[ "Indicate", "that", "the", "given", "attribute", "should", "be", "loaded", "using", "subquery", "eager", "loading", "." ]

[ "def", "subqueryload", "(", "loadopt", ",", "attr", ")", ":", "return", "loadopt", ".", "set_relationship_strategy", "(", "attr", ",", "{", "\"lazy\"", ":", "\"subquery\"", "}", ")" ]

[ "Create", "and", "possibly", "populate", "the", "datasets", "in", "the", "gmf_data", "group" ]

[ "def", "create_gmf_data", "(", "dstore", ",", "prim_imts", ",", "sec_imts", "=", "(", ")", ",", "data", "=", "None", ")", ":", "oq", "=", "dstore", "[", "'oqparam'", "]", "R", "=", "dstore", "[", "'full_lt'", "]", ".", "get_num_rlzs", "(", ")", "M", "=", "len", "(", "prim_imts", ")", "n", "=", "0", "if", "data", "is", "None", "else", "len", "(", "data", "[", "'sid'", "]", ")", "items", "=", "[", "(", "'sid'", ",", "U32", "if", "n", "==", "0", "else", "data", "[", "'sid'", "]", ")", ",", "(", "'eid'", ",", "U32", "if", "n", "==", "0", "else", "data", "[", "'eid'", "]", ")", "]", "for", "m", "in", "range", "(", "M", ")", ":", "col", "=", "f'gmv_{m}'", "items", ".", "append", "(", "(", "col", ",", "F32", "if", "data", "is", "None", "else", "data", "[", "col", "]", ")", ")", "for", "imt", "in", "sec_imts", ":", "items", ".", "append", "(", "(", "str", "(", "imt", ")", ",", "F32", "if", "n", "==", "0", "else", "data", "[", "imt", "]", ")", ")", "if", "oq", ".", "investigation_time", ":", "eff_time", "=", "oq", ".", "investigation_time", "*", "oq", ".", "ses_per_logic_tree_path", "*", "R", "else", ":", "eff_time", "=", "0", "dstore", ".", "create_df", "(", "'gmf_data'", ",", "items", ",", "'gzip'", ")", "dstore", ".", "set_attrs", "(", "'gmf_data'", ",", "num_events", "=", "len", "(", "dstore", "[", "'events'", "]", ")", ",", "imts", "=", "' '", ".", "join", "(", "map", "(", "str", ",", "prim_imts", ")", ")", ",", "effective_time", "=", "eff_time", ")", "if", "data", "is", "not", "None", ":", "df", "=", "pandas", ".", "DataFrame", "(", "dict", "(", "items", ")", ")", "avg_gmf", "=", "numpy", ".", "zeros", "(", "(", "2", ",", "n", ",", "M", "+", "len", "(", "sec_imts", ")", ")", ",", "F32", ")", "for", "sid", ",", "df", "in", "df", ".", "groupby", "(", "df", ".", "sid", ")", ":", "df", ".", "pop", "(", "'eid'", ")", "df", ".", "pop", "(", "'sid'", ")", "avg_gmf", "[", ":", ",", "sid", "]", "=", "stats", ".", "avg_std", "(", "df", ".", "to_numpy", "(", ")", ")", "dstore", "[", "'avg_gmf'", "]", "=", "avg_gmf" ]

[]

[ "def", "hostmask", "(", "self", ")", ":", "x", "=", "self", ".", "_cache", ".", "get", "(", "'hostmask'", ")", "if", "x", "is", "None", ":", "x", "=", "self", ".", "_address_class", "(", "int", "(", "self", ".", "netmask", ")", "^", "self", ".", "_ALL_ONES", ")", "self", ".", "_cache", "[", "'hostmask'", "]", "=", "x", "return", "x" ]

[ "Create", "a", "shared", "link", ".", "If", "a", "shared", "link", "already", "exists", "for", "the", "given", "path", "that", "link", "is", "returned", ".", "Previously", "it", "was", "technically", "possible", "to", "break", "a", "shared", "link", "by", "moving", "or", "renaming", "the", "corresponding", "file", "or", "folder", ".", "In", "the", "future", "this", "will", "no", "longer", "be", "the", "case", "so", "your", "app", "shouldn", "t", "rely", "on", "this", "behavior", ".", "Instead", "if", "your", "app", "needs", "to", "revoke", "a", "shared", "link", "use", ":", "meth", ":", "sharing_revoke_shared_link", "." ]

[ "def", "sharing_create_shared_link", "(", "self", ",", "path", ",", "short_url", "=", "False", ",", "pending_upload", "=", "None", ")", ":", "warnings", ".", "warn", "(", "'create_shared_link is deprecated. Use create_shared_link_with_settings.'", ",", "DeprecationWarning", ",", ")", "arg", "=", "sharing", ".", "CreateSharedLinkArg", "(", "path", ",", "short_url", ",", "pending_upload", ")", "r", "=", "self", ".", "request", "(", "sharing", ".", "create_shared_link", ",", "'sharing'", ",", "arg", ",", "None", ",", ")", "return", "r" ]

[ "If", "the", "application", "configuration", "is", "empty", "we", "do", "not", "use", "Duckling", "." ]

[ "def", "load_from_app_path", "(", "app_path", ")", ":", "if", "not", "app_path", ":", "raise", "SystemEntityError", "(", "\"App path must be valid to load entity recognizer config.\"", ")", "if", "is_duckling_configured", "(", "app_path", ")", ":", "url", "=", "get_system_entity_url_config", "(", "app_path", "=", "app_path", ")", "return", "DucklingRecognizer", ".", "get_instance", "(", "url", ")", "else", ":", "return", "NoOpSystemEntityRecognizer", ".", "get_instance", "(", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "model", ",", "filepath", ",", "monitor", "=", "'val_loss'", ",", "verbose", "=", "0", ",", "save_best_only", "=", "False", ",", "save_weights_only", "=", "False", ",", "mode", "=", "'auto'", ",", "save_freq", "=", "'epoch'", ",", "load_weights_on_restart", "=", "False", ",", "period", "=", "1", ")", ":", "self", ".", "model_to_save", "=", "model", "super", "(", ")", ".", "__init__", "(", "filepath", "=", "filepath", ",", "monitor", "=", "monitor", ",", "verbose", "=", "verbose", ",", "save_best_only", "=", "save_best_only", ",", "save_weights_only", "=", "save_weights_only", ",", "mode", "=", "mode", ",", "save_freq", "=", "save_freq", ",", "load_weights_on_restart", "=", "load_weights_on_restart", ",", "period", "=", "period", ")" ]

[]

[ "def", "deactivate_srm", "(", "self", ")", ":", "if", "self", ".", "cleanup", ":", "try", ":", "srm_deactivation_task", "=", "self", ".", "vmc_client", ".", "draas", ".", "SiteRecovery", ".", "delete", "(", "self", ".", "org_id", ",", "self", ".", "sddc_id", ",", "force", "=", "True", ")", "except", "InvalidRequest", "as", "e", ":", "# Convert InvalidRequest to ErrorResponse to get error message", "error_response", "=", "e", ".", "data", ".", "convert_to", "(", "ErrorResponse", ")", "raise", "Exception", "(", "error_response", ".", "error_messages", ")", "wait_for_task", "(", "task_client", "=", "self", ".", "vmc_client", ".", "draas", ".", "Task", ",", "org_id", "=", "self", ".", "org_id", ",", "task_id", "=", "srm_deactivation_task", ".", "id", ",", "interval_sec", "=", "self", ".", "interval_sec", ")" ]

[ "Temporary", "function", "to", "obtain", "reddit", "coo", "data", "for", "GIN" ]

[ "def", "get_reddit_coo_data", "(", "dirpath", ")", ":", "print", "(", "\"Loading node feature and label\"", ")", "reddit_data", "=", "numpy", ".", "load", "(", "os", ".", "path", ".", "join", "(", "dirpath", ",", "\"reddit_data.npz\"", ")", ")", "print", "(", "\"Loading edge data\"", ")", "coo_adj", "=", "scipy", ".", "sparse", ".", "load_npz", "(", "os", ".", "path", ".", "join", "(", "dirpath", ",", "\"reddit_graph.npz\"", ")", ")", "row", "=", "coo_adj", ".", "row", ".", "astype", "(", "numpy", ".", "int32", ")", "col", "=", "coo_adj", ".", "col", ".", "astype", "(", "numpy", ".", "int32", ")", "data", "=", "coo_adj", ".", "data", ".", "astype", "(", "numpy", ".", "float32", ")", "# ensure row is sorted", "if", "not", "numpy", ".", "all", "(", "row", "[", ":", "-", "1", "]", "<=", "row", "[", "1", ":", "]", ")", ":", "order", "=", "numpy", ".", "argsort", "(", "row", ")", "row", "=", "row", "[", "order", "]", "col", "=", "col", "[", "order", "]", "assert", "numpy", ".", "all", "(", "row", "[", ":", "-", "1", "]", "<=", "row", "[", "1", ":", "]", ")", "adj", "=", "chainer", ".", "utils", ".", "CooMatrix", "(", "data", "=", "data", ",", "row", "=", "row", ",", "col", "=", "col", ",", "shape", "=", "coo_adj", ".", "shape", ",", "order", "=", "'C'", ")", "return", "PaddingGraphData", "(", "x", "=", "reddit_data", "[", "'feature'", "]", ".", "astype", "(", "numpy", ".", "float32", ")", ",", "adj", "=", "adj", ",", "y", "=", "reddit_data", "[", "'label'", "]", ".", "astype", "(", "numpy", ".", "int32", ")", ",", "label_num", "=", "41", ")" ]

[ ":", "example", "rue" ]

[ "def", "street_prefix", "(", "self", ")", ":", "return", "self", ".", "random_element", "(", "self", ".", "street_prefixes", ")" ]

[ "Convert", "the", "input", "to", "a", "masked", "array", "conserving", "subclasses", "." ]

[ "def", "asanyarray", "(", "a", ",", "dtype", "=", "None", ")", ":", "return", "masked_array", "(", "a", ",", "dtype", "=", "dtype", ",", "copy", "=", "False", ",", "keep_mask", "=", "True", ",", "subok", "=", "True", ")" ]

[ "Return", "a", "Message", "representation", "or", "raise", "a", "KeyError", "." ]

[ "def", "get_message", "(", "self", ",", "key", ")", ":", "try", ":", "if", "self", ".", "_locked", ":", "f", "=", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_path", ",", "str", "(", "key", ")", ")", ",", "'r+'", ")", "else", ":", "f", "=", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_path", ",", "str", "(", "key", ")", ")", ",", "'r'", ")", "except", "IOError", ",", "e", ":", "if", "e", ".", "errno", "==", "errno", ".", "ENOENT", ":", "raise", "KeyError", "(", "'No message with key: %s'", "%", "key", ")", "else", ":", "raise", "try", ":", "if", "self", ".", "_locked", ":", "_lock_file", "(", "f", ")", "try", ":", "msg", "=", "MHMessage", "(", "f", ")", "finally", ":", "if", "self", ".", "_locked", ":", "_unlock_file", "(", "f", ")", "finally", ":", "f", ".", "close", "(", ")", "for", "name", ",", "key_list", "in", "self", ".", "get_sequences", "(", ")", ".", "iteritems", "(", ")", ":", "if", "key", "in", "key_list", ":", "msg", ".", "add_sequence", "(", "name", ")", "return", "msg" ]

[]

[ "def", "stream", "(", "params", ")", ":", "torr_link", "=", "'f4a94963c11a47f213b145697f494b5fc5485b02'", "TSplayer", "=", "tsengine", "(", ")", "out", "=", "TSplayer", ".", "load_torrent", "(", "torr_link", ",", "'INFOHASH'", ",", "port", "=", "aceport", ")", "if", "out", "==", "'Ok'", ":", "TSplayer", ".", "play_url_ind", "(", "0", ",", "'stream'", ",", "None", ")", "TSplayer", ".", "end", "(", ")" ]

[ "This", "must", "be", "a", "method", "because", "a", "model", "may", "have", "properties", "that", "are", "of", "type", "self", "this", "must", "run", "after", "the", "class", "is", "loaded" ]

[ "def", "openapi_types", "(", ")", ":", "lazy_import", "(", ")", "return", "{", "'account'", ":", "(", "str", ",", ")", ",", "# noqa: E501", "'sort_code'", ":", "(", "str", ",", ")", ",", "# noqa: E501", "}" ]

[ "Return", "extra", "attributes", "to", "place", "on", "the", "root", "(", "i", ".", "e", ".", "feed", "/", "channel", ")", "element", ".", "Called", "from", "write", "()", "." ]

[ "def", "root_attributes", "(", "self", ")", ":", "return", "{", "}" ]