Datasets:

sia-precision-education

/

pile_python

like 3

[]

[ "def", "send_data", "(", "self", ",", "data", ")", ":", "epdconfig", ".", "digital_write", "(", "self", ".", "dc_pin", ",", "1", ")", "epdconfig", ".", "digital_write", "(", "self", ".", "cs_pin", ",", "0", ")", "epdconfig", ".", "spi_writebyte", "(", "[", "data", "]", ")", "epdconfig", ".", "digital_write", "(", "self", ".", "cs_pin", ",", "1", ")" ]

[ "Returns", "array", "with", "parsed", "DBMS", "names", "till", "now" ]

[ "def", "getErrorParsedDBMSes", "(", ")", ":", "return", "kb", ".", "htmlFp", "if", "kb", ".", "get", "(", "\"heuristicTest\"", ")", "==", "HEURISTIC_TEST", ".", "POSITIVE", "else", "[", "]" ]

[ "Write", "an", "HTTP", "header", "block", "." ]

[ "def", "write_headers", "(", "self", ",", "start_line", ":", "Union", "[", "\"RequestStartLine\"", ",", "\"ResponseStartLine\"", "]", ",", "headers", ":", "HTTPHeaders", ",", "chunk", ":", "bytes", "=", "None", ",", ")", "->", "\"Future[None]\"", ":", "raise", "NotImplementedError", "(", ")" ]

[ "Forward", "function", "." ]

[ "def", "forward", "(", "self", ",", "x", ",", "style", ",", "skip", "=", "None", ")", ":", "out", "=", "self", ".", "modulated_conv", "(", "x", ",", "style", ")", "out", "=", "out", "+", "self", ".", "bias", "if", "skip", "is", "not", "None", ":", "if", "self", ".", "upsample", ":", "skip", "=", "self", ".", "upsample", "(", "skip", ")", "out", "=", "out", "+", "skip", "return", "out" ]

[ "Process", "a", "LAST", "command", ".", "No", "arguments", ".", "Return", "as", "for", "STAT", "." ]

[ "def", "last", "(", "self", ")", ":", "return", "self", ".", "statcmd", "(", "'LAST'", ")" ]

[ "Called", "from", "callback", "in", "self", ".", "setup_operations_downloads_tab", "()", "." ]

[ "def", "on_json_button_toggled", "(", "self", ",", "checkbutton", ")", ":", "if", "checkbutton", ".", "get_active", "(", ")", "and", "not", "self", ".", "app_obj", ".", "apply_json_timeout_flag", ":", "self", ".", "app_obj", ".", "set_apply_json_timeout_flag", "(", "True", ")", "elif", "not", "checkbutton", ".", "get_active", "(", ")", "and", "self", ".", "app_obj", ".", "apply_json_timeout_flag", ":", "self", ".", "app_obj", ".", "set_apply_json_timeout_flag", "(", "False", ")" ]

[ "Creates", "notifications", ":", "1", ".", "Notifies", "removed", "followers", "that", "conversation", "has", "new", "activity", ".", "2", ".", "Notifies", "existing", "followers", "of", "the", "viewpoint", "that", "metadata", "has", "changed", "." ]

[ "def", "_Notify", "(", "self", ")", ":", "# Creates notifications for any revived followers.", "yield", "NotificationManager", ".", "NotifyReviveFollowers", "(", "self", ".", "_client", ",", "self", ".", "_viewpoint_id", ",", "self", ".", "_revive_follower_ids", ",", "self", ".", "_op", ".", "timestamp", ")", "# Notifies followers that viewpoint metadata has changed.", "yield", "NotificationManager", ".", "NotifyUpdateViewpoint", "(", "self", ".", "_client", ",", "self", ".", "_vp_dict", ",", "self", ".", "_followers", ",", "self", ".", "_prev_values", ",", "self", ".", "_act_dict", ")" ]

[ "Filter", "out", "overlapping", "spans", ".", "Returns", "a", "list", "of", "Spans", "." ]

[ "def", "filter_spans", "(", "spans", ")", "->", "List", "[", "Span", "]", ":", "def", "get_sort_key", "(", "span", ":", "Span", ")", ":", "return", "(", "span", ".", "end", "-", "span", ".", "start", ",", "span", ".", "start", ")", "sorted_spans", "=", "sorted", "(", "spans", ",", "key", "=", "get_sort_key", ",", "reverse", "=", "True", ")", "result", "=", "[", "]", "seen_tokens", "=", "set", "(", ")", "for", "span", "in", "sorted_spans", ":", "if", "span", ".", "start", "not", "in", "seen_tokens", "and", "span", ".", "end", "-", "1", "not", "in", "seen_tokens", ":", "result", ".", "append", "(", "span", ")", "seen_tokens", ".", "update", "(", "range", "(", "span", ".", "start", ",", "span", ".", "end", ")", ")", "return", "result" ]

[ "Call", "a", "docker", "method", "in", "a", "background", "thread" ]

[ "def", "docker", "(", "self", ",", "method", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "asyncio", ".", "wrap_future", "(", "self", ".", "executor", ".", "submit", "(", "self", ".", "_docker", ",", "method", ",", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "declaration_specifiers", ":", "storage_class_specifier", "declaration_specifiers_opt" ]

[ "def", "p_declaration_specifiers_3", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "self", ".", "_add_declaration_specifier", "(", "p", "[", "2", "]", ",", "p", "[", "1", "]", ",", "'storage'", ")" ]

[ "This", "will", "be", "executed", "when", "hooktype", "happens" ]

[ "def", "run", "(", "self", ",", "regs", ")", ":", "imm", "=", "immlib", ".", "Debugger", "(", ")", "readaddr", "=", "\"\"", "size", "=", "\"\"", "res", "=", "imm", ".", "readMemory", "(", "regs", "[", "'EBP'", "]", "+", "8", ",", "0xc", ")", "if", "len", "(", "res", ")", "!=", "0xc", "or", "not", "res", ":", "imm", ".", "log", "(", "\"RtlAllocateHeap: ESP seems to broken, unable to get args\"", ")", "return", "0x0", "(", "heap", ",", "flags", ",", "size", ")", "=", "struct", ".", "unpack", "(", "\"LLL\"", ",", "res", ")", "#imm.log(\"RtlAllocateHeap(0x%08x, 0x%08x, 0x%08x)\" % (heap, flags, size)) ", "called", "=", "imm", ".", "getKnowledge", "(", "\"heap_%08x\"", "%", "self", ".", "hookaddr", ")", "if", "not", "called", ":", "called", "=", "[", "]", "try", ":", "callstack", "=", "imm", ".", "readLong", "(", "regs", "[", "'EBP'", "]", "+", "4", ")", "except", "Exception", ":", "callstack", "=", "0x0", "called", ".", "append", "(", "(", "1", ",", "callstack", ",", "heap", ",", "flags", ",", "size", ",", "regs", "[", "'EAX'", "]", ")", ")", "imm", ".", "addKnowledge", "(", "\"heap_%08x\"", "%", "self", ".", "hookaddr", ",", "called", ",", "force_add", "=", "0x1", ")" ]

[ "Pull", "a", "file", "directly", "from", "S3", "." ]

[ "def", "s3_get", "(", "url", ":", "str", ",", "temp_file", ":", "IO", ")", "->", "None", ":", "s3_resource", "=", "get_s3_resource", "(", ")", "bucket_name", ",", "s3_path", "=", "split_s3_path", "(", "url", ")", "s3_resource", ".", "Bucket", "(", "bucket_name", ")", ".", "download_fileobj", "(", "s3_path", ",", "temp_file", ")" ]

[ "Merge", "config", "dictionary", "a", "into", "config", "dictionary", "b", "clobbering", "the", "options", "in", "b", "whenever", "they", "are", "also", "specified", "in", "a", "." ]

[ "def", "_merge_a_into_b", "(", "a", ",", "b", ")", ":", "if", "type", "(", "a", ")", "is", "not", "edict", ":", "return", "for", "k", ",", "v", "in", "a", ".", "iteritems", "(", ")", ":", "# a must specify keys that are in b", "if", "not", "b", ".", "has_key", "(", "k", ")", ":", "raise", "KeyError", "(", "'{} is not a valid config key'", ".", "format", "(", "k", ")", ")", "# the types must match, too", "old_type", "=", "type", "(", "b", "[", "k", "]", ")", "if", "old_type", "is", "not", "type", "(", "v", ")", ":", "if", "isinstance", "(", "b", "[", "k", "]", ",", "np", ".", "ndarray", ")", ":", "v", "=", "np", ".", "array", "(", "v", ",", "dtype", "=", "b", "[", "k", "]", ".", "dtype", ")", "else", ":", "raise", "ValueError", "(", "(", "'Type mismatch ({} vs. {}) '", "'for config key: {}'", ")", ".", "format", "(", "type", "(", "b", "[", "k", "]", ")", ",", "type", "(", "v", ")", ",", "k", ")", ")", "# recursively merge dicts", "if", "type", "(", "v", ")", "is", "edict", ":", "try", ":", "_merge_a_into_b", "(", "a", "[", "k", "]", ",", "b", "[", "k", "]", ")", "except", ":", "print", "(", "'Error under config key: {}'", ".", "format", "(", "k", ")", ")", "raise", "else", ":", "b", "[", "k", "]", "=", "v" ]

[ "Rewrite", "a", "file", "adding", "a", "line", "to", "its", "beginning", "." ]

[ "def", "prepend_line", "(", "filepath", ",", "line", ")", ":", "with", "open", "(", "filepath", ")", "as", "f", ":", "lines", "=", "f", ".", "readlines", "(", ")", "lines", ".", "insert", "(", "0", ",", "line", ")", "with", "open", "(", "filepath", ",", "'w'", ")", "as", "f", ":", "f", ".", "writelines", "(", "lines", ")" ]

[ "Parse", "a", "map", "of", "entry", "point", "groups" ]

[ "def", "parse_map", "(", "cls", ",", "data", ",", "dist", "=", "None", ")", ":", "if", "isinstance", "(", "data", ",", "dict", ")", ":", "data", "=", "data", ".", "items", "(", ")", "else", ":", "data", "=", "split_sections", "(", "data", ")", "maps", "=", "{", "}", "for", "group", ",", "lines", "in", "data", ":", "if", "group", "is", "None", ":", "if", "not", "lines", ":", "continue", "raise", "ValueError", "(", "\"Entry points must be listed in groups\"", ")", "group", "=", "group", ".", "strip", "(", ")", "if", "group", "in", "maps", ":", "raise", "ValueError", "(", "\"Duplicate group name\"", ",", "group", ")", "maps", "[", "group", "]", "=", "cls", ".", "parse_group", "(", "group", ",", "lines", ",", "dist", ")", "return", "maps" ]

