Datasets:

google

/

code_x_glue_tc_nl_code_search_adv

like 6

[ "def", "get_listener_count", "(", "self", ")", ":", "if", "hasattr", "(", "self", ",", "\"listener_count\"", ")", ":", "return", "self", ".", "listener_count", "else", ":", "self", ".", "listener_count", "=", "_number", "(", "_extract", "(", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", ",", "\"listeners\"", ")", ")", "return", "self", ".", "listener_count" ]

[ "Returns", "the", "number", "of", "listeners", "on", "the", "network", "." ]

[ "def", "is_streamable", "(", "self", ")", ":", "return", "bool", "(", "_number", "(", "_extract", "(", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", ",", "\"streamable\"", ")", ")", ")" ]

[ "Returns", "True", "if", "the", "artist", "is", "streamable", "." ]

[ "def", "get_similar", "(", "self", ",", "limit", "=", "None", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getSimilar\"", ",", "True", ",", "params", ")", "names", "=", "_extract_all", "(", "doc", ",", "\"name\"", ")", "matches", "=", "_extract_all", "(", "doc", ",", "\"match\"", ")", "artists", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "names", ")", ")", ":", "artists", ".", "append", "(", "SimilarItem", "(", "Artist", "(", "names", "[", "i", "]", ",", "self", ".", "network", ")", ",", "_number", "(", "matches", "[", "i", "]", ")", ")", ")", "return", "artists" ]

[ "Returns", "the", "similar", "artists", "on", "the", "network", "." ]

[ "def", "get_top_albums", "(", "self", ",", "limit", "=", "None", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "return", "self", ".", "_get_things", "(", "\"getTopAlbums\"", ",", "\"album\"", ",", "Album", ",", "params", ",", "cacheable", ")" ]

[ "Returns", "a", "list", "of", "the", "top", "albums", "." ]

[ "def", "get_top_tracks", "(", "self", ",", "limit", "=", "None", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "return", "self", ".", "_get_things", "(", "\"getTopTracks\"", ",", "\"track\"", ",", "Track", ",", "params", ",", "cacheable", ")" ]

[ "Returns", "a", "list", "of", "the", "most", "played", "Tracks", "by", "this", "artist", "." ]

[ "def", "get_top_artists", "(", "self", ",", "limit", "=", "None", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "doc", "=", "self", ".", "_request", "(", "\"geo.getTopArtists\"", ",", "cacheable", ",", "params", ")", "return", "_extract_top_artists", "(", "doc", ",", "self", ")" ]

[ "Returns", "a", "sequence", "of", "the", "most", "played", "artists", "." ]

[ "def", "get_duration", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "_number", "(", "_extract", "(", "doc", ",", "\"duration\"", ")", ")" ]

[ "Returns", "the", "track", "duration", "." ]

[ "def", "get_userloved", "(", "self", ")", ":", "if", "not", "self", ".", "username", ":", "return", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"username\"", "]", "=", "self", ".", "username", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ",", "params", ")", "loved", "=", "_number", "(", "_extract", "(", "doc", ",", "\"userloved\"", ")", ")", "return", "bool", "(", "loved", ")" ]

[ "Whether", "the", "user", "loved", "this", "track" ]

[ "def", "is_streamable", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "_extract", "(", "doc", ",", "\"streamable\"", ")", "==", "\"1\"" ]

[ "Returns", "True", "if", "the", "track", "is", "available", "at", "Last", ".", "fm", "." ]

[ "def", "is_fulltrack_available", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "(", "doc", ".", "getElementsByTagName", "(", "\"streamable\"", ")", "[", "0", "]", ".", "getAttribute", "(", "\"fulltrack\"", ")", "==", "\"1\"", ")" ]

[ "Returns", "True", "if", "the", "full", "track", "is", "available", "for", "streaming", "." ]

[ "def", "get_album", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "albums", "=", "doc", ".", "getElementsByTagName", "(", "\"album\"", ")", "if", "len", "(", "albums", ")", "==", "0", ":", "return", "node", "=", "doc", ".", "getElementsByTagName", "(", "\"album\"", ")", "[", "0", "]", "return", "Album", "(", "_extract", "(", "node", ",", "\"artist\"", ")", ",", "_extract", "(", "node", ",", "\"title\"", ")", ",", "self", ".", "network", ")" ]

[ "Returns", "the", "album", "object", "of", "this", "track", "." ]

[ "def", "get_similar", "(", "self", ",", "limit", "=", "None", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getSimilar\"", ",", "True", ",", "params", ")", "seq", "=", "[", "]", "for", "node", "in", "doc", ".", "getElementsByTagName", "(", "self", ".", "ws_prefix", ")", ":", "title", "=", "_extract", "(", "node", ",", "\"name\"", ")", "artist", "=", "_extract", "(", "node", ",", "\"name\"", ",", "1", ")", "match", "=", "_number", "(", "_extract", "(", "node", ",", "\"match\"", ")", ")", "seq", ".", "append", "(", "SimilarItem", "(", "Track", "(", "artist", ",", "title", ",", "self", ".", "network", ")", ",", "match", ")", ")", "return", "seq" ]

[ "Returns", "similar", "tracks", "for", "this", "track", "on", "the", "network", "based", "on", "listening", "data", "." ]

[ "def", "get_artist_tracks", "(", "self", ",", "artist", ",", "cacheable", "=", "False", ")", ":", "# Not implemented:", "# \"Can be limited to specific timeranges, defaults to all time.\"", "warnings", ".", "warn", "(", "\"User.get_artist_tracks is deprecated and will be removed in a future \"", "\"version. User.get_track_scrobbles is a partial replacement. \"", "\"See https://github.com/pylast/pylast/issues/298\"", ",", "DeprecationWarning", ",", "stacklevel", "=", "2", ",", ")", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"artist\"", "]", "=", "artist", "seq", "=", "[", "]", "for", "track", "in", "_collect_nodes", "(", "None", ",", "self", ",", "self", ".", "ws_prefix", "+", "\".getArtistTracks\"", ",", "cacheable", ",", "params", ")", ":", "title", "=", "_extract", "(", "track", ",", "\"name\"", ")", "artist", "=", "_extract", "(", "track", ",", "\"artist\"", ")", "date", "=", "_extract", "(", "track", ",", "\"date\"", ")", "album", "=", "_extract", "(", "track", ",", "\"album\"", ")", "timestamp", "=", "track", ".", "getElementsByTagName", "(", "\"date\"", ")", "[", "0", "]", ".", "getAttribute", "(", "\"uts\"", ")", "seq", ".", "append", "(", "PlayedTrack", "(", "Track", "(", "artist", ",", "title", ",", "self", ".", "network", ")", ",", "album", ",", "date", ",", "timestamp", ")", ")", "return", "seq" ]

[ "Get", "a", "list", "of", "tracks", "by", "a", "given", "artist", "scrobbled", "by", "this", "user", "including", "scrobble", "time", "." ]

[ "def", "get_friends", "(", "self", ",", "limit", "=", "50", ",", "cacheable", "=", "False", ")", ":", "seq", "=", "[", "]", "for", "node", "in", "_collect_nodes", "(", "limit", ",", "self", ",", "self", ".", "ws_prefix", "+", "\".getFriends\"", ",", "cacheable", ")", ":", "seq", ".", "append", "(", "User", "(", "_extract", "(", "node", ",", "\"name\"", ")", ",", "self", ".", "network", ")", ")", "return", "seq" ]

[ "Returns", "a", "list", "of", "the", "user", "s", "friends", "." ]

[ "def", "get_loved_tracks", "(", "self", ",", "limit", "=", "50", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "seq", "=", "[", "]", "for", "track", "in", "_collect_nodes", "(", "limit", ",", "self", ",", "self", ".", "ws_prefix", "+", "\".getLovedTracks\"", ",", "cacheable", ",", "params", ")", ":", "try", ":", "artist", "=", "_extract", "(", "track", ",", "\"name\"", ",", "1", ")", "except", "IndexError", ":", "# pragma: no cover", "continue", "title", "=", "_extract", "(", "track", ",", "\"name\"", ")", "date", "=", "_extract", "(", "track", ",", "\"date\"", ")", "timestamp", "=", "track", ".", "getElementsByTagName", "(", "\"date\"", ")", "[", "0", "]", ".", "getAttribute", "(", "\"uts\"", ")", "seq", ".", "append", "(", "LovedTrack", "(", "Track", "(", "artist", ",", "title", ",", "self", ".", "network", ")", ",", "date", ",", "timestamp", ")", ")", "return", "seq" ]

[ "Returns", "this", "user", "s", "loved", "track", "as", "a", "sequence", "of", "LovedTrack", "objects", "in", "reverse", "order", "of", "their", "timestamp", "all", "the", "way", "back", "to", "the", "first", "track", "." ]

[ "def", "get_now_playing", "(", "self", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"limit\"", "]", "=", "\"1\"", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getRecentTracks\"", ",", "False", ",", "params", ")", "tracks", "=", "doc", ".", "getElementsByTagName", "(", "\"track\"", ")", "if", "len", "(", "tracks", ")", "==", "0", ":", "return", "None", "e", "=", "tracks", "[", "0", "]", "if", "not", "e", ".", "hasAttribute", "(", "\"nowplaying\"", ")", ":", "return", "None", "artist", "=", "_extract", "(", "e", ",", "\"artist\"", ")", "title", "=", "_extract", "(", "e", ",", "\"name\"", ")", "return", "Track", "(", "artist", ",", "title", ",", "self", ".", "network", ",", "self", ".", "name", ")" ]

[ "Returns", "the", "currently", "playing", "track", "or", "None", "if", "nothing", "is", "playing", "." ]

[ "def", "get_recent_tracks", "(", "self", ",", "limit", "=", "10", ",", "cacheable", "=", "True", ",", "time_from", "=", "None", ",", "time_to", "=", "None", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "if", "time_from", ":", "params", "[", "\"from\"", "]", "=", "time_from", "if", "time_to", ":", "params", "[", "\"to\"", "]", "=", "time_to", "seq", "=", "[", "]", "for", "track", "in", "_collect_nodes", "(", "limit", ",", "self", ",", "self", ".", "ws_prefix", "+", "\".getRecentTracks\"", ",", "cacheable", ",", "params", ")", ":", "if", "track", ".", "hasAttribute", "(", "\"nowplaying\"", ")", ":", "continue", "# to prevent the now playing track from sneaking in", "title", "=", "_extract", "(", "track", ",", "\"name\"", ")", "artist", "=", "_extract", "(", "track", ",", "\"artist\"", ")", "date", "=", "_extract", "(", "track", ",", "\"date\"", ")", "album", "=", "_extract", "(", "track", ",", "\"album\"", ")", "timestamp", "=", "track", ".", "getElementsByTagName", "(", "\"date\"", ")", "[", "0", "]", ".", "getAttribute", "(", "\"uts\"", ")", "seq", ".", "append", "(", "PlayedTrack", "(", "Track", "(", "artist", ",", "title", ",", "self", ".", "network", ")", ",", "album", ",", "date", ",", "timestamp", ")", ")", "return", "seq" ]

[ "Returns", "this", "user", "s", "played", "track", "as", "a", "sequence", "of", "PlayedTrack", "objects", "in", "reverse", "order", "of", "playtime", "all", "the", "way", "back", "to", "the", "first", "track", "." ]

