Datasets:

---

CM

/

codexglue_code2text_python

like 8

[ "def", "add_grouping", "(", "state_collection", ",", "grouping_name", ",", "loaded_processes", ",", "overriding_parameters", "=", "None", ")", ":", "if", "(", "grouping_name", "not", "in", "state_collection", ".", "groupings", "and", "loaded_processes", "!=", "None", "and", "loaded_processes", "[", "\"grouping_selector\"", "]", ".", "get", "(", "grouping_name", ")", "!=", "None", ")", ":", "state_collection", "=", "loaded_processes", "[", "\"grouping_selector\"", "]", "[", "grouping_name", "]", ".", "process_function", "(", "state_collection", ",", "overriding_parameters", ")", "return", "state_collection" ]

[ "Adds", "a", "grouping", "to", "a", "state", "collection", "by", "using", "the", "process", "selected", "by", "the", "grouping", "name", "Does", "not", "override", "existing", "groupings" ]

[ "def", "add_group_to_grouping", "(", "state_collection", ",", "grouping_name", ",", "group", ",", "group_key", "=", "None", ")", ":", "if", "state_collection", ".", "groupings", ".", "get", "(", "grouping_name", ")", "is", "None", ":", "state_collection", ".", "groupings", "[", "grouping_name", "]", "=", "{", "}", "if", "group_key", "is", "None", ":", "group_key", "=", "_next_lowest_integer", "(", "state_collection", ".", "groupings", "[", "grouping_name", "]", ".", "keys", "(", ")", ")", "state_collection", ".", "groupings", "[", "grouping_name", "]", "[", "group_key", "]", "=", "group", "return", "state_collection" ]

[ "Adds", "a", "group", "to", "the", "named", "grouping", "with", "a", "given", "group", "key" ]

[ "def", "_combined_grouping_values", "(", "grouping_name", ",", "collection_a", ",", "collection_b", ")", ":", "new_grouping", "=", "collection_a", ".", "groupings", ".", "get", "(", "grouping_name", ",", "{", "}", ")", ".", "copy", "(", ")", "new_grouping", ".", "update", "(", "collection_b", ".", "groupings", ".", "get", "(", "grouping_name", ",", "{", "}", ")", ")", "return", "new_grouping" ]

[ "returns", "a", "dict", "with", "values", "from", "both", "collections", "for", "a", "given", "grouping", "name" ]

[ "def", "_next_lowest_integer", "(", "group_keys", ")", ":", "try", ":", "#TODO Replace with max default value when dropping compatibility with Python < 3.4", "largest_int", "=", "max", "(", "[", "int", "(", "val", ")", "for", "val", "in", "group_keys", "if", "_is_int", "(", "val", ")", "]", ")", "except", ":", "largest_int", "=", "0", "return", "largest_int", "+", "1" ]

[ "returns", "the", "lowest", "available", "integer", "in", "a", "set", "of", "dict", "keys" ]

[ "def", "grant_user_access", "(", "self", ",", "uid", ",", "rid", ",", "expire_datetime", "=", "None", ",", "send_email", "=", "False", ")", ":", "path", "=", "\"/api/v3/publisher/user/access/grant\"", "# convert expire_date to gmt seconds", "if", "expire_datetime", ":", "expires_seconds", "=", "calendar", ".", "timegm", "(", "expires_datetime", ".", "timetuple", "(", ")", ")", "else", ":", "expires_seconds", "=", "calendar", ".", "timegm", "(", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "timetuple", "(", ")", ")", "+", "(", "60", "*", "60", "*", "24", ")", "data", "=", "{", "'api_token'", ":", "self", ".", "api_token", ",", "'aid'", ":", "self", ".", "app_id", ",", "'rid'", ":", "rid", ",", "'uid'", ":", "uid", ",", "'expire_date'", ":", "expires_seconds", ",", "'send_email'", ":", "send_email", ",", "}", "r", "=", "requests", ".", "get", "(", "self", ".", "base_url", "+", "path", ",", "data", "=", "data", ")", "if", "r", ".", "status_code", "!=", "200", ":", "raise", "ValueError", "(", "path", "+", "\":\"", "+", "r", ".", "reason", ")" ]

[ "Takes", "a", "user", "id", "and", "resource", "id", "and", "records", "a", "grant", "of", "access", "to", "that", "reseource", "for", "the", "user", ".", "If", "no", "expire_date", "is", "set", "we", "ll", "default", "to", "24", "hours", ".", "If", "send_email", "is", "set", "to", "True", "Tinypass", "will", "send", "an", "email", "related", "to", "the", "grant", ".", "No", "return", "value", "raises", "ValueError", "." ]

[ "def", "revoke_user_access", "(", "self", ",", "access_id", ")", ":", "path", "=", "\"/api/v3/publisher/user/access/revoke\"", "data", "=", "{", "'api_token'", ":", "self", ".", "api_token", ",", "'access_id'", ":", "access_id", ",", "}", "r", "=", "requests", ".", "get", "(", "self", ".", "base_url", "+", "path", ",", "data", "=", "data", ")", "if", "r", ".", "status_code", "!=", "200", ":", "raise", "ValueError", "(", "path", "+", "\":\"", "+", "r", ".", "reason", ")" ]

[ "Takes", "an", "access_id", "probably", "obtained", "from", "the", "get_access_list", "structure", "and", "revokes", "that", "access", ".", "No", "return", "value", "but", "may", "raise", "ValueError", "." ]

[ "def", "process", "(", "self", ")", ":", "for", "filename", ",", "warnings", "in", "self", ".", "warnings", ".", "iteritems", "(", ")", ":", "self", ".", "fileCounts", "[", "filename", "]", "=", "{", "}", "fc", "=", "self", ".", "fileCounts", "[", "filename", "]", "fc", "[", "\"warning_count\"", "]", "=", "len", "(", "warnings", ")", "fc", "[", "\"warning_breakdown\"", "]", "=", "self", ".", "_warnCount", "(", "warnings", ")", "self", ".", "warningCounts", "=", "self", ".", "_warnCount", "(", "warnings", ",", "warningCount", "=", "self", ".", "warningCounts", ")" ]

[ "Process", "the", "warnings", "." ]