[ "Compute", "categorical", "accuracy", "given", "one", "-", "hot", "matrices", "." ]

[ "def", "cat_acc", "(", "y", ",", "z", ")", ":", "weights", "=", "_cat_sample_weights", "(", "y", ")", "_acc", "=", "K", ".", "cast", "(", "K", ".", "equal", "(", "K", ".", "argmax", "(", "y", ",", "axis", "=", "-", "1", ")", ",", "K", ".", "argmax", "(", "z", ",", "axis", "=", "-", "1", ")", ")", ",", "K", ".", "floatx", "(", ")", ")", "_acc", "=", "K", ".", "sum", "(", "_acc", "*", "weights", ")", "/", "K", ".", "sum", "(", "weights", ")", "return", "_acc" ]

[]

[ "def", "__init__", "(", "self", ",", "csv", ")", ":", "InstrumentCSVResultsFileParser", ".", "__init__", "(", "self", ",", "csv", ")", "self", ".", "_end_header", "=", "False", "self", ".", "_quantitationresultsheader", "=", "[", "]", "self", ".", "_numline", "=", "0" ]

[]

[ "def", "__init__", "(", "self", ")", ":", "super", "(", "ReductionB", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "path0", "=", "nn", ".", "Sequential", "(", "BasicConv2d", "(", "1152", ",", "256", ",", "kernel_size", "=", "1", ")", ",", "BasicConv2d", "(", "256", ",", "256", ",", "kernel_size", "=", "3", ",", "padding", "=", "1", ")", ",", "BasicConv2d", "(", "256", ",", "256", ",", "kernel_size", "=", "3", ",", "stride", "=", "2", ")", ",", ")", "self", ".", "path1", "=", "nn", ".", "Sequential", "(", "BasicConv2d", "(", "1152", ",", "256", ",", "kernel_size", "=", "1", ")", ",", "BasicConv2d", "(", "256", ",", "256", ",", "kernel_size", "=", "3", ",", "stride", "=", "2", ")", ",", ")", "self", ".", "path2", "=", "nn", ".", "Sequential", "(", "BasicConv2d", "(", "1152", ",", "256", ",", "kernel_size", "=", "1", ")", ",", "BasicConv2d", "(", "256", ",", "384", ",", "kernel_size", "=", "3", ",", "stride", "=", "2", ")", ",", ")", "self", ".", "path3", "=", "nn", ".", "MaxPool2d", "(", "3", ",", "stride", "=", "2", ")" ]

[ "Accessor", "for", "name", "attribute", "(", "e", ".", "g", ".", ":", "Linux", "2", ".", "4", ".", "26", "(", "Slackware", "10", ".", "0", ".", "0", "))" ]

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

[ "Translate", "CamelCaseNames", "to", "Camel", "Case", "Names", ".", "Used", "when", "generating", "names", "from", "view", "classes", "." ]

[ "def", "camelcase_to_spaces", "(", "content", ")", ":", "camelcase_boundary", "=", "'(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))'", "content", "=", "re", ".", "sub", "(", "camelcase_boundary", ",", "' \\\\1'", ",", "content", ")", ".", "strip", "(", ")", "return", "' '", ".", "join", "(", "content", ".", "split", "(", "'_'", ")", ")", ".", "title", "(", ")" ]

[]

[ "def", "_get_column_name", "(", "field_names", ",", "options", ")", ":", "# XXX: this function expects all keys already in lowercase and slugified by `rows` library", "valid_columns", "=", "[", "key", "for", "key", "in", "field_names", "if", "key", "in", "options", "]", "if", "not", "valid_columns", ":", "raise", "ValueError", "(", "f\"A coluna '{options[0]}' não existe\")", "", "elif", "len", "(", "valid_columns", ")", ">", "1", ":", "raise", "ValueError", "(", "f\"Foi encontrada mais de uma coluna possível para '{options[0]}'\")", "", "return", "valid_columns", "[", "0", "]" ]

[ "Converts", "a", "IPv4", "-", "mapped", "IPv6", "address", "into", "a", "IPv4", "address", ".", "Handles", "both", "the", "::", "ffff", ":", "192", ".", "0", ".", "2", ".", "128", "format", "as", "well", "as", "the", "deprecated", "::", "192", ".", "0", ".", "2", ".", "128", "format", "." ]

[ "def", "normalize_mapped_address", "(", "ipaddr", ")", ":", "ipaddr", "=", "IPAddress", "(", "ipaddr", ")", "if", "ipaddr", ".", "is_ipv4_compat", "(", ")", "or", "ipaddr", ".", "is_ipv4_mapped", "(", ")", ":", "ipaddr", "=", "ipaddr", ".", "ipv4", "(", ")", "return", "str", "(", "ipaddr", ")" ]

[ "generates", "plots", "and", "saves", "function", "values", "func", "(", "y", ")", "where", "y", "is", "close", "to", "x", "(", "see", "__init__", "()", ")", ".", "The", "data", "are", "stored", "in", "the", "res", "attribute", "and", "the", "class", "instance", "is", "saved", "in", "a", "file", "with", "(", "the", "weired", ")", "name", "str", "(", "func", ")", "." ]

[ "def", "do", "(", "self", ",", "repetitions", "=", "1", ",", "locations", "=", "np", ".", "arange", "(", "-", "0.5", ",", "0.6", ",", "0.2", ")", ",", "plot", "=", "True", ")", ":", "if", "not", "repetitions", ":", "self", ".", "plot", "(", ")", "return", "res", "=", "self", ".", "res", "for", "i", "in", "range", "(", "len", "(", "self", ".", "basis", ")", ")", ":", "# i-th coordinate", "if", "i", "not", "in", "res", ":", "res", "[", "i", "]", "=", "{", "}", "# xx = np.array(self.x)", "# TODO: store res[i]['dx'] = self.basis[i] here?", "for", "dx", "in", "locations", ":", "xx", "=", "self", ".", "x", "+", "dx", "*", "self", ".", "basis", "[", "i", "]", "xkey", "=", "dx", "# xx[i] if (self.basis == np.eye(len(self.basis))).all() else dx", "if", "xkey", "not", "in", "res", "[", "i", "]", ":", "res", "[", "i", "]", "[", "xkey", "]", "=", "[", "]", "n", "=", "repetitions", "while", "n", ">", "0", ":", "n", "-=", "1", "res", "[", "i", "]", "[", "xkey", "]", ".", "append", "(", "self", ".", "func", "(", "xx", ",", "*", "self", ".", "args", ")", ")", "if", "plot", ":", "self", ".", "plot", "(", ")", "self", ".", "save", "(", ")", "return", "self" ]

[]

[ "def", "__hash__", "(", "self", ")", ":", "return", "hash", "(", "(", "Equivalence", ",", "self", ".", "codeloc", ",", "self", ".", "atom0", ",", "self", ".", "atom1", ")", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "block", ",", "layers", ",", "num_classes", "=", "1000", ")", ":", "self", ".", "inplanes", "=", "64", "super", "(", "ResNet", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "conv1", "=", "nn", ".", "Conv2d", "(", "3", ",", "64", ",", "kernel_size", "=", "7", ",", "stride", "=", "2", ",", "padding", "=", "3", ",", "bias", "=", "False", ")", "self", ".", "bn1", "=", "nn", ".", "BatchNorm2d", "(", "64", ")", "self", ".", "relu", "=", "nn", ".", "ReLU", "(", "inplace", "=", "True", ")", "self", ".", "maxpool", "=", "nn", ".", "MaxPool2d", "(", "kernel_size", "=", "3", ",", "stride", "=", "2", ",", "padding", "=", "1", ")", "self", ".", "layer1", "=", "self", ".", "_make_layer", "(", "block", ",", "64", ",", "layers", "[", "0", "]", ")", "self", ".", "layer2", "=", "self", ".", "_make_layer", "(", "block", ",", "128", ",", "layers", "[", "1", "]", ",", "stride", "=", "2", ")", "self", ".", "layer3", "=", "self", ".", "_make_layer", "(", "block", ",", "256", ",", "layers", "[", "2", "]", ",", "stride", "=", "2", ")", "self", ".", "layer4", "=", "self", ".", "_make_layer", "(", "block", ",", "512", ",", "layers", "[", "3", "]", ",", "stride", "=", "2", ")", "self", ".", "avgpool", "=", "nn", ".", "AvgPool2d", "(", "8", ",", "stride", "=", "1", ")", "self", ".", "baselayer", "=", "[", "self", ".", "conv1", ",", "self", ".", "bn1", ",", "self", ".", "layer1", ",", "self", ".", "layer2", ",", "self", ".", "layer3", ",", "self", ".", "layer4", "]", "self", ".", "fc", "=", "nn", ".", "Linear", "(", "512", "*", "block", ".", "expansion", ",", "num_classes", ")", "for", "m", "in", "self", ".", "modules", "(", ")", ":", "if", "isinstance", "(", "m", ",", "nn", ".", "Conv2d", ")", ":", "n", "=", "m", ".", "kernel_size", "[", "0", "]", "*", "m", ".", "kernel_size", "[", "1", "]", "*", "m", ".", "out_channels", "m", ".", "weight", ".", "data", ".", "normal_", "(", "0", ",", "math", ".", "sqrt", "(", "2.", "/", "n", ")", ")", "elif", "isinstance", "(", "m", ",", "nn", ".", "BatchNorm2d", ")", ":", "m", ".", "weight", ".", "data", ".", "fill_", "(", "1", ")", "m", ".", "bias", ".", "data", ".", "zero_", "(", ")" ]

[ "Projects", "the", "point", "from", "the", "cartesian", "space", "into", "the", "geographic", "space", ".", "The", "x", "component", "is", "considered", "to", "be", "the", "easting", "the", "y", "component", "to", "be", "the", "northing", "." ]

[ "def", "inverse", "(", "self", ",", "projection", ")", ":", "return", "inverse_", "(", "self", ",", "projection", ")" ]

[ "Calculate", "and", "return", "the", "MD5", "checksum", "for", "a", "given", "file", ".", "file", "may", "either", "be", "a", "filename", "or", "an", "open", "stream", "." ]