[ "def", "get_country", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "country", "=", "_extract", "(", "doc", ",", "\"country\"", ")", "if", "country", "is", "None", "or", "country", "==", "\"None\"", ":", "return", "None", "else", ":", "return", "Country", "(", "country", ",", "self", ".", "network", ")" ]

[ "Returns", "the", "name", "of", "the", "country", "of", "the", "user", "." ]

[ "def", "is_subscriber", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "_extract", "(", "doc", ",", "\"subscriber\"", ")", "==", "\"1\"" ]

[ "Returns", "whether", "the", "user", "is", "a", "subscriber", "or", "not", ".", "True", "or", "False", "." ]

[ "def", "get_playcount", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "_number", "(", "_extract", "(", "doc", ",", "\"playcount\"", ")", ")" ]

[ "Returns", "the", "user", "s", "playcount", "so", "far", "." ]

[ "def", "get_registered", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "_extract", "(", "doc", ",", "\"registered\"", ")" ]

[ "Returns", "the", "user", "s", "registration", "date", "." ]

[ "def", "get_unixtime_registered", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getInfo\"", ",", "True", ")", "return", "int", "(", "doc", ".", "getElementsByTagName", "(", "\"registered\"", ")", "[", "0", "]", ".", "getAttribute", "(", "\"unixtime\"", ")", ")" ]

[ "Returns", "the", "user", "s", "registration", "date", "as", "a", "UNIX", "timestamp", "." ]

[ "def", "get_tagged_albums", "(", "self", ",", "tag", ",", "limit", "=", "None", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"tag\"", "]", "=", "tag", "params", "[", "\"taggingtype\"", "]", "=", "\"album\"", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getpersonaltags\"", ",", "cacheable", ",", "params", ")", "return", "_extract_albums", "(", "doc", ",", "self", ".", "network", ")" ]

[ "Returns", "the", "albums", "tagged", "by", "a", "user", "." ]

[ "def", "get_tagged_artists", "(", "self", ",", "tag", ",", "limit", "=", "None", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"tag\"", "]", "=", "tag", "params", "[", "\"taggingtype\"", "]", "=", "\"artist\"", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getpersonaltags\"", ",", "True", ",", "params", ")", "return", "_extract_artists", "(", "doc", ",", "self", ".", "network", ")" ]

[ "Returns", "the", "artists", "tagged", "by", "a", "user", "." ]

[ "def", "get_tagged_tracks", "(", "self", ",", "tag", ",", "limit", "=", "None", ",", "cacheable", "=", "True", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"tag\"", "]", "=", "tag", "params", "[", "\"taggingtype\"", "]", "=", "\"track\"", "if", "limit", ":", "params", "[", "\"limit\"", "]", "=", "limit", "doc", "=", "self", ".", "_request", "(", "self", ".", "ws_prefix", "+", "\".getpersonaltags\"", ",", "cacheable", ",", "params", ")", "return", "_extract_tracks", "(", "doc", ",", "self", ".", "network", ")" ]

[ "Returns", "the", "tracks", "tagged", "by", "a", "user", "." ]

[ "def", "get_track_scrobbles", "(", "self", ",", "artist", ",", "track", ",", "cacheable", "=", "False", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"artist\"", "]", "=", "artist", "params", "[", "\"track\"", "]", "=", "track", "seq", "=", "[", "]", "for", "track", "in", "_collect_nodes", "(", "None", ",", "self", ",", "self", ".", "ws_prefix", "+", "\".getTrackScrobbles\"", ",", "cacheable", ",", "params", ")", ":", "title", "=", "_extract", "(", "track", ",", "\"name\"", ")", "artist", "=", "_extract", "(", "track", ",", "\"artist\"", ")", "date", "=", "_extract", "(", "track", ",", "\"date\"", ")", "album", "=", "_extract", "(", "track", ",", "\"album\"", ")", "timestamp", "=", "track", ".", "getElementsByTagName", "(", "\"date\"", ")", "[", "0", "]", ".", "getAttribute", "(", "\"uts\"", ")", "seq", ".", "append", "(", "PlayedTrack", "(", "Track", "(", "artist", ",", "title", ",", "self", ".", "network", ")", ",", "album", ",", "date", ",", "timestamp", ")", ")", "return", "seq" ]

[ "Get", "a", "list", "of", "this", "user", "s", "scrobbles", "of", "this", "artist", "s", "track", "including", "scrobble", "time", "." ]

[ "def", "get_total_result_count", "(", "self", ")", ":", "doc", "=", "self", ".", "_request", "(", "self", ".", "_ws_prefix", "+", "\".search\"", ",", "True", ")", "return", "_extract", "(", "doc", ",", "\"totalResults\"", ")" ]

[ "Returns", "the", "total", "count", "of", "all", "the", "results", "." ]

[ "def", "_retrieve_page", "(", "self", ",", "page_index", ")", ":", "params", "=", "self", ".", "_get_params", "(", ")", "params", "[", "\"page\"", "]", "=", "str", "(", "page_index", ")", "doc", "=", "self", ".", "_request", "(", "self", ".", "_ws_prefix", "+", "\".search\"", ",", "True", ",", "params", ")", "return", "doc", ".", "getElementsByTagName", "(", "self", ".", "_ws_prefix", "+", "\"matches\"", ")", "[", "0", "]" ]

[ "Returns", "the", "node", "of", "matches", "to", "be", "processed" ]

[ "def", "get_next_page", "(", "self", ")", ":", "master_node", "=", "self", ".", "_retrieve_next_page", "(", ")", "seq", "=", "[", "]", "for", "node", "in", "master_node", ".", "getElementsByTagName", "(", "\"album\"", ")", ":", "seq", ".", "append", "(", "Album", "(", "_extract", "(", "node", ",", "\"artist\"", ")", ",", "_extract", "(", "node", ",", "\"name\"", ")", ",", "self", ".", "network", ",", "info", "=", "{", "\"image\"", ":", "_extract_all", "(", "node", ",", "\"image\"", ")", "}", ",", ")", ")", "return", "seq" ]

[ "Returns", "the", "next", "page", "of", "results", "as", "a", "sequence", "of", "Album", "objects", "." ]

[ "def", "get_next_page", "(", "self", ")", ":", "master_node", "=", "self", ".", "_retrieve_next_page", "(", ")", "seq", "=", "[", "]", "for", "node", "in", "master_node", ".", "getElementsByTagName", "(", "\"artist\"", ")", ":", "artist", "=", "Artist", "(", "_extract", "(", "node", ",", "\"name\"", ")", ",", "self", ".", "network", ",", "info", "=", "{", "\"image\"", ":", "_extract_all", "(", "node", ",", "\"image\"", ")", "}", ",", ")", "artist", ".", "listener_count", "=", "_number", "(", "_extract", "(", "node", ",", "\"listeners\"", ")", ")", "seq", ".", "append", "(", "artist", ")", "return", "seq" ]

[ "Returns", "the", "next", "page", "of", "results", "as", "a", "sequence", "of", "Artist", "objects", "." ]

[ "def", "get_next_page", "(", "self", ")", ":", "master_node", "=", "self", ".", "_retrieve_next_page", "(", ")", "seq", "=", "[", "]", "for", "node", "in", "master_node", ".", "getElementsByTagName", "(", "\"track\"", ")", ":", "track", "=", "Track", "(", "_extract", "(", "node", ",", "\"artist\"", ")", ",", "_extract", "(", "node", ",", "\"name\"", ")", ",", "self", ".", "network", ",", "info", "=", "{", "\"image\"", ":", "_extract_all", "(", "node", ",", "\"image\"", ")", "}", ",", ")", "track", ".", "listener_count", "=", "_number", "(", "_extract", "(", "node", ",", "\"listeners\"", ")", ")", "seq", ".", "append", "(", "track", ")", "return", "seq" ]

[ "Returns", "the", "next", "page", "of", "results", "as", "a", "sequence", "of", "Track", "objects", "." ]

[ "def", "write_file", "(", "self", ",", "fp", ",", "data", ")", ":", "with", "open", "(", "fp", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "data", ")" ]

[ "Write", "output", "to", "a", "file", "." ]

[ "def", "detect_function_style", "(", "self", ",", "test_record", ")", ":", "index", "=", "0", "# IMPORTANT: apply regex sequentially and stop on the first match:", "for", "regex", "in", "FUNCTION_STYLE_REGEX", ":", "if", "re", ".", "search", "(", "regex", ",", "test_record", ")", ":", "return", "index", "index", "+=", "1", "return", "None" ]

[ "Returns", "the", "index", "for", "the", "function", "declaration", "style", "detected", "in", "the", "given", "string", "or", "None", "if", "no", "function", "declarations", "are", "detected", "." ]

[ "def", "change_function_style", "(", "self", ",", "stripped_record", ",", "func_decl_style", ")", ":", "if", "func_decl_style", "is", "None", ":", "return", "stripped_record", "if", "self", ".", "apply_function_style", "is", "None", ":", "# user does not want to enforce any specific function style", "return", "stripped_record", "regex", "=", "FUNCTION_STYLE_REGEX", "[", "func_decl_style", "]", "replacement", "=", "FUNCTION_STYLE_REPLACEMENT", "[", "self", ".", "apply_function_style", "]", "changed_record", "=", "re", ".", "sub", "(", "regex", ",", "replacement", ",", "stripped_record", ")", "return", "changed_record", ".", "strip", "(", ")" ]

[ "Converts", "a", "function", "definition", "syntax", "from", "the", "func_decl_style", "to", "the", "one", "that", "has", "been", "set", "in", "self", ".", "apply_function_style", "and", "returns", "the", "string", "with", "the", "converted", "syntax", "." ]

[ "def", "beautify_file", "(", "self", ",", "path", ")", ":", "error", "=", "False", "if", "(", "path", "==", "'-'", ")", ":", "data", "=", "sys", ".", "stdin", ".", "read", "(", ")", "result", ",", "error", "=", "self", ".", "beautify_string", "(", "data", ",", "'(stdin)'", ")", "sys", ".", "stdout", ".", "write", "(", "result", ")", "else", ":", "# named file", "data", "=", "self", ".", "read_file", "(", "path", ")", "result", ",", "error", "=", "self", ".", "beautify_string", "(", "data", ",", "path", ")", "if", "(", "data", "!=", "result", ")", ":", "if", "(", "self", ".", "check_only", ")", ":", "if", "not", "error", ":", "# we want to return 0 (success) only if the given file is already", "# well formatted:", "error", "=", "(", "result", "!=", "data", ")", "else", ":", "if", "(", "self", ".", "backup", ")", ":", "self", ".", "write_file", "(", "path", "+", "'.bak'", ",", "data", ")", "self", ".", "write_file", "(", "path", ",", "result", ")", "return", "error" ]

[ "Beautify", "bash", "script", "file", "." ]