[ "def", "deliverTextResults", "(", "self", ")", ":", "output", "=", "\"=======================\\ntxctools Hotspot Report\\n\"", "\"=======================\\n\\n\"", "fileResults", "=", "sorted", "(", "self", ".", "fileCounts", ".", "items", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", "[", "\"warning_count\"", "]", ",", "reverse", "=", "True", ")", "output", "+=", "\"Warnings per File\\n=================\\n\"", "count", "=", "0", "for", "item", "in", "fileResults", ":", "count", "+=", "1", "output", "+=", "\"#%s - %s - %s\\n\"", "%", "(", "count", ",", "item", "[", "0", "]", ",", "item", "[", "1", "]", "[", "\"warning_count\"", "]", ")", "output", "+=", "\"\\nWarnings Breakdown\\n==================\\n\"", "count", "=", "0", "warningCount", "=", "0", "warningResults", "=", "sorted", "(", "self", ".", "warningCounts", ".", "items", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", "[", "\"count\"", "]", ",", "reverse", "=", "True", ")", "for", "item", "in", "warningResults", ":", "warningCount", "+=", "item", "[", "1", "]", "[", "\"count\"", "]", "for", "warning", ",", "winfo", "in", "warningResults", ":", "count", "+=", "1", "output", "+=", "\"#%s - %s - %s (%s%%) - %s\\n\"", "%", "(", "count", ",", "warning", ",", "winfo", "[", "\"count\"", "]", ",", "int", "(", "winfo", "[", "\"count\"", "]", "/", "warningCount", "*", "100", ")", ",", "tools", ".", "cleanupMessage", "(", "warning", ",", "winfo", ")", ")", "return", "output" ]

[ "Deliver", "the", "results", "in", "a", "pretty", "text", "output", "." ]

[ "def", "_warnCount", "(", "self", ",", "warnings", ",", "warningCount", "=", "None", ")", ":", "if", "not", "warningCount", ":", "warningCount", "=", "{", "}", "for", "warning", "in", "warnings", ":", "wID", "=", "warning", "[", "\"warning_id\"", "]", "if", "not", "warningCount", ".", "get", "(", "wID", ")", ":", "warningCount", "[", "wID", "]", "=", "{", "}", "warningCount", "[", "wID", "]", "[", "\"count\"", "]", "=", "1", "warningCount", "[", "wID", "]", "[", "\"message\"", "]", "=", "warning", ".", "get", "(", "\"warning_message\"", ")", "else", ":", "warningCount", "[", "wID", "]", "[", "\"count\"", "]", "+=", "1", "return", "warningCount" ]

[ "Calculate", "the", "count", "of", "each", "warning", "being", "given", "a", "list", "of", "them", "." ]

[ "def", "list_", "(", "self", ")", ":", "with", "self", ".", "lock", ":", "self", ".", "send", "(", "'LIST'", ")", "list_", "=", "{", "}", "while", "self", ".", "readable", "(", ")", ":", "msg", "=", "self", ".", "_recv", "(", "expected_replies", "=", "(", "'322'", ",", "'321'", ",", "'323'", ")", ")", "if", "msg", "[", "0", "]", "==", "'322'", ":", "channel", ",", "usercount", ",", "modes", ",", "topic", "=", "msg", "[", "2", "]", ".", "split", "(", "' '", ",", "3", ")", "modes", "=", "modes", ".", "replace", "(", "':'", ",", "''", ",", "1", ")", ".", "replace", "(", "':'", ",", "''", ",", "1", ")", "modes", "=", "modes", ".", "replace", "(", "'['", ",", "''", ")", ".", "replace", "(", "']'", ",", "''", ")", ".", "replace", "(", "'+'", ",", "''", ")", "list_", "[", "channel", "]", "=", "usercount", ",", "modes", ",", "topic", "elif", "msg", "[", "0", "]", "==", "'321'", ":", "pass", "elif", "msg", "[", "0", "]", "==", "'323'", ":", "break", "return", "list_" ]

[ "Gets", "a", "list", "of", "channels", "on", "the", "server", "." ]

[ "def", "servers_with_roles", "(", "self", ",", "roles", ",", "env", "=", "None", ",", "match_all", "=", "False", ")", ":", "result", "=", "[", "]", "roles", "=", "set", "(", "roles", ")", "for", "instance", "in", "self", ".", "server_details", "(", ")", ":", "instroles", "=", "set", "(", "instance", "[", "'roles'", "]", ")", "envmatches", "=", "(", "env", "is", "None", ")", "or", "(", "instance", "[", "'environment'", "]", "==", "env", ")", "if", "envmatches", "and", "match_all", "and", "roles", "<=", "instroles", ":", "result", ".", "append", "(", "instance", ")", "elif", "envmatches", "and", "not", "match_all", "and", "len", "(", "roles", "&", "instroles", ")", ">", "0", ":", "result", ".", "append", "(", "instance", ")", "return", "result" ]

[ "Get", "servers", "with", "the", "given", "roles", ".", "If", "env", "is", "given", "then", "the", "environment", "must", "match", "as", "well", ".", "If", "match_all", "is", "True", "then", "only", "return", "servers", "who", "have", "all", "of", "the", "given", "roles", ".", "Otherwise", "return", "servers", "that", "have", "one", "or", "more", "of", "the", "given", "roles", "." ]

[ "def", "ips_with_roles", "(", "self", ",", "roles", ",", "env", "=", "None", ",", "match_all", "=", "False", ")", ":", "def", "func", "(", ")", ":", "return", "[", "s", "[", "'external_ip'", "]", "for", "s", "in", "self", ".", "servers_with_roles", "(", "roles", ",", "env", ",", "match_all", ")", "]", "return", "func" ]

[ "Returns", "a", "function", "that", "when", "called", "gets", "servers", "with", "the", "given", "roles", ".", "If", "env", "is", "given", "then", "the", "environment", "must", "match", "as", "well", ".", "If", "match_all", "is", "True", "then", "only", "return", "servers", "who", "have", "all", "of", "the", "given", "roles", ".", "Otherwise", "return", "servers", "that", "have", "one", "or", "more", "of", "the", "given", "roles", "." ]

[ "def", "create", "(", "spellchecker_cache_path", ")", ":", "user_dictionary", "=", "os", ".", "path", ".", "join", "(", "os", ".", "getcwd", "(", ")", ",", "\"DICTIONARY\"", ")", "user_words", "=", "read_dictionary_file", "(", "user_dictionary", ")", "valid_words", "=", "Dictionary", "(", "valid_words_set", "(", "user_dictionary", ",", "user_words", ")", ",", "\"valid_words\"", ",", "[", "user_dictionary", "]", ",", "spellchecker_cache_path", ")", "return", "(", "user_words", ",", "valid_words", ")" ]

[ "Create", "a", "Dictionary", "at", "spellchecker_cache_path", "with", "valid", "words", "." ]

[ "def", "process_event", "(", "self", ",", "event", ")", ":", "if", "not", "isinstance", "(", "event", ",", "KindleEvent", ")", ":", "pass", "elif", "isinstance", "(", "event", ",", "AddEvent", ")", ":", "self", ".", "_data", "[", "event", ".", "asin", "]", "=", "BookSnapshot", "(", "event", ".", "asin", ")", "elif", "isinstance", "(", "event", ",", "SetReadingEvent", ")", ":", "self", ".", "_data", "[", "event", ".", "asin", "]", ".", "status", "=", "ReadingStatus", ".", "CURRENT", "self", ".", "_data", "[", "event", ".", "asin", "]", ".", "progress", "=", "event", ".", "initial_progress", "elif", "isinstance", "(", "event", ",", "ReadEvent", ")", ":", "self", ".", "_data", "[", "event", ".", "asin", "]", ".", "progress", "+=", "event", ".", "progress", "elif", "isinstance", "(", "event", ",", "SetFinishedEvent", ")", ":", "self", ".", "_data", "[", "event", ".", "asin", "]", ".", "status", "=", "ReadingStatus", ".", "COMPLETED", "else", ":", "raise", "TypeError" ]

[ "Apply", "an", "event", "to", "the", "snapshot", "instance" ]

[ "def", "calc_update_events", "(", "self", ",", "asin_to_progress", ")", ":", "new_events", "=", "[", "]", "for", "asin", ",", "new_progress", "in", "asin_to_progress", ".", "iteritems", "(", ")", ":", "try", ":", "book_snapshot", "=", "self", ".", "get_book", "(", "asin", ")", "except", "KeyError", ":", "new_events", ".", "append", "(", "AddEvent", "(", "asin", ")", ")", "else", ":", "if", "book_snapshot", ".", "status", "==", "ReadingStatus", ".", "CURRENT", ":", "change", "=", "new_progress", "-", "book_snapshot", ".", "progress", "if", "change", ">", "0", ":", "new_events", ".", "append", "(", "ReadEvent", "(", "asin", ",", "change", ")", ")", "return", "new_events" ]

[ "Calculate", "and", "return", "an", "iterable", "of", "KindleEvent", "s", "which", "when", "applied", "to", "the", "current", "snapshot", "result", "in", "the", "the", "current", "snapshot", "reflecting", "the", "progress", "state", "of", "the", "asin_to_progress", "mapping", "." ]

[ "def", "_reset", "(", "self", ")", ":", "self", ".", "_filename", "=", "None", "self", ".", "_block_map", "=", "{", "}", "self", ".", "_ast", "=", "[", "]", "self", ".", "_ast", ".", "append", "(", "None", ")", "# header", "self", ".", "_ast", ".", "append", "(", "[", "]", ")", "# options list", "self", ".", "_ast", ".", "append", "(", "[", "]", ")" ]

[ "Rebuilds", "structure", "for", "AST", "and", "resets", "internal", "data", "." ]

[ "def", "_get_token", "(", "self", ",", "regex", "=", "None", ")", ":", "item", "=", "self", ".", "_lexer", ".", "get_token", "(", ")", "if", "not", "item", ":", "raise", "ParseError", "(", "u'Unexpected end of file'", ")", "else", ":", "line_no", ",", "token", "=", "item", "if", "regex", "and", "not", "regex", ".", "match", "(", "token", ")", ":", "pattern", "=", "u\"Unexpected format in token '{0}' on line {1}\"", "token_val", "=", "common", ".", "from_utf8", "(", "token", ".", "strip", "(", ")", ")", "raise", "ParseError", "(", "pattern", ".", "format", "(", "token_val", ",", "line_no", ")", ")", "return", "token" ]

[ "Consumes", "the", "next", "token", "in", "the", "token", "stream", "." ]

[ "def", "_lookahead_token", "(", "self", ",", "count", "=", "1", ")", ":", "stack", "=", "[", "]", "next_token", "=", "None", "# fetch the specified number of tokens ahead in stream", "while", "count", ">", "0", ":", "item", "=", "self", ".", "_lexer", ".", "get_token", "(", ")", "if", "not", "item", ":", "break", "stack", ".", "append", "(", "item", ")", "count", "-=", "1", "# store the latest token and push the tokens back on the", "# lexer stack so we don't consume them", "while", "stack", ":", "line_no", ",", "token", "=", "stack", ".", "pop", "(", ")", "if", "not", "next_token", ":", "next_token", "=", "token", "self", ".", "_lexer", ".", "push_token", "(", "line_no", ",", "token", ")", "return", "next_token" ]

[ "Peeks", "into", "the", "token", "stream", "up", "to", "the", "specified", "number", "of", "tokens", "without", "consuming", "any", "tokens", "from", "the", "stream", "." ]

[ "def", "_expect_token", "(", "self", ",", "expected", ")", ":", "item", "=", "self", ".", "_lexer", ".", "get_token", "(", ")", "if", "not", "item", ":", "raise", "ParseError", "(", "u'Unexpected end of file'", ")", "else", ":", "line_no", ",", "token", "=", "item", "if", "token", "!=", "expected", ":", "raise", "ParseError", "(", "u\"Unexpected token '{0}', \"", "u\"expecting '{1}' on line {2}\"", ".", "format", "(", "common", ".", "from_utf8", "(", "token", ".", "strip", "(", ")", ")", ",", "expected", ",", "line_no", ")", ")" ]

[ "Compares", "the", "next", "token", "in", "the", "stream", "to", "the", "specified", "token", "." ]

[ "def", "_expect_empty", "(", "self", ")", ":", "item", "=", "self", ".", "_lexer", ".", "get_token", "(", ")", "if", "item", ":", "line_no", ",", "token", "=", "item", "raise", "ParseError", "(", "u\"Unexpected token '{0}' on line {1}\"", ".", "format", "(", "common", ".", "from_utf8", "(", "token", ".", "strip", "(", ")", ")", ",", "line_no", ")", ")" ]

[ "Checks", "if", "the", "token", "stream", "is", "empty", "." ]

[ "def", "readstream", "(", "self", ",", "stream", ")", ":", "self", ".", "_reset", "(", ")", "try", ":", "# tokenize input stream", "self", ".", "_lexer", "=", "SettingLexer", "(", ")", "self", ".", "_lexer", ".", "readstream", "(", "stream", ")", "# parse tokens into AST", "self", ".", "_parse", "(", ")", "return", "True", "except", "IOError", ":", "self", ".", "_reset", "(", ")", "return", "False" ]

[ "Reads", "the", "specified", "stream", "and", "parses", "the", "token", "elements", "generated", "from", "tokenizing", "the", "input", "data", "." ]

[ "def", "write", "(", "self", ",", "filename", ",", "header", "=", "None", ")", ":", "origfile", "=", "self", ".", "_filename", "try", ":", "with", "open", "(", "filename", ",", "'w'", ")", "as", "_file", ":", "self", ".", "writestream", "(", "_file", ",", "header", ")", "self", ".", "_filename", "=", "filename", "return", "True", "except", "IOError", ":", "self", ".", "_filename", "=", "origfile", "return", "False" ]

[ "Writes", "the", "AST", "as", "a", "configuration", "file", "." ]

[ "def", "add_option", "(", "self", ",", "block", ",", "name", ",", "*", "values", ")", ":", "if", "not", "self", ".", "RE_NAME", ".", "match", "(", "name", ")", ":", "raise", "ValueError", "(", "u\"Invalid option name '{0}'\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "if", "not", "values", ":", "raise", "ValueError", "(", "u\"Must provide a value\"", ")", "else", ":", "values", "=", "list", "(", "values", ")", "if", "block", ":", "# block doesn't exist", "if", "not", "block", "in", "self", ".", "_block_map", ":", "raise", "ValueError", "(", "u\"Block '{0}' does not exist\"", ".", "format", "(", "common", ".", "from_utf8", "(", "block", ")", ")", ")", "# lookup block index and append", "block_idx", "=", "self", ".", "_block_map", "[", "block", "]", "# 0: block name, 1: option_list", "self", ".", "_ast", "[", "2", "]", "[", "block_idx", "]", "[", "1", "]", ".", "append", "(", "[", "name", ",", "values", "]", ")", "else", ":", "# non-block option", "self", ".", "_ast", "[", "1", "]", ".", "append", "(", "[", "name", ",", "values", "]", ")" ]

[ "Adds", "an", "option", "to", "the", "AST", "either", "as", "a", "non", "-", "block", "option", "or", "for", "an", "existing", "block", "." ]

[ "def", "remove_option", "(", "self", ",", "block", ",", "name", ")", ":", "if", "block", ":", "# block doesn't exist", "if", "not", "self", ".", "_ast", "or", "not", "block", "in", "self", ".", "_block_map", ":", "raise", "ValueError", "(", "u\"Block '{0}' does not exist\"", ".", "format", "(", "common", ".", "from_utf8", "(", "block", ")", ")", ")", "# lookup block index and remove", "block_idx", "=", "self", ".", "_block_map", "[", "block", "]", "for", "i", ",", "opt", "in", "enumerate", "(", "self", ".", "_ast", "[", "2", "]", "[", "block_idx", "]", "[", "1", "]", ")", ":", "if", "opt", "[", "0", "]", "==", "name", ":", "item_idx", "=", "i", "break", "else", ":", "raise", "ValueError", "(", "u\"Option '{0}' does not exist\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "# pop off the block option", "options", "=", "self", ".", "_ast", "[", "2", "]", "[", "block_idx", "]", "[", "1", "]", "options", ".", "pop", "(", "item_idx", ")", "else", ":", "if", "not", "self", ".", "_ast", ":", "raise", "ValueError", "(", "u\"Option '{0}' does not exist\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "# non-block option", "for", "i", ",", "opt", "in", "enumerate", "(", "self", ".", "_ast", "[", "1", "]", ")", ":", "if", "opt", "[", "0", "]", "==", "name", ":", "item_idx", "=", "i", "break", "else", ":", "raise", "ValueError", "(", "u\"Option '{0}' does not exist\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "# pop off non-block option", "self", ".", "_ast", "[", "1", "]", ".", "pop", "(", "item_idx", ")" ]

[ "Removes", "first", "matching", "option", "that", "exists", "from", "the", "AST", "." ]

[ "def", "add_block", "(", "self", ",", "name", ")", ":", "if", "not", "self", ".", "RE_NAME", ".", "match", "(", "name", ")", ":", "raise", "ValueError", "(", "u\"Invalid block name '{0}'\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "if", "name", "in", "self", ".", "_block_map", ":", "raise", "ValueError", "(", "u\"Block '{0}' already exists\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "# add new block and index mapping", "self", ".", "_block_map", "[", "name", "]", "=", "len", "(", "self", ".", "_ast", "[", "2", "]", ")", "# must come first", "option_list", "=", "[", "]", "block", "=", "[", "name", ",", "option_list", "]", "self", ".", "_ast", "[", "2", "]", ".", "append", "(", "block", ")" ]

[ "Adds", "a", "new", "block", "to", "the", "AST", "." ]

[ "def", "remove_block", "(", "self", ",", "name", ")", ":", "if", "not", "self", ".", "_ast", "or", "not", "name", "in", "self", ".", "_block_map", ":", "raise", "ValueError", "(", "u\"Block '{0}' does not exist\"", ".", "format", "(", "common", ".", "from_utf8", "(", "name", ")", ")", ")", "block_idx", "=", "self", ".", "_block_map", "[", "name", "]", "# remove block", "self", ".", "_ast", "[", "2", "]", ".", "pop", "(", "block_idx", ")", "del", "self", ".", "_block_map", "[", "name", "]" ]

[ "Removes", "an", "existing", "block", "from", "the", "AST", "." ]

[ "def", "init", "(", "db_url", ",", "alembic_ini", "=", "None", ",", "debug", "=", "False", ",", "create", "=", "False", ")", ":", "engine", "=", "create_engine", "(", "db_url", ",", "echo", "=", "debug", ")", "if", "create", ":", "BASE", ".", "metadata", ".", "create_all", "(", "engine", ")", "# This... \"causes problems\"", "#if db_url.startswith('sqlite:'):", "# def _fk_pragma_on_connect(dbapi_con, con_record):", "# dbapi_con.execute('pragma foreign_keys=ON')", "# sa.event.listen(engine, 'connect', _fk_pragma_on_connect)", "if", "alembic_ini", "is", "not", "None", ":", "# pragma: no cover", "# then, load the Alembic configuration and generate the", "# version table, \"stamping\" it with the most recent rev:", "from", "alembic", ".", "config", "import", "Config", "from", "alembic", "import", "command", "alembic_cfg", "=", "Config", "(", "alembic_ini", ")", "command", ".", "stamp", "(", "alembic_cfg", ",", "\"head\"", ")", "scopedsession", "=", "scoped_session", "(", "sessionmaker", "(", "bind", "=", "engine", ")", ")", "return", "scopedsession" ]

[ "Create", "the", "tables", "in", "the", "database", "using", "the", "information", "from", "the", "url", "obtained", "." ]

[ "def", "hash_producer", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "hashlib", ".", "md5", "(", "six", ".", "text_type", "(", "uuid", ".", "uuid4", "(", ")", ")", ".", "encode", "(", "'utf-8'", ")", ")", ".", "hexdigest", "(", ")" ]

[ "Returns", "a", "random", "hash", "for", "a", "confirmation", "secret", "." ]

[ "def", "validate_code_path", "(", "valid_paths", ",", "code_path", ",", "*", "*", "kw", ")", ":", "root", ",", "name", "=", "code_path", ".", "split", "(", "':'", ",", "1", ")", "if", "name", "not", "in", "valid_paths", "[", "root", "]", ":", "raise", "ValueError", "(", "\"%r is not a valid code_path\"", "%", "code_path", ")" ]

[ "Raise", "an", "exception", "if", "code_path", "is", "not", "one", "of", "our", "whitelisted", "valid_paths", "." ]

[ "def", "hlp_source_under", "(", "folder", ")", ":", "# walk the folder and find the __init__.py entries for packages.", "packages", "=", "[", "]", "package_dir", "=", "dict", "(", ")", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "folder", ")", ":", "for", "file", "in", "files", ":", "if", "file", "!=", "'__init__.py'", ":", "continue", "full", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "join", "(", "root", ",", "file", ")", ")", "relative", "=", "os", ".", "path", ".", "relpath", "(", "full", ",", "folder", ")", "packages", ".", "append", "(", "relative", ")", "package_dir", "[", "relative", "]", "=", "full", "# we use pprint because we want the order to always remain the same", "return", "'packages={0},\\npackage_dir={1}'", ".", "format", "(", "sorted", "(", "packages", ")", ",", "pprint", ".", "pformat", "(", "package_dir", ")", ")" ]

[ "this", "function", "finds", "all", "the", "python", "packages", "under", "a", "folder", "and", "write", "the", "packages", "and", "package_dir", "entries", "for", "a", "python", "setup", ".", "py", "script" ]

[ "def", "show", "(", "self", ")", ":", "for", "entry", "in", "self", ".", "_entries", ":", "print", "\"{'%s': %s, 'records': %s}\"", "%", "(", "entry", ".", "_record_type", ",", "entry", ".", "host", ",", "entry", ".", "records", ")", "print" ]

[ "This", "could", "use", "some", "love", "it", "s", "currently", "here", "as", "reference" ]

[ "def", "add_record", "(", "self", ",", "record", ")", ":", "rec", "=", "self", ".", "get_record", "(", "record", ".", "_record_type", ",", "record", ".", "host", ")", "if", "rec", ":", "rec", "=", "record", "for", "i", ",", "r", "in", "enumerate", "(", "self", ".", "_entries", ")", ":", "if", "r", ".", "_record_type", "==", "record", ".", "_record_type", "and", "r", ".", "host", "==", "record", ".", "host", ":", "self", ".", "_entries", "[", "i", "]", "=", "record", "else", ":", "self", ".", "_entries", ".", "append", "(", "record", ")", "self", ".", "sort", "(", ")", "return", "True" ]

[ "Add", "or", "update", "a", "given", "DNS", "record" ]

[ "def", "diff_record", "(", "self", ",", "record", ")", ":", "rec", "=", "self", ".", "get_record", "(", "record", ".", "_record_type", ",", "record", ".", "host", ")", "if", "rec", "is", "not", "None", "and", "record", "is", "not", "None", ":", "return", "{", "'removed'", ":", "tuple", "(", "set", "(", "rec", ".", "results", ")", "-", "set", "(", "record", ".", "results", ")", ")", ",", "'added'", ":", "tuple", "(", "set", "(", "record", ".", "results", ")", "-", "set", "(", "rec", ".", "recults", ")", ")", "}", "else", ":", "return", "False" ]

[ "Return", "the", "removed", "and", "added", "diffs" ]

[ "def", "get_record", "(", "self", ",", "dns_record_type", ",", "host", ")", ":", "record_list", "=", "self", ".", "_entries", "for", "record", "in", "record_list", ":", "if", "record", ".", "_record_type", "==", "dns_record_type", "and", "record", ".", "host", "==", "host", ":", "return", "record", "return", "False" ]

[ "Fetch", "a", "DNS", "record" ]

[ "def", "del_record", "(", "self", ",", "dns_record_type", ",", "host", ")", ":", "rec", "=", "self", ".", "get_record", "(", "dns_record_type", ",", "host", ")", "if", "rec", ":", "self", ".", "_entries", "=", "list", "(", "set", "(", "self", ".", "_entries", ")", "-", "set", "(", "[", "rec", "]", ")", ")", "return", "True" ]

[ "Remove", "a", "DNS", "record" ]

[ "def", "config", "(", "self", ")", ":", "root", "=", "etree", ".", "Element", "(", "\"xml\"", ")", "resource_records", "=", "etree", ".", "SubElement", "(", "root", ",", "\"resource_records\"", ")", "# Append SOA and NS records", "resource_records", ".", "append", "(", "SOARecord", "(", ")", ".", "_etree", ")", "resource_records", ".", "append", "(", "NSRecord", "(", ")", ".", "_etree", ")", "# Append the rest", "for", "record", "in", "self", ".", "_entries", ":", "resource_records", ".", "append", "(", "record", ".", "_etree", ")", "return", "etree", ".", "tostring", "(", "root", ",", "encoding", "=", "\"utf-8\"", ",", "pretty_print", "=", "True", ")" ]

[ "Create", "the", "finalized", "configuration" ]

[ "def", "parsePortSpec", "(", "spec", ",", "separator", "=", "'-'", ")", ":", "x", "=", "list", "(", "map", "(", "lambda", "x", ":", "x", ".", "strip", "(", ")", ",", "spec", ".", "split", "(", "separator", ")", ")", ")", "return", "tuple", "(", "map", "(", "int", ",", "x", "*", "(", "3", "-", "len", "(", "x", ")", ")", ")", ")" ]

[ "Parses", "a", "port", "specification", "in", "two", "forms", "into", "the", "same", "form", "." ]

[ "def", "dump", "(", "self", ",", "msg", ")", ":", "msg_size", "=", "len", "(", "msg", ")", "# We start a new batch if the resulting batch file is larger than the", "# max batch file size. However, if the current batch file size is zero", "# then that means the message alone is larger than the max batch file", "# size. In this case instead of splitting up the message across files", "# which would greatly increase complexity we simply dump that message", "# into a file of its own even though it will be larger than the max", "# batch file size.", "if", "self", ".", "_batch_size", "+", "msg_size", ">", "self", ".", "_max_batch_file_size", "and", "self", ".", "_batch_size", ">", "0", ":", "self", ".", "_startNewBatch", "(", ")", "# Write the time stamp and information on how to retrieve the message", "# from the batch files (batch filename, byte offset, and byte size)", "global", "getTime", "index_file_entry", "=", "'{:},{:09d},{:},{:}\\n'", ".", "format", "(", "getTime", "(", ")", ",", "self", ".", "_batch_index", ",", "self", ".", "_batch_size", ",", "msg_size", ")", "if", "sys", ".", "version_info", ">=", "(", "3", ",", ")", ":", "self", ".", "_index_file", ".", "write", "(", "index_file_entry", ".", "encode", "(", "'utf-8'", ")", ")", "else", ":", "self", ".", "_index_file", ".", "write", "(", "index_file_entry", ")", "# Dump the message itself to the current batch file", "self", ".", "_batch_file", ".", "write", "(", "msg", ")", "self", ".", "_batch_size", "+=", "msg_size", "# Increment message count", "self", ".", "_message_count", "+=", "1" ]

[ "Dumps", "the", "provided", "message", "to", "this", "dump", "." ]

[ "def", "api_server", "(", "connection", ",", "server_class", ")", ":", "# run api server on connection", "return", "server_class", "(", "link", "=", "xbahn", ".", "connection", ".", "link", ".", "Link", "(", "# use the connection to receive messages", "receive", "=", "connection", ",", "# use the connection to respond to received messages", "respond", "=", "connection", ")", ")" ]

[ "Establishes", "an", "API", "Server", "on", "the", "supplied", "connection" ]

[ "def", "list_nodes", "(", "search", "=", "\"unsigned\"", ")", ":", "nodes", "=", "nago", ".", "core", ".", "get_nodes", "(", ")", "if", "search", "==", "\"all\"", ":", "return", "map", "(", "lambda", "x", ":", "{", "x", "[", "0", "]", ":", "x", "[", "1", "]", ".", "data", "}", ",", "nodes", ".", "items", "(", ")", ")", "elif", "search", "==", "'unsigned'", ":", "result", "=", "{", "}", "for", "token", ",", "node", "in", "nodes", ".", "items", "(", ")", ":", "if", "node", ".", "get", "(", "'access'", ")", "is", "None", ":", "result", "[", "token", "]", "=", "node", ".", "data", "return", "result", "else", ":", "result", "=", "{", "}", "for", "token", ",", "node", "in", "nodes", ".", "items", "(", ")", ":", "host_name", "=", "node", ".", "get", "(", "'host_name'", ")", "if", "search", "in", "(", "token", ",", "host_name", ")", ":", "result", "[", "token", "]", "=", "node", ".", "data", "return", "result" ]

[ "List", "all", "connected", "nodes" ]

[ "def", "add", "(", "node_name", ",", "*", "*", "kwargs", ")", ":", "result", "=", "{", "}", "kwargs", "=", "kwargs", ".", "copy", "(", ")", "overwrite", "=", "kwargs", ".", "pop", "(", "'overwrite'", ",", "False", ")", "node", "=", "nago", ".", "core", ".", "get_node", "(", "node_name", ")", "if", "not", "node", ":", "node", "=", "nago", ".", "core", ".", "Node", "(", ")", "elif", "not", "overwrite", ":", "result", "[", "'status'", "]", "=", "'error'", "result", "[", "'message'", "]", "=", "\"node %s already exists. add argument overwrite=1 to overwrite it.\"", "%", "(", "node_name", ")", "return", "result", "else", ":", "node", ".", "delete", "(", ")", "node", "=", "nago", ".", "core", ".", "Node", "(", ")", "node", "[", "'host_name'", "]", "=", "node_name", "for", "k", ",", "v", "in", "kwargs", ".", "items", "(", ")", ":", "node", "[", "k", "]", "=", "v", "node", ".", "save", "(", ")", "result", "[", "'message'", "]", "=", "\"node successfully saved\"", "result", "[", "'node_data'", "]", "=", "node", ".", "data", "return", "result" ]

[ "Create", "a", "new", "node", "and", "generate", "a", "token", "for", "it" ]

[ "def", "delete", "(", "node_name", ")", ":", "result", "=", "{", "}", "node", "=", "nago", ".", "core", ".", "get_node", "(", "node_name", ")", "if", "not", "node", ":", "result", "[", "'status'", "]", "=", "'error'", "result", "[", "'message'", "]", "=", "\"node not found.\"", "else", ":", "node", ".", "delete", "(", ")", "result", "[", "'status'", "]", "=", "'success'", "result", "[", "'message'", "]", "=", "'node deleted.'", "return", "result" ]

[ "Delete", "a", "specific", "node" ]

[ "def", "sign", "(", "node", "=", "None", ")", ":", "if", "not", "node", ":", "raise", "Exception", "(", "\"Specify either 'all' your specify token/host_name of node to sign. \"", ")", "if", "node", "==", "'all'", ":", "node", "=", "'unsigned'", "nodes", "=", "list_nodes", "(", "search", "=", "node", ")", "result", "=", "{", "}", "for", "token", ",", "i", "in", "nodes", ".", "items", "(", ")", ":", "i", "[", "'access'", "]", "=", "'node'", "i", ".", "save", "(", ")", "result", "[", "token", "]", "=", "i", "return", "result" ]

[ "Sign", "a", "specific", "node", "to", "grant", "it", "access" ]

[ "def", "set_attribute", "(", "token_or_hostname", ",", "*", "*", "kwargs", ")", ":", "node", "=", "nago", ".", "core", ".", "get_node", "(", "token_or_hostname", ")", "or", "{", "}", "if", "not", "kwargs", ":", "return", "\"No changes made\"", "for", "k", ",", "v", "in", "kwargs", ".", "items", "(", ")", ":", "node", "[", "k", "]", "=", "v", "node", ".", "save", "(", ")", "return", "\"Saved %s changes\"", "%", "len", "(", "kwargs", ")" ]

[ "Change", "the", "attributes", "of", "a", "connected", "node" ]

[ "def", "ping", "(", "token_or_hostname", "=", "None", ")", ":", "if", "not", "token_or_hostname", ":", "return", "\"Pong!\"", "node", "=", "nago", ".", "core", ".", "get_node", "(", "token_or_hostname", ")", "if", "not", "node", "and", "token_or_hostname", "in", "(", "'master'", ",", "'server'", ")", ":", "token_or_hostname", "=", "nago", ".", "settings", ".", "get_option", "(", "'server'", ")", "node", "=", "nago", ".", "core", ".", "get_node", "(", "token_or_hostname", ")", "if", "not", "node", ":", "try", ":", "address", "=", "socket", ".", "gethostbyname", "(", "token_or_hostname", ")", "node", "=", "nago", ".", "core", ".", "Node", "(", ")", "node", "[", "'host_name'", "]", "=", "token_or_hostname", "node", "[", "'address'", "]", "=", "address", "node", "[", "'access'", "]", "=", "'node'", "if", "token_or_hostname", "==", "nago", ".", "settings", ".", "get_option", "(", "'server'", ")", ":", "node", "[", "'access'", "]", "=", "'master'", "node", ".", "save", "(", ")", "except", "Exception", ":", "raise", "Exception", "(", "\"'%s' was not found in list of known hosts, and does not resolve to a valid address\"", "%", "token_or_hostname", ")", "return", "node", ".", "send_command", "(", "'nodes'", ",", "'ping'", ")" ]

[ "Send", "an", "echo", "request", "to", "a", "nago", "host", "." ]

[ "def", "connect", "(", "remote_host", ")", ":", "if", "remote_host", "in", "(", "'master'", ",", "'server'", ")", ":", "remote_host", "=", "nago", ".", "settings", ".", "get_option", "(", "'server'", ")", "node", "=", "nago", ".", "core", ".", "get_node", "(", "remote_host", ")", "if", "not", "node", ":", "try", ":", "address", "=", "socket", ".", "gethostbyname", "(", "remote_host", ")", "node", "=", "nago", ".", "core", ".", "Node", "(", ")", "node", "[", "'host_name'", "]", "=", "remote_host", "node", "[", "'address'", "]", "=", "address", "node", "[", "'access'", "]", "=", "'node'", "if", "token_or_hostname", "==", "nago", ".", "settings", ".", "get_option", "(", "'server'", ")", ":", "node", "[", "'access'", "]", "=", "'master'", "node", ".", "save", "(", ")", "except", "Exception", ":", "raise", "Exception", "(", "\"'%s' was not found in list of known hosts, and does not resolve to a valid address\"", "%", "remote_host", ")", "ping_result", "=", "node", ".", "send_command", "(", "'nodes'", ",", "'ping'", ")", "if", "'Pong'", "in", "ping_result", ".", "get", "(", "'result'", ",", "''", ")", ":", "return", "\"Connection with %s ok\"", "%", "remote_host", "else", ":", "return", "ping_result", ".", "get", "(", "'result'", ",", "ping_result", ")" ]

[ "Connect", "to", "remote", "host", "and", "show", "our", "status" ]

[ "def", "set_environ", "(", "inherit", "=", "True", ",", "append", "=", "{", "}", ")", ":", "_environ", "=", "{", "}", "if", "not", "inherit", "else", "environ", "for", "k", ",", "v", "in", "append", ".", "iteritems", "(", ")", ":", "_environ", "[", "k", "]", "=", "v", "return", "_environ" ]

[ "Helper", "method", "for", "passing", "environment", "variables", "to", "the", "subprocess", "." ]

[ "def", "_colorize", "(", "self", ",", "msg", ",", "color", "=", "None", ",", "encode", "=", "False", ")", ":", "# Valid colors", "colors", "=", "{", "'red'", ":", "'31'", ",", "'green'", ":", "'32'", ",", "'yellow'", ":", "'33'", "}", "# No color specified or unsupported color", "if", "not", "color", "or", "not", "color", "in", "colors", ":", "return", "msg", "# The colorized string", "if", "encode", ":", "return", "u'\\x1b[1;{}m{}\\x1b[0m'", ".", "format", "(", "colors", "[", "color", "]", ",", "msg", ")", "return", "'\\x1b[1;{}m{}\\x1b[0m'", ".", "format", "(", "colors", "[", "color", "]", ",", "msg", ")" ]

[ "Colorize", "a", "string", "." ]

[ "def", "is_running", "(", "self", ")", ":", "try", ":", "kill", "(", "int", "(", "self", ".", "pid", ".", "get", "(", ")", ")", ",", "0", ")", "return", "True", "# Process not running, remove PID/lock file if it exists", "except", ":", "self", ".", "pid", ".", "remove", "(", ")", "self", ".", "lock", ".", "remove", "(", ")", "return", "False" ]

[ "Check", "if", "the", "service", "is", "running", "." ]

[ "def", "set_output", "(", "self", ")", ":", "if", "not", "self", ".", "output", ":", "return", "open", "(", "devnull", ",", "'w'", ")", "# Get the output file path", "output_dir", "=", "dirname", "(", "self", ".", "output", ")", "# Make the path exists", "if", "not", "isdir", "(", "output_dir", ")", ":", "try", ":", "makedirs", "(", "output_dir", ")", "except", "Exception", "as", "e", ":", "self", ".", "die", "(", "'Failed to create output directory \"{}\": {}'", ".", "format", "(", "output_dir", ",", "str", "(", "e", ")", ")", ")", "return", "open", "(", "self", ".", "output", ",", "'a'", ")" ]

[ "Set", "the", "output", "for", "the", "service", "command", "." ]

[ "def", "do_status", "(", "self", ")", ":", "# Get the PID of the service", "pid", "=", "self", ".", "pid", ".", "get", "(", ")", "# Status color / attributes", "status_color", "=", "'green'", "if", "pid", "else", "'red'", "status_dot", "=", "self", ".", "_colorize", "(", "UNICODE", "[", "'dot'", "]", ",", "status_color", ",", "encode", "=", "True", ")", "# Active text", "active_txt", "=", "{", "'active'", ":", "'{} since {}'", ".", "format", "(", "self", ".", "_colorize", "(", "'active (running)'", ",", "'green'", ")", ",", "self", ".", "pid", ".", "birthday", "(", ")", "[", "1", "]", ")", ",", "'inactive'", ":", "'inactive (dead)'", "}", "# Print the status message", "print", "(", "status_dot", ",", "end", "=", "' '", ")", "print", "(", "'{}.service - LSB: {}'", ".", "format", "(", "self", ".", "name", ",", "self", ".", "desc", ")", ")", "print", "(", "' Loaded: loaded (/etc/init.d/{})'", ".", "format", "(", "self", ".", "name", ")", ")", "print", "(", "' Active: {}'", ".", "format", "(", "active_txt", "[", "'active'", "if", "pid", "else", "'inactive'", "]", ")", ")", "# Extra information if running", "if", "pid", ":", "ps", "=", "self", ".", "pid", ".", "ps", "(", ")", "print", "(", "' Process: {}; [{}]'", ".", "format", "(", "pid", ",", "ps", "[", "0", "]", ")", ")", "if", "ps", "[", "1", "]", ":", "for", "c", "in", "ps", "[", "1", "]", ":", "print", "(", "' Child: {}'", ".", "format", "(", "c", ")", ")", "print", "(", "''", ")" ]

[ "Get", "the", "status", "of", "the", "service", "." ]

[ "def", "interface", "(", "self", ")", ":", "# Possible control arguments", "controls", "=", "{", "'start'", ":", "self", ".", "do_start", ",", "'stop'", ":", "self", ".", "do_stop", ",", "'status'", ":", "self", ".", "do_status", ",", "'restart'", ":", "self", ".", "do_restart", ",", "'reload'", ":", "self", ".", "do_restart", "}", "# Process the control argument", "try", ":", "controls", "[", "self", ".", "command", "]", "(", ")", "except", "KeyError", ":", "self", ".", "write_stdout", "(", "'Usage: {} {{start|stop|status|restart|reload}}'", ".", "format", "(", "self", ".", "name", ")", ",", "3", ")", "exit", "(", "0", ")" ]

[ "Public", "method", "for", "handling", "service", "command", "argument", "." ]

[ "def", "parse_cell", "(", "self", ",", "cell", ",", "coords", ",", "cell_mode", "=", "CellMode", ".", "cooked", ")", ":", "try", ":", "return", "int", "(", "cell", ")", "except", "ValueError", ":", "pass", "try", ":", "return", "float", "(", "cell", ")", "except", "ValueError", ":", "pass", "# TODO Check for dates?", "return", "cell" ]

[ "Tries", "to", "convert", "the", "value", "first", "to", "an", "int", "then", "a", "float", "and", "if", "neither", "is", "successful", "it", "returns", "the", "string", "value", "." ]

[ "def", "iterate_sheets", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "self", ".", "filename", ",", "str", ")", ":", "if", "self", ".", "filename", ".", "endswith", "(", "\".gz\"", ")", "or", "self", ".", "is_gzipped", ":", "with", "gzip", ".", "open", "(", "self", ".", "filename", ",", "\"rt\"", ")", "as", "rfile", ":", "reader", "=", "csv", ".", "reader", "(", "rfile", ",", "*", "args", ",", "*", "*", "kwargs", ")", "yield", "list", "(", "reader", ")", "else", ":", "with", "open", "(", "self", ".", "filename", ",", "\"r\"", ")", "as", "rfile", ":", "reader", "=", "csv", ".", "reader", "(", "rfile", ",", "*", "args", ",", "*", "*", "kwargs", ")", "yield", "list", "(", "reader", ")", "else", ":", "reader", "=", "csv", ".", "reader", "(", "self", ".", "filename", ",", "*", "args", ",", "*", "*", "kwargs", ")", "yield", "list", "(", "reader", ")" ]

[ "Opens", "self", ".", "filename", "and", "reads", "it", "with", "a", "csv", "reader", "." ]

[ "def", "time_methods", "(", "obj", ",", "methods", ",", "prefix", "=", "None", ")", ":", "if", "prefix", ":", "prefix", "=", "prefix", "+", "'.'", "else", ":", "prefix", "=", "''", "for", "method", "in", "methods", ":", "current_method", "=", "getattr", "(", "obj", ",", "method", ")", "new_method", "=", "timed", "(", "prefix", ")", "(", "current_method", ")", "setattr", "(", "obj", ",", "method", ",", "new_method", ")" ]

[ "Patch", "obj", "so", "calls", "to", "given", "methods", "are", "timed" ]

[ "def", "validate_fields", "(", "self", ",", "*", "*", "kwargs", ")", ":", "for", "field", "in", "self", ".", "fields", ":", "value", "=", "kwargs", "[", "field", "]", "required_type", "=", "self", ".", "fields", "[", "field", "]", "if", "type", "(", "value", ")", "!=", "required_type", ":", "raise", "TypeError", "(", "'{}.{} needs to be a {}, recieved: {}({})'", ".", "format", "(", "self", ".", "name", ",", "field", ",", "required_type", ".", "__name__", ",", "type", "(", "value", ")", ".", "__name__", ",", "value", ".", "__repr__", "(", ")", ")", ")" ]

[ "ensures", "that", "all", "incoming", "fields", "are", "the", "types", "that", "were", "specified" ]

[ "def", "upload", "(", "self", ",", "path", ",", "engine", ",", "description", "=", "None", ")", ":", "if", "description", "is", "None", ":", "head", ",", "tail", "=", "ntpath", ".", "split", "(", "path", ")", "description", "=", "tail", "or", "ntpath", ".", "basename", "(", "head", ")", "url", "=", "\"http://quickslice.{}/config/raw/\"", ".", "format", "(", "self", ".", "config", ".", "host", ")", "with", "open", "(", "path", ")", "as", "config_file", ":", "content", "=", "config_file", ".", "read", "(", ")", "payload", "=", "{", "\"engine\"", ":", "engine", ",", "\"description\"", ":", "description", ",", "\"content\"", ":", "content", "}", "post_resp", "=", "requests", ".", "post", "(", "url", ",", "json", "=", "payload", ",", "cookies", "=", "{", "\"session\"", ":", "self", ".", "session", "}", ")", "if", "not", "post_resp", ".", "ok", ":", "raise", "errors", ".", "ResourceError", "(", "\"config upload to slicing service failed\"", ")", "self", ".", "description", "=", "description", "self", ".", "location", "=", "post_resp", ".", "headers", "[", "\"Location\"", "]" ]

[ "Create", "a", "new", "config", "resource", "in", "the", "slicing", "service", "and", "upload", "the", "path", "contents", "to", "it" ]

[ "def", "download", "(", "self", ",", "path", ")", ":", "service_get_resp", "=", "requests", ".", "get", "(", "self", ".", "location", ",", "cookies", "=", "{", "\"session\"", ":", "self", ".", "session", "}", ")", "payload", "=", "service_get_resp", ".", "json", "(", ")", "download_get_resp", "=", "requests", ".", "get", "(", "payload", "[", "\"content\"", "]", ")", "with", "open", "(", "path", ",", "\"wb\"", ")", "as", "config_file", ":", "config_file", ".", "write", "(", "download_get_resp", ".", "content", ")" ]

[ "downloads", "a", "config", "resource", "to", "the", "path" ]

[ "def", "save_and_scan", "(", "filename", ",", "b64_data", ")", ":", "with", "NTFile", "(", "suffix", "=", "\"_\"", "+", "os", ".", "path", ".", "basename", "(", "filename", ")", ",", "mode", "=", "\"wb\"", ")", "as", "ifile", ":", "ifile", ".", "write", "(", "b64decode", "(", "b64_data", ")", ")", "ifile", ".", "flush", "(", ")", "os", ".", "chmod", "(", "ifile", ".", "name", ",", "0755", ")", "return", "scan_file", "(", "ifile", ".", "name", ")" ]

[ "Save", "b64_data", "to", "temporary", "file", "and", "scan", "it", "for", "viruses", "." ]

[ "def", "pagure_specific_project_filter", "(", "config", ",", "message", ",", "project", "=", "None", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "if", "not", "pagure_catchall", "(", "config", ",", "message", ")", ":", "return", "False", "project", "=", "kw", ".", "get", "(", "'project'", ",", "project", ")", "link", "=", "fedmsg", ".", "meta", ".", "msg2link", "(", "message", ",", "*", "*", "config", ")", "if", "not", "link", ":", "return", "False", "project", "=", "project", ".", "split", "(", "','", ")", "if", "project", "else", "[", "]", "valid", "=", "False", "for", "proj", "in", "project", ":", "if", "'://pagure.io/%s/'", "%", "proj", ".", "strip", "(", ")", "in", "link", ":", "valid", "=", "True", "return", "valid" ]

[ "Particular", "pagure", "projects" ]

[ "def", "pagure_specific_project_tag_filter", "(", "config", ",", "message", ",", "tags", "=", "None", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "if", "not", "pagure_catchall", "(", "config", ",", "message", ")", ":", "return", "False", "tags", "=", "tags", ".", "split", "(", "','", ")", "if", "tags", "else", "[", "]", "tags", "=", "[", "tag", ".", "strip", "(", ")", "for", "tag", "in", "tags", "if", "tag", "and", "tag", ".", "strip", "(", ")", "]", "project_tags", "=", "set", "(", ")", "project_tags", ".", "update", "(", "message", ".", "get", "(", "'project'", ",", "{", "}", ")", ".", "get", "(", "'tags'", ",", "[", "]", ")", ")", "project_tags", ".", "update", "(", "message", ".", "get", "(", "'pullrequest'", ",", "{", "}", ")", ".", "get", "(", "'project'", ",", "{", "}", ")", ".", "get", "(", "'tags'", ",", "[", "]", ")", ")", "project_tags", ".", "update", "(", "message", ".", "get", "(", "'commit'", ",", "{", "}", ")", ".", "get", "(", "'repo'", ",", "{", "}", ")", ".", "get", "(", "'tags'", ",", "[", "]", ")", ")", "valid", "=", "len", "(", "project_tags", ".", "intersection", "(", "set", "(", "tags", ")", ")", ")", ">", "0", "return", "valid" ]

[ "Particular", "pagure", "project", "tags" ]

[ "def", "build_uri", "(", "orig_uriparts", ",", "kwargs", ")", ":", "uriparts", "=", "[", "]", "for", "uripart", "in", "orig_uriparts", ":", "# If this part matches a keyword argument (starting with _), use", "# the supplied value. Otherwise, just use the part.", "if", "uripart", ".", "startswith", "(", "\"_\"", ")", ":", "part", "=", "(", "str", "(", "kwargs", ".", "pop", "(", "uripart", ",", "uripart", ")", ")", ")", "else", ":", "part", "=", "uripart", "uriparts", ".", "append", "(", "part", ")", "uri", "=", "'/'", ".", "join", "(", "uriparts", ")", "# If an id kwarg is present and there is no id to fill in in", "# the list of uriparts, assume the id goes at the end.", "id", "=", "kwargs", ".", "pop", "(", "'id'", ",", "None", ")", "if", "id", ":", "uri", "+=", "\"/%s\"", "%", "(", "id", ")", "return", "uri" ]

[ "Build", "the", "URI", "from", "the", "original", "uriparts", "and", "kwargs", ".", "Modifies", "kwargs", "." ]

[ "def", "load", "(", "path", ")", ":", "with", "open", "(", "path", ")", "as", "rfile", ":", "steps", "=", "MODEL", ".", "parse", "(", "rfile", ".", "read", "(", ")", ")", "new_steps", "=", "[", "]", "for", "step", "in", "steps", ":", "new_steps", "+=", "expand_includes", "(", "step", ",", "path", ")", "return", "new_steps" ]

[ "Load", "|path|", "and", "recursively", "expand", "any", "includes", "." ]

[ "def", "parse_serialdiff", "(", "sd_dict", ")", ":", "if", "isinstance", "(", "sd_dict", ",", "list", ")", ":", "if", "len", "(", "sd_dict", ")", "!=", "2", "or", "sd_dict", "[", "0", "]", "!=", "'checkstale'", ":", "raise", "NotImplementedError", "(", "sd_dict", "[", "0", "]", ",", "len", "(", "sd_dict", ")", ")", "return", "CheckStale", "(", "sd_dict", "[", "1", "]", ")", "if", "isinstance", "(", "sd_dict", "[", "'deltas'", "]", ",", "list", ")", ":", "# i.e. for VHString the whole deltas field is a single string", "# warning below: Delta.text will be a list sometimes. always?", "sd_dict", "[", "'deltas'", "]", "=", "[", "diff", ".", "Delta", "(", "d", "[", "'slice'", "]", "[", "'a'", "]", ",", "d", "[", "'slice'", "]", "[", "'b'", "]", ",", "d", "[", "'replace'", "]", ")", "for", "d", "in", "sd_dict", "[", "'deltas'", "]", "]", "return", "SerialDiff", "(", "*", "*", "sd_dict", ")" ]

[ "helper", "for", "translate_check" ]

[ "def", "translate_update", "(", "blob", ")", ":", "# note below: v will be int or null", "return", "{", "translate_key", "(", "k", ")", ":", "parse_serialdiff", "(", "v", ")", "for", "k", ",", "v", "in", "blob", ".", "items", "(", ")", "}" ]

[ "converts", "JSON", "parse", "output", "to", "self", "-", "aware", "objects" ]

[ "def", "process_check", "(", "pool", ",", "model", ",", "field", ",", "version", ")", ":", "try", ":", "syncable", "=", "model", "[", "field", "]", "except", "pg", ".", "FieldError", ":", "return", "[", "'?field'", "]", "if", "not", "isinstance", "(", "syncable", ",", "syncschema", ".", "Syncable", ")", ":", "return", "[", "'here'", ",", "None", ",", "syncable", "]", "if", "syncable", ".", "version", "(", ")", ">", "version", ":", "# this includes version=None. this is the load case as well as update.", "return", "[", "'here'", ",", "syncable", ".", "version", "(", ")", ",", "syncable", ".", "generate", "(", ")", "]", "# 'here' as in 'here, take this' or 'here you go'", "elif", "syncable", ".", "version", "(", ")", "==", "version", ":", "return", "[", "'ok'", ",", "version", "]", "elif", "syncable", ".", "version", "(", ")", "<", "version", ":", "return", "[", "'upload'", ",", "syncable", ".", "version", "(", ")", "]", "else", ":", "raise", "RuntimeError", "(", "\"shouldn't get here\"", ")" ]

[ "helper", "for", "do_check", ".", "version", "is", "an", "integer", "or", "null", ".", "returns", "..." ]

[ "def", "add_missing_children", "(", "models", ",", "request", ",", "include_children_for", ",", "modelgb", ")", ":", "for", "(", "nombre", ",", "pkey", ")", ",", "model", "in", "models", ".", "items", "(", ")", ":", "for", "modelclass", ",", "pkeys", "in", "model", ".", "refkeys", "(", "include_children_for", ".", "get", "(", "nombre", ",", "(", ")", ")", ")", ".", "items", "(", ")", ":", "# warning: this is defaulting to all fields of child object. don't give clients a way to restrict that until there's a reason to.", "childname", "=", "modelgb", "[", "'row'", ",", "modelclass", "]", ".", "name", "for", "childfield", ",", "cftype", "in", "modelclass", ".", "FIELDS", ":", "if", "not", "isinstance", "(", "cftype", ",", "basestring", ")", "and", "inspect", ".", "isclass", "(", "cftype", ")", "and", "issubclass", "(", "cftype", ",", "syncschema", ".", "Syncable", ")", ":", "merge_null_missing", "(", "request", ",", "childname", ",", "childfield", ",", "pkeys", ")", "elif", "childfield", "in", "modelclass", ".", "SENDRAW", ":", "merge_null_missing", "(", "request", ",", "childname", ",", "childfield", ",", "pkeys", ")", "else", ":", "pass", "# intentional: ignore the field", "return", "request", "# the in-place updated original" ]

[ "helper", "for", "do_check", ".", "mutates", "request" ]

[ "def", "parse_args", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "\"Uploads specified VMDK file to AWS s3 bucket, and converts to AMI\"", ")", "parser", ".", "add_argument", "(", "'-r'", ",", "'--aws_regions'", ",", "type", "=", "str", ",", "nargs", "=", "'+'", ",", "required", "=", "True", ",", "help", "=", "'list of AWS regions where uploaded ami should be copied. Available'", "' regions: {}.'", ".", "format", "(", "AWSUtilities", ".", "aws_regions", ")", ")", "parser", ".", "add_argument", "(", "'-a'", ",", "'--aws_profile'", ",", "type", "=", "str", ",", "required", "=", "True", ",", "help", "=", "'AWS profile name to use for aws cli commands'", ")", "parser", ".", "add_argument", "(", "'-b'", ",", "'--s3_bucket'", ",", "type", "=", "str", ",", "required", "=", "True", ",", "help", "=", "'The aws_bucket of the profile to upload and save vmdk to'", ")", "parser", ".", "add_argument", "(", "'-f'", ",", "'--vmdk_upload_file'", ",", "type", "=", "str", ",", "required", "=", "True", ",", "help", "=", "\"The file to upload if executing \"", ")", "parser", ".", "add_argument", "(", "'-n'", ",", "'--ami_name'", ",", "type", "=", "str", ",", "required", "=", "False", ",", "help", "=", "'The name to give to the uploaded ami. '", "'Defaults to the name of the file'", ")", "parser", ".", "add_argument", "(", "'-d'", ",", "'--directory'", ",", "type", "=", "str", ",", "default", "=", "tempfile", ".", "mkdtemp", "(", ")", ",", "help", "=", "'Directory to save temp aws config upload files'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "if", "not", "args", ".", "ami_name", ":", "args", ".", "ami_name", "=", "os", ".", "path", ".", "basename", "(", "args", ".", "vmdk_upload_file", ")", "validate_args", "(", "args", ")", "return", "args" ]

[ "Argument", "parser", "and", "validator" ]

[ "def", "R_rot_2d", "(", "th", ")", ":", "s", ",", "=", "np", ".", "sin", "(", "th", ")", ".", "T", "c", ",", "=", "np", ".", "cos", "(", "th", ")", ".", "T", "R", "=", "np", ".", "empty", "(", "(", "len", "(", "th", ")", ",", "2", ",", "2", ")", ",", "dtype", "=", "np", ".", "float", ")", "R", "[", ":", ",", "0", ",", "0", "]", "=", "c", "R", "[", ":", ",", "0", ",", "1", "]", "=", "-", "s", "R", "[", ":", ",", "1", ",", "0", "]", "=", "s", "R", "[", ":", ",", "1", ",", "1", "]", "=", "c", "return", "R" ]

[ "Return", "a", "2", "-", "dimensional", "rotation", "matrix", "." ]

[ "def", "R_rot_3d", "(", "th", ")", ":", "sx", ",", "sy", ",", "sz", "=", "np", ".", "sin", "(", "th", ")", ".", "T", "cx", ",", "cy", ",", "cz", "=", "np", ".", "cos", "(", "th", ")", ".", "T", "R", "=", "np", ".", "empty", "(", "(", "len", "(", "th", ")", ",", "3", ",", "3", ")", ",", "dtype", "=", "np", ".", "float", ")", "R", "[", ":", ",", "0", ",", "0", "]", "=", "cy", "*", "cz", "R", "[", ":", ",", "0", ",", "1", "]", "=", "-", "cy", "*", "sz", "R", "[", ":", ",", "0", ",", "2", "]", "=", "sy", "R", "[", ":", ",", "1", ",", "0", "]", "=", "sx", "*", "sy", "*", "cz", "+", "cx", "*", "sz", "R", "[", ":", ",", "1", ",", "1", "]", "=", "-", "sx", "*", "sy", "*", "sz", "+", "cx", "*", "cz", "R", "[", ":", ",", "1", ",", "2", "]", "=", "-", "sx", "*", "cy", "R", "[", ":", ",", "2", ",", "0", "]", "=", "-", "cx", "*", "sy", "*", "cz", "+", "sx", "*", "sz", "R", "[", ":", ",", "2", ",", "1", "]", "=", "cx", "*", "sy", "*", "sz", "+", "sx", "*", "cz", "R", "[", ":", ",", "2", ",", "2", "]", "=", "cx", "*", "cy", "return", "R" ]

[ "Return", "a", "3", "-", "dimensional", "rotation", "matrix", "." ]

[ "def", "R_rot", "(", "th", ")", ":", "try", ":", "dof", "=", "th", ".", "shape", "[", "-", "1", "]", "# If th is a python float", "except", "AttributeError", ":", "dof", "=", "1", "th", "=", "np", ".", "array", "(", "[", "th", "]", ")", "except", "IndexError", ":", "dof", "=", "1", "th", "=", "np", ".", "array", "(", "[", "th", "]", ")", "# If th is a numpy float, i.e. 0d array", "if", "dof", "==", "1", ":", "return", "R_rot_2d", "(", "th", ")", "elif", "dof", "==", "3", ":", "return", "R_rot_3d", "(", "th", ")", "else", ":", "raise", "Exception", "(", "'Rotation matrix not implemented in this dimension'", ")" ]

[ "Return", "a", "rotation", "matrix", "." ]

[ "def", "rotate", "(", "a", ",", "th", ")", ":", "return", "np", ".", "sum", "(", "a", "[", "...", ",", "np", ".", "newaxis", "]", "*", "R_rot", "(", "th", ")", ",", "axis", "=", "-", "2", ")" ]

[ "Return", "cartesian", "vectors", "after", "rotation", "by", "specified", "angles", "about", "each", "degree", "of", "freedom", "." ]

[ "def", "export_select_fields_csv_action", "(", "description", "=", "\"Export selected objects as CSV file\"", ",", "fields", "=", "None", ",", "exclude", "=", "None", ",", "header", "=", "True", ")", ":", "def", "export_as_csv", "(", "modeladmin", ",", "request", ",", "queryset", ")", ":", "\"\"\"\n Generic csv export admin action.\n based on http://djangosnippets.org/snippets/1697/\n \"\"\"", "opts", "=", "modeladmin", ".", "model", ".", "_meta", "field_names", "=", "[", "field", ".", "name", "for", "field", "in", "opts", ".", "fields", "]", "labels", "=", "[", "]", "if", "exclude", ":", "field_names", "=", "[", "v", "for", "v", "in", "field_names", "if", "v", "not", "in", "exclude", "]", "elif", "fields", ":", "field_names", "=", "[", "k", "for", "k", ",", "v", "in", "fields", "if", "k", "in", "field_names", "]", "labels", "=", "[", "v", "for", "k", ",", "v", "in", "fields", "if", "k", "in", "field_names", "]", "response", "=", "HttpResponse", "(", "mimetype", "=", "'text/csv'", ")", "response", "[", "'Content-Disposition'", "]", "=", "(", "'attachment; filename=%s.csv'", "%", "unicode", "(", "opts", ")", ".", "replace", "(", "'.'", ",", "'_'", ")", ")", "writer", "=", "csv", ".", "writer", "(", "response", ")", "if", "header", ":", "if", "labels", ":", "writer", ".", "writerow", "(", "labels", ")", "else", ":", "writer", ".", "writerow", "(", "field_names", ")", "for", "obj", "in", "queryset", ":", "writer", ".", "writerow", "(", "[", "unicode", "(", "getattr", "(", "obj", ",", "field", ")", ")", ".", "encode", "(", "'utf-8'", ")", "for", "field", "in", "field_names", "]", ")", "return", "response", "export_as_csv", ".", "short_description", "=", "description", "return", "export_as_csv" ]

[ "This", "function", "returns", "an", "export", "csv", "action" ]

[ "def", "render", "(", "self", ",", "name", "=", "None", ",", "template", "=", "None", ",", "context", "=", "{", "}", ")", ":", "if", "isinstance", "(", "template", ",", "Template", ")", ":", "_template", "=", "template", "else", ":", "_template", "=", "Template", ".", "objects", ".", "get", "(", "name", "=", "name", ")", "# Maybe cache or save local ?", "response", "=", "self", ".", "env", ".", "from_string", "(", "_template", ".", "content", ")", ".", "render", "(", "context", ")", "return", "response" ]

[ "Render", "Template", "meta", "from", "jinja2", "templates", "." ]

[ "def", "get", "(", "self", ")", ":", "output", "=", "helm", "(", "\"get\"", ",", "self", ".", "release", ")", "if", "output", ".", "returncode", "!=", "0", ":", "print", "(", "\"Something went wrong!\"", ")", "print", "(", "output", ".", "stderr", ")", "else", ":", "print", "(", "output", ".", "stdout", ")" ]

[ "Get", "specific", "information", "about", "this", "hub", "." ]

[ "def", "create", "(", "self", ")", ":", "# Point to chart repo.", "out", "=", "helm", "(", "\"repo\"", ",", "\"add\"", ",", "\"jupyterhub\"", ",", "self", ".", "helm_repo", ")", "out", "=", "helm", "(", "\"repo\"", ",", "\"update\"", ")", "# Get token to secure Jupyterhub", "secret_yaml", "=", "self", ".", "get_security_yaml", "(", ")", "# Get Jupyterhub.", "out", "=", "helm", "(", "\"upgrade\"", ",", "\"--install\"", ",", "self", ".", "release", ",", "\"jupyterhub/jupyterhub\"", ",", "namespace", "=", "self", ".", "namespace", ",", "version", "=", "self", ".", "version", ",", "input", "=", "secret_yaml", ")", "if", "out", ".", "returncode", "!=", "0", ":", "print", "(", "out", ".", "stderr", ")", "else", ":", "print", "(", "out", ".", "stdout", ")" ]

[ "Create", "a", "single", "instance", "of", "notebook", "." ]

[ "def", "delete", "(", "self", ")", ":", "# Delete the Helm Release", "out", "=", "helm", "(", "\"delete\"", ",", "self", ".", "release", ",", "\"--purge\"", ")", "if", "out", ".", "returncode", "!=", "0", ":", "print", "(", "out", ".", "stderr", ")", "else", ":", "print", "(", "out", ".", "stdout", ")", "# Delete the Kubernetes namespace", "out", "=", "kubectl", "(", "\"delete\"", ",", "\"namespace\"", ",", "self", ".", "namespace", ")", "if", "out", ".", "returncode", "!=", "0", ":", "print", "(", "out", ".", "stderr", ")", "else", ":", "print", "(", "out", ".", "stdout", ")" ]

[ "Delete", "a", "Jupyterhub", "." ]

[ "def", "_parse_description", "(", "self", ",", "description_text", ")", ":", "text", "=", "description_text", "text", "=", "text", ".", "strip", "(", ")", "lines", "=", "text", ".", "split", "(", "'\\n'", ")", "data", "=", "{", "}", "for", "line", "in", "lines", ":", "if", "\":\"", "in", "line", ":", "idx", "=", "line", ".", "index", "(", "\":\"", ")", "key", "=", "line", "[", ":", "idx", "]", "value", "=", "line", "[", "idx", "+", "1", ":", "]", ".", "lstrip", "(", ")", ".", "rstrip", "(", ")", "data", "[", "key", "]", "=", "value", "else", ":", "if", "isinstance", "(", "value", ",", "list", ")", "is", "False", ":", "value", "=", "[", "value", "]", "value", ".", "append", "(", "line", ".", "lstrip", "(", ")", ".", "rstrip", "(", ")", ")", "data", "[", "key", "]", "=", "value", "return", "data" ]

[ "Turn", "description", "to", "dictionary", "." ]

[ "def", "_validate_data", "(", "data", ")", ":", "data_keys", "=", "set", "(", "data", ".", "keys", "(", ")", ")", "extra_keys", "=", "data_keys", "-", "set", "(", "ALLOWED_KEYS", ")", "missing_keys", "=", "set", "(", "REQUIRED_KEYS", ")", "-", "data_keys", "if", "extra_keys", ":", "raise", "ValueError", "(", "'Invalid data keys {!r}'", ".", "format", "(", "', '", ".", "join", "(", "extra_keys", ")", ")", ")", "if", "missing_keys", ":", "raise", "ValueError", "(", "'Missing keys {!r}'", ".", "format", "(", "', '", ".", "join", "(", "missing_keys", ")", ")", ")" ]

[ "Validates", "the", "given", "data", "and", "raises", "an", "error", "if", "any", "non", "-", "allowed", "keys", "are", "provided", "or", "any", "required", "keys", "are", "missing", "." ]

[ "def", "_send", "(", "data", ")", ":", "url", "=", "data", ".", "get", "(", "'url'", ",", "CLOWDER_API_URL", ")", "_validate_data", "(", "data", ")", "if", "api_key", "is", "not", "None", ":", "data", "[", "'api_key'", "]", "=", "api_key", "if", "'value'", "not", "in", "data", ":", "data", "[", "'value'", "]", "=", "data", ".", "get", "(", "'status'", ",", "1", ")", "if", "'frequency'", "in", "data", ":", "data", "[", "'frequency'", "]", "=", "_clean_frequency", "(", "data", "[", "'frequency'", "]", ")", "try", ":", "requests", ".", "post", "(", "url", ",", "data", "=", "data", ",", "timeout", "=", "TIMEOUT", ")", ".", "text", "# This confirms you that the request has reached server", "# And that the request has been sent", "# Because we don't care about the response, we set the timeout", "# value to be low and ignore read exceptions", "except", "requests", ".", "exceptions", ".", "ReadTimeout", "as", "err", ":", "pass", "# Allow a wildcard expection for any other type of processing error", "except", "requests", ".", "exceptions", ".", "RequestException", "as", "err", ":", "logging", ".", "error", "(", "'Clowder expection %s'", ",", "err", ")" ]

[ "Send", "data", "to", "the", "Clowder", "API", "." ]

[ "def", "submit", "(", "*", "*", "kwargs", ")", ":", "if", "'alert'", "not", "in", "kwargs", ":", "raise", "ValueError", "(", "'Alert required'", ")", "if", "'value'", "not", "in", "kwargs", ":", "raise", "ValueError", "(", "'Value required'", ")", "alert", "=", "kwargs", ".", "pop", "(", "'alert'", ")", "value", "=", "kwargs", "[", "'value'", "]", "if", "alert", "(", "value", ")", ":", "fail", "(", "kwargs", ")", "else", ":", "ok", "(", "kwargs", ")" ]

[ "Shortcut", "that", "takes", "an", "alert", "to", "evaluate", "and", "makes", "the", "appropriate", "API", "call", "based", "on", "the", "results", "." ]

[ "def", "_clean_frequency", "(", "frequency", ")", ":", "if", "isinstance", "(", "frequency", ",", "int", ")", ":", "return", "frequency", "elif", "isinstance", "(", "frequency", ",", "datetime", ".", "timedelta", ")", ":", "return", "int", "(", "frequency", ".", "total_seconds", "(", ")", ")", "raise", "ValueError", "(", "'Invalid frequency {!r}'", ".", "format", "(", "frequency", ")", ")" ]

[ "Converts", "a", "frequency", "value", "to", "an", "integer", ".", "Raises", "an", "error", "if", "an", "invalid", "type", "is", "given", "." ]

[ "def", "koschei_group", "(", "config", ",", "message", ",", "group", "=", "None", ")", ":", "if", "not", "group", "or", "'koschei'", "not", "in", "message", "[", "'topic'", "]", ":", "return", "False", "groups", "=", "set", "(", "[", "item", ".", "strip", "(", ")", "for", "item", "in", "group", ".", "split", "(", "','", ")", "]", ")", "return", "bool", "(", "groups", ".", "intersection", "(", "message", "[", "'msg'", "]", ".", "get", "(", "'groups'", ",", "[", "]", ")", ")", ")" ]

[ "Particular", "Koschei", "package", "groups" ]

[ "def", "on_response", "(", "self", ",", "ch", ",", "method_frame", ",", "props", ",", "body", ")", ":", "LOGGER", ".", "debug", "(", "\"rabbitmq.Requester.on_response\"", ")", "if", "self", ".", "corr_id", "==", "props", ".", "correlation_id", ":", "self", ".", "response", "=", "{", "'props'", ":", "props", ",", "'body'", ":", "body", "}", "else", ":", "LOGGER", ".", "warn", "(", "\"rabbitmq.Requester.on_response - discarded response : \"", "+", "str", "(", "props", ".", "correlation_id", ")", ")", "LOGGER", ".", "debug", "(", "\"natsd.Requester.on_response - discarded response : \"", "+", "str", "(", "{", "'properties'", ":", "props", ",", "'body'", ":", "body", "}", ")", ")" ]

[ "setup", "response", "is", "correlation", "id", "is", "the", "good", "one" ]

[ "def", "error", "(", "message", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "print", "(", "'[!] '", "+", "message", ".", "format", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "print", "an", "error", "message" ]

[ "def", "parse_changes", "(", ")", ":", "with", "open", "(", "'CHANGES'", ")", "as", "changes", ":", "for", "match", "in", "re", ".", "finditer", "(", "RE_CHANGES", ",", "changes", ".", "read", "(", "1024", ")", ",", "re", ".", "M", ")", ":", "if", "len", "(", "match", ".", "group", "(", "1", ")", ")", "!=", "len", "(", "match", ".", "group", "(", "3", ")", ")", ":", "error", "(", "'incorrect underline in CHANGES'", ")", "date", "=", "datetime", ".", "datetime", ".", "strptime", "(", "match", ".", "group", "(", "4", ")", ",", "'%Y-%m-%d'", ")", ".", "date", "(", ")", "if", "date", "!=", "datetime", ".", "date", ".", "today", "(", ")", ":", "error", "(", "'release date is not today'", ")", "return", "match", ".", "group", "(", "2", ")", "error", "(", "'invalid release entry in CHANGES'", ")" ]

[ "grab", "version", "from", "CHANGES", "and", "validate", "entry" ]

[ "def", "increment_version", "(", "version", ")", ":", "parts", "=", "[", "int", "(", "v", ")", "for", "v", "in", "version", ".", "split", "(", "'.'", ")", "]", "parts", "[", "-", "1", "]", "+=", "1", "parts", ".", "append", "(", "'dev0'", ")", "return", "'.'", ".", "join", "(", "map", "(", "str", ",", "parts", ")", ")" ]

[ "get", "the", "next", "version" ]

[ "def", "set_version", "(", "version", ")", ":", "with", "open", "(", "FILENAME", ")", "as", "pythonfile", ":", "content", "=", "pythonfile", ".", "read", "(", ")", "output", "=", "re", ".", "sub", "(", "RE_VERSION", ",", "r\"\\1'{}'\"", ".", "format", "(", "version", ")", ",", "content", ")", "if", "content", "==", "output", ":", "error", "(", "'failed updating {}'", ".", "format", "(", "FILENAME", ")", ")", "with", "open", "(", "FILENAME", ",", "'w'", ")", "as", "pythonfile", ":", "pythonfile", ".", "write", "(", "output", ")" ]

[ "set", "the", "version", "in", "the", "projects", "root", "module" ]

[ "def", "upload", "(", ")", ":", "def", "twine", "(", "*", "args", ")", ":", "\"\"\" run a twine command \"\"\"", "process", "=", "run", "(", "sys", ".", "executable", ",", "'-m'", ",", "'twine'", ",", "*", "args", ")", "return", "process", ".", "wait", "(", ")", "!=", "0", "if", "run", "(", "sys", ".", "executable", ",", "'setup.py'", ",", "'sdist'", ",", "'bdist_wheel'", ")", ".", "wait", "(", ")", "!=", "0", ":", "error", "(", "'failed building packages'", ")", "if", "twine", "(", "'register'", ",", "glob", ".", "glob", "(", "'dist/*'", ")", "[", "0", "]", ")", ":", "error", "(", "'register failed'", ")", "if", "twine", "(", "'upload'", ",", "'-s'", ",", "'-i'", ",", "'CB164668'", ",", "'--skip-existing'", ",", "'dist/*'", ")", ":", "error", "(", "'upload failed'", ")" ]

[ "build", "the", "files", "and", "upload", "to", "pypi" ]

[ "def", "check_tag", "(", "version", ")", ":", "output", "=", "run", "(", "'git'", ",", "'tag'", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", ".", "communicate", "(", ")", "[", "0", "]", "tags", "=", "set", "(", "output", ".", "decode", "(", "'utf-8'", ")", ".", "splitlines", "(", ")", ")", "if", "'v{}'", ".", "format", "(", "version", ")", "in", "tags", ":", "error", "(", "'version already exists'", ")" ]

[ "check", "theres", "not", "already", "a", "tag", "for", "this", "version" ]

[ "def", "as_multi_dict", "(", "d", ")", ":", "if", "isinstance", "(", "d", ",", "bottle", ".", "MultiDict", ")", ":", "return", "d", "md", "=", "bottle", ".", "MultiDict", "(", ")", "for", "k", ",", "v", "in", "d", ".", "iteritems", "(", ")", ":", "if", "isinstance", "(", "v", ",", "list", ")", ":", "for", "x", "in", "v", ":", "md", "[", "k", "]", "=", "x", "else", ":", "md", "[", "k", "]", "=", "v", "return", "md" ]

[ "Coerce", "a", "dictionary", "to", "a", "bottle", ".", "MultiDict" ]

[ "def", "set_query_params", "(", "self", ",", "query_params", ")", ":", "self", ".", "query_params", "=", "as_multi_dict", "(", "query_params", ")", "self", ".", "apply_param_schema", "(", ")", "return", "self" ]

[ "Set", "the", "query", "parameters", "." ]

[ "def", "add_query_params", "(", "self", ",", "query_params", ")", ":", "query_params", "=", "as_multi_dict", "(", "query_params", ")", "for", "k", "in", "query_params", ":", "self", ".", "query_params", ".", "pop", "(", "k", ",", "None", ")", "for", "v", "in", "query_params", ".", "getlist", "(", "k", ")", ":", "self", ".", "query_params", "[", "k", "]", "=", "v", "self", ".", "apply_param_schema", "(", ")", "return", "self" ]

[ "Overwrite", "the", "given", "query", "parameters", "." ]

[ "def", "apply_param_schema", "(", "self", ")", ":", "def", "param_str", "(", "name", ",", "cons", ",", "default", ")", ":", "try", ":", "v", "=", "self", ".", "query_params", ".", "get", "(", "name", ",", "default", ")", "if", "v", "is", "None", ":", "return", "v", "if", "len", "(", "v", ")", "==", "0", ":", "return", "default", "return", "cons", "(", "v", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "return", "default", "def", "param_num", "(", "name", ",", "cons", ",", "default", ",", "minimum", ",", "maximum", ")", ":", "try", ":", "n", "=", "cons", "(", "self", ".", "query_params", ".", "get", "(", "name", ",", "default", ")", ")", "return", "min", "(", "maximum", ",", "max", "(", "minimum", ",", "n", ")", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "return", "default", "for", "name", ",", "schema", "in", "getattr", "(", "self", ",", "'param_schema'", ",", "{", "}", ")", ".", "iteritems", "(", ")", ":", "default", "=", "self", ".", "config_params", ".", "get", "(", "name", ",", "schema", ".", "get", "(", "'default'", ",", "None", ")", ")", "v", "=", "None", "if", "schema", "[", "'type'", "]", "==", "'bool'", ":", "v", "=", "param_str", "(", "name", ",", "lambda", "s", ":", "bool", "(", "int", "(", "s", ")", ")", ",", "False", ")", "elif", "schema", "[", "'type'", "]", "==", "'int'", ":", "v", "=", "param_num", "(", "name", ",", "int", ",", "default", "=", "default", ",", "minimum", "=", "schema", ".", "get", "(", "'min'", ",", "0", ")", ",", "maximum", "=", "schema", ".", "get", "(", "'max'", ",", "1000000", ")", ")", "elif", "schema", "[", "'type'", "]", "==", "'float'", ":", "v", "=", "param_num", "(", "name", ",", "float", ",", "default", "=", "default", ",", "minimum", "=", "schema", ".", "get", "(", "'min'", ",", "0", ")", ",", "maximum", "=", "schema", ".", "get", "(", "'max'", ",", "1000000", ")", ")", "elif", "schema", "[", "'type'", "]", "is", "'bytes'", ":", "v", "=", "param_str", "(", "name", ",", "schema", ".", "get", "(", "'cons'", ",", "str", ")", ",", "default", ")", "elif", "schema", "[", "'type'", "]", "is", "'unicode'", ":", "encoding", "=", "schema", ".", "get", "(", "'encoding'", ",", "'utf-8'", ")", "v", "=", "param_str", "(", "name", ",", "lambda", "s", ":", "s", ".", "decode", "(", "encoding", ")", ",", "default", ")", "self", ".", "params", "[", "name", "]", "=", "v" ]

[ "Applies", "the", "schema", "defined", "to", "the", "given", "parameters", "." ]

[ "def", "create_filter_predicate", "(", "self", ")", ":", "assert", "self", ".", "query_content_id", "is", "not", "None", ",", "'must call SearchEngine.set_query_id first'", "filter_names", "=", "self", ".", "query_params", ".", "getlist", "(", "'filter'", ")", "if", "len", "(", "filter_names", ")", "==", "0", "and", "'already_labeled'", "in", "self", ".", "_filters", ":", "filter_names", "=", "[", "'already_labeled'", "]", "init_filters", "=", "[", "(", "n", ",", "self", ".", "_filters", "[", "n", "]", ")", "for", "n", "in", "filter_names", "]", "preds", "=", "[", "lambda", "_", ":", "True", "]", "for", "name", ",", "p", "in", "init_filters", ":", "preds", ".", "append", "(", "p", ".", "set_query_id", "(", "self", ".", "query_content_id", ")", ".", "set_query_params", "(", "self", ".", "query_params", ")", ".", "create_predicate", "(", ")", ")", "return", "lambda", "(", "cid", ",", "fc", ")", ":", "fc", "is", "not", "None", "and", "all", "(", "p", "(", "(", "cid", ",", "fc", ")", ")", "for", "p", "in", "preds", ")" ]

[ "Creates", "a", "filter", "predicate", "." ]

[ "def", "results", "(", "self", ")", ":", "results", "=", "self", ".", "recommendations", "(", ")", "transformed", "=", "[", "]", "for", "t", "in", "results", "[", "'results'", "]", ":", "if", "len", "(", "t", ")", "==", "2", ":", "cid", ",", "fc", "=", "t", "info", "=", "{", "}", "elif", "len", "(", "t", ")", "==", "3", ":", "cid", ",", "fc", ",", "info", "=", "t", "else", ":", "bottle", ".", "abort", "(", "500", ",", "'Invalid search result: \"%r\"'", "%", "t", ")", "result", "=", "info", "result", "[", "'content_id'", "]", "=", "cid", "if", "not", "self", ".", "params", "[", "'omit_fc'", "]", ":", "result", "[", "'fc'", "]", "=", "util", ".", "fc_to_json", "(", "fc", ")", "transformed", ".", "append", "(", "result", ")", "results", "[", "'results'", "]", "=", "transformed", "return", "results" ]

[ "Returns", "results", "as", "a", "JSON", "encodable", "Python", "value", "." ]

[ "def", "_get_entry_link", "(", "self", ",", "entry", ")", ":", "entry_link", "=", "None", "for", "link", "in", "entry", ".", "link", ":", "if", "'/data/'", "not", "in", "link", ".", "href", "and", "'/lh/'", "not", "in", "link", ".", "href", ":", "entry_link", "=", "link", ".", "href", "break", "return", "entry_link", "or", "entry", ".", "link", "[", "0", "]", ".", "href" ]

[ "Returns", "a", "unique", "link", "for", "an", "entry" ]

[ "def", "find", "(", "value", ")", ":", "value", "=", "str", "(", "value", ")", ".", "lower", "(", ")", "rtn_dict", "=", "RegistryDictionary", "(", ")", "for", "attr", "in", "dir", "(", "MODULE", ".", "rdfclass", ")", ":", "if", "value", "in", "attr", ".", "lower", "(", ")", ":", "try", ":", "item", "=", "getattr", "(", "MODULE", ".", "rdfclass", ",", "attr", ")", "if", "issubclass", "(", "item", ",", "RdfClassBase", ")", ":", "rtn_dict", "[", "attr", "]", "=", "item", "except", "TypeError", ":", "pass", "return", "rtn_dict" ]

[ "returns", "a", "dictionary", "of", "rdfclasses", "based", "on", "the", "a", "lowercase", "search" ]

[ "def", "list_hierarchy", "(", "class_name", ",", "bases", ")", ":", "class_list", "=", "[", "Uri", "(", "class_name", ")", "]", "for", "base", "in", "bases", ":", "if", "base", ".", "__name__", "not", "in", "IGNORE_CLASSES", ":", "class_list", ".", "append", "(", "Uri", "(", "base", ".", "__name__", ")", ")", "return", "list", "(", "[", "i", "for", "i", "in", "set", "(", "class_list", ")", "]", ")" ]

[ "Creates", "a", "list", "of", "the", "class", "hierarchy" ]

[ "def", "es_get_class_defs", "(", "cls_def", ",", "cls_name", ")", ":", "rtn_dict", "=", "{", "key", ":", "value", "for", "key", ",", "value", "in", "cls_def", ".", "items", "(", ")", "if", "key", ".", "startswith", "(", "\"kds_es\"", ")", "}", "for", "key", "in", "rtn_dict", ":", "del", "cls_def", "[", "key", "]", "return", "rtn_dict" ]

[ "Reads", "through", "the", "class", "defs", "and", "gets", "the", "related", "es", "class", "defintions" ]