[ "def", "md5_hexdigest", "(", "file", ")", ":", "if", "isinstance", "(", "file", ",", "basestring", ")", ":", "file", "=", "open", "(", "file", ",", "'rb'", ")", "md5_digest", "=", "md5", "(", ")", "while", "True", ":", "block", "=", "file", ".", "read", "(", "1024", "*", "16", ")", "# 16k blocks", "if", "not", "block", ":", "break", "md5_digest", ".", "update", "(", "block", ")", "return", "md5_digest", ".", "hexdigest", "(", ")" ]

[ "Set", "configuration", "options", "for", "all", "subwidgets", "(", "and", "self", ")", "." ]

[ "def", "config_all", "(", "self", ",", "option", ",", "value", ")", ":", "if", "option", "==", "''", ":", "return", "elif", "not", "isinstance", "(", "option", ",", "StringType", ")", ":", "option", "=", "repr", "(", "option", ")", "if", "not", "isinstance", "(", "value", ",", "StringType", ")", ":", "value", "=", "repr", "(", "value", ")", "names", "=", "self", ".", "_subwidget_names", "(", ")", "for", "name", "in", "names", ":", "self", ".", "tk", ".", "call", "(", "name", ",", "'configure'", ",", "'-'", "+", "option", ",", "value", ")" ]

[ "Uploads", "the", "index", "definitions", "." ]

[ "def", "DoUpload", "(", "self", ")", ":", "StatusUpdate", "(", "'Uploading index definitions.'", ",", "self", ".", "error_fh", ")", "with", "TempChangeField", "(", "self", ".", "definitions", ",", "'application'", ",", "None", ")", "as", "app_id", ":", "self", ".", "rpcserver", ".", "Send", "(", "'/api/datastore/index/add'", ",", "app_id", "=", "app_id", ",", "payload", "=", "self", ".", "definitions", ".", "ToYAML", "(", ")", ")" ]

[ ":", "param", "text", ":", "The", "text", "which", "should", "be", "scanned", ":", "param", "flags", ":", "default", "regular", "expression", "flags" ]

[ "def", "__init__", "(", "self", ",", "text", ",", "flags", "=", "0", ")", ":", "self", ".", "data", "=", "text", "self", ".", "data_length", "=", "len", "(", "text", ")", "self", ".", "start_pos", "=", "0", "self", ".", "pos", "=", "0", "self", ".", "flags", "=", "flags", "self", ".", "last", "=", "None", "self", ".", "match", "=", "None", "self", ".", "_re_cache", "=", "{", "}" ]

[ "Return", "certain", "machine", "-", "readable", "information", "about", "the", "Linux", "distribution", "." ]

[ "def", "info", "(", "self", ",", "pretty", "=", "False", ",", "best", "=", "False", ")", ":", "return", "dict", "(", "id", "=", "self", ".", "id", "(", ")", ",", "version", "=", "self", ".", "version", "(", "pretty", ",", "best", ")", ",", "version_parts", "=", "dict", "(", "major", "=", "self", ".", "major_version", "(", "best", ")", ",", "minor", "=", "self", ".", "minor_version", "(", "best", ")", ",", "build_number", "=", "self", ".", "build_number", "(", "best", ")", ")", ",", "like", "=", "self", ".", "like", "(", ")", ",", "codename", "=", "self", ".", "codename", "(", ")", ",", ")" ]

[ "Compute", "derivatives", "wrt", ".", "hyperparameters", "." ]

[ "def", "getDerMatrix", "(", "self", ",", "x", "=", "None", ",", "der", "=", "None", ")", ":", "pass" ]

[ "Abstract", "episode", "mutation", "." ]

[ "def", "episode_mutation", "(", "self", ",", "episode", ":", "List", "[", "Message", "]", ")", "->", "List", "[", "Message", "]", ":", "pass" ]

[ "Visit", "ScheduleBlock", ".", "Recursively", "visit", "context", "blocks", "and", "search", "parameters", "." ]

[ "def", "visit_ScheduleBlock", "(", "self", ",", "node", ":", "ScheduleBlock", ")", ":", "for", "parameter", "in", "node", ".", "parameters", ":", "self", ".", "parameters", ".", "add", "(", "parameter", ")" ]

[ "Add", "checkbutton", "menu", "item", "at", "INDEX", "." ]

[ "def", "insert_checkbutton", "(", "self", ",", "index", ",", "cnf", "=", "{", "}", ",", "*", "*", "kw", ")", ":", "self", ".", "insert", "(", "index", ",", "'checkbutton'", ",", "cnf", "or", "kw", ")" ]

[]

[ "def", "documentation", "(", ")", ":", "webbrowser", ".", "open", "(", "HELP_URL", ")" ]

[]

[ "def", "get_cluster", "(", "self", ",", "cluster_name", ":", "str", "=", "''", ")", ":", "session", "=", "self", ".", "_create_session", "(", ")", "response", "=", "session", ".", "get", "(", "self", ".", "service_url", "+", "CLUSTER", ".", "format", "(", "cluster_name", ")", ")", "return", "response" ]

[ "Get", "the", "plugins", "directory", "path", "." ]

[ "def", "getPluginsDirectoryPath", "(", ")", ":", "return", "archive", ".", "getInterpretPluginsPath", "(", "'xml_plugins'", ")" ]

[ "Request", "data", "from", "the", "ISNI", "API" ]

[ "def", "request_isni_data", "(", "search_index", ",", "search_term", ",", "max_records", "=", "5", ")", ":", "search_string", "=", "f'{search_index}=\"{search_term}\"'", "query_params", "=", "{", "\"query\"", ":", "search_string", ",", "\"version\"", ":", "\"1.1\"", ",", "\"operation\"", ":", "\"searchRetrieve\"", ",", "\"recordSchema\"", ":", "\"isni-b\"", ",", "\"maximumRecords\"", ":", "max_records", ",", "\"startRecord\"", ":", "\"1\"", ",", "\"recordPacking\"", ":", "\"xml\"", ",", "\"sortKeys\"", ":", "\"RLV,pica,0,,\"", ",", "}", "result", "=", "requests", ".", "get", "(", "\"http://isni.oclc.org/sru/\"", ",", "params", "=", "query_params", ",", "timeout", "=", "15", ")", "# the OCLC ISNI server asserts the payload is encoded", "# in latin1, but we know better", "result", ".", "encoding", "=", "\"utf-8\"", "return", "result", ".", "text" ]

[ "Given", "an", ":", "class", ":", "httplib", ".", "HTTPResponse", "instance", "r", "return", "a", "corresponding", ":", "class", ":", "urllib3", ".", "response", ".", "HTTPResponse", "object", "." ]

[ "def", "from_httplib", "(", "ResponseCls", ",", "r", ",", "*", "*", "response_kw", ")", ":", "headers", "=", "r", ".", "msg", "if", "not", "isinstance", "(", "headers", ",", "HTTPHeaderDict", ")", ":", "if", "PY3", ":", "# Python 3", "headers", "=", "HTTPHeaderDict", "(", "headers", ".", "items", "(", ")", ")", "else", ":", "# Python 2", "headers", "=", "HTTPHeaderDict", ".", "from_httplib", "(", "headers", ")", "# HTTPResponse objects in Python 3 don't have a .strict attribute", "strict", "=", "getattr", "(", "r", ",", "'strict'", ",", "0", ")", "resp", "=", "ResponseCls", "(", "body", "=", "r", ",", "headers", "=", "headers", ",", "status", "=", "r", ".", "status", ",", "version", "=", "r", ".", "version", ",", "reason", "=", "r", ".", "reason", ",", "strict", "=", "strict", ",", "original_response", "=", "r", ",", "*", "*", "response_kw", ")", "return", "resp" ]

[ "Whether", "resource", "multipart" ]

[ "def", "multipart", "(", "self", ")", ":", "return", "self", ".", "__source_inspection", ".", "get", "(", "'multipart'", ",", "False", ")" ]

[ "Entry", "point", "for", "the", "aggregator", "." ]

[ "def", "run", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "raise", "NotImplementedError" ]

[ "Closes", "the", "connection", "to", "this", "MySQL", "server", "." ]

[ "def", "close", "(", "self", ")", ":", "if", "self", ".", "cursor", ":", "self", ".", "cursor", ".", "close", "(", ")", "self", ".", "cursor", "=", "None", "if", "self", ".", "db", ":", "self", ".", "db", ".", "close", "(", ")", "self", ".", "db", "=", "None" ]

[ "Report", "a", "missing", "or", "non", "-", "accessible", "member", "." ]