[ "def", "main", "(", "self", ")", ":", "error", "=", "False", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "\"A Bash beautifier for the masses, version {}\"", ".", "format", "(", "self", ".", "get_version", "(", ")", ")", ",", "add_help", "=", "False", ")", "parser", ".", "add_argument", "(", "'--indent-size'", ",", "'-i'", ",", "nargs", "=", "1", ",", "type", "=", "int", ",", "default", "=", "4", ",", "help", "=", "\"Sets the number of spaces to be used in \"", "\"indentation.\"", ")", "parser", ".", "add_argument", "(", "'--files'", ",", "'-f'", ",", "nargs", "=", "'*'", ",", "help", "=", "\"Files to be beautified. This is mandatory. \"", "\"If - is provided as filename, then beautysh reads \"", "\"from stdin and writes on stdout.\"", ")", "parser", ".", "add_argument", "(", "'--backup'", ",", "'-b'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Beautysh will create a backup file in the \"", "\"same path as the original.\"", ")", "parser", ".", "add_argument", "(", "'--check'", ",", "'-c'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Beautysh will just check the files without doing \"", "\"any in-place beautify.\"", ")", "parser", ".", "add_argument", "(", "'--tab'", ",", "'-t'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Sets indentation to tabs instead of spaces.\"", ")", "parser", ".", "add_argument", "(", "'--force-function-style'", ",", "'-s'", ",", "nargs", "=", "1", ",", "help", "=", "\"Force a specific Bash function formatting. See below for more info.\"", ")", "parser", ".", "add_argument", "(", "'--version'", ",", "'-v'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Prints the version and exits.\"", ")", "parser", ".", "add_argument", "(", "'--help'", ",", "'-h'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Print this help message.\"", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "if", "(", "len", "(", "sys", ".", "argv", ")", "<", "2", ")", "or", "args", ".", "help", ":", "self", ".", "print_help", "(", "parser", ")", "exit", "(", ")", "if", "args", ".", "version", ":", "sys", ".", "stdout", ".", "write", "(", "\"%s\\n\"", "%", "self", ".", "get_version", "(", ")", ")", "exit", "(", ")", "if", "(", "type", "(", "args", ".", "indent_size", ")", "is", "list", ")", ":", "args", ".", "indent_size", "=", "args", ".", "indent_size", "[", "0", "]", "if", "not", "args", ".", "files", ":", "sys", ".", "stdout", ".", "write", "(", "\"Please provide at least one input file\\n\"", ")", "exit", "(", ")", "self", ".", "tab_size", "=", "args", ".", "indent_size", "self", ".", "backup", "=", "args", ".", "backup", "self", ".", "check_only", "=", "args", ".", "check", "if", "(", "args", ".", "tab", ")", ":", "self", ".", "tab_size", "=", "1", "self", ".", "tab_str", "=", "'\\t'", "if", "(", "type", "(", "args", ".", "force_function_style", ")", "is", "list", ")", ":", "provided_style", "=", "self", ".", "parse_function_style", "(", "args", ".", "force_function_style", "[", "0", "]", ")", "if", "provided_style", "is", "None", ":", "sys", ".", "stdout", ".", "write", "(", "\"Invalid value for the function style. See --help for details.\\n\"", ")", "exit", "(", ")", "self", ".", "apply_function_style", "=", "provided_style", "for", "path", "in", "args", ".", "files", ":", "error", "|=", "self", ".", "beautify_file", "(", "path", ")", "sys", ".", "exit", "(", "(", "0", ",", "1", ")", "[", "error", "]", ")" ]

[ "Main", "beautifying", "function", "." ]

[ "def", "init_default", "(", "required", ",", "default", ",", "optional_default", ")", ":", "if", "not", "required", "and", "default", "==", "NOTHING", ":", "default", "=", "optional_default", "return", "default" ]

[ "Returns", "optional", "default", "if", "field", "is", "not", "required", "and", "default", "was", "not", "provided", "." ]

[ "def", "to_child_field", "(", "cls", ")", ":", "class", "ChildConverter", "(", "object", ")", ":", "def", "__init__", "(", "self", ",", "cls", ")", ":", "self", ".", "_cls", "=", "cls", "@", "property", "def", "cls", "(", "self", ")", ":", "return", "resolve_class", "(", "self", ".", "_cls", ")", "def", "__call__", "(", "self", ",", "value", ")", ":", "try", ":", "# Issue #33: if value is the class and callable, then invoke", "if", "value", "==", "self", ".", "_cls", "and", "callable", "(", "value", ")", ":", "value", "=", "value", "(", ")", "return", "to_model", "(", "self", ".", "cls", ",", "value", ")", "except", "ValueError", "as", "e", ":", "error_msg", "=", "CHILD_ERROR_MSG", ".", "format", "(", "value", ",", "self", ".", "cls", ",", "str", "(", "e", ")", ")", "raise", "ValueError", "(", "error_msg", ")", "return", "ChildConverter", "(", "cls", ")" ]

[ "Returns", "an", "callable", "instance", "that", "will", "convert", "a", "value", "to", "a", "Child", "object", "." ]

[ "def", "to_mapping_field", "(", "cls", ",", "key", ")", ":", "# pragma: no mccabe", "class", "MappingConverter", "(", "object", ")", ":", "def", "__init__", "(", "self", ",", "cls", ",", "key", ")", ":", "self", ".", "_cls", "=", "cls", "self", ".", "key", "=", "key", "@", "property", "def", "cls", "(", "self", ")", ":", "return", "resolve_class", "(", "self", ".", "_cls", ")", "def", "__call__", "(", "self", ",", "values", ")", ":", "kwargs", "=", "OrderedDict", "(", ")", "if", "isinstance", "(", "values", ",", "TypedMapping", ")", ":", "return", "values", "if", "not", "isinstance", "(", "values", ",", "(", "type", "(", "{", "}", ")", ",", "type", "(", "None", ")", ")", ")", ":", "raise", "TypeError", "(", "\"Invalid type : {}\"", ".", "format", "(", "type", "(", "values", ")", ")", ")", "if", "values", ":", "for", "key_value", ",", "item", "in", "values", ".", "items", "(", ")", ":", "if", "isinstance", "(", "item", ",", "dict", ")", ":", "item", "[", "self", ".", "key", "]", "=", "key_value", "item", "=", "to_model", "(", "self", ".", "cls", ",", "item", ")", "kwargs", "[", "key_value", "]", "=", "item", "return", "TypedMapping", "(", "cls", "=", "self", ".", "cls", ",", "kwargs", "=", "kwargs", ",", "key", "=", "self", ".", "key", ")", "return", "MappingConverter", "(", "cls", ",", "key", ")" ]

[ "Returns", "a", "callable", "instance", "that", "will", "convert", "a", "value", "to", "a", "Mapping", "." ]

[ "def", "to_date_field", "(", "formatter", ")", ":", "class", "DateConverter", "(", "object", ")", ":", "def", "__init__", "(", "self", ",", "formatter", ")", ":", "self", ".", "formatter", "=", "formatter", "def", "__call__", "(", "self", ",", "value", ")", ":", "if", "isinstance", "(", "value", ",", "string_types", ")", ":", "value", "=", "datetime", ".", "strptime", "(", "value", ",", "self", ".", "formatter", ")", ".", "date", "(", ")", "if", "isinstance", "(", "value", ",", "datetime", ")", ":", "value", "=", "value", ".", "date", "(", ")", "return", "value", "return", "DateConverter", "(", "formatter", ")" ]

[ "Returns", "a", "callable", "instance", "that", "will", "convert", "a", "string", "to", "a", "Date", "." ]

[ "def", "to_datetime_field", "(", "formatter", ")", ":", "class", "DateTimeConverter", "(", "object", ")", ":", "def", "__init__", "(", "self", ",", "formatter", ")", ":", "self", ".", "formatter", "=", "formatter", "def", "__call__", "(", "self", ",", "value", ")", ":", "if", "isinstance", "(", "value", ",", "string_types", ")", ":", "value", "=", "parser", ".", "parse", "(", "value", ")", "return", "value", "return", "DateTimeConverter", "(", "formatter", ")" ]

[ "Returns", "a", "callable", "instance", "that", "will", "convert", "a", "string", "to", "a", "DateTime", "." ]

[ "def", "to_time_field", "(", "formatter", ")", ":", "class", "TimeConverter", "(", "object", ")", ":", "def", "__init__", "(", "self", ",", "formatter", ")", ":", "self", ".", "formatter", "=", "formatter", "def", "__call__", "(", "self", ",", "value", ")", ":", "if", "isinstance", "(", "value", ",", "string_types", ")", ":", "value", "=", "datetime", ".", "strptime", "(", "value", ",", "self", ".", "formatter", ")", ".", "time", "(", ")", "return", "value", "return", "TimeConverter", "(", "formatter", ")" ]

[ "Returns", "a", "callable", "instance", "that", "will", "convert", "a", "string", "to", "a", "Time", "." ]

[ "def", "to_dict", "(", "obj", ",", "*", "*", "kwargs", ")", ":", "# if is_related, then iterate attrs.", "if", "is_model", "(", "obj", ".", "__class__", ")", ":", "return", "related_obj_to_dict", "(", "obj", ",", "*", "*", "kwargs", ")", "# else, return obj directly. register a custom to_dict if you need to!", "# reference: https://pypi.python.org/pypi/singledispatch", "else", ":", "return", "obj" ]

[ "Convert", "an", "object", "into", "dictionary", ".", "Uses", "singledispatch", "to", "allow", "for", "clean", "extensions", "for", "custom", "class", "types", "." ]

[ "def", "related_obj_to_dict", "(", "obj", ",", "*", "*", "kwargs", ")", ":", "# Explicitly discard formatter kwarg, should not be cascaded down.", "kwargs", ".", "pop", "(", "'formatter'", ",", "None", ")", "# If True, remove fields that start with an underscore (e.g. _secret)", "suppress_private_attr", "=", "kwargs", ".", "get", "(", "\"suppress_private_attr\"", ",", "False", ")", "# if True, don't store fields with None values into dictionary.", "suppress_empty_values", "=", "kwargs", ".", "get", "(", "\"suppress_empty_values\"", ",", "False", ")", "# get list of attrs fields", "attrs", "=", "fields", "(", "obj", ".", "__class__", ")", "# instantiate return dict, use OrderedDict type by default", "return_dict", "=", "kwargs", ".", "get", "(", "\"dict_factory\"", ",", "OrderedDict", ")", "(", ")", "for", "a", "in", "attrs", ":", "# skip if private attr and flag tells you to skip", "if", "suppress_private_attr", "and", "a", ".", "name", ".", "startswith", "(", "\"_\"", ")", ":", "continue", "metadata", "=", "a", ".", "metadata", "or", "{", "}", "# formatter is a related-specific `attrs` meta field", "# see fields.DateField", "formatter", "=", "metadata", ".", "get", "(", "'formatter'", ")", "# get value and call to_dict on it, passing the kwargs/formatter", "value", "=", "getattr", "(", "obj", ",", "a", ".", "name", ")", "value", "=", "to_dict", "(", "value", ",", "formatter", "=", "formatter", ",", "*", "*", "kwargs", ")", "# check flag, skip None values", "if", "suppress_empty_values", "and", "value", "is", "None", ":", "continue", "# field name can be overridden by the metadata field", "key_name", "=", "a", ".", "metadata", ".", "get", "(", "'key'", ")", "or", "a", ".", "name", "# store converted / formatted value into return dictionary", "return_dict", "[", "key_name", "]", "=", "value", "return", "return_dict" ]

[ "Covert", "a", "known", "related", "object", "to", "a", "dictionary", "." ]