[ "def", "has_no_attr", "(", "self", ",", "original_type", ":", "Type", ",", "typ", ":", "Type", ",", "member", ":", "str", ",", "context", ":", "Context", ",", "module_symbol_table", ":", "Optional", "[", "SymbolTable", "]", "=", "None", ")", "->", "Type", ":", "original_type", "=", "get_proper_type", "(", "original_type", ")", "typ", "=", "get_proper_type", "(", "typ", ")", "if", "(", "isinstance", "(", "original_type", ",", "Instance", ")", "and", "original_type", ".", "type", ".", "has_readable_member", "(", "member", ")", ")", ":", "self", ".", "fail", "(", "'Member \"{}\" is not assignable'", ".", "format", "(", "member", ")", ",", "context", ")", "elif", "member", "==", "'__contains__'", ":", "self", ".", "fail", "(", "'Unsupported right operand type for in ({})'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "OPERATOR", ")", "elif", "member", "in", "op_methods", ".", "values", "(", ")", ":", "# Access to a binary operator member (e.g. _add). This case does", "# not handle indexing operations.", "for", "op", ",", "method", "in", "op_methods", ".", "items", "(", ")", ":", "if", "method", "==", "member", ":", "self", ".", "unsupported_left_operand", "(", "op", ",", "original_type", ",", "context", ")", "break", "elif", "member", "==", "'__neg__'", ":", "self", ".", "fail", "(", "'Unsupported operand type for unary - ({})'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "OPERATOR", ")", "elif", "member", "==", "'__pos__'", ":", "self", ".", "fail", "(", "'Unsupported operand type for unary + ({})'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "OPERATOR", ")", "elif", "member", "==", "'__invert__'", ":", "self", ".", "fail", "(", "'Unsupported operand type for ~ ({})'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "OPERATOR", ")", "elif", "member", "==", "'__getitem__'", ":", "# Indexed get.", "# TODO: Fix this consistently in format_type", "if", "isinstance", "(", "original_type", ",", "CallableType", ")", "and", "original_type", ".", "is_type_obj", "(", ")", ":", "self", ".", "fail", "(", "'The type {} is not generic and not indexable'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ")", "else", ":", "self", ".", "fail", "(", "'Value of type {} is not indexable'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "INDEX", ")", "elif", "member", "==", "'__setitem__'", ":", "# Indexed set.", "self", ".", "fail", "(", "'Unsupported target for indexed assignment ({})'", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "INDEX", ")", "elif", "member", "==", "'__call__'", ":", "if", "isinstance", "(", "original_type", ",", "Instance", ")", "and", "(", "original_type", ".", "type", ".", "fullname", "==", "'builtins.function'", ")", ":", "# \"'function' not callable\" is a confusing error message.", "# Explain that the problem is that the type of the function is not known.", "self", ".", "fail", "(", "'Cannot call function of unknown type'", ",", "context", ",", "code", "=", "codes", ".", "OPERATOR", ")", "else", ":", "self", ".", "fail", "(", "message_registry", ".", "NOT_CALLABLE", ".", "format", "(", "format_type", "(", "original_type", ")", ")", ",", "context", ",", "code", "=", "codes", ".", "OPERATOR", ")", "else", ":", "# The non-special case: a missing ordinary attribute.", "extra", "=", "''", "if", "member", "==", "'__iter__'", ":", "extra", "=", "' (not iterable)'", "elif", "member", "==", "'__aiter__'", ":", "extra", "=", "' (not async iterable)'", "if", "not", "self", ".", "disable_type_names_count", ":", "failed", "=", "False", "if", "isinstance", "(", "original_type", ",", "Instance", ")", "and", "original_type", ".", "type", ".", "names", ":", "alternatives", "=", "set", "(", "original_type", ".", "type", ".", "names", ".", "keys", "(", ")", ")", "if", "module_symbol_table", "is", "not", "None", ":", "alternatives", "|=", "{", "key", "for", "key", "in", "module_symbol_table", ".", "keys", "(", ")", "}", "# in some situations, the member is in the alternatives set", "# but since we're in this function, we shouldn't suggest it", "if", "member", "in", "alternatives", ":", "alternatives", ".", "remove", "(", "member", ")", "matches", "=", "[", "m", "for", "m", "in", "COMMON_MISTAKES", ".", "get", "(", "member", ",", "[", "]", ")", "if", "m", "in", "alternatives", "]", "matches", ".", "extend", "(", "best_matches", "(", "member", ",", "alternatives", ")", "[", ":", "3", "]", ")", "if", "member", "==", "'__aiter__'", "and", "matches", "==", "[", "'__iter__'", "]", ":", "matches", "=", "[", "]", "# Avoid misleading suggestion", "if", "member", "==", "'__div__'", "and", "matches", "==", "[", "'__truediv__'", "]", ":", "# TODO: Handle differences in division between Python 2 and 3 more cleanly", "matches", "=", "[", "]", "if", "matches", ":", "self", ".", "fail", "(", "'{} has no attribute \"{}\"; maybe {}?{}'", ".", "format", "(", "format_type", "(", "original_type", ")", ",", "member", ",", "pretty_seq", "(", "matches", ",", "\"or\"", ")", ",", "extra", ",", ")", ",", "context", ",", "code", "=", "codes", ".", "ATTR_DEFINED", ")", "failed", "=", "True", "if", "not", "failed", ":", "self", ".", "fail", "(", "'{} has no attribute \"{}\"{}'", ".", "format", "(", "format_type", "(", "original_type", ")", ",", "member", ",", "extra", ")", ",", "context", ",", "code", "=", "codes", ".", "ATTR_DEFINED", ")", "elif", "isinstance", "(", "original_type", ",", "UnionType", ")", ":", "# The checker passes \"object\" in lieu of \"None\" for attribute", "# checks, so we manually convert it back.", "typ_format", ",", "orig_type_format", "=", "format_type_distinctly", "(", "typ", ",", "original_type", ")", "if", "typ_format", "==", "'\"object\"'", "and", "any", "(", "type", "(", "item", ")", "==", "NoneType", "for", "item", "in", "original_type", ".", "items", ")", ":", "typ_format", "=", "'\"None\"'", "self", ".", "fail", "(", "'Item {} of {} has no attribute \"{}\"{}'", ".", "format", "(", "typ_format", ",", "orig_type_format", ",", "member", ",", "extra", ")", ",", "context", ",", "code", "=", "codes", ".", "UNION_ATTR", ")", "elif", "isinstance", "(", "original_type", ",", "TypeVarType", ")", ":", "bound", "=", "get_proper_type", "(", "original_type", ".", "upper_bound", ")", "if", "isinstance", "(", "bound", ",", "UnionType", ")", ":", "typ_fmt", ",", "bound_fmt", "=", "format_type_distinctly", "(", "typ", ",", "bound", ")", "original_type_fmt", "=", "format_type", "(", "original_type", ")", "self", ".", "fail", "(", "'Item {} of the upper bound {} of type variable {} has no '", "'attribute \"{}\"{}'", ".", "format", "(", "typ_fmt", ",", "bound_fmt", ",", "original_type_fmt", ",", "member", ",", "extra", ")", ",", "context", ",", "code", "=", "codes", ".", "UNION_ATTR", ")", "return", "AnyType", "(", "TypeOfAny", ".", "from_error", ")" ]

[ "Validates", "the", "given", "value", "and", "returns", "its", "cleaned", "value", "as", "an", "appropriate", "Python", "object", "." ]

[ "def", "clean", "(", "self", ",", "value", ")", ":", "value", "=", "self", ".", "to_python", "(", "value", ")", "self", ".", "validate", "(", "value", ")", "self", ".", "run_validators", "(", "value", ")", "return", "value" ]

[ "Show", "a", "message", "page", "with", "the", "given", ".", "html", "file", "." ]

[ "def", "show_message", "(", "self", ",", "page", ")", ":", "self", ".", "setHtml", "(", "page", ")" ]

[ "DEPRECATED", "Write", "a", "list", "of", "dicts", "to", "a", "csv", "file" ]

[ "def", "to_csv", "(", "data", ",", "field_names", "=", "None", ",", "filename", "=", "'data.csv'", ",", "overwrite", "=", "True", ",", "write_headers", "=", "True", ",", "append", "=", "False", ",", "flat", "=", "True", ",", "primary_fields", "=", "None", ",", "sort_fields", "=", "True", ")", ":", "# Don't overwrite if not specified", "if", "not", "overwrite", "and", "path", ".", "isfile", "(", "filename", ")", ":", "raise", "FileExistsError", "(", "'The file already exists'", ")", "# Replace file if append not specified", "write_type", "=", "'w'", "if", "not", "append", "else", "'a'", "# Flatten if flat is specified, or there are no predefined field names", "if", "flat", "or", "not", "field_names", ":", "data", "=", "[", "flatten", "(", "datum", ")", "for", "datum", "in", "data", "]", "# Fill in gaps between dicts with empty string", "if", "not", "field_names", ":", "field_names", ",", "data", "=", "fill_gaps", "(", "data", ")", "# Sort fields if specified", "if", "sort_fields", ":", "field_names", ".", "sort", "(", ")", "# If there are primary fields, move the field names to the front and sort", "# based on first field", "if", "primary_fields", ":", "for", "key", "in", "primary_fields", "[", ":", ":", "-", "1", "]", ":", "field_names", ".", "insert", "(", "0", ",", "field_names", ".", "pop", "(", "field_names", ".", "index", "(", "key", ")", ")", ")", "data", "=", "sorted", "(", "data", ",", "key", "=", "lambda", "k", ":", "k", "[", "field_names", "[", "0", "]", "]", ",", "reverse", "=", "True", ")", "# Write the file", "with", "open", "(", "filename", ",", "write_type", ",", "encoding", "=", "'utf-8'", ")", "as", "f", ":", "writer", "=", "csv", ".", "DictWriter", "(", "f", ",", "fieldnames", "=", "field_names", ",", "lineterminator", "=", "'\\n'", ")", "if", "not", "append", "or", "write_headers", ":", "writer", ".", "writeheader", "(", ")", "# Write rows containing fields in field names", "for", "datum", "in", "data", ":", "for", "key", "in", "list", "(", "datum", ".", "keys", "(", ")", ")", ":", "if", "key", "not", "in", "field_names", ":", "del", "datum", "[", "key", "]", "elif", "type", "(", "datum", "[", "key", "]", ")", "is", "str", ":", "datum", "[", "key", "]", "=", "datum", "[", "key", "]", ".", "strip", "(", ")", "datum", "[", "key", "]", "=", "str", "(", "datum", "[", "key", "]", ")", "writer", ".", "writerow", "(", "datum", ")" ]

[]

[ "def", "generate", "(", "sites", ",", "warninglist", ",", "dst", ")", ":", "warninglist", "[", "'version'", "]", "=", "get_version", "(", ")", "warninglist", "[", "'type'", "]", "=", "'string'", "warninglist", "[", "'matching_attributes'", "]", "=", "[", "'hostname'", ",", "'domain'", ",", "'url'", ",", "'domain|ip'", "]", "warninglist", "[", "'list'", "]", "=", "[", "]", "for", "site", "in", "sites", ":", "v", "=", "site", ".", "decode", "(", "'UTF-8'", ")", ".", "split", "(", "','", ")", "[", "1", "]", "warninglist", "[", "'list'", "]", ".", "append", "(", "v", ".", "strip", "(", ")", ".", "replace", "(", "'\\\\r\\\\n'", ",", "''", ")", ")", "write_to_file", "(", "warninglist", ",", "dst", ")" ]

[ "Get", "min", "/", "max", "values", "for", "each", "band", "in", "the", "image" ]

[ "def", "_getextrema", "(", "self", ")", ":", "def", "minmax", "(", "histogram", ")", ":", "n", "=", "255", "x", "=", "0", "for", "i", "in", "range", "(", "256", ")", ":", "if", "histogram", "[", "i", "]", ":", "n", "=", "min", "(", "n", ",", "i", ")", "x", "=", "max", "(", "x", ",", "i", ")", "return", "n", ",", "x", "# returns (255, 0) if there's no data in the histogram", "v", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "self", ".", "h", ")", ",", "256", ")", ":", "v", ".", "append", "(", "minmax", "(", "self", ".", "h", "[", "i", ":", "]", ")", ")", "return", "v" ]

[ "Dumps", "all", "information", "from", "an", "exception", "that", "came", "from", "the", "server", "to", "the", "log", "." ]

[ "def", "_log_server_exception", "(", "self", ",", "e", ")", ":", "template", "=", "\"\"\"Exception occurred:\n href: %(h)s\n method: %(m)s\n status: %(s)s\n error: %(e)s\n traceback: %(t)s\n data: %(d)s\n \"\"\"", "data", "=", "{", "'h'", ":", "e", ".", "href", ",", "'m'", ":", "e", ".", "http_request_method", ",", "'s'", ":", "e", ".", "http_status", ",", "'e'", ":", "e", ".", "error_message", ",", "'t'", ":", "e", ".", "traceback", ",", "'d'", ":", "e", ".", "extra_data", "}", "_logger", ".", "error", "(", "template", "%", "data", ")" ]

[ "Return", "the", "value", "of", "a", "specified", "option", "in", "a", "specified", "section", "the", "specified", "default", "value", "if", "the", "specified", "section", "and", "/", "or", "option", "are", "not", "found", "in", "the", "configuration", "content", ".", ":", "param", "section", ":", "the", "section", "in", "which", "to", "look", ".", ":", "param", "option", ":", "the", "option", "for", "which", "to", "look", ".", ":", "param", "default", ":", "the", "default", "value", "to", "use", "in", "case", "section", "and", "/", "or", "option", "are", "missing", ".", ":", "return", ":", "the", "desired", "section", "/", "option", "value", "or", "the", "default", "is", "missing", "." ]

[ "def", "get", "(", "self", ",", "section", ",", "option", ",", "default", "=", "None", ")", ":", "return", "self", ".", "_parser", ".", "get", "(", "section", ",", "option", ",", "default", ")" ]

[ "Generate", "merged", "ranges", "." ]

[ "def", "merge_ranges", "(", "self", ",", "pid", ")", ":", "old_vad", "=", "None", "for", "vad", "in", "self", ".", "generate_vads", "(", "pid", ")", ":", "# Try to merge this range with the previous range.", "if", "(", "old_vad", "and", "old_vad", ".", "end", "==", "vad", ".", "start", "and", "old_vad", ".", "protection", "==", "vad", ".", "protection", "and", "old_vad", ".", "filename", "==", "vad", ".", "filename", ")", ":", "old_vad", ".", "end", "=", "vad", ".", "end", "continue", "# Yield the old range:", "if", "old_vad", ":", "yield", "old_vad", "old_vad", "=", "vad", "# Emit the last range.", "if", "old_vad", ":", "yield", "old_vad" ]

[ "Initializes", "a", "new", "instance", "of", "the", ":", "class", ":", "LuisApplication", "class", "." ]

[ "def", "__init__", "(", "self", ",", "application_id", ":", "str", ",", "endpoint_key", ":", "str", ",", "endpoint", ":", "str", ")", ":", "_", ",", "valid", "=", "LuisApplication", ".", "_try_parse_uuid4", "(", "application_id", ")", "if", "not", "valid", ":", "raise", "ValueError", "(", "f'\"{application_id}\" is not a valid LUIS application id.'", ")", "_", ",", "valid", "=", "LuisApplication", ".", "_try_parse_uuid4", "(", "endpoint_key", ")", "if", "not", "valid", ":", "raise", "ValueError", "(", "f'\"{endpoint_key}\" is not a valid LUIS subscription key.'", ")", "if", "not", "endpoint", "or", "endpoint", ".", "isspace", "(", ")", ":", "endpoint", "=", "\"https://westus.api.cognitive.microsoft.com\"", "_", ",", "valid", "=", "LuisApplication", ".", "_try_parse_url", "(", "endpoint", ")", "if", "not", "valid", ":", "raise", "ValueError", "(", "f'\"{endpoint}\" is not a valid LUIS endpoint.'", ")", "self", ".", "application_id", "=", "application_id", "self", ".", "endpoint_key", "=", "endpoint_key", "self", ".", "endpoint", "=", "endpoint" ]

[ "Params", "for", "RelativeBias", "." ]

[ "def", "Params", "(", "cls", ")", "->", "InstantiableParams", ":", "p", "=", "super", "(", ")", ".", "Params", "(", ")", "p", ".", "Define", "(", "'num_heads'", ",", "1", ",", "'Num of attention heads.'", ")", "p", ".", "Define", "(", "'relative_attention_num_buckets'", ",", "32", ",", "'Relative attention num buckets.'", ")", "p", ".", "Define", "(", "'relative_attention_max_distance'", ",", "128", ",", "'Max relative distance (outer bucket boundary).'", ")", "return", "p" ]

[ "Iterating", "over", "a", "tag", "iterates", "over", "its", "contents", "." ]

[ "def", "__iter__", "(", "self", ")", ":", "return", "iter", "(", "self", ".", "contents", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "guid", "=", "\"{00000000-0000-0000-0000-000000000000}\"", ")", ":", "super", "(", ")", ".", "__init__", "(", ")", "if", "isinstance", "(", "guid", ",", "str", ")", ":", "ret", "=", "_ole32", ".", "CLSIDFromString", "(", "ctypes", ".", "create_unicode_buffer", "(", "guid", ")", ",", "ctypes", ".", "byref", "(", "self", ")", ")", "if", "ret", "<", "0", ":", "err_no", "=", "ctypes", ".", "GetLastError", "(", ")", "raise", "WindowsError", "(", "err_no", ",", "ctypes", ".", "FormatError", "(", "err_no", ")", ",", "guid", ")", "else", ":", "ctypes", ".", "memmove", "(", "ctypes", ".", "byref", "(", "self", ")", ",", "bytes", "(", "guid", ")", ",", "ctypes", ".", "sizeof", "(", "self", ")", ")" ]

[ "Fill", "in", "all", "the", "cache", "information", ".", "This", "method", "is", "threadsafe", "in", "the", "sense", "that", "every", "caller", "will", "see", "the", "same", "state", "upon", "return", "and", "if", "the", "cache", "is", "already", "initialised", "it", "does", "no", "work", "." ]

[ "def", "_populate", "(", "self", ")", ":", "if", "self", ".", "loaded", ":", "return", "self", ".", "write_lock", ".", "acquire", "(", ")", "try", ":", "if", "self", ".", "loaded", ":", "return", "for", "app_name", "in", "settings", ".", "INSTALLED_APPS", ":", "if", "app_name", "in", "self", ".", "handled", ":", "continue", "self", ".", "load_app", "(", "app_name", ",", "True", ")", "if", "not", "self", ".", "nesting_level", ":", "for", "app_name", "in", "self", ".", "postponed", ":", "self", ".", "load_app", "(", "app_name", ")", "self", ".", "loaded", "=", "True", "finally", ":", "self", ".", "write_lock", ".", "release", "(", ")" ]

[]

[ "def", "difference_update", "(", "self", ",", "iterable", ":", "T", ".", "Iterable", "[", "_T", "]", ")", "->", "None", ":", "for", "item", "in", "iterable", ":", "self", ".", "discard", "(", "item", ")" ]

[ "Perform", "an", "SRV", "record", "lookup", "." ]

[ "def", "lookupService", "(", "name", ",", "timeout", "=", "None", ")", ":", "return", "getResolver", "(", ")", ".", "lookupService", "(", "name", ",", "timeout", ")" ]

[ "Signs", "a", "claims", "set", "and", "returns", "a", "JWS", "string", "." ]

[ "def", "sign", "(", "payload", ",", "key", ",", "headers", "=", "None", ",", "algorithm", "=", "ALGORITHMS", ".", "HS256", ")", ":", "if", "algorithm", "not", "in", "ALGORITHMS", ".", "SUPPORTED", ":", "raise", "JWSError", "(", "\"Algorithm %s not supported.\"", "%", "algorithm", ")", "encoded_header", "=", "_encode_header", "(", "algorithm", ",", "additional_headers", "=", "headers", ")", "encoded_payload", "=", "_encode_payload", "(", "payload", ")", "signed_output", "=", "_sign_header_and_claims", "(", "encoded_header", ",", "encoded_payload", ",", "algorithm", ",", "key", ")", "return", "signed_output" ]

[]

[ "def", "__init__", "(", "self", ",", "max_active_size", ":", "int", "=", "5000000", ")", ":", "self", ".", "max_active_size", "=", "max_active_size", "self", ".", "queue", ":", "Deque", "[", "QueueTuple", "]", "=", "deque", "(", ")", "self", ".", "active", ":", "Set", "[", "Request", "]", "=", "set", "(", ")", "self", ".", "active_size", ":", "int", "=", "0", "self", ".", "itemproc_size", ":", "int", "=", "0", "self", ".", "closing", ":", "Optional", "[", "Deferred", "]", "=", "None" ]

[ "Remove", "component", "parameter", "variable", "input", "function" ]

[ "def", "remove", "(", "self", ",", "obj", ")", ":", "self", ".", "trans_gen", ".", "modelspec", ".", "remove", "(", "obj", ")", "self", ".", "changelog", ".", "append", "(", "common", ".", "args", "(", "action", "=", "'remove'", ",", "target", "=", "obj", ".", "name", ")", ")" ]

[ "For", "print", "and", "pprint" ]

[ "def", "__repr__", "(", "self", ")", ":", "return", "self", ".", "to_str", "(", ")" ]

[ "tag_strlen", "(", "line", ")", "-", ">", "ssize_t" ]

[ "def", "tag_strlen", "(", "*", "args", ")", ":", "return", "_idaapi", ".", "tag_strlen", "(", "*", "args", ")" ]

[ "Return", "a", "set", "of", "node", "names", "." ]

[ "def", "get_nodes", "(", "self", ")", ":", "if", "self", ".", "nodes", "is", "None", ":", "self", ".", "_build_nodes", "(", ")", "return", "self", ".", "nodes", ".", "keys", "(", ")" ]

[ "Horizontally", "stack", "two", "L", "{", "TensorType", "}", "s", "." ]

[ "def", "horizontal_stack", "(", "*", "args", ")", ":", "# Note: 'horizontal_stack' and 'vertical_stack' do not behave exactly like", "# Numpy's hstack and vstack functions. This is intended, because Numpy's", "# functions have potentially confusing/incoherent behavior (try them on 1D", "# arrays). If this is fixed in a future version of Numpy, it may be worth", "# trying to get closer to Numpy's way of doing things. In the meantime,", "# better keep different names to emphasize the implementation divergences.", "assert", "len", "(", "args", ")", ">=", "2", "for", "arg", "in", "args", ":", "assert", "arg", ".", "type", ".", "ndim", "==", "2", "return", "concatenate", "(", "args", ",", "axis", "=", "1", ")" ]

[ "monitor", "()", "-", "Main", "function", "...", "creates", "and", "starts", "threads" ]