[ "def", "convert_key_to_attr_names", "(", "cls", ",", "original", ")", ":", "attrs", "=", "fields", "(", "cls", ")", "updated", "=", "{", "}", "keys_pulled", "=", "set", "(", ")", "for", "a", "in", "attrs", ":", "key_name", "=", "a", ".", "metadata", ".", "get", "(", "'key'", ")", "or", "a", ".", "name", "if", "key_name", "in", "original", ":", "updated", "[", "a", ".", "name", "]", "=", "original", ".", "get", "(", "key_name", ")", "keys_pulled", ".", "add", "(", "key_name", ")", "if", "getattr", "(", "cls", ",", "'__related_strict__'", ",", "False", ")", ":", "extra", "=", "set", "(", "original", ".", "keys", "(", ")", ")", "-", "keys_pulled", "if", "len", "(", "extra", ")", ":", "raise", "ValueError", "(", "\"Extra keys (strict mode): {}\"", ".", "format", "(", "extra", ")", ")", "return", "updated" ]

[ "convert", "key", "names", "to", "their", "corresponding", "attribute", "names" ]

[ "def", "to_yaml", "(", "obj", ",", "stream", "=", "None", ",", "dumper_cls", "=", "yaml", ".", "Dumper", ",", "default_flow_style", "=", "False", ",", "*", "*", "kwargs", ")", ":", "class", "OrderedDumper", "(", "dumper_cls", ")", ":", "pass", "def", "dict_representer", "(", "dumper", ",", "data", ")", ":", "return", "dumper", ".", "represent_mapping", "(", "yaml", ".", "resolver", ".", "BaseResolver", ".", "DEFAULT_MAPPING_TAG", ",", "data", ".", "items", "(", ")", ")", "OrderedDumper", ".", "add_representer", "(", "OrderedDict", ",", "dict_representer", ")", "obj_dict", "=", "to_dict", "(", "obj", ",", "*", "*", "kwargs", ")", "return", "yaml", ".", "dump", "(", "obj_dict", ",", "stream", ",", "OrderedDumper", ",", "default_flow_style", "=", "default_flow_style", ")" ]

[ "Serialize", "a", "Python", "object", "into", "a", "YAML", "stream", "with", "OrderedDict", "and", "default_flow_style", "defaulted", "to", "False", "." ]

[ "def", "from_yaml", "(", "stream", ",", "cls", "=", "None", ",", "loader_cls", "=", "yaml", ".", "Loader", ",", "object_pairs_hook", "=", "OrderedDict", ",", "*", "*", "extras", ")", ":", "class", "OrderedLoader", "(", "loader_cls", ")", ":", "pass", "def", "construct_mapping", "(", "loader", ",", "node", ")", ":", "loader", ".", "flatten_mapping", "(", "node", ")", "return", "object_pairs_hook", "(", "loader", ".", "construct_pairs", "(", "node", ")", ")", "OrderedLoader", ".", "add_constructor", "(", "yaml", ".", "resolver", ".", "BaseResolver", ".", "DEFAULT_MAPPING_TAG", ",", "construct_mapping", ")", "yaml_dict", "=", "yaml", ".", "load", "(", "stream", ",", "OrderedLoader", ")", "or", "{", "}", "yaml_dict", ".", "update", "(", "extras", ")", "return", "cls", "(", "*", "*", "yaml_dict", ")", "if", "cls", "else", "yaml_dict" ]

[ "Convert", "a", "YAML", "stream", "into", "a", "class", "via", "the", "OrderedLoader", "class", "." ]

[ "def", "from_json", "(", "stream", ",", "cls", "=", "None", ",", "object_pairs_hook", "=", "OrderedDict", ",", "*", "*", "extras", ")", ":", "stream", "=", "stream", ".", "read", "(", ")", "if", "hasattr", "(", "stream", ",", "'read'", ")", "else", "stream", "json_dict", "=", "json", ".", "loads", "(", "stream", ",", "object_pairs_hook", "=", "object_pairs_hook", ")", "if", "extras", ":", "json_dict", ".", "update", "(", "extras", ")", "# pragma: no cover", "return", "to_model", "(", "cls", ",", "json_dict", ")", "if", "cls", "else", "json_dict" ]

[ "Convert", "a", "JSON", "string", "or", "stream", "into", "specified", "class", "." ]

[ "def", "BooleanField", "(", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "bool", ")", "return", "attrib", "(", "default", "=", "default", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "bool", "field", "on", "a", "model", "." ]

[ "def", "ChildField", "(", "cls", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "converter", "=", "converters", ".", "to_child_field", "(", "cls", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "object", "if", "isinstance", "(", "cls", ",", "str", ")", "else", "cls", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "child", "field", "on", "a", "model", "." ]

[ "def", "DateField", "(", "formatter", "=", "types", ".", "DEFAULT_DATE_FORMAT", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "date", ")", "converter", "=", "converters", ".", "to_date_field", "(", "formatter", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "formatter", "=", "formatter", ",", "key", "=", "key", ")", ")" ]

[ "Create", "new", "date", "field", "on", "a", "model", "." ]

[ "def", "DateTimeField", "(", "formatter", "=", "types", ".", "DEFAULT_DATETIME_FORMAT", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "datetime", ")", "converter", "=", "converters", ".", "to_datetime_field", "(", "formatter", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "formatter", "=", "formatter", ",", "key", "=", "key", ")", ")" ]

[ "Create", "new", "datetime", "field", "on", "a", "model", "." ]

[ "def", "TimeField", "(", "formatter", "=", "types", ".", "DEFAULT_TIME_FORMAT", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "time", ")", "converter", "=", "converters", ".", "to_time_field", "(", "formatter", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "formatter", "=", "formatter", ",", "key", "=", "key", ")", ")" ]

[ "Create", "new", "time", "field", "on", "a", "model", "." ]