[ "def", "monitor", "(", ")", ":", "import", "argparse", "parser", "=", "argparse", ".", "ArgumentParser", "(", ")", "parser", ".", "add_argument", "(", "\"-v\"", ",", "\"--verbose\"", ",", "help", "=", "\"more verbose\"", ",", "action", "=", "\"store_true\"", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "level", "=", "logging", ".", "INFO", "if", "args", ".", "verbose", ":", "level", "=", "logging", ".", "DEBUG", "#logging to both stdout and file", "file_handler", "=", "logging", ".", "FileHandler", "(", "log_file", ")", "handlers", "=", "[", "file_handler", "]", "if", "PRINT_LOG", ":", "stdout_handler", "=", "logging", ".", "StreamHandler", "(", "sys", ".", "stdout", ")", "handlers", ".", "append", "(", "stdout_handler", ")", "logging", ".", "basicConfig", "(", "level", "=", "level", ",", "format", "=", "'%(asctime)s [%(levelname)s] %(message)s'", ",", "handlers", "=", "handlers", ")", "logging", ".", "info", "(", "'Monitoring...'", ")", "paste_lock", "=", "threading", ".", "Lock", "(", ")", "pastebin_thread", "=", "threading", ".", "Thread", "(", "target", "=", "Pastebin", "(", ")", ".", "monitor", ",", "args", "=", "[", "paste_lock", "]", ")", "# changed threading to not be in a for loop", "# we're only monitoring one site now - Moe", "pastebin_thread", ".", "daemon", "=", "True", "pastebin_thread", ".", "start", "(", ")", "# Let threads run", "try", ":", "while", "(", "1", ")", ":", "sleep", "(", "5", ")", "except", "KeyboardInterrupt", ":", "logging", ".", "warning", "(", "'Stopped.'", ")" ]

[ "r", "Return", "the", "Higman", "-", "Sims", "graph", "." ]

[ "def", "HigmanSimsGraph", "(", "relabel", "=", "True", ")", ":", "HS", "=", "Graph", "(", ")", "HS", ".", "name", "(", "'Higman-Sims graph'", ")", "# Four groups of either five pentagons, or five pentagrams 4 x 5 x 5 = 100", "# vertices", "# First digit is \"group\", second is \"penta{gon|gram}\", third is \"vertex\"", "vlist", "=", "[", "'%d%d%d'", "%", "(", "g", ",", "p", ",", "v", ")", "for", "g", "in", "range", "(", "4", ")", "for", "p", "in", "range", "(", "5", ")", "for", "v", "in", "range", "(", "5", ")", "]", "HS", ".", "add_vertices", "(", "vlist", ")", "# Edges: Within groups 0 and 2, joined as pentagons", "# Edges: Within groups 1 and 3, joined as pentagrams", "for", "g", "in", "range", "(", "4", ")", ":", "shift", "=", "1", "if", "g", "in", "[", "1", ",", "3", "]", ":", "shift", "+=", "1", "for", "p", "in", "range", "(", "5", ")", ":", "for", "v", "in", "range", "(", "5", ")", ":", "HS", ".", "add_edge", "(", "(", "'%d%d%d'", "%", "(", "g", ",", "p", ",", "v", ")", ",", "'%d%d%d'", "%", "(", "g", ",", "p", ",", "(", "v", "+", "shift", ")", "%", "5", ")", ")", ")", "# Edges: group 0 to group 1", "for", "x", "in", "range", "(", "5", ")", ":", "for", "m", "in", "range", "(", "5", ")", ":", "for", "c", "in", "range", "(", "5", ")", ":", "y", "=", "(", "m", "*", "x", "+", "c", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'0%d%d'", "%", "(", "x", ",", "y", ")", ",", "'1%d%d'", "%", "(", "m", ",", "c", ")", ")", ")", "# Edges: group 1 to group 2", "for", "m", "in", "range", "(", "5", ")", ":", "for", "A", "in", "range", "(", "5", ")", ":", "for", "B", "in", "range", "(", "5", ")", ":", "c", "=", "(", "2", "*", "(", "m", "-", "A", ")", "*", "(", "m", "-", "A", ")", "+", "B", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'1%d%d'", "%", "(", "m", ",", "c", ")", ",", "'2%d%d'", "%", "(", "A", ",", "B", ")", ")", ")", "# Edges: group 2 to group 3", "for", "A", "in", "range", "(", "5", ")", ":", "for", "a", "in", "range", "(", "5", ")", ":", "for", "b", "in", "range", "(", "5", ")", ":", "B", "=", "(", "2", "*", "A", "*", "A", "+", "3", "*", "a", "*", "A", "-", "a", "*", "a", "+", "b", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'2%d%d'", "%", "(", "A", ",", "B", ")", ",", "'3%d%d'", "%", "(", "a", ",", "b", ")", ")", ")", "# Edges: group 3 to group 0", "for", "a", "in", "range", "(", "5", ")", ":", "for", "b", "in", "range", "(", "5", ")", ":", "for", "x", "in", "range", "(", "5", ")", ":", "y", "=", "(", "(", "x", "-", "a", ")", "*", "(", "x", "-", "a", ")", "+", "b", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'3%d%d'", "%", "(", "a", ",", "b", ")", ",", "'0%d%d'", "%", "(", "x", ",", "y", ")", ")", ")", "# Edges: group 0 to group 2", "for", "x", "in", "range", "(", "5", ")", ":", "for", "A", "in", "range", "(", "5", ")", ":", "for", "B", "in", "range", "(", "5", ")", ":", "y", "=", "(", "3", "*", "x", "*", "x", "+", "A", "*", "x", "+", "B", "+", "1", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'0%d%d'", "%", "(", "x", ",", "y", ")", ",", "'2%d%d'", "%", "(", "A", ",", "B", ")", ")", ")", "y", "=", "(", "3", "*", "x", "*", "x", "+", "A", "*", "x", "+", "B", "-", "1", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'0%d%d'", "%", "(", "x", ",", "y", ")", ",", "'2%d%d'", "%", "(", "A", ",", "B", ")", ")", ")", "# Edges: group 1 to group 3", "for", "m", "in", "range", "(", "5", ")", ":", "for", "a", "in", "range", "(", "5", ")", ":", "for", "b", "in", "range", "(", "5", ")", ":", "c", "=", "(", "m", "*", "(", "m", "-", "a", ")", "+", "b", "+", "2", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'1%d%d'", "%", "(", "m", ",", "c", ")", ",", "'3%d%d'", "%", "(", "a", ",", "b", ")", ")", ")", "c", "=", "(", "m", "*", "(", "m", "-", "a", ")", "+", "b", "-", "2", ")", "%", "5", "HS", ".", "add_edge", "(", "(", "'1%d%d'", "%", "(", "m", ",", "c", ")", ",", "'3%d%d'", "%", "(", "a", ",", "b", ")", ")", ")", "# Layout vertices in a circle, in the order given in vlist", "HS", ".", "_circle_embedding", "(", "vlist", ",", "radius", "=", "10", ",", "angle", "=", "pi", "/", "2", ")", "if", "relabel", ":", "HS", ".", "relabel", "(", "range", "(", "100", ")", ")", "return", "HS" ]

[]

[ "def", "visit_mypy_file", "(", "self", ",", "o", ":", "'mypy.nodes.MypyFile'", ")", "->", "T", ":", "# Skip some stdlib stuff. A lot of it is brought in by 'import", "# typing'.", "if", "o", ".", "fullname", "(", ")", "in", "(", "'__future__'", ",", "'sys'", ",", "'types'", ",", "'typing'", ",", "'abc'", ",", "'_ast'", ",", "'ast'", ",", "'_weakrefset'", ",", "'collections'", ",", "'cStringIO'", ",", "'re'", ",", "'builtins'", ")", ":", "# These module are special; their contents are currently all", "# built-in primitives.", "return", "self", ".", "log", "(", "''", ")", "self", ".", "log", "(", "'mypyfile %s'", ",", "o", ".", "fullname", "(", ")", ")", "self", ".", "module_path", "=", "o", ".", "path", "self", ".", "indent", "+=", "1", "for", "node", "in", "o", ".", "defs", ":", "self", ".", "accept", "(", "node", ")", "self", ".", "indent", "-=", "1" ]

[]

[ "def", "_widen_jobs", "(", "self", ",", "*", "jobs", ")", ":", "job_0", ",", "job_1", "=", "jobs", "[", "-", "2", ":", "]", "# type: VFGJob", "# update jobs", "for", "job", "in", "jobs", ":", "if", "job", "in", "self", ".", "_top_function_analysis_task", ".", "jobs", ":", "self", ".", "_top_function_analysis_task", ".", "jobs", ".", "remove", "(", "job", ")", "l", ".", "debug", "(", "\"Widening %s\"", ",", "job_1", ")", "new_state", ",", "_", "=", "self", ".", "_widen_states", "(", "job_0", ".", "state", ",", "job_1", ".", "state", ")", "# print \"job_0.state.eax =\", job_0.state.regs.eax._model_vsa, \"job_1.state.eax =\", job_1.state.regs.eax._model_vsa", "# print \"new_job.state.eax =\", new_state.regs.eax._model_vsa", "new_job", "=", "VFGJob", "(", "jobs", "[", "0", "]", ".", "addr", ",", "new_state", ",", "self", ".", "_context_sensitivity_level", ",", "jumpkind", "=", "jobs", "[", "0", "]", ".", "jumpkind", ",", "block_id", "=", "jobs", "[", "0", "]", ".", "block_id", ",", "call_stack", "=", "jobs", "[", "0", "]", ".", "call_stack", ",", "src_block_id", "=", "jobs", "[", "0", "]", ".", "src_block_id", ",", "src_exit_stmt_idx", "=", "jobs", "[", "0", "]", ".", "src_exit_stmt_idx", ",", "src_ins_addr", "=", "jobs", "[", "0", "]", ".", "src_ins_addr", ",", ")", "self", ".", "_top_function_analysis_task", ".", "jobs", ".", "append", "(", "new_job", ")", "return", "new_job" ]

[ "Copy", "drivers", "sections", "from", "this", "xml", "state", "to", "the", "target", "xml", "state" ]

[ "def", "copy_drivers_sections", "(", "self", ",", "target_state", ":", "Any", ")", "->", "None", ":", "drivers_sections", "=", "self", ".", "_profiled", "(", "self", ".", "xml_data", ".", "get_drivers", "(", ")", ")", "if", "drivers_sections", ":", "for", "drivers_section", "in", "drivers_sections", ":", "target_state", ".", "xml_data", ".", "add_drivers", "(", "drivers_section", ")" ]

[ "Grab", "the", "user", "age", "from", "the", "DOM" ]

[ "def", "grab_age", "(", "self", ")", ":", "age", "=", "\"Unknown\"", "try", ":", "age1", "=", "self", ".", "soup2", ".", "find", "(", "'span'", ",", "{", "'class'", ":", "'content-value'", "}", ")", "age2", "=", "\" \"", ".", "join", "(", "str", "(", "age1", ")", ".", "split", "(", ")", ")", "age", "=", "age2", ".", "split", "(", "\">\"", ")", "[", "1", "]", ".", "split", "(", "\"<\"", ")", "[", "0", "]", ".", "split", "(", ")", "[", "1", "]", "print", "(", "(", "\" [\"", "+", "bc", ".", "CGRN", "+", "\"+\"", "+", "bc", ".", "CEND", "+", "\"] \"", "+", "bc", ".", "CRED", "+", "\"Age: \"", "+", "bc", ".", "CEND", "+", "\"%s\"", ")", "%", "(", "age", ")", ")", "except", "Exception", "as", "e", ":", "print", "(", "e", ")", "finally", ":", "return", "age" ]

[ "gets", "the", "default", "value", "of", "--", "max", "-", "worker", "-", "restart", "option", "if", "it", "is", "not", "provided", "." ]

[ "def", "get_default_max_worker_restart", "(", "config", ")", ":", "result", "=", "config", ".", "option", ".", "maxworkerrestart", "if", "result", "is", "not", "None", ":", "result", "=", "int", "(", "result", ")", "elif", "config", ".", "option", ".", "numprocesses", ":", "# if --max-worker-restart was not provided, use a reasonable default (#226)", "result", "=", "config", ".", "option", ".", "numprocesses", "*", "4", "return", "result" ]

[ "Modifies", "a", "GDataService", "object", "to", "allow", "it", "to", "run", "on", "App", "Engine", "." ]

[ "def", "run_on_appengine", "(", "gdata_service", ",", "store_tokens", "=", "True", ",", "single_user_mode", "=", "False", ",", "deadline", "=", "None", ")", ":", "gdata_service", ".", "http_client", "=", "AppEngineHttpClient", "(", "deadline", "=", "deadline", ")", "gdata_service", ".", "token_store", "=", "AppEngineTokenStore", "(", ")", "gdata_service", ".", "auto_store_tokens", "=", "store_tokens", "gdata_service", ".", "auto_set_current_token", "=", "single_user_mode", "return", "gdata_service" ]

[ "login", "using", "given", "username", "and", "password" ]

[ "def", "login", "(", "self", ")", ":", "data", "=", "{", "'username'", ":", "self", ".", "user", ",", "'password'", ":", "self", ".", "passwd", "}", "data_encoded", "=", "json", ".", "dumps", "(", "data", ")", "try", ":", "r_post", "=", "requests", ".", "post", "(", "url", "=", "'https://api.zoomeye.org/user/login'", ",", "data", "=", "data_encoded", ",", "timeout", "=", "30", ")", "r_decoded", "=", "json", ".", "loads", "(", "r_post", ".", "text", ")", "return", "r_decoded", "[", "'access_token'", "]", "except", "requests", ".", "exceptions", ".", "RequestException", "as", "exc", ":", "console", ".", "print_error", "(", "f\"Login error: request failed: {exc}\"", ")", "return", "\"\"", "except", "KeyError", ":", "console", ".", "print_error", "(", "f\"Login error: {r_post.status_code}: {r_post.text}\"", ")", "return", "\"\"", "except", "KeyboardInterrupt", ":", "return", "\"\"", "except", "BaseException", ":", "console", ".", "debug_except", "(", ")" ]

[ "gnt", "-", "cluster", "command" ]

[ "def", "TestClusterCommand", "(", ")", ":", "uniqueid", "=", "utils", ".", "NewUUID", "(", ")", "rfile", "=", "\"/tmp/gnt%s\"", "%", "utils", ".", "NewUUID", "(", ")", "rcmd", "=", "utils", ".", "ShellQuoteArgs", "(", "[", "\"echo\"", ",", "\"-n\"", ",", "uniqueid", "]", ")", "cmd", "=", "utils", ".", "ShellQuoteArgs", "(", "[", "\"gnt-cluster\"", ",", "\"command\"", ",", "\"%s >%s\"", "%", "(", "rcmd", ",", "rfile", ")", "]", ")", "try", ":", "AssertCommand", "(", "cmd", ")", "_CheckFileOnAllNodes", "(", "rfile", ",", "uniqueid", ")", "finally", ":", "_RemoveFileFromAllNodes", "(", "rfile", ")" ]

[ "simpleGUI", "-", "shortner", "for", "textArea", "()" ]