[ "def", "FloatField", "(", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "float", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converters", ".", "float_if_not_none", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "float", "field", "on", "a", "model", "." ]

[ "def", "IntegerField", "(", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "int", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converters", ".", "int_if_not_none", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "int", "field", "on", "a", "model", "." ]

[ "def", "MappingField", "(", "cls", ",", "child_key", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "False", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "OrderedDict", "(", ")", ")", "converter", "=", "converters", ".", "to_mapping_field", "(", "cls", ",", "child_key", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "types", ".", "TypedMapping", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "mapping", "field", "on", "a", "model", "." ]

[ "def", "RegexField", "(", "regex", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "string_types", ",", "validators", ".", "regex", "(", "regex", ")", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converters", ".", "str_if_not_none", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "str", "field", "on", "a", "model", "." ]

[ "def", "SequenceField", "(", "cls", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "False", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "[", "]", ")", "converter", "=", "converters", ".", "to_sequence_field", "(", "cls", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "types", ".", "TypedSequence", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "sequence", "field", "on", "a", "model", "." ]

[ "def", "SetField", "(", "cls", ",", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "False", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "set", "(", ")", ")", "converter", "=", "converters", ".", "to_set_field", "(", "cls", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "types", ".", "TypedSet", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "converter", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "set", "field", "on", "a", "model", "." ]

[ "def", "DecimalField", "(", "default", "=", "NOTHING", ",", "required", "=", "True", ",", "repr", "=", "True", ",", "cmp", "=", "True", ",", "key", "=", "None", ")", ":", "default", "=", "_init_fields", ".", "init_default", "(", "required", ",", "default", ",", "None", ")", "validator", "=", "_init_fields", ".", "init_validator", "(", "required", ",", "Decimal", ")", "return", "attrib", "(", "default", "=", "default", ",", "converter", "=", "lambda", "x", ":", "Decimal", "(", "x", ")", ",", "validator", "=", "validator", ",", "repr", "=", "repr", ",", "cmp", "=", "cmp", ",", "metadata", "=", "dict", "(", "key", "=", "key", ")", ")" ]

[ "Create", "new", "decimal", "field", "on", "a", "model", "." ]

[ "def", "run_clingo", "(", "draco_query", ":", "List", "[", "str", "]", ",", "constants", ":", "Dict", "[", "str", ",", "str", "]", "=", "None", ",", "files", ":", "List", "[", "str", "]", "=", "None", ",", "relax_hard", "=", "False", ",", "silence_warnings", "=", "False", ",", "debug", "=", "False", ",", ")", "->", "Tuple", "[", "str", ",", "str", "]", ":", "# default args", "files", "=", "files", "or", "DRACO_LP", "if", "relax_hard", "and", "\"hard-integrity.lp\"", "in", "files", ":", "files", ".", "remove", "(", "\"hard-integrity.lp\"", ")", "constants", "=", "constants", "or", "{", "}", "options", "=", "[", "\"--outf=2\"", ",", "\"--quiet=1,2,2\"", "]", "if", "silence_warnings", ":", "options", ".", "append", "(", "\"--warn=no-atom-undefined\"", ")", "for", "name", ",", "value", "in", "constants", ".", "items", "(", ")", ":", "options", ".", "append", "(", "f\"-c {name}={value}\"", ")", "cmd", "=", "[", "\"clingo\"", "]", "+", "options", "logger", ".", "debug", "(", "\"Command: %s\"", ",", "\" \"", ".", "join", "(", "cmd", ")", ")", "proc", "=", "subprocess", ".", "Popen", "(", "args", "=", "cmd", ",", "stdin", "=", "subprocess", ".", "PIPE", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "program", "=", "\"\\n\"", ".", "join", "(", "draco_query", ")", "file_names", "=", "[", "os", ".", "path", ".", "join", "(", "DRACO_LP_DIR", ",", "f", ")", "for", "f", "in", "files", "]", "asp_program", "=", "b\"\\n\"", ".", "join", "(", "map", "(", "load_file", ",", "file_names", ")", ")", "+", "program", ".", "encode", "(", "\"utf8\"", ")", "if", "debug", ":", "with", "tempfile", ".", "NamedTemporaryFile", "(", "mode", "=", "\"w\"", ",", "delete", "=", "False", ")", "as", "fd", ":", "fd", ".", "write", "(", "program", ")", "logger", ".", "info", "(", "'Debug ASP with \"clingo %s %s\"'", ",", "\" \"", ".", "join", "(", "file_names", ")", ",", "fd", ".", "name", ")", "stdout", ",", "stderr", "=", "proc", ".", "communicate", "(", "asp_program", ")", "return", "(", "stderr", ",", "stdout", ")" ]

[ "Run", "draco", "and", "return", "stderr", "and", "stdout" ]

[ "def", "run", "(", "draco_query", ":", "List", "[", "str", "]", ",", "constants", ":", "Dict", "[", "str", ",", "str", "]", "=", "None", ",", "files", ":", "List", "[", "str", "]", "=", "None", ",", "relax_hard", "=", "False", ",", "silence_warnings", "=", "False", ",", "debug", "=", "False", ",", "clear_cache", "=", "False", ",", ")", "->", "Optional", "[", "Result", "]", ":", "# Clear file cache. useful during development in notebooks.", "if", "clear_cache", "and", "file_cache", ":", "logger", ".", "warning", "(", "\"Cleared file cache\"", ")", "file_cache", ".", "clear", "(", ")", "stderr", ",", "stdout", "=", "run_clingo", "(", "draco_query", ",", "constants", ",", "files", ",", "relax_hard", ",", "silence_warnings", ",", "debug", ")", "try", ":", "json_result", "=", "json", ".", "loads", "(", "stdout", ")", "except", "json", ".", "JSONDecodeError", ":", "logger", ".", "error", "(", "\"stdout: %s\"", ",", "stdout", ")", "logger", ".", "error", "(", "\"stderr: %s\"", ",", "stderr", ")", "raise", "if", "stderr", ":", "logger", ".", "error", "(", "stderr", ")", "result", "=", "json_result", "[", "\"Result\"", "]", "if", "result", "==", "\"UNSATISFIABLE\"", ":", "logger", ".", "info", "(", "\"Constraints are unsatisfiable.\"", ")", "return", "None", "elif", "result", "==", "\"OPTIMUM FOUND\"", ":", "# get the last witness, which is the best result", "answers", "=", "json_result", "[", "\"Call\"", "]", "[", "0", "]", "[", "\"Witnesses\"", "]", "[", "-", "1", "]", "logger", ".", "debug", "(", "answers", "[", "\"Value\"", "]", ")", "return", "Result", "(", "clyngor", ".", "Answers", "(", "answers", "[", "\"Value\"", "]", ")", ".", "sorted", ",", "cost", "=", "json_result", "[", "\"Models\"", "]", "[", "\"Costs\"", "]", "[", "0", "]", ",", ")", "elif", "result", "==", "\"SATISFIABLE\"", ":", "answers", "=", "json_result", "[", "\"Call\"", "]", "[", "0", "]", "[", "\"Witnesses\"", "]", "[", "-", "1", "]", "assert", "(", "json_result", "[", "\"Models\"", "]", "[", "\"Number\"", "]", "==", "1", ")", ",", "\"Should not have more than one model if we don't optimize\"", "logger", ".", "debug", "(", "answers", "[", "\"Value\"", "]", ")", "return", "Result", "(", "clyngor", ".", "Answers", "(", "answers", "[", "\"Value\"", "]", ")", ".", "sorted", ")", "else", ":", "logger", ".", "error", "(", "\"Unsupported result: %s\"", ",", "result", ")", "return", "None" ]

[ "Run", "clingo", "to", "compute", "a", "completion", "of", "a", "partial", "spec", "or", "violations", "." ]

[ "def", "get", "(", "self", ")", ":", "self", ".", "index", "+=", "1", "# If we've gone through the entire deque once, shuffle it again to", "# simulate ever-flowing random. self.shuffle() will run __init__(),", "# which will reset the index to 0.", "if", "self", ".", "index", "==", "len", "(", "self", ")", ":", "self", ".", "shuffle", "(", ")", "self", ".", "rotate", "(", "1", ")", "try", ":", "return", "self", "[", "0", "]", "except", ":", "return", "\"wow\"" ]

[ "Get", "one", "item", ".", "This", "will", "rotate", "the", "deque", "one", "step", ".", "Repeated", "gets", "will", "return", "different", "items", "." ]

[ "def", "shuffle", "(", "self", ")", ":", "args", "=", "list", "(", "self", ")", "random", ".", "shuffle", "(", "args", ")", "self", ".", "clear", "(", ")", "super", "(", "DogeDeque", ",", "self", ")", ".", "__init__", "(", "args", ")" ]

[ "Shuffle", "the", "deque" ]

[ "def", "get", "(", "self", ")", ":", "if", "len", "(", "self", ")", "<", "1", ":", "return", "\"wow\"", "if", "self", ".", "index", ">=", "len", "(", "self", ")", ":", "self", ".", "index", "=", "0", "step", "=", "random", ".", "randint", "(", "1", ",", "min", "(", "self", ".", "step", ",", "len", "(", "self", ")", ")", ")", "res", "=", "self", "[", "0", "]", "self", ".", "index", "+=", "step", "self", ".", "rotate", "(", "step", ")", "return", "res" ]

[ "Get", "one", "item", "and", "prepare", "to", "get", "an", "item", "with", "lower", "rank", "on", "the", "next", "call", "." ]

[ "def", "onscreen_len", "(", "s", ")", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", "0", ")", "and", "isinstance", "(", "s", ",", "str", ")", ":", "return", "len", "(", "s", ")", "length", "=", "0", "for", "ch", "in", "s", ":", "length", "+=", "2", "if", "unicodedata", ".", "east_asian_width", "(", "ch", ")", "==", "'W'", "else", "1", "return", "length" ]

[ "Calculate", "the", "length", "of", "a", "unicode", "string", "on", "screen", "accounting", "for", "double", "-", "width", "characters" ]

[ "def", "setup_seasonal", "(", "self", ")", ":", "# If we've specified a season, just run that one", "if", "self", ".", "ns", ".", "season", ":", "return", "self", ".", "load_season", "(", "self", ".", "ns", ".", "season", ")", "# If we've specified another doge or no doge at all, it does not make", "# sense to use seasons.", "if", "self", ".", "ns", ".", "doge_path", "is", "not", "None", "and", "not", "self", ".", "ns", ".", "no_shibe", ":", "return", "now", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "for", "season", ",", "data", "in", "wow", ".", "SEASONS", ".", "items", "(", ")", ":", "start", ",", "end", "=", "data", "[", "'dates'", "]", "start_dt", "=", "datetime", ".", "datetime", "(", "now", ".", "year", ",", "start", "[", "0", "]", ",", "start", "[", "1", "]", ")", "# Be sane if the holiday season spans over New Year's day.", "end_dt", "=", "datetime", ".", "datetime", "(", "now", ".", "year", "+", "(", "start", "[", "0", "]", ">", "end", "[", "0", "]", "and", "1", "or", "0", ")", ",", "end", "[", "0", "]", ",", "end", "[", "1", "]", ")", "if", "start_dt", "<=", "now", "<=", "end_dt", ":", "# Wow, much holiday!", "return", "self", ".", "load_season", "(", "season", ")" ]

[ "Check", "if", "there", "s", "some", "seasonal", "holiday", "going", "on", "setup", "appropriate", "Shibe", "picture", "and", "load", "holiday", "words", "." ]

[ "def", "apply_text", "(", "self", ")", ":", "# Calculate a random sampling of lines that are to have text applied", "# onto them. Return value is a sorted list of line index integers.", "linelen", "=", "len", "(", "self", ".", "lines", ")", "affected", "=", "sorted", "(", "random", ".", "sample", "(", "range", "(", "linelen", ")", ",", "int", "(", "linelen", "/", "3.5", ")", ")", ")", "for", "i", ",", "target", "in", "enumerate", "(", "affected", ",", "start", "=", "1", ")", ":", "line", "=", "self", ".", "lines", "[", "target", "]", "line", "=", "re", ".", "sub", "(", "'\\n'", ",", "' '", ",", "line", ")", "word", "=", "self", ".", "words", ".", "get", "(", ")", "# If first or last line, or a random selection, use standalone wow.", "if", "i", "==", "1", "or", "i", "==", "len", "(", "affected", ")", "or", "random", ".", "choice", "(", "range", "(", "20", ")", ")", "==", "0", ":", "word", "=", "'wow'", "# Generate a new DogeMessage, possibly based on a word.", "self", ".", "lines", "[", "target", "]", "=", "DogeMessage", "(", "self", ",", "line", ",", "word", ")", ".", "generate", "(", ")" ]

[ "Apply", "text", "around", "doge" ]

[ "def", "load_doge", "(", "self", ")", ":", "if", "self", ".", "ns", ".", "no_shibe", ":", "return", "[", "''", "]", "with", "open", "(", "self", ".", "doge_path", ")", "as", "f", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", "0", ")", ":", "if", "locale", ".", "getpreferredencoding", "(", ")", "==", "'UTF-8'", ":", "doge_lines", "=", "[", "l", ".", "decode", "(", "'utf-8'", ")", "for", "l", "in", "f", ".", "xreadlines", "(", ")", "]", "else", ":", "# encode to printable characters, leaving a space in place", "# of untranslatable characters, resulting in a slightly", "# blockier doge on non-UTF8 terminals", "doge_lines", "=", "[", "l", ".", "decode", "(", "'utf-8'", ")", ".", "encode", "(", "locale", ".", "getpreferredencoding", "(", ")", ",", "'replace'", ")", ".", "replace", "(", "'?'", ",", "' '", ")", "for", "l", "in", "f", ".", "xreadlines", "(", ")", "]", "else", ":", "doge_lines", "=", "[", "l", "for", "l", "in", "f", ".", "readlines", "(", ")", "]", "return", "doge_lines" ]

[ "Return", "pretty", "ASCII", "Shibe", "." ]

[ "def", "get_real_data", "(", "self", ")", ":", "ret", "=", "[", "]", "username", "=", "os", ".", "environ", ".", "get", "(", "'USER'", ")", "if", "username", ":", "ret", ".", "append", "(", "username", ")", "editor", "=", "os", ".", "environ", ".", "get", "(", "'EDITOR'", ")", "if", "editor", ":", "editor", "=", "editor", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", "ret", ".", "append", "(", "editor", ")", "# OS, hostname and... architechture (because lel)", "if", "hasattr", "(", "os", ",", "'uname'", ")", ":", "uname", "=", "os", ".", "uname", "(", ")", "ret", ".", "append", "(", "uname", "[", "0", "]", ")", "ret", ".", "append", "(", "uname", "[", "1", "]", ")", "ret", ".", "append", "(", "uname", "[", "4", "]", ")", "# Grab actual files from $HOME.", "files", "=", "os", ".", "listdir", "(", "os", ".", "environ", ".", "get", "(", "'HOME'", ")", ")", "if", "files", ":", "ret", ".", "append", "(", "random", ".", "choice", "(", "files", ")", ")", "# Grab some processes", "ret", "+=", "self", ".", "get_processes", "(", ")", "[", ":", "2", "]", "# Prepare the returned data. First, lowercase it.", "# If there is unicode data being returned from any of the above", "# Python 2 needs to decode the UTF bytes to not crash. See issue #45.", "func", "=", "str", ".", "lower", "if", "sys", ".", "version_info", "<", "(", "3", ",", ")", ":", "func", "=", "lambda", "x", ":", "str", ".", "lower", "(", "x", ")", ".", "decode", "(", "'utf-8'", ")", "self", ".", "words", ".", "extend", "(", "map", "(", "func", ",", "ret", ")", ")" ]

[ "Grab", "actual", "data", "from", "the", "system" ]

[ "def", "get_stdin_data", "(", "self", ")", ":", "if", "self", ".", "tty", ".", "in_is_tty", ":", "# No pipez found", "return", "False", "if", "sys", ".", "version_info", "<", "(", "3", ",", "0", ")", ":", "stdin_lines", "=", "(", "l", ".", "decode", "(", "'utf-8'", ")", "for", "l", "in", "sys", ".", "stdin", ".", "xreadlines", "(", ")", ")", "else", ":", "stdin_lines", "=", "(", "l", "for", "l", "in", "sys", ".", "stdin", ".", "readlines", "(", ")", ")", "rx_word", "=", "re", ".", "compile", "(", "\"\\w+\"", ",", "re", ".", "UNICODE", ")", "# If we have stdin data, we should remove everything else!", "self", ".", "words", ".", "clear", "(", ")", "word_list", "=", "[", "match", ".", "group", "(", "0", ")", "for", "line", "in", "stdin_lines", "for", "match", "in", "rx_word", ".", "finditer", "(", "line", ".", "lower", "(", ")", ")", "]", "if", "self", ".", "ns", ".", "filter_stopwords", ":", "word_list", "=", "self", ".", "filter_words", "(", "word_list", ",", "stopwords", "=", "wow", ".", "STOPWORDS", ",", "min_length", "=", "self", ".", "ns", ".", "min_length", ")", "self", ".", "words", ".", "extend", "(", "word_list", ")", "return", "True" ]

[ "Get", "words", "from", "stdin", "." ]

[ "def", "get_processes", "(", "self", ")", ":", "procs", "=", "set", "(", ")", "try", ":", "# POSIX ps, so it should work in most environments where doge would", "p", "=", "sp", ".", "Popen", "(", "[", "'ps'", ",", "'-A'", ",", "'-o'", ",", "'comm='", "]", ",", "stdout", "=", "sp", ".", "PIPE", ")", "output", ",", "error", "=", "p", ".", "communicate", "(", ")", "if", "sys", ".", "version_info", ">", "(", "3", ",", "0", ")", ":", "output", "=", "output", ".", "decode", "(", "'utf-8'", ")", "for", "comm", "in", "output", ".", "split", "(", "'\\n'", ")", ":", "name", "=", "comm", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", "# Filter short and weird ones", "if", "name", "and", "len", "(", "name", ")", ">=", "2", "and", "':'", "not", "in", "name", ":", "procs", ".", "add", "(", "name", ")", "finally", ":", "# Either it executed properly or no ps was found.", "proc_list", "=", "list", "(", "procs", ")", "random", ".", "shuffle", "(", "proc_list", ")", "return", "proc_list" ]

[ "Grab", "a", "shuffled", "list", "of", "all", "currently", "running", "process", "names" ]

[ "def", "get_tty_size", "(", "self", ")", ":", "if", "sys", ".", "platform", "==", "'win32'", ":", "# stdin, stdout, stderr = -10, -11, -12", "ret", "=", "self", ".", "_tty_size_windows", "(", "-", "10", ")", "ret", "=", "ret", "or", "self", ".", "_tty_size_windows", "(", "-", "11", ")", "ret", "=", "ret", "or", "self", ".", "_tty_size_windows", "(", "-", "12", ")", "else", ":", "# stdin, stdout, stderr = 0, 1, 2", "ret", "=", "self", ".", "_tty_size_linux", "(", "0", ")", "ret", "=", "ret", "or", "self", ".", "_tty_size_linux", "(", "1", ")", "ret", "=", "ret", "or", "self", ".", "_tty_size_linux", "(", "2", ")", "return", "ret", "or", "(", "25", ",", "80", ")" ]

[ "Get", "the", "current", "terminal", "size", "without", "using", "a", "subprocess" ]

[ "def", "_coords", "(", "shape", ")", ":", "assert", "shape", ".", "geom_type", "==", "'Polygon'", "coords", "=", "[", "list", "(", "shape", ".", "exterior", ".", "coords", ")", "]", "for", "interior", "in", "shape", ".", "interiors", ":", "coords", ".", "append", "(", "list", "(", "interior", ".", "coords", ")", ")", "return", "coords" ]

[ "Return", "a", "list", "of", "lists", "of", "coordinates", "of", "the", "polygon", ".", "The", "list", "consists", "firstly", "of", "the", "list", "of", "exterior", "coordinates", "followed", "by", "zero", "or", "more", "lists", "of", "any", "interior", "coordinates", "." ]

[ "def", "_union_in_blocks", "(", "contours", ",", "block_size", ")", ":", "n_contours", "=", "len", "(", "contours", ")", "for", "i", "in", "range", "(", "0", ",", "n_contours", ",", "block_size", ")", ":", "j", "=", "min", "(", "i", "+", "block_size", ",", "n_contours", ")", "inners", "=", "[", "]", "for", "c", "in", "contours", "[", "i", ":", "j", "]", ":", "p", "=", "_contour_to_poly", "(", "c", ")", "if", "p", ".", "type", "==", "'Polygon'", ":", "inners", ".", "append", "(", "p", ")", "elif", "p", ".", "type", "==", "'MultiPolygon'", ":", "inners", ".", "extend", "(", "p", ".", "geoms", ")", "holes", "=", "unary_union", "(", "inners", ")", "assert", "holes", ".", "is_valid", "yield", "holes" ]

[ "Generator", "which", "yields", "a", "valid", "shape", "for", "each", "block_size", "multiple", "of", "input", "contours", ".", "This", "merges", "together", "the", "contours", "for", "each", "block", "before", "yielding", "them", "." ]

[ "def", "_polytree_node_to_shapely", "(", "node", ")", ":", "polygons", "=", "[", "]", "children", "=", "[", "]", "for", "ch", "in", "node", ".", "Childs", ":", "p", ",", "c", "=", "_polytree_node_to_shapely", "(", "ch", ")", "polygons", ".", "extend", "(", "p", ")", "children", ".", "extend", "(", "c", ")", "if", "node", ".", "IsHole", ":", "# check expectations: a node should be a hole, _or_ return children.", "# this is because children of holes must be outers, and should be on", "# the polygons list.", "assert", "len", "(", "children", ")", "==", "0", "if", "node", ".", "Contour", ":", "children", "=", "[", "node", ".", "Contour", "]", "else", ":", "children", "=", "[", "]", "elif", "node", ".", "Contour", ":", "poly", "=", "_contour_to_poly", "(", "node", ".", "Contour", ")", "# we add each inner one-by-one so that we can reject them individually", "# if they cause the polygon to become invalid. if the shape has lots", "# of inners, then this can mean a proportional amount of work, and may", "# take 1,000s of seconds. instead, we can group inners together, which", "# reduces the number of times we call the expensive 'difference'", "# method.", "block_size", "=", "200", "if", "len", "(", "children", ")", ">", "block_size", ":", "inners", "=", "_union_in_blocks", "(", "children", ",", "block_size", ")", "else", ":", "inners", "=", "_generate_polys", "(", "children", ")", "for", "inner", "in", "inners", ":", "# the difference of two valid polygons may fail, and in this", "# situation we'd like to be able to display the polygon anyway.", "# so we discard the bad inner and continue.", "#", "# see test_polygon_inners_crossing_outer for a test case.", "try", ":", "diff", "=", "poly", ".", "difference", "(", "inner", ")", "except", ":", "continue", "if", "not", "diff", ".", "is_valid", ":", "diff", "=", "diff", ".", "buffer", "(", "0", ")", "# keep this for when https://trac.osgeo.org/geos/ticket/789 is", "# resolved.", "#", "# assert diff.is_valid, \\", "# \"Difference of %s and %s did not make valid polygon %s \" \\", "# \" because %s\" \\", "# % (poly.wkt, inner.wkt, diff.wkt, explain_validity(diff))", "#", "# NOTE: this throws away the inner ring if we can't produce a", "# valid difference. not ideal, but we'd rather produce something", "# that's valid than nothing.", "if", "diff", ".", "is_valid", ":", "poly", "=", "diff", "assert", "poly", ".", "is_valid", "if", "poly", ".", "type", "==", "'MultiPolygon'", ":", "polygons", ".", "extend", "(", "poly", ".", "geoms", ")", "else", ":", "polygons", ".", "append", "(", "poly", ")", "children", "=", "[", "]", "else", ":", "# check expectations: this branch gets executed if this node is not a", "# hole, and has no contour. in that situation we'd expect that it has", "# no children, as it would not be possible to subtract children from", "# an empty outer contour.", "assert", "len", "(", "children", ")", "==", "0", "return", "(", "polygons", ",", "children", ")" ]

[ "Recurses", "down", "a", "Clipper", "PolyTree", "extracting", "the", "results", "as", "Shapely", "objects", "." ]

[ "def", "make_valid_pyclipper", "(", "shape", ")", ":", "# drop all degenerate inners", "clean_shape", "=", "_drop_degenerate_inners", "(", "shape", ")", "pc", "=", "pyclipper", ".", "Pyclipper", "(", ")", "try", ":", "pc", ".", "AddPaths", "(", "_coords", "(", "clean_shape", ")", ",", "pyclipper", ".", "PT_SUBJECT", ",", "True", ")", "# note: Execute2 returns the polygon tree, not the list of paths", "result", "=", "pc", ".", "Execute2", "(", "pyclipper", ".", "CT_UNION", ",", "pyclipper", ".", "PFT_EVENODD", ")", "except", "pyclipper", ".", "ClipperException", ":", "return", "MultiPolygon", "(", "[", "]", ")", "return", "_polytree_to_shapely", "(", "result", ")" ]

[ "Use", "the", "pyclipper", "library", "to", "union", "a", "polygon", "on", "its", "own", ".", "This", "operation", "uses", "the", "even", "-", "odd", "rule", "to", "determine", "which", "points", "are", "in", "the", "interior", "of", "the", "polygon", "and", "can", "reconstruct", "the", "orientation", "of", "the", "polygon", "from", "that", ".", "The", "pyclipper", "library", "is", "robust", "and", "uses", "integer", "coordinates", "so", "should", "not", "produce", "any", "additional", "degeneracies", "." ]

[ "def", "make_valid_polygon", "(", "shape", ")", ":", "assert", "shape", ".", "geom_type", "==", "'Polygon'", "shape", "=", "make_valid_pyclipper", "(", "shape", ")", "assert", "shape", ".", "is_valid", "return", "shape" ]

[ "Make", "a", "polygon", "valid", ".", "Polygons", "can", "be", "invalid", "in", "many", "ways", "such", "as", "self", "-", "intersection", "self", "-", "touching", "and", "degeneracy", ".", "This", "process", "attempts", "to", "make", "a", "polygon", "valid", "while", "retaining", "as", "much", "of", "its", "extent", "or", "area", "as", "possible", "." ]

[ "def", "make_it_valid", "(", "shape", ")", ":", "if", "shape", ".", "is_empty", ":", "return", "shape", "elif", "shape", ".", "type", "==", "'MultiPolygon'", ":", "shape", "=", "make_valid_multipolygon", "(", "shape", ")", "elif", "shape", ".", "type", "==", "'Polygon'", ":", "shape", "=", "make_valid_polygon", "(", "shape", ")", "return", "shape" ]

[ "Attempt", "to", "make", "any", "polygon", "or", "multipolygon", "valid", "." ]

[ "def", "_decode_lines", "(", "geom", ")", ":", "lines", "=", "[", "]", "current_line", "=", "[", "]", "current_moveto", "=", "None", "# to keep track of the position. we'll adapt the move-to commands to all", "# be relative to 0,0 at the beginning of each linestring.", "x", "=", "0", "y", "=", "0", "end", "=", "len", "(", "geom", ")", "i", "=", "0", "while", "i", "<", "end", ":", "header", "=", "geom", "[", "i", "]", "cmd", "=", "header", "&", "7", "run_length", "=", "header", "//", "8", "if", "cmd", "==", "1", ":", "# move to", "# flush previous line.", "if", "current_moveto", ":", "lines", ".", "append", "(", "Line", "(", "current_moveto", ",", "EndsAt", "(", "x", ",", "y", ")", ",", "current_line", ")", ")", "current_line", "=", "[", "]", "assert", "run_length", "==", "1", "x", "+=", "unzigzag", "(", "geom", "[", "i", "+", "1", "]", ")", "y", "+=", "unzigzag", "(", "geom", "[", "i", "+", "2", "]", ")", "i", "+=", "3", "current_moveto", "=", "MoveTo", "(", "x", ",", "y", ")", "elif", "cmd", "==", "2", ":", "# line to", "assert", "current_moveto", "# we just copy this run, since it's encoding isn't going to change", "next_i", "=", "i", "+", "1", "+", "run_length", "*", "2", "current_line", ".", "extend", "(", "geom", "[", "i", ":", "next_i", "]", ")", "# but we still need to decode it to figure out where each move-to", "# command is in absolute space.", "for", "j", "in", "xrange", "(", "0", ",", "run_length", ")", ":", "dx", "=", "unzigzag", "(", "geom", "[", "i", "+", "1", "+", "2", "*", "j", "]", ")", "dy", "=", "unzigzag", "(", "geom", "[", "i", "+", "2", "+", "2", "*", "j", "]", ")", "x", "+=", "dx", "y", "+=", "dy", "i", "=", "next_i", "else", ":", "raise", "ValueError", "(", "'Unhandled command: %d'", "%", "cmd", ")", "if", "current_line", ":", "assert", "current_moveto", "lines", ".", "append", "(", "Line", "(", "current_moveto", ",", "EndsAt", "(", "x", ",", "y", ")", ",", "current_line", ")", ")", "return", "lines" ]

[ "Decode", "a", "linear", "MVT", "geometry", "into", "a", "list", "of", "Lines", "." ]

[ "def", "_reorder_lines", "(", "lines", ")", ":", "x", "=", "0", "y", "=", "0", "new_lines", "=", "[", "]", "# treat the list of lines as a stack, off which we keep popping the best", "# one to add next.", "while", "lines", ":", "# looping over all the lines like this isn't terribly efficient, but", "# in local tests seems to handle a few thousand lines without a", "# problem.", "min_dist", "=", "None", "min_i", "=", "None", "for", "i", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "moveto", ",", "_", ",", "_", "=", "line", "dist", "=", "abs", "(", "moveto", ".", "x", "-", "x", ")", "+", "abs", "(", "moveto", ".", "y", "-", "y", ")", "if", "min_dist", "is", "None", "or", "dist", "<", "min_dist", ":", "min_dist", "=", "dist", "min_i", "=", "i", "assert", "min_i", "is", "not", "None", "line", "=", "lines", ".", "pop", "(", "min_i", ")", "_", ",", "endsat", ",", "_", "=", "line", "x", "=", "endsat", ".", "x", "y", "=", "endsat", ".", "y", "new_lines", ".", "append", "(", "line", ")", "return", "new_lines" ]

[ "Reorder", "lines", "so", "that", "the", "distance", "from", "the", "end", "of", "one", "to", "the", "beginning", "of", "the", "next", "is", "minimised", "." ]

[ "def", "_rewrite_geometry", "(", "geom", ",", "new_lines", ")", ":", "new_geom", "=", "[", "]", "x", "=", "0", "y", "=", "0", "for", "line", "in", "new_lines", ":", "moveto", ",", "endsat", ",", "lineto_cmds", "=", "line", "dx", "=", "moveto", ".", "x", "-", "x", "dy", "=", "moveto", ".", "y", "-", "y", "x", "=", "endsat", ".", "x", "y", "=", "endsat", ".", "y", "new_geom", ".", "append", "(", "9", ")", "# move to, run_length = 1", "new_geom", ".", "append", "(", "zigzag", "(", "dx", ")", ")", "new_geom", ".", "append", "(", "zigzag", "(", "dy", ")", ")", "new_geom", ".", "extend", "(", "lineto_cmds", ")", "# write the lines back out to geom", "del", "geom", "[", ":", "]", "geom", ".", "extend", "(", "new_geom", ")" ]

[ "Re", "-", "encode", "a", "list", "of", "Lines", "with", "absolute", "MoveTos", "as", "a", "continuous", "stream", "of", "MVT", "geometry", "commands", "each", "relative", "to", "the", "last", ".", "Replace", "geom", "with", "that", "stream", "." ]

[ "def", "optimise_tile", "(", "tile_bytes", ")", ":", "t", "=", "tile", "(", ")", "t", ".", "ParseFromString", "(", "tile_bytes", ")", "for", "layer", "in", "t", ".", "layers", ":", "sto", "=", "StringTableOptimiser", "(", ")", "for", "feature", "in", "layer", ".", "features", ":", "# (multi)linestrings only", "if", "feature", ".", "type", "==", "2", ":", "optimise_multilinestring", "(", "feature", ".", "geometry", ")", "sto", ".", "add_tags", "(", "feature", ".", "tags", ")", "sto", ".", "update_string_table", "(", "layer", ")", "return", "t", ".", "SerializeToString", "(", ")" ]

[ "Decode", "a", "sequence", "of", "bytes", "as", "an", "MVT", "tile", "and", "reorder", "the", "string", "table", "of", "its", "layers", "and", "the", "order", "of", "its", "multilinestrings", "to", "save", "a", "few", "bytes", "." ]

[ "def", "coords_on_grid", "(", "self", ",", "x", ",", "y", ")", ":", "if", "isinstance", "(", "x", ",", "float", ")", ":", "x", "=", "int", "(", "self", ".", "_round", "(", "x", ")", ")", "if", "isinstance", "(", "y", ",", "float", ")", ":", "y", "=", "int", "(", "self", ".", "_round", "(", "y", ")", ")", "if", "not", "self", ".", "_y_coord_down", ":", "y", "=", "self", ".", "_extents", "-", "y", "return", "x", ",", "y" ]

[ "Snap", "coordinates", "on", "the", "grid", "with", "integer", "coordinates" ]

[ "def", "encode_arc", "(", "self", ",", "coords", ")", ":", "last_x", ",", "last_y", "=", "self", ".", "_last_x", ",", "self", ".", "_last_y", "float_x", ",", "float_y", "=", "next", "(", "coords", ")", "x", ",", "y", "=", "self", ".", "coords_on_grid", "(", "float_x", ",", "float_y", ")", "dx", ",", "dy", "=", "x", "-", "last_x", ",", "y", "-", "last_y", "cmd_encoded", "=", "encode_cmd_length", "(", "CMD_MOVE_TO", ",", "1", ")", "commands", "=", "[", "cmd_encoded", ",", "zigzag", "(", "dx", ")", ",", "zigzag", "(", "dy", ")", ",", "CMD_FAKE", "]", "pairs_added", "=", "0", "last_x", ",", "last_y", "=", "x", ",", "y", "for", "float_x", ",", "float_y", "in", "coords", ":", "x", ",", "y", "=", "self", ".", "coords_on_grid", "(", "float_x", ",", "float_y", ")", "dx", ",", "dy", "=", "x", "-", "last_x", ",", "y", "-", "last_y", "if", "dx", "==", "0", "and", "dy", "==", "0", ":", "continue", "commands", ".", "append", "(", "zigzag", "(", "dx", ")", ")", "commands", ".", "append", "(", "zigzag", "(", "dy", ")", ")", "last_x", ",", "last_y", "=", "x", ",", "y", "pairs_added", "+=", "1", "if", "pairs_added", "==", "0", ":", "return", "False", "cmd_encoded", "=", "encode_cmd_length", "(", "CMD_LINE_TO", ",", "pairs_added", ")", "commands", "[", "3", "]", "=", "cmd_encoded", "self", ".", "_geometry", ".", "extend", "(", "commands", ")", "self", ".", "_last_x", ",", "self", ".", "_last_y", "=", "last_x", ",", "last_y", "return", "True" ]

[ "Appends", "commands", "to", "_geometry", "to", "create", "an", "arc", ".", "-", "Returns", "False", "if", "nothing", "was", "added", "-", "Returns", "True", "and", "moves", "_last_x", "_last_y", "if", "some", "points", "where", "added" ]

[ "def", "sigterm", "(", "self", ",", "signum", ",", "frame", ")", ":", "self", ".", "logger", ".", "warning", "(", "\"Caught signal %s. Stopping daemon.\"", "%", "signum", ")", "sys", ".", "exit", "(", "0", ")" ]

[ "These", "actions", "will", "be", "done", "after", "SIGTERM", "." ]

[ "def", "exit", "(", "self", ")", ":", "self", ".", "logger", ".", "warning", "(", "\"Stopping daemon.\"", ")", "os", ".", "remove", "(", "self", ".", "pid", ")", "sys", ".", "exit", "(", "0", ")" ]

[ "Cleanup", "pid", "file", "at", "exit", "." ]

[ "def", "js_reverse_inline", "(", "context", ")", ":", "if", "'request'", "in", "context", ":", "default_urlresolver", "=", "get_resolver", "(", "getattr", "(", "context", "[", "'request'", "]", ",", "'urlconf'", ",", "None", ")", ")", "else", ":", "default_urlresolver", "=", "get_resolver", "(", "None", ")", "return", "mark_safe", "(", "generate_js", "(", "default_urlresolver", ")", ")" ]

[ "Outputs", "a", "string", "of", "javascript", "that", "can", "generate", "URLs", "via", "the", "use", "of", "the", "names", "given", "to", "those", "URLs", "." ]

[ "def", "_iterate_records", "(", "self", ")", ":", "raise_invalid_gzip", "=", "False", "empty_record", "=", "False", "while", "True", ":", "try", ":", "self", ".", "record", "=", "self", ".", "_next_record", "(", "self", ".", "next_line", ")", "if", "raise_invalid_gzip", ":", "self", ".", "_raise_invalid_gzip_err", "(", ")", "yield", "self", ".", "record", "except", "EOFError", ":", "empty_record", "=", "True", "self", ".", "read_to_end", "(", ")", "if", "self", ".", "reader", ".", "decompressor", ":", "# if another gzip member, continue", "if", "self", ".", "reader", ".", "read_next_member", "(", ")", ":", "continue", "# if empty record, then we're done", "elif", "empty_record", ":", "break", "# otherwise, probably a gzip", "# containing multiple non-chunked records", "# raise this as an error", "else", ":", "raise_invalid_gzip", "=", "True", "# non-gzip, so we're done", "elif", "empty_record", ":", "break", "self", ".", "close", "(", ")" ]

[ "iterate", "over", "each", "record" ]

[ "def", "_consume_blanklines", "(", "self", ")", ":", "empty_size", "=", "0", "first_line", "=", "True", "while", "True", ":", "line", "=", "self", ".", "reader", ".", "readline", "(", ")", "if", "len", "(", "line", ")", "==", "0", ":", "return", "None", ",", "empty_size", "stripped", "=", "line", ".", "rstrip", "(", ")", "if", "len", "(", "stripped", ")", "==", "0", "or", "first_line", ":", "empty_size", "+=", "len", "(", "line", ")", "if", "len", "(", "stripped", ")", "!=", "0", ":", "# if first line is not blank,", "# likely content-length was invalid, display warning", "err_offset", "=", "self", ".", "fh", ".", "tell", "(", ")", "-", "self", ".", "reader", ".", "rem_length", "(", ")", "-", "empty_size", "sys", ".", "stderr", ".", "write", "(", "self", ".", "INC_RECORD", ".", "format", "(", "err_offset", ",", "line", ")", ")", "self", ".", "err_count", "+=", "1", "first_line", "=", "False", "continue", "return", "line", ",", "empty_size" ]

[ "Consume", "blank", "lines", "that", "are", "between", "records", "-", "For", "warcs", "there", "are", "usually", "2", "-", "For", "arcs", "may", "be", "1", "or", "0", "-", "For", "block", "gzipped", "files", "these", "are", "at", "end", "of", "each", "gzip", "envelope", "and", "are", "included", "in", "record", "length", "which", "is", "the", "full", "gzip", "envelope", "-", "For", "uncompressed", "they", "are", "between", "records", "and", "so", "are", "NOT", "part", "of", "the", "record", "length" ]

[ "def", "read_to_end", "(", "self", ",", "record", "=", "None", ")", ":", "# no current record to read", "if", "not", "self", ".", "record", ":", "return", "None", "# already at end of this record, don't read until it is consumed", "if", "self", ".", "member_info", ":", "return", "None", "curr_offset", "=", "self", ".", "offset", "while", "True", ":", "b", "=", "self", ".", "record", ".", "raw_stream", ".", "read", "(", "BUFF_SIZE", ")", "if", "not", "b", ":", "break", "\"\"\"\n - For compressed files, blank lines are consumed\n since they are part of record length\n - For uncompressed files, blank lines are read later,\n and not included in the record length\n \"\"\"", "#if self.reader.decompressor:", "self", ".", "next_line", ",", "empty_size", "=", "self", ".", "_consume_blanklines", "(", ")", "self", ".", "offset", "=", "self", ".", "fh", ".", "tell", "(", ")", "-", "self", ".", "reader", ".", "rem_length", "(", ")", "#if self.offset < 0:", "# raise Exception('Not Gzipped Properly')", "if", "self", ".", "next_line", ":", "self", ".", "offset", "-=", "len", "(", "self", ".", "next_line", ")", "length", "=", "self", ".", "offset", "-", "curr_offset", "if", "not", "self", ".", "reader", ".", "decompressor", ":", "length", "-=", "empty_size", "self", ".", "member_info", "=", "(", "curr_offset", ",", "length", ")" ]

[ "Read", "remainder", "of", "the", "stream", "If", "a", "digester", "is", "included", "update", "it", "with", "the", "data", "read" ]

[ "def", "_next_record", "(", "self", ",", "next_line", ")", ":", "record", "=", "self", ".", "loader", ".", "parse_record_stream", "(", "self", ".", "reader", ",", "next_line", ",", "self", ".", "known_format", ",", "self", ".", "no_record_parse", ",", "self", ".", "ensure_http_headers", ")", "self", ".", "member_info", "=", "None", "# Track known format for faster parsing of other records", "if", "not", "self", ".", "mixed_arc_warc", ":", "self", ".", "known_format", "=", "record", ".", "format", "return", "record" ]

[ "Use", "loader", "to", "parse", "the", "record", "from", "the", "reader", "stream", "Supporting", "warc", "and", "arc", "records" ]

[ "def", "wrap_stream", "(", "stream", ",", "content_length", ")", ":", "try", ":", "content_length", "=", "int", "(", "content_length", ")", "if", "content_length", ">=", "0", ":", "# optimize: if already a LimitStream, set limit to", "# the smaller of the two limits", "if", "isinstance", "(", "stream", ",", "LimitReader", ")", ":", "stream", ".", "limit", "=", "min", "(", "stream", ".", "limit", ",", "content_length", ")", "else", ":", "stream", "=", "LimitReader", "(", "stream", ",", "content_length", ")", "except", "(", "ValueError", ",", "TypeError", ")", ":", "pass", "return", "stream" ]

[ "If", "given", "content_length", "is", "an", "int", ">", "0", "wrap", "the", "stream", "in", "a", "LimitReader", ".", "Otherwise", "return", "the", "stream", "unaltered" ]

[ "def", "replace_header", "(", "self", ",", "name", ",", "value", ")", ":", "name_lower", "=", "name", ".", "lower", "(", ")", "for", "index", "in", "range", "(", "len", "(", "self", ".", "headers", ")", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "curr_name", ",", "curr_value", "=", "self", ".", "headers", "[", "index", "]", "if", "curr_name", ".", "lower", "(", ")", "==", "name_lower", ":", "self", ".", "headers", "[", "index", "]", "=", "(", "curr_name", ",", "value", ")", "return", "curr_value", "self", ".", "headers", ".", "append", "(", "(", "name", ",", "value", ")", ")", "return", "None" ]

[ "replace", "header", "with", "new", "value", "or", "add", "new", "header", "return", "old", "header", "value", "if", "any" ]

[ "def", "validate_statusline", "(", "self", ",", "valid_statusline", ")", ":", "code", "=", "self", ".", "get_statuscode", "(", ")", "try", ":", "code", "=", "int", "(", "code", ")", "assert", "(", "code", ">", "0", ")", "return", "True", "except", "(", "ValueError", ",", "AssertionError", ")", ":", "self", ".", "statusline", "=", "valid_statusline", "return", "False" ]

[ "Check", "that", "the", "statusline", "is", "valid", "eg", ".", "starts", "with", "a", "numeric", "code", ".", "If", "not", "replace", "with", "passed", "in", "valid_statusline" ]

[ "def", "add_range", "(", "self", ",", "start", ",", "part_len", ",", "total_len", ")", ":", "content_range", "=", "'bytes {0}-{1}/{2}'", ".", "format", "(", "start", ",", "start", "+", "part_len", "-", "1", ",", "total_len", ")", "self", ".", "statusline", "=", "'206 Partial Content'", "self", ".", "replace_header", "(", "'Content-Range'", ",", "content_range", ")", "self", ".", "replace_header", "(", "'Content-Length'", ",", "str", "(", "part_len", ")", ")", "self", ".", "replace_header", "(", "'Accept-Ranges'", ",", "'bytes'", ")", "return", "self" ]

[ "Add", "range", "headers", "indicating", "that", "this", "a", "partial", "response" ]

[ "def", "parse", "(", "self", ",", "stream", ",", "full_statusline", "=", "None", ")", ":", "# status line w newlines intact", "if", "full_statusline", "is", "None", ":", "full_statusline", "=", "stream", ".", "readline", "(", ")", "full_statusline", "=", "self", ".", "decode_header", "(", "full_statusline", ")", "statusline", ",", "total_read", "=", "_strip_count", "(", "full_statusline", ",", "0", ")", "headers", "=", "[", "]", "# at end of stream", "if", "total_read", "==", "0", ":", "raise", "EOFError", "(", ")", "elif", "not", "statusline", ":", "return", "StatusAndHeaders", "(", "statusline", "=", "statusline", ",", "headers", "=", "headers", ",", "protocol", "=", "''", ",", "total_len", "=", "total_read", ")", "# validate only if verify is set", "if", "self", ".", "verify", ":", "protocol_status", "=", "self", ".", "split_prefix", "(", "statusline", ",", "self", ".", "statuslist", ")", "if", "not", "protocol_status", ":", "msg", "=", "'Expected Status Line starting with {0} - Found: {1}'", "msg", "=", "msg", ".", "format", "(", "self", ".", "statuslist", ",", "statusline", ")", "raise", "StatusAndHeadersParserException", "(", "msg", ",", "full_statusline", ")", "else", ":", "protocol_status", "=", "statusline", ".", "split", "(", "' '", ",", "1", ")", "line", ",", "total_read", "=", "_strip_count", "(", "self", ".", "decode_header", "(", "stream", ".", "readline", "(", ")", ")", ",", "total_read", ")", "while", "line", ":", "result", "=", "line", ".", "split", "(", "':'", ",", "1", ")", "if", "len", "(", "result", ")", "==", "2", ":", "name", "=", "result", "[", "0", "]", ".", "rstrip", "(", "' \\t'", ")", "value", "=", "result", "[", "1", "]", ".", "lstrip", "(", ")", "else", ":", "name", "=", "result", "[", "0", "]", "value", "=", "None", "next_line", ",", "total_read", "=", "_strip_count", "(", "self", ".", "decode_header", "(", "stream", ".", "readline", "(", ")", ")", ",", "total_read", ")", "# append continuation lines, if any", "while", "next_line", "and", "next_line", ".", "startswith", "(", "(", "' '", ",", "'\\t'", ")", ")", ":", "if", "value", "is", "not", "None", ":", "value", "+=", "next_line", "next_line", ",", "total_read", "=", "_strip_count", "(", "self", ".", "decode_header", "(", "stream", ".", "readline", "(", ")", ")", ",", "total_read", ")", "if", "value", "is", "not", "None", ":", "header", "=", "(", "name", ",", "value", ")", "headers", ".", "append", "(", "header", ")", "line", "=", "next_line", "if", "len", "(", "protocol_status", ")", ">", "1", ":", "statusline", "=", "protocol_status", "[", "1", "]", ".", "strip", "(", ")", "else", ":", "statusline", "=", "''", "return", "StatusAndHeaders", "(", "statusline", "=", "statusline", ",", "headers", "=", "headers", ",", "protocol", "=", "protocol_status", "[", "0", "]", ",", "total_len", "=", "total_read", ")" ]

[ "parse", "stream", "for", "status", "line", "and", "headers", "return", "a", "StatusAndHeaders", "object" ]

[ "def", "split_prefix", "(", "key", ",", "prefixs", ")", ":", "key_upper", "=", "key", ".", "upper", "(", ")", "for", "prefix", "in", "prefixs", ":", "if", "key_upper", ".", "startswith", "(", "prefix", ")", ":", "plen", "=", "len", "(", "prefix", ")", "return", "(", "key_upper", "[", ":", "plen", "]", ",", "key", "[", "plen", ":", "]", ")" ]

[ "split", "key", "string", "into", "prefix", "and", "remainder", "for", "first", "matching", "prefix", "from", "a", "list" ]

[ "def", "ask_questions", "(", "self", ")", ":", "out_config", "=", "{", "}", "for", "key", "in", "c", ".", "CONFIG_QUESTIONS", ":", "section", "=", "key", "[", "1", "]", "print", "for", "question", "in", "section", ":", "answer", "=", "utils", ".", "ask", "(", "question", "[", "1", "]", ",", "question", "[", "2", "]", ")", "out_config", "[", "\"{0}_{1}\"", ".", "format", "(", "key", "[", "0", "]", ",", "question", "[", "0", "]", ")", "]", "=", "answer", "for", "key", "in", "c", ".", "CONFIG_MULTIPLE_CHOICE_QUESTIONS", ":", "section", "=", "key", "[", "1", "]", "print", "# keep going until we get what we want", "while", "True", ":", "input", "=", "utils", ".", "ask", "(", "section", "[", "1", "]", ",", "\"\"", ")", "if", "(", "input", ".", "isdigit", "(", ")", "and", "int", "(", "input", ")", ">", "0", "and", "int", "(", "input", ")", "<=", "section", "[", "0", "]", ")", ":", "answer", "=", "input", "break", "print", "# store the answer as 1 less than it is, we're dealing with", "# a list to select the number which is 0 indexed", "answer", "=", "int", "(", "input", ")", "-", "1", "if", "key", "[", "0", "]", "==", "\"license\"", ":", "out_config", "[", "\"license_type\"", "]", "=", "c", ".", "LICENSE_TYPES", "[", "answer", "]", "[", "0", "]", "out_config", "[", "\"license_url\"", "]", "=", "c", ".", "LICENSE_TYPES", "[", "answer", "]", "[", "1", "]", "# merge in defaults without asking questions", "merged_config", "=", "dict", "(", "c", ".", "CONFIG_DEFAULTS", ".", "items", "(", ")", "+", "out_config", ".", "items", "(", ")", ")", "return", "merged_config" ]

[ "Obtain", "config", "settings", "from", "the", "user", "." ]

[ "def", "log", "(", "color", ",", "*", "args", ")", ":", "if", "color", "in", "c", ".", "LOG_COLOR", ".", "keys", "(", ")", ":", "out_color", "=", "c", ".", "LOG_COLOR", "[", "color", "]", "else", ":", "out_color", "=", "color", "for", "arg", "in", "args", ":", "print", "clr", ".", "stringc", "(", "arg", ",", "out_color", ")" ]

[ "Print", "a", "message", "with", "a", "specific", "color", "." ]