[ "def", "text", "(", "self", ",", "title", ",", "value", "=", "None", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "textArea", "(", "title", ",", "value", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Extract", "nev", "header", "information", "from", "a", "2", ".", "1", ".", "nev", "file" ]

[ "def", "__read_nev_header_variant_a", "(", "self", ")", ":", "ext_header_variants", "=", "{", "b'NEUEVWAV'", ":", "'a'", ",", "b'ARRAYNME'", ":", "'a'", ",", "b'ECOMMENT'", ":", "'a'", ",", "b'CCOMMENT'", ":", "'a'", ",", "b'MAPFILE'", ":", "'a'", ",", "b'NSASEXEV'", ":", "'a'", "}", "return", "self", ".", "__read_nev_header", "(", "ext_header_variants", ")" ]

[ "retrieves", "the", "alert", "policy", "id", "of", "the", "account", "based", "on", "the", "name", "of", "the", "policy", ":", "param", "module", ":", "the", "AnsibleModule", "object", ":", "param", "alert_policy_name", ":", "the", "alert", "policy", "name", ":", "return", ":", "alert_policy_id", ":", "The", "alert", "policy", "id" ]

[ "def", "_get_alert_policy_id", "(", "self", ",", "module", ",", "alert_policy_name", ")", ":", "alert_policy_id", "=", "None", "for", "policy_id", "in", "self", ".", "policy_dict", ":", "if", "self", ".", "policy_dict", ".", "get", "(", "policy_id", ")", ".", "get", "(", "'name'", ")", "==", "alert_policy_name", ":", "if", "not", "alert_policy_id", ":", "alert_policy_id", "=", "policy_id", "else", ":", "return", "module", ".", "fail_json", "(", "msg", "=", "'multiple alert policies were found with policy name : %s'", "%", "alert_policy_name", ")", "return", "alert_policy_id" ]

[ "Rewrite", "the", "given", "LLVM", "module", "to", "use", "fastmath", "everywhere", "." ]

[ "def", "rewrite_module", "(", "mod", ",", "options", ")", ":", "flags", "=", "options", ".", "flags", "FastFloatBinOpVisitor", "(", "flags", ")", ".", "visit", "(", "mod", ")", "FastFloatCallVisitor", "(", "flags", ")", ".", "visit", "(", "mod", ")" ]

[ "Sends", "the", "device", "a", "miscellaneous", "command", "or", "query", "and", "/", "or", "retrieves", "the", "response", "to", "a", "previous", "query", "." ]

[ "def", "vxi_command_query", "(", "self", ",", "session", ",", "mode", ",", "command", ")", ":", "response", "=", "Types", ".", "UInt32", "(", ")", "self", ".", "lib", ".", "viVxiCommandQuery", "(", "session", ",", "mode", ",", "command", ",", "ct", ".", "byref", "(", "response", ")", ")", "return", "response", ".", "value" ]

[ "Class", "decorator", "for", "creating", "a", "class", "with", "a", "metaclass", "." ]

[ "def", "add_metaclass", "(", "metaclass", ")", ":", "def", "wrapper", "(", "cls", ")", ":", "orig_vars", "=", "cls", ".", "__dict__", ".", "copy", "(", ")", "slots", "=", "orig_vars", ".", "get", "(", "'__slots__'", ")", "if", "slots", "is", "not", "None", ":", "if", "isinstance", "(", "slots", ",", "str", ")", ":", "slots", "=", "[", "slots", "]", "for", "slots_var", "in", "slots", ":", "orig_vars", ".", "pop", "(", "slots_var", ")", "orig_vars", ".", "pop", "(", "'__dict__'", ",", "None", ")", "orig_vars", ".", "pop", "(", "'__weakref__'", ",", "None", ")", "if", "hasattr", "(", "cls", ",", "'__qualname__'", ")", ":", "orig_vars", "[", "'__qualname__'", "]", "=", "cls", ".", "__qualname__", "return", "metaclass", "(", "cls", ".", "__name__", ",", "cls", ".", "__bases__", ",", "orig_vars", ")", "return", "wrapper" ]

[ "Set", "a", "(", "reusable", ")", "drawing", "context", "and", "provide", "default", "values", "for", "the", "image", "and", "image", "size" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "super", "(", ")", ".", "__init__", "(", "*", "args", ",", "*", "*", "kwargs", ")", "CIContext", "=", "ObjCClass", "(", "'CIContext'", ")", "self", ".", "_ctx", "=", "CIContext", ".", "contextWithOptions_", "(", "None", ")", "ci_img", "=", "ObjCClass", "(", "'CIImage'", ")", ".", "imageWithContentsOfURL_", "(", "nsurl", "(", "'photosplash.png'", ")", ")", "self", ".", "rect", "=", "CGRect", "(", "(", "0.0", ",", "0.0", ")", ",", "(", "640", ",", "427", ")", ")", "self", ".", "ci_img", "=", "ci_img" ]

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

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

[ "Log", "a", "scalar", "variable", "." ]

[ "def", "scalar_summary", "(", "self", ",", "tag", ",", "value", ",", "step", ")", ":", "summary", "=", "tf", ".", "Summary", "(", "value", "=", "[", "tf", ".", "Summary", ".", "Value", "(", "tag", "=", "tag", ",", "simple_value", "=", "value", ")", "]", ")", "self", ".", "writer", ".", "add_summary", "(", "summary", ",", "step", ")" ]

[ "Return", "the", "suffix", "code", "for", "the", "given", "word", ".", "Consider", "a", "suffix", "of", "the", "given", "size", "." ]

[ "def", "get_suffix", "(", "cls", ",", "word", ",", "size", ")", ":", "if", "word", "==", "WD", ".", "padding_left", "or", "word", "==", "WD", ".", "padding_right", ":", "return", "cls", ".", "padding", "if", "len", "(", "word", ")", "<=", "size", ":", "return", "cls", ".", "other", "suffix", "=", "word", "[", "-", "size", ":", "]", ".", "lower", "(", ")", "code", "=", "cls", ".", "suffix_codes", "[", "size", "]", ".", "get", "(", "suffix", ",", "cls", ".", "other", ")", "return", "code" ]

[]

[ "def", "get_score", "(", ")", ":", "res", "=", "http", "(", "'get'", ",", "flag_server", ",", "8080", ",", "'/score.php?key=%s'", "%", "key", ",", "''", ",", "headers", ")", "print", "res", "user_scores", "=", "res", ".", "split", "(", "'|'", ")", "print", "\"******************************************************************\"", "res", "=", "''", "i", "=", "0", "for", "user_score", "in", "user_scores", ":", "res", "+=", "(", "user_id", "[", "i", "]", "+", "\":\"", "+", "user_score", ")", ".", "ljust", "(", "20", ",", "'*'", ")", "i", "+=", "1", "print", "res", "print", "\"******************************************************************\"", "return", "user_scores" ]

[ "Set", "parameters", "manually" ]

[ "def", "set_parameters", "(", "self", ",", "t", ",", "phi", ",", "rotation_center", "=", "None", ")", ":", "self", ".", "_t_x", "=", "Parameter", "(", "th", ".", "tensor", "(", "t", "[", "0", "]", ")", ".", "to", "(", "dtype", "=", "self", ".", "_dtype", ",", "device", "=", "self", ".", "_device", ")", ")", "self", ".", "_t_y", "=", "Parameter", "(", "th", ".", "tensor", "(", "t", "[", "1", "]", ")", ".", "to", "(", "dtype", "=", "self", ".", "_dtype", ",", "device", "=", "self", ".", "_device", ")", ")", "self", ".", "_phi_z", "=", "Parameter", "(", "th", ".", "tensor", "(", "phi", "[", "0", "]", ")", ".", "to", "(", "dtype", "=", "self", ".", "_dtype", ",", "device", "=", "self", ".", "_device", ")", ")", "if", "rotation_center", "is", "not", "None", ":", "self", ".", "_center_mass_x", "=", "rotation_center", "[", "0", "]", "self", ".", "_center_mass_y", "=", "rotation_center", "[", "1", "]", "if", "len", "(", "t", ")", "==", "2", ":", "self", ".", "_compute_transformation_2d", "(", ")", "else", ":", "self", ".", "_t_z", "=", "Parameter", "(", "th", ".", "tensor", "(", "t", "[", "2", "]", ")", ".", "to", "(", "dtype", "=", "self", ".", "_dtype", ",", "device", "=", "self", ".", "_device", ")", ")", "self", ".", "_phi_x", "=", "Parameter", "(", "th", ".", "tensor", "(", "phi", "[", "1", "]", ")", ".", "to", "(", "dtype", "=", "self", ".", "_dtype", ",", "device", "=", "self", ".", "_device", ")", ")", "self", ".", "_phi_y", "=", "Parameter", "(", "th", ".", "tensor", "(", "phi", "[", "2", "]", ")", ".", "to", "(", "dtype", "=", "self", ".", "_dtype", ",", "device", "=", "self", ".", "_device", ")", ")", "if", "rotation_center", "is", "not", "None", ":", "self", ".", "_center_mass_z", "=", "rotation_center", "[", "1", "]", "self", ".", "_compute_transformation_3d", "(", ")" ]

[ "Define", "the", "layout", "." ]

[ "def", "make_layout", "(", ")", "->", "Layout", ":", "layout", "=", "Layout", "(", "name", "=", "\"root\"", ")", "layout", ".", "split", "(", "Layout", "(", "name", "=", "\"header\"", ",", "size", "=", "3", ")", ",", "Layout", "(", "name", "=", "\"main\"", ",", "ratio", "=", "1", ")", ",", "Layout", "(", "name", "=", "\"footer\"", ",", "size", "=", "7", ")", ",", ")", "layout", "[", "\"main\"", "]", ".", "split_row", "(", "Layout", "(", "name", "=", "\"side\"", ")", ",", "Layout", "(", "name", "=", "\"body\"", ",", "ratio", "=", "2", ",", "minimum_size", "=", "60", ")", ",", ")", "layout", "[", "\"side\"", "]", ".", "split", "(", "Layout", "(", "name", "=", "\"box1\"", ")", ",", "Layout", "(", "name", "=", "\"box2\"", ")", ")", "return", "layout" ]

[ "Create", "a", ":", "class", ":", "SequentialEventletHandler", "instance" ]

[ "def", "__init__", "(", "self", ")", ":", "self", ".", "callback_queue", "=", "self", ".", "queue_impl", "(", ")", "self", ".", "completion_queue", "=", "self", ".", "queue_impl", "(", ")", "self", ".", "_workers", "=", "[", "]", "self", ".", "_started", "=", "False" ]

[ "Configure", "the", "stdio", "StreamHandler", "levels", "on", "the", "specified", "loggers", ".", "If", "no", "log", "configurations", "are", "specified", "then", "the", "default_level", "will", "be", "applied", "to", "all", "handlers", "." ]

[ "def", "config_stdio", "(", "self", ",", "log_configurations", ":", "Optional", "[", "List", "[", "LogConfiguration", "]", "]", "=", "None", ",", "default_level", "=", "logging", ".", "INFO", ")", "->", "None", ":", "# no configuration specified, apply `default_level` to the stdio handler of all known loggers", "if", "not", "log_configurations", ":", "for", "logger", "in", "self", ".", "loggers", ".", "values", "(", ")", ":", "self", ".", "_restrict_output", "(", "logger", ",", "default_level", ")", "# only apply specified configuration to the stdio `StreamHandler` of the specific component", "else", ":", "for", "component", ",", "level", "in", "log_configurations", ":", "try", ":", "logger", "=", "self", ".", "loggers", "[", "self", ".", "root", "+", "component", "]", "except", "KeyError", ":", "raise", "ValueError", "(", "\"Failed to configure component. Invalid name: {}\"", ".", "format", "(", "component", ")", ")", "self", ".", "_restrict_output", "(", "logger", ",", "level", ")" ]

[ "The", "browser", "will", "navigate", "to", "the", "previous", "URL", "in", "the", "history", "." ]

[ "def", "back", "(", "self", ")", ":", "raise", "NotImplementedError", "(", "\"%s doesn't support moving back in history.\"", "%", "self", ".", "driver_name", ")" ]

[ "A", "wrapper", "on", "the", "ovsdbapp", "transaction", "to", "work", "with", "revisions", "." ]

[ "def", "transaction", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "with", "super", "(", "OvsdbNbOvnIdl", ",", "self", ")", ".", "transaction", "(", "*", "args", ",", "*", "*", "kwargs", ")", "as", "t", ":", "yield", "t", "except", "ovn_exc", ".", "RevisionConflict", "as", "e", ":", "LOG", ".", "info", "(", "'Transaction aborted. Reason: %s'", ",", "e", ")" ]

[ "Construct", "feed", "dictionary", "." ]

[ "def", "construct_feed_dict", "(", "self", ",", "labels_mask", ")", ":", "feed_dict", "=", "dict", "(", ")", "feed_dict", ".", "update", "(", "{", "self", ".", "placeholders", "[", "'labels'", "]", ":", "self", ".", "labels", "}", ")", "feed_dict", ".", "update", "(", "{", "self", ".", "placeholders", "[", "'labels_mask'", "]", ":", "labels_mask", "}", ")", "feed_dict", ".", "update", "(", "{", "self", ".", "placeholders", "[", "'features'", "]", ":", "self", ".", "features", "}", ")", "feed_dict", ".", "update", "(", "{", "self", ".", "placeholders", "[", "'support'", "]", "[", "i", "]", ":", "self", ".", "support", "[", "i", "]", "for", "i", "in", "range", "(", "len", "(", "self", ".", "support", ")", ")", "}", ")", "feed_dict", ".", "update", "(", "{", "self", ".", "placeholders", "[", "'num_features_nonzero'", "]", ":", "self", ".", "features", "[", "1", "]", ".", "shape", "}", ")", "return", "feed_dict" ]

[ "Return", "any", "data", "available", "in", "the", "SB", "...", "SE", "queue", "." ]

[ "def", "read_sb_data", "(", "self", ")", ":", "buf", "=", "self", ".", "sbdataq", "self", ".", "sbdataq", "=", "b''", "return", "buf" ]

[ "initialize", "proxy", "filter" ]

[ "def", "__init__", "(", "self", ",", "parent", "=", "None", ")", ":", "super", "(", "CapaExplorerRangeProxyModel", ",", "self", ")", ".", "__init__", "(", "parent", ")", "self", ".", "min_ea", "=", "None", "self", ".", "max_ea", "=", "None" ]

[ "Creates", "an", "operator", "AST", "node", "from", "a", "parse", "result", "." ]

[ "def", "create", "(", "cls", ",", "parse_result", ")", ":", "cls", ".", "__converters__", "[", "\"negated\"", "]", "=", "lambda", "o", ":", "o", ".", "negated", "!=", "\"\"", "modifiers", "=", "dict", "(", "(", "name", ",", "cls", ".", "__converters__", "[", "name", "]", "(", "parse_result", ".", "operator", ")", ")", "for", "name", "in", "cls", ".", "__modifiers__", ")", "return", "cls", "(", "parse_result", ".", "leftOperand", ",", "parse_result", ".", "rightOperand", ",", "*", "*", "modifiers", ")" ]

[ "Sync", "using", "rsync", "a", "local", "folder", "to", "a", "remote", "folder", "on", "the", "server", "." ]

[ "def", "sync_folder", "(", "self", ",", "local_folder", ",", "remote_folder", ")", ":", "command", "=", "'rsync -Pa {0} {1}@{2}:{3}'", ".", "format", "(", "local_folder", ",", "self", ".", "username", ",", "self", ".", "server", ",", "remote_folder", ")", "self", ".", "local_command", "(", "command", "=", "command", ")" ]

[ "Tries", "to", "guess", "the", "filename", "of", "the", "given", "object", "." ]

[ "def", "guess_filename", "(", "obj", ")", ":", "name", "=", "getattr", "(", "obj", ",", "'name'", ",", "None", ")", "if", "(", "name", "and", "isinstance", "(", "name", ",", "basestring", ")", "and", "name", "[", "0", "]", "!=", "'<'", "and", "name", "[", "-", "1", "]", "!=", "'>'", ")", ":", "return", "os", ".", "path", ".", "basename", "(", "name", ")" ]

[ "Render", "the", "given", "content", "as", "template", "with", "the", "data", "dictionary", "." ]

[ "def", "render", "(", "self", ",", "content", ",", "data", ")", ":", "stache", "=", "Renderer", "(", "partials", "=", "self", ".", "_partials_loader", ")", "return", "stache", ".", "render", "(", "content", ",", "data", ")" ]