Datasets:

---

jqop

/

python-code-dataset

like 0

[ "def", "find_ips_by_equip", "(", "self", ",", "id_equip", ")", ":", "url", "=", "'ip/getbyequip/'", "+", "str", "(", "id_equip", ")", "+", "\"/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "None", ",", "'GET'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ",", "[", "'ipv4'", ",", "'ipv6'", "]", ")" ]

[ "Get", "Ips", "related", "to", "equipment", "by", "its", "identifier" ]

[ "def", "find_ip6_by_id", "(", "self", ",", "id_ip", ")", ":", "if", "not", "is_valid_int_param", "(", "id_ip", ")", ":", "raise", "InvalidParameterError", "(", "u'Ipv6 identifier is invalid or was not informed.'", ")", "url", "=", "'ipv6/get/'", "+", "str", "(", "id_ip", ")", "+", "\"/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "None", ",", "'GET'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Get", "an", "IP6", "by", "ID" ]

[ "def", "save_ipv6", "(", "self", ",", "ip6", ",", "id_equip", ",", "descricao", ",", "id_net", ")", ":", "if", "not", "is_valid_int_param", "(", "id_net", ")", ":", "raise", "InvalidParameterError", "(", "u'Network identifier is invalid or was not informed.'", ")", "if", "not", "is_valid_int_param", "(", "id_equip", ")", ":", "raise", "InvalidParameterError", "(", "u'Equipment identifier is invalid or was not informed.'", ")", "if", "ip6", "is", "None", "or", "ip6", "==", "\"\"", ":", "raise", "InvalidParameterError", "(", "u'IPv6 is invalid or was not informed.'", ")", "ip_map", "=", "dict", "(", ")", "ip_map", "[", "'id_net'", "]", "=", "id_net", "ip_map", "[", "'descricao'", "]", "=", "descricao", "ip_map", "[", "'ip6'", "]", "=", "ip6", "ip_map", "[", "'id_equip'", "]", "=", "id_equip", "url", "=", "\"ipv6/save/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "{", "'ip_map'", ":", "ip_map", "}", ",", "'POST'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Save", "an", "IP6", "and", "associate", "with", "equipment" ]

[ "def", "delete_ip4", "(", "self", ",", "id_ip", ")", ":", "if", "not", "is_valid_int_param", "(", "id_ip", ")", ":", "raise", "InvalidParameterError", "(", "u'Ipv4 identifier is invalid or was not informed.'", ")", "url", "=", "'ip4/delete/'", "+", "str", "(", "id_ip", ")", "+", "\"/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "None", ",", "'DELETE'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Delete", "an", "IP4" ]

[ "def", "find_ip6_by_network", "(", "self", ",", "id_network", ")", ":", "if", "not", "is_valid_int_param", "(", "id_network", ")", ":", "raise", "InvalidParameterError", "(", "u'Network identifier is invalid or was not informed.'", ")", "url", "=", "'ip/id_network_ipv6/'", "+", "str", "(", "id_network", ")", "+", "\"/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "None", ",", "'GET'", ",", "url", ")", "key", "=", "\"ips\"", "return", "get_list_map", "(", "self", ".", "response", "(", "code", ",", "xml", ",", "[", "key", "]", ")", ",", "key", ")" ]

[ "List", "IPv6", "from", "network", "." ]

[ "def", "search_ipv6_environment", "(", "self", ",", "ipv6", ",", "id_environment", ")", ":", "if", "not", "is_valid_int_param", "(", "id_environment", ")", ":", "raise", "InvalidParameterError", "(", "u'Environment identifier is invalid or was not informed.'", ")", "ipv6_map", "=", "dict", "(", ")", "ipv6_map", "[", "'ipv6'", "]", "=", "ipv6", "ipv6_map", "[", "'id_environment'", "]", "=", "id_environment", "code", ",", "xml", "=", "self", ".", "submit", "(", "{", "'ipv6_map'", ":", "ipv6_map", "}", ",", "'POST'", ",", "'ipv6/environment/'", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Get", "IPv6", "with", "an", "associated", "environment", "." ]

[ "def", "assoc_ipv4", "(", "self", ",", "id_ip", ",", "id_equip", ",", "id_net", ")", ":", "if", "not", "is_valid_int_param", "(", "id_ip", ")", ":", "raise", "InvalidParameterError", "(", "u'Ip identifier is invalid or was not informed.'", ")", "if", "not", "is_valid_int_param", "(", "id_net", ")", ":", "raise", "InvalidParameterError", "(", "u'Network identifier is invalid or was not informed.'", ")", "if", "not", "is_valid_int_param", "(", "id_equip", ")", ":", "raise", "InvalidParameterError", "(", "u'Equipment identifier is invalid or was not informed.'", ")", "ip_map", "=", "dict", "(", ")", "ip_map", "[", "'id_ip'", "]", "=", "id_ip", "ip_map", "[", "'id_net'", "]", "=", "id_net", "ip_map", "[", "'id_equip'", "]", "=", "id_equip", "url", "=", "\"ipv4/assoc/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "{", "'ip_map'", ":", "ip_map", "}", ",", "'POST'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Associate", "an", "IP4", "with", "equipment", "." ]

[ "def", "assoc_ipv6", "(", "self", ",", "id_ip", ",", "id_equip", ",", "id_net", ")", ":", "if", "not", "is_valid_int_param", "(", "id_ip", ")", ":", "raise", "InvalidParameterError", "(", "u'Ipv6 identifier is invalid or was not informed.'", ")", "if", "not", "is_valid_int_param", "(", "id_net", ")", ":", "raise", "InvalidParameterError", "(", "u'Network identifier is invalid or was not informed.'", ")", "if", "not", "is_valid_int_param", "(", "id_equip", ")", ":", "raise", "InvalidParameterError", "(", "u'Equipment identifier is invalid or was not informed.'", ")", "ip_map", "=", "dict", "(", ")", "ip_map", "[", "'id_ip'", "]", "=", "id_ip", "ip_map", "[", "'id_net'", "]", "=", "id_net", "ip_map", "[", "'id_equip'", "]", "=", "id_equip", "url", "=", "\"ipv6/assoc/\"", "code", ",", "xml", "=", "self", ".", "submit", "(", "{", "'ip_map'", ":", "ip_map", "}", ",", "'POST'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Associate", "an", "IP6", "with", "equipment", "." ]

[ "def", "listar", "(", "self", ")", ":", "code", ",", "xml", "=", "self", ".", "submit", "(", "None", ",", "'GET'", ",", "'net_type/'", ")", "key", "=", "'net_type'", "return", "get_list_map", "(", "self", ".", "response", "(", "code", ",", "xml", ",", "[", "key", "]", ")", ",", "key", ")" ]

[ "List", "all", "network", "types", "." ]

[ "def", "inserir", "(", "self", ",", "name", ")", ":", "net_type_map", "=", "dict", "(", ")", "net_type_map", "[", "'name'", "]", "=", "name", "code", ",", "xml", "=", "self", ".", "submit", "(", "{", "'net_type'", ":", "net_type_map", "}", ",", "'POST'", ",", "'net_type/'", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Insert", "new", "network", "type", "and", "return", "its", "identifier", "." ]

[ "def", "alterar", "(", "self", ",", "id_net_type", ",", "name", ")", ":", "if", "not", "is_valid_int_param", "(", "id_net_type", ")", ":", "raise", "InvalidParameterError", "(", "u'Network type is invalid or was not informed.'", ")", "url", "=", "'net_type/'", "+", "str", "(", "id_net_type", ")", "+", "'/'", "net_type_map", "=", "dict", "(", ")", "net_type_map", "[", "'name'", "]", "=", "name", "code", ",", "xml", "=", "self", ".", "submit", "(", "{", "'net_type'", ":", "net_type_map", "}", ",", "'PUT'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Edit", "network", "type", "by", "its", "identifier", "." ]

[ "def", "remover", "(", "self", ",", "id_net_type", ")", ":", "if", "not", "is_valid_int_param", "(", "id_net_type", ")", ":", "raise", "InvalidParameterError", "(", "u'Network type is invalid or was not informed.'", ")", "url", "=", "'net_type/'", "+", "str", "(", "id_net_type", ")", "+", "'/'", "code", ",", "xml", "=", "self", ".", "submit", "(", "None", ",", "'DELETE'", ",", "url", ")", "return", "self", ".", "response", "(", "code", ",", "xml", ")" ]

[ "Remove", "network", "type", "by", "its", "identifier", "." ]

[ "def", "cc", "(", "filename", ":", "'input source file'", ",", "output", ":", "'output file name. default to be replacing input file\\'s suffix with \".py\"'", "=", "None", ",", "name", ":", "'name of language'", "=", "'unname'", ")", ":", "lang", "=", "Language", "(", "name", ")", "with", "Path", "(", "filename", ")", ".", "open", "(", "'r'", ")", "as", "fr", ":", "build_language", "(", "fr", ".", "read", "(", ")", ",", "lang", ",", "filename", ")", "if", "not", "output", ":", "base", ",", "_", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "output", "=", "base", "+", "'.py'", "lang", ".", "dump", "(", "output", ")" ]

[ "rbnf", "source", "code", "compiler", "." ]

[ "def", "run", "(", "filename", ":", "'python file generated by `rbnf` command, or rbnf sour file'", ",", "opt", ":", "'optimize switch'", "=", "False", ")", ":", "from", "rbnf", ".", "easy", "import", "build_parser", "import", "importlib", ".", "util", "import", "traceback", "full_path", "=", "Path", "(", "filename", ")", "base", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "str", "(", "full_path", ")", ")", "full_path_str", "=", "str", "(", "full_path", ")", "if", "not", "ext", ":", "if", "full_path", ".", "into", "(", "'.py'", ")", ".", "exists", "(", ")", ":", "full_path_str", "=", "base", "+", "'.py'", "elif", "Path", "(", "base", ")", ".", "into", "(", "'.rbnf'", ")", ":", "full_path_str", "=", "base", "+", "'.rbnf'", "if", "full_path_str", "[", "-", "3", ":", "]", ".", "lower", "(", ")", "!=", "'.py'", ":", "with", "Path", "(", "full_path_str", ")", ".", "open", "(", "'r'", ")", "as", "fr", ":", "ze_exp", "=", "ze", ".", "compile", "(", "fr", ".", "read", "(", ")", ",", "filename", "=", "full_path_str", ")", "lang", "=", "ze_exp", ".", "lang", "else", ":", "spec", "=", "importlib", ".", "util", ".", "spec_from_file_location", "(", "\"runbnf\"", ",", "full_path_str", ")", "mod", "=", "importlib", ".", "util", ".", "module_from_spec", "(", "spec", ")", "spec", ".", "loader", ".", "exec_module", "(", "mod", ")", "try", ":", "lang", "=", "next", "(", "each", "for", "each", "in", "mod", ".", "__dict__", ".", "values", "(", ")", "if", "isinstance", "(", "each", ",", "Language", ")", ")", "except", "StopIteration", ":", "raise", "NameError", "(", "\"Found no language in {}\"", ".", "format", "(", "full_path_str", ")", ")", "parse", "=", "build_parser", "(", "lang", ",", "opt", "=", "bool", "(", "opt", ")", ")", "namespace", "=", "{", "}", "print", "(", "Purple", "(", "'type `:i` to switch between python mode and parsing mode.'", ")", ")", "print", "(", "Purple", "(", "'The last result of parsing is stored as symbol `res`.'", ")", ")", "while", "True", ":", "inp", "=", "input", "(", "'runbnf> '", ")", "if", "not", "inp", ".", "strip", "(", ")", ":", "continue", "elif", "inp", ".", "strip", "(", ")", "==", "'exit'", ":", "break", "if", "inp", ".", "strip", "(", ")", "==", "':i'", ":", "while", "True", ":", "inp", "=", "input", "(", "'python> '", ")", "if", "inp", ".", "strip", "(", ")", "==", "':i'", ":", "break", "try", ":", "try", ":", "res", "=", "eval", "(", "inp", ",", "namespace", ")", "if", "res", "is", "not", "None", ":", "print", "(", "res", ")", "namespace", "[", "'_'", "]", "=", "res", "except", "SyntaxError", ":", "exec", "(", "inp", ",", "namespace", ")", "except", "Exception", ":", "traceback", ".", "print_exc", "(", ")", "else", ":", "res", "=", "namespace", "[", "'res'", "]", "=", "parse", "(", "inp", ")", "print", "(", "LightBlue", "(", "'parsed result = res: ResultDescription{result, tokens, state}'", ")", ")", "print", "(", "res", ".", "result", ")" ]

[ "You", "can", "apply", "immediate", "tests", "on", "your", "parser", ".", "P", ".", "S", ":", "use", "--", "opt", "option", "takes", "longer", "starting", "time", "." ]

[ "def", "rbnf_lexing", "(", "text", ":", "str", ")", ":", "cast_map", ":", "const", "=", "_cast_map", "lexer_table", ":", "const", "=", "_lexer_table", "keyword", ":", "const", "=", "_keyword", "drop_table", ":", "const", "=", "_DropTable", "end", ":", "const", "=", "_END", "unknown", ":", "const", "=", "_UNKNOWN", "text_length", "=", "len", "(", "text", ")", "colno", "=", "0", "lineno", "=", "0", "position", "=", "0", "cast_const", "=", "ConstStrPool", ".", "cast_to_const", "while", "True", ":", "if", "text_length", "<=", "position", ":", "break", "for", "case_name", ",", "text_match_case", "in", "lexer_table", ":", "matched_text", "=", "text_match_case", "(", "text", ",", "position", ")", "if", "not", "matched_text", ":", "continue", "case_mem_addr", "=", "id", "(", "case_name", ")", "# memory address of case_name", "if", "case_mem_addr", "not", "in", "drop_table", ":", "if", "matched_text", "in", "cast_map", ":", "yield", "Tokenizer", "(", "keyword", ",", "cast_const", "(", "matched_text", ")", ",", "lineno", ",", "colno", ")", "else", ":", "yield", "Tokenizer", "(", "cast_const", "(", "case_name", ")", ",", "matched_text", ",", "lineno", ",", "colno", ")", "n", "=", "len", "(", "matched_text", ")", "line_inc", "=", "matched_text", ".", "count", "(", "'\\n'", ")", "if", "line_inc", ":", "latest_newline_idx", "=", "matched_text", ".", "rindex", "(", "'\\n'", ")", "colno", "=", "n", "-", "latest_newline_idx", "lineno", "+=", "line_inc", "if", "case_name", "is", "_Space", "and", "matched_text", "[", "-", "1", "]", "==", "'\\n'", ":", "yield", "Tokenizer", "(", "end", ",", "''", ",", "lineno", ",", "colno", ")", "else", ":", "colno", "+=", "n", "position", "+=", "n", "break", "else", ":", "char", "=", "text", "[", "position", "]", "yield", "Tokenizer", "(", "unknown", ",", "char", ",", "lineno", ",", "colno", ")", "position", "+=", "1", "if", "char", "==", "'\\n'", ":", "lineno", "+=", "1", "colno", "=", "0", "else", ":", "colno", "+=", "1" ]

[ "Read", "loudly", "for", "documentation", "." ]

[ "def", "recover_codes", "(", "tokens", ":", "Iterator", "[", "Tokenizer", "]", ")", "->", "str", ":", "tokens", "=", "iter", "(", "tokens", ")", "s", "=", "[", "]", "try", ":", "head", "=", "next", "(", "tokens", ")", "except", "StopIteration", ":", "return", "s", "append", "=", "s", ".", "append", "lineno", "=", "head", ".", "lineno", "start_indent", "=", "colno", "=", "head", ".", "colno", "append", "(", "head", ".", "value", ")", "colno", "+=", "len", "(", "s", "[", "-", "1", "]", ")", "for", "each", "in", "tokens", ":", "n", "=", "each", ".", "lineno", "-", "lineno", "if", "n", ":", "append", "(", "'\\n'", "*", "n", ")", "lineno", "=", "each", ".", "lineno", "colno", "=", "each", ".", "colno", "if", "colno", "-", "start_indent", ">", "0", ":", "append", "(", "' '", "*", "colno", ")", "else", ":", "c", "=", "each", ".", "colno", "-", "colno", "if", "c", ":", "colno", "=", "each", ".", "colno", "if", "c", ">", "0", ":", "append", "(", "' '", "*", "c", ")", "append", "(", "each", ".", "value", ")", "colno", "+=", "len", "(", "s", "[", "-", "1", "]", ")", "return", "s" ]

[ "from", "a", "series", "of", "tokenizers", "to", "code", "string", ".", "(", "preserve", "the", "indentation", ")" ]

[ "def", "str_lexer", "(", "mode", ")", ":", "cast_to_const", "=", "ConstStrPool", ".", "cast_to_const", "def", "f_raw", "(", "inp_str", ",", "pos", ")", ":", "return", "cast_to_const", "(", "mode", ")", "if", "inp_str", ".", "startswith", "(", "mode", ",", "pos", ")", "else", "None", "def", "f_collection", "(", "inp_str", ",", "pos", ")", ":", "for", "each", "in", "mode", ":", "if", "inp_str", ".", "startswith", "(", "each", ",", "pos", ")", ":", "return", "cast_to_const", "(", "each", ")", "return", "None", "if", "isinstance", "(", "mode", ",", "str", ")", ":", "return", "f_raw", "if", "len", "(", "mode", ")", "is", "1", ":", "mode", "=", "mode", "[", "0", "]", "return", "f_raw", "return", "f_collection" ]

[ "generate", "token", "strings", "cache" ]

[ "def", "regex_lexer", "(", "regex_pat", ")", ":", "if", "isinstance", "(", "regex_pat", ",", "str", ")", ":", "regex_pat", "=", "re", ".", "compile", "(", "regex_pat", ")", "def", "f", "(", "inp_str", ",", "pos", ")", ":", "m", "=", "regex_pat", ".", "match", "(", "inp_str", ",", "pos", ")", "return", "m", ".", "group", "(", ")", "if", "m", "else", "None", "elif", "hasattr", "(", "regex_pat", ",", "'match'", ")", ":", "def", "f", "(", "inp_str", ",", "pos", ")", ":", "m", "=", "regex_pat", ".", "match", "(", "inp_str", ",", "pos", ")", "return", "m", ".", "group", "(", ")", "if", "m", "else", "None", "else", ":", "regex_pats", "=", "tuple", "(", "re", ".", "compile", "(", "e", ")", "for", "e", "in", "regex_pat", ")", "def", "f", "(", "inp_str", ",", "pos", ")", ":", "for", "each_pat", "in", "regex_pats", ":", "m", "=", "each_pat", ".", "match", "(", "inp_str", ",", "pos", ")", "if", "m", ":", "return", "m", ".", "group", "(", ")", "return", "f" ]

[ "generate", "token", "names", "cache" ]

[ "def", "dispatch", "(", "self", ",", "tree", ")", ":", "if", "isinstance", "(", "tree", ",", "list", ")", ":", "for", "t", "in", "tree", ":", "self", ".", "dispatch", "(", "t", ")", "return", "meth", "=", "getattr", "(", "self", ",", "\"_\"", "+", "tree", ".", "__class__", ".", "__name__", ")", "meth", "(", "tree", ")" ]

[ "Dispatcher", "function", "dispatching", "tree", "type", "T", "to", "method", "_T", "." ]

[ "def", "process", "(", "fn", ",", "bound_names", ")", ":", "if", "isinstance", "(", "fn", ",", "_AutoContext", ")", ":", "fn", "=", "fn", ".", "fn", "# noinspection PyArgumentList,PyArgumentList", "if", "isinstance", "(", "fn", ",", "_FnCodeStr", ")", ":", "if", "bound_names", ":", "assign_code_str", "=", "'{syms} = map(state.ctx.get, {names})'", ".", "format", "(", "syms", "=", "', '", ".", "join", "(", "bound_names", ")", "+", "','", ",", "names", "=", "repr", "(", "bound_names", ")", ")", "else", ":", "assign_code_str", "=", "''", "code", "=", "\"def {0}({1}):\\n{2}\"", ".", "format", "(", "fn", ".", "fn_name", ",", "\", \"", ".", "join", "(", "fn", ".", "fn_args", ")", ",", "textwrap", ".", "indent", "(", "assign_code_str", "+", "'\\n'", "+", "fn", ".", "code", ",", "\" \"", ")", ")", "module_ast", "=", "ast", ".", "parse", "(", "code", ",", "fn", ".", "filename", ")", "bound_name_line_inc", "=", "int", "(", "bool", "(", "bound_names", ")", ")", "+", "1", "module_ast", ":", "ast", ".", "Module", "=", "ast", ".", "increment_lineno", "(", "module_ast", ",", "fn", ".", "lineno", "-", "bound_name_line_inc", ")", "fn_ast", "=", "module_ast", ".", "body", "[", "0", "]", "if", "isinstance", "(", "fn_ast", ".", "body", "[", "-", "1", "]", ",", "ast", ".", "Expr", ")", ":", "# auto addition of tail expr return", "# in rbnf you don't need to write return if the last statement in the end is an expression.", "it", ":", "ast", ".", "Expr", "=", "fn_ast", ".", "body", "[", "-", "1", "]", "fn_ast", ".", "body", "[", "-", "1", "]", "=", "ast", ".", "Return", "(", "lineno", "=", "it", ".", "lineno", ",", "col_offset", "=", "it", ".", "col_offset", ",", "value", "=", "it", ".", "value", ")", "filename", "=", "fn", ".", "filename", "name", "=", "fn", ".", "fn_name", "code_object", "=", "compile", "(", "module_ast", ",", "filename", ",", "\"exec\"", ")", "local", "=", "{", "}", "# TODO: using types.MethodType here to create the function object leads to various problems.", "# Actually I don't really known why util now.", "exec", "(", "code_object", ",", "fn", ".", "namespace", ",", "local", ")", "ret", "=", "local", "[", "name", "]", "else", ":", "if", "not", "bound_names", ":", "return", "fn", ",", "get_ast", "(", "fn", ")", "code", "=", "fn", ".", "__code__", "assigns", "=", "ast", ".", "parse", "(", "\"ctx = state.ctx\\n\"", "+", "\"\\n\"", ".", "join", "(", "\"{0} = ctx.get({0!r})\"", ".", "format", "(", "name", ")", "for", "name", "in", "bound_names", ")", ")", "module_ast", "=", "get_ast", "(", "fn", ")", "fn_ast", ":", "ast", ".", "FunctionDef", "=", "module_ast", ".", "body", "[", "0", "]", "fn_ast", ".", "body", "=", "assigns", ".", "body", "+", "fn_ast", ".", "body", "module_ast", "=", "ast", ".", "Module", "(", "[", "fn_ast", "]", ")", "filename", "=", "code", ".", "co_filename", "name", "=", "code", ".", "co_name", "__defaults__", "=", "fn", ".", "__defaults__", "__closure__", "=", "fn", ".", "__closure__", "__globals__", "=", "fn", ".", "__globals__", "code_object", "=", "compile", "(", "module_ast", ",", "filename", ",", "\"exec\"", ")", "code_object", "=", "next", "(", "each", "for", "each", "in", "code_object", ".", "co_consts", "if", "isinstance", "(", "each", ",", "types", ".", "CodeType", ")", "and", "each", ".", "co_name", "==", "name", ")", "# noinspection PyArgumentList,PyUnboundLocalVariable", "ret", "=", "types", ".", "FunctionType", "(", "code_object", ",", "__globals__", ",", "name", ",", "__defaults__", ",", "__closure__", ")", "return", "ret", ",", "module_ast" ]

[ "process", "automatic", "context", "variable", "capturing", ".", "return", "the", "transformed", "function", "and", "its", "ast", "." ]

[ "def", "ignore", "(", "self", ",", "*", "ignore_lst", ":", "str", ")", ":", "def", "stream", "(", ")", ":", "for", "each", "in", "ignore_lst", ":", "each", "=", "ConstStrPool", ".", "cast_to_const", "(", "each", ")", "yield", "id", "(", "each", ")", ",", "each", "self", ".", "ignore_lst", ".", "update", "(", "stream", "(", ")", ")" ]

[ "ignore", "a", "set", "of", "tokens", "with", "specific", "names" ]

[ "def", "build_language", "(", "source_code", ":", "str", ",", "lang", ":", "Language", ",", "filename", ":", "str", ")", ":", "state", "=", "MetaState", "(", "rbnf", ".", "implementation", ",", "requires", "=", "_Wild", "(", ")", ",", "filename", "=", "filename", ")", "state", ".", "data", "=", "lang", "_build_language", "(", "source_code", ",", "state", ")", "lang", ".", "build", "(", ")" ]

[ "lang", ":", "language", "object", "represents", "your", "language", "." ]

[ "def", "_decode_POST_value", "(", "request", ",", "field_name", ",", "default", "=", "None", ")", ":", "if", "default", "is", "None", ":", "value", "=", "request", ".", "POST", "[", "field_name", "]", "else", ":", "value", "=", "request", ".", "POST", ".", "get", "(", "field_name", ",", "default", ")", "# it's inefficient to load this each time it gets called, but we're", "# not anticipating incoming email being a performance bottleneck right now!", "charsets", "=", "json", ".", "loads", "(", "request", ".", "POST", ".", "get", "(", "'charsets'", ",", "\"{}\"", ")", ")", "charset", "=", "charsets", ".", "get", "(", "field_name", ",", "'utf-8'", ")", "if", "charset", ".", "lower", "(", ")", "!=", "'utf-8'", ":", "logger", ".", "debug", "(", "\"Incoming email field '%s' has %s encoding.\"", ",", "field_name", ",", "charset", ")", "return", "smart_text", "(", "value", ",", "encoding", "=", "charset", ")" ]

[ "Helper", "to", "decode", "a", "request", "field", "into", "unicode", "based", "on", "charsets", "encoding", "." ]

[ "def", "_get_addresses", "(", "self", ",", "address_data", ",", "retain_name", "=", "False", ")", ":", "if", "retain_name", ":", "raise", "NotImplementedError", "(", "\"Not yet implemented, but will need client-code changes too\"", ")", "# We trust than an email address contains an \"@\" after", "# email.utils.getaddresses has done the hard work. If we wanted", "# to we could use a regex to check for greater email validity", "# NB: getaddresses expects a list, so ensure we feed it appropriately", "if", "isinstance", "(", "address_data", ",", "str", ")", ":", "if", "\"[\"", "not", "in", "address_data", ":", "# Definitely turn these into a list", "# NB: this is pretty assumptive, but still prob OK", "address_data", "=", "[", "address_data", "]", "output", "=", "[", "x", "[", "1", "]", "for", "x", "in", "getaddresses", "(", "address_data", ")", "if", "\"@\"", "in", "x", "[", "1", "]", "]", "return", "output" ]

[ "Takes", "RFC", "-", "compliant", "email", "addresses", "in", "both", "terse", "(", "email", "only", ")", "and", "verbose", "(", "name", "+", "email", ")", "forms", "and", "returns", "a", "list", "of", "email", "address", "strings" ]

[ "def", "parse", "(", "self", ",", "request", ")", ":", "assert", "isinstance", "(", "request", ",", "HttpRequest", ")", ",", "\"Invalid request type: %s\"", "%", "type", "(", "request", ")", "try", ":", "# from_email should never be a list (unless we change our API)", "from_email", "=", "self", ".", "_get_addresses", "(", "[", "_decode_POST_value", "(", "request", ",", "'from'", ")", "]", ")", "[", "0", "]", "# ...but all these can and will be a list", "to_email", "=", "self", ".", "_get_addresses", "(", "[", "_decode_POST_value", "(", "request", ",", "'to'", ")", "]", ")", "cc", "=", "self", ".", "_get_addresses", "(", "[", "_decode_POST_value", "(", "request", ",", "'cc'", ",", "default", "=", "''", ")", "]", ")", "bcc", "=", "self", ".", "_get_addresses", "(", "[", "_decode_POST_value", "(", "request", ",", "'bcc'", ",", "default", "=", "''", ")", "]", ")", "subject", "=", "_decode_POST_value", "(", "request", ",", "'subject'", ")", "text", "=", "_decode_POST_value", "(", "request", ",", "'text'", ",", "default", "=", "''", ")", "html", "=", "_decode_POST_value", "(", "request", ",", "'html'", ",", "default", "=", "''", ")", "except", "IndexError", "as", "ex", ":", "raise", "RequestParseError", "(", "\"Inbound request lacks a valid from address: %s.\"", "%", "request", ".", "get", "(", "'from'", ")", ")", "except", "MultiValueDictKeyError", "as", "ex", ":", "raise", "RequestParseError", "(", "\"Inbound request is missing required value: %s.\"", "%", "ex", ")", "if", "\"@\"", "not", "in", "from_email", ":", "# Light sanity check for potential issues related to taking just the", "# first element of the 'from' address list", "raise", "RequestParseError", "(", "\"Could not get a valid from address out of: %s.\"", "%", "request", ")", "email", "=", "EmailMultiAlternatives", "(", "subject", "=", "subject", ",", "body", "=", "text", ",", "from_email", "=", "from_email", ",", "to", "=", "to_email", ",", "cc", "=", "cc", ",", "bcc", "=", "bcc", ",", ")", "if", "html", "is", "not", "None", "and", "len", "(", "html", ")", ">", "0", ":", "email", ".", "attach_alternative", "(", "html", ",", "\"text/html\"", ")", "# TODO: this won't cope with big files - should really read in in chunks", "for", "n", ",", "f", "in", "list", "(", "request", ".", "FILES", ".", "items", "(", ")", ")", ":", "if", "f", ".", "size", ">", "self", ".", "max_file_size", ":", "logger", ".", "debug", "(", "\"File attachment %s is too large to process (%sB)\"", ",", "f", ".", "name", ",", "f", ".", "size", ")", "raise", "AttachmentTooLargeError", "(", "email", "=", "email", ",", "filename", "=", "f", ".", "name", ",", "size", "=", "f", ".", "size", ")", "else", ":", "email", ".", "attach", "(", "f", ".", "name", ",", "f", ".", "read", "(", ")", ",", "f", ".", "content_type", ")", "return", "email" ]

[ "Parse", "incoming", "request", "and", "return", "an", "email", "instance", "." ]

[ "def", "parse", "(", "self", ",", "request", ")", ":", "assert", "isinstance", "(", "request", ",", "HttpRequest", ")", ",", "\"Invalid request type: %s\"", "%", "type", "(", "request", ")", "try", ":", "subject", "=", "request", ".", "POST", ".", "get", "(", "'subject'", ",", "''", ")", "text", "=", "\"%s\\n\\n%s\"", "%", "(", "request", ".", "POST", ".", "get", "(", "'stripped-text'", ",", "''", ")", ",", "request", ".", "POST", ".", "get", "(", "'stripped-signature'", ",", "''", ")", ")", "html", "=", "request", ".", "POST", ".", "get", "(", "'stripped-html'", ")", "from_email", "=", "request", ".", "POST", ".", "get", "(", "'sender'", ")", "to_email", "=", "request", ".", "POST", ".", "get", "(", "'recipient'", ")", ".", "split", "(", "','", ")", "cc", "=", "request", ".", "POST", ".", "get", "(", "'cc'", ",", "''", ")", ".", "split", "(", "','", ")", "bcc", "=", "request", ".", "POST", ".", "get", "(", "'bcc'", ",", "''", ")", ".", "split", "(", "','", ")", "except", "MultiValueDictKeyError", "as", "ex", ":", "raise", "RequestParseError", "(", "\"Inbound request is missing required value: %s.\"", "%", "ex", ")", "except", "AttributeError", "as", "ex", ":", "raise", "RequestParseError", "(", "\"Inbound request is missing required value: %s.\"", "%", "ex", ")", "email", "=", "EmailMultiAlternatives", "(", "subject", "=", "subject", ",", "body", "=", "text", ",", "from_email", "=", "from_email", ",", "to", "=", "to_email", ",", "cc", "=", "cc", ",", "bcc", "=", "bcc", ",", ")", "if", "html", "is", "not", "None", "and", "len", "(", "html", ")", ">", "0", ":", "email", ".", "attach_alternative", "(", "html", ",", "\"text/html\"", ")", "# TODO: this won't cope with big files - should really read in in chunks", "for", "n", ",", "f", "in", "list", "(", "request", ".", "FILES", ".", "items", "(", ")", ")", ":", "if", "f", ".", "size", ">", "self", ".", "max_file_size", ":", "logger", ".", "debug", "(", "\"File attachment %s is too large to process (%sB)\"", ",", "f", ".", "name", ",", "f", ".", "size", ")", "raise", "AttachmentTooLargeError", "(", "email", "=", "email", ",", "filename", "=", "f", ".", "name", ",", "size", "=", "f", ".", "size", ")", "else", ":", "email", ".", "attach", "(", "n", ",", "f", ".", "read", "(", ")", ",", "f", ".", "content_type", ")", "return", "email" ]

[ "Parse", "incoming", "request", "and", "return", "an", "email", "instance", "." ]

[ "def", "_get_recipients", "(", "self", ",", "array", ")", ":", "for", "address", ",", "name", "in", "array", ":", "if", "not", "name", ":", "yield", "address", "else", ":", "yield", "\"\\\"%s\\\" <%s>\"", "%", "(", "name", ",", "address", ")" ]

[ "Returns", "an", "iterator", "of", "objects", "in", "the", "form", "[", "Name", "<address" ]

[ "def", "parse", "(", "self", ",", "request", ")", ":", "assert", "isinstance", "(", "request", ",", "HttpRequest", ")", ",", "\"Invalid request type: %s\"", "%", "type", "(", "request", ")", "if", "settings", ".", "INBOUND_MANDRILL_AUTHENTICATION_KEY", ":", "_check_mandrill_signature", "(", "request", "=", "request", ",", "key", "=", "settings", ".", "INBOUND_MANDRILL_AUTHENTICATION_KEY", ",", ")", "try", ":", "messages", "=", "json", ".", "loads", "(", "request", ".", "POST", "[", "'mandrill_events'", "]", ")", "except", "(", "ValueError", ",", "KeyError", ")", "as", "ex", ":", "raise", "RequestParseError", "(", "\"Request is not a valid json: %s\"", "%", "ex", ")", "if", "not", "messages", ":", "logger", ".", "debug", "(", "\"No messages found in mandrill request: %s\"", ",", "request", ".", "body", ")", "return", "[", "]", "emails", "=", "[", "]", "for", "message", "in", "messages", ":", "if", "message", ".", "get", "(", "'event'", ")", "!=", "'inbound'", ":", "logger", ".", "debug", "(", "\"Discarding non-inbound message\"", ")", "continue", "msg", "=", "message", ".", "get", "(", "'msg'", ")", "try", ":", "from_email", "=", "msg", "[", "'from_email'", "]", "to", "=", "list", "(", "self", ".", "_get_recipients", "(", "msg", "[", "'to'", "]", ")", ")", "cc", "=", "list", "(", "self", ".", "_get_recipients", "(", "msg", "[", "'cc'", "]", ")", ")", "if", "'cc'", "in", "msg", "else", "[", "]", "bcc", "=", "list", "(", "self", ".", "_get_recipients", "(", "msg", "[", "'bcc'", "]", ")", ")", "if", "'bcc'", "in", "msg", "else", "[", "]", "subject", "=", "msg", ".", "get", "(", "'subject'", ",", "\"\"", ")", "attachments", "=", "msg", ".", "get", "(", "'attachments'", ",", "{", "}", ")", "attachments", ".", "update", "(", "msg", ".", "get", "(", "'images'", ",", "{", "}", ")", ")", "text", "=", "msg", ".", "get", "(", "'text'", ",", "\"\"", ")", "html", "=", "msg", ".", "get", "(", "'html'", ",", "\"\"", ")", "except", "(", "KeyError", ",", "ValueError", ")", "as", "ex", ":", "raise", "RequestParseError", "(", "\"Inbound request is missing or got an invalid value.: %s.\"", "%", "ex", ")", "email", "=", "EmailMultiAlternatives", "(", "subject", "=", "subject", ",", "body", "=", "text", ",", "from_email", "=", "self", ".", "_get_sender", "(", "from_email", "=", "from_email", ",", "from_name", "=", "msg", ".", "get", "(", "'from_name'", ")", ",", ")", ",", "to", "=", "to", ",", "cc", "=", "cc", ",", "bcc", "=", "bcc", ",", ")", "if", "html", "is", "not", "None", "and", "len", "(", "html", ")", ">", "0", ":", "email", ".", "attach_alternative", "(", "html", ",", "\"text/html\"", ")", "email", "=", "self", ".", "_process_attachments", "(", "email", ",", "attachments", ")", "emails", ".", "append", "(", "email", ")", "return", "emails" ]

[ "Parse", "incoming", "request", "and", "return", "an", "email", "instance", "." ]

[ "def", "_log_request", "(", "request", ")", ":", "logger", ".", "debug", "(", "\"Inbound email received\"", ")", "for", "k", ",", "v", "in", "list", "(", "request", ".", "POST", ".", "items", "(", ")", ")", ":", "logger", ".", "debug", "(", "\"- POST['%s']='%s'\"", "%", "(", "k", ",", "v", ")", ")", "for", "n", ",", "f", "in", "list", "(", "request", ".", "FILES", ".", "items", "(", ")", ")", ":", "logger", ".", "debug", "(", "\"- FILES['%s']: '%s', %sB\"", ",", "n", ",", "f", ".", "content_type", ",", "f", ".", "size", ")" ]

[ "Helper", "function", "to", "dump", "out", "debug", "info", "." ]

[ "def", "receive_inbound_email", "(", "request", ")", ":", "# log the request.POST and request.FILES contents", "if", "log_requests", "is", "True", ":", "_log_request", "(", "request", ")", "# HEAD requests are used by some backends to validate the route", "if", "request", ".", "method", "==", "'HEAD'", ":", "return", "HttpResponse", "(", "'OK'", ")", "try", ":", "# clean up encodings and extract relevant fields from request.POST", "backend", "=", "get_backend_instance", "(", ")", "emails", "=", "backend", ".", "parse", "(", "request", ")", "# backend.parse can return either an EmailMultiAlternatives", "# or a list of those", "if", "emails", ":", "if", "isinstance", "(", "emails", ",", "EmailMultiAlternatives", ")", ":", "emails", "=", "[", "emails", "]", "for", "email", "in", "emails", ":", "# fire the signal for each email", "email_received", ".", "send", "(", "sender", "=", "backend", ".", "__class__", ",", "email", "=", "email", ",", "request", "=", "request", ")", "except", "AttachmentTooLargeError", "as", "ex", ":", "logger", ".", "exception", "(", "ex", ")", "email_received_unacceptable", ".", "send", "(", "sender", "=", "backend", ".", "__class__", ",", "email", "=", "ex", ".", "email", ",", "request", "=", "request", ",", "exception", "=", "ex", ")", "except", "AuthenticationError", "as", "ex", ":", "logger", ".", "exception", "(", "ex", ")", "email_received_unacceptable", ".", "send", "(", "sender", "=", "backend", ".", "__class__", ",", "email", "=", "None", ",", "request", "=", "request", ",", "exception", "=", "ex", ")", "except", "RequestParseError", "as", "ex", ":", "logger", ".", "exception", "(", "ex", ")", "if", "getattr", "(", "settings", ",", "'INBOUND_EMAIL_RESPONSE_200'", ",", "True", ")", ":", "# NB even if we have a problem, always use HTTP_STATUS=200, as", "# otherwise the email service will continue polling us with the email.", "# This is the default behaviour.", "status_code", "=", "200", "else", ":", "status_code", "=", "400", "return", "HttpResponse", "(", "\"Unable to parse inbound email: %s\"", "%", "ex", ",", "status", "=", "status_code", ")", "return", "HttpResponse", "(", "\"Successfully parsed inbound email.\"", ",", "status", "=", "200", ")" ]

[ "Receives", "inbound", "email", "from", "SendGrid", "." ]

[ "def", "get_backend_class", "(", ")", ":", "# this will (intentionally) blow up if the setting does not exist", "assert", "hasattr", "(", "settings", ",", "'INBOUND_EMAIL_PARSER'", ")", "assert", "getattr", "(", "settings", ",", "'INBOUND_EMAIL_PARSER'", ")", "is", "not", "None", "package", ",", "klass", "=", "settings", ".", "INBOUND_EMAIL_PARSER", ".", "rsplit", "(", "'.'", ",", "1", ")", "module", "=", "import_module", "(", "package", ")", "return", "getattr", "(", "module", ",", "klass", ")" ]

[ "Return", "reference", "to", "the", "configured", "backed", "class", "." ]

[ "def", "sorted_exists", "(", "values", ",", "x", ")", ":", "i", "=", "bisect_left", "(", "values", ",", "x", ")", "j", "=", "bisect_right", "(", "values", ",", "x", ")", "exists", "=", "x", "in", "values", "[", "i", ":", "j", "]", "return", "exists", ",", "i" ]

[ "For", "list", "values", "returns", "the", "insert", "position", "for", "item", "x", "and", "whether", "the", "item", "already", "exists", "in", "the", "list", ".", "This", "allows", "one", "function", "call", "to", "return", "either", "the", "index", "to", "overwrite", "an", "existing", "value", "in", "the", "list", "or", "the", "index", "to", "insert", "a", "new", "item", "in", "the", "list", "and", "keep", "the", "list", "in", "sorted", "order", "." ]

[ "def", "sorted_index", "(", "values", ",", "x", ")", ":", "i", "=", "bisect_left", "(", "values", ",", "x", ")", "j", "=", "bisect_right", "(", "values", ",", "x", ")", "return", "values", "[", "i", ":", "j", "]", ".", "index", "(", "x", ")", "+", "i" ]

[ "For", "list", "values", "returns", "the", "index", "location", "of", "element", "x", ".", "If", "x", "does", "not", "exist", "will", "raise", "an", "error", "." ]

[ "def", "sorted_list_indexes", "(", "list_to_sort", ",", "key", "=", "None", ",", "reverse", "=", "False", ")", ":", "if", "key", "is", "not", "None", ":", "def", "key_func", "(", "i", ")", ":", "return", "key", "(", "list_to_sort", ".", "__getitem__", "(", "i", ")", ")", "else", ":", "key_func", "=", "list_to_sort", ".", "__getitem__", "return", "sorted", "(", "range", "(", "len", "(", "list_to_sort", ")", ")", ",", "key", "=", "key_func", ",", "reverse", "=", "reverse", ")" ]

[ "Sorts", "a", "list", "but", "returns", "the", "order", "of", "the", "index", "values", "of", "the", "list", "for", "the", "sort", "and", "not", "the", "values", "themselves", ".", "For", "example", "is", "the", "list", "provided", "is", "[", "b", "a", "c", "]", "then", "the", "result", "will", "be", "[", "2", "1", "3", "]" ]

[ "def", "runDia", "(", "diagram", ")", ":", "ifname", "=", "'{}.dia'", ".", "format", "(", "diagram", ")", "ofname", "=", "'{}.png'", ".", "format", "(", "diagram", ")", "cmd", "=", "'dia -t png-libart -e {} {}'", ".", "format", "(", "ofname", ",", "ifname", ")", "print", "(", "' {}'", ".", "format", "(", "cmd", ")", ")", "subprocess", ".", "call", "(", "cmd", ",", "shell", "=", "True", ")", "return", "True" ]

[ "Generate", "the", "diagrams", "using", "Dia", "." ]

[ "def", "init2", "(", "self", ",", "input_tube", ",", "# Read task from the input tube.", "output_tubes", ",", "# Send result on all the output tubes.", "num_workers", ",", "# Total number of workers in the stage.", "disable_result", ",", "# Whether to override any result with None.", "do_stop_task", ",", "# Whether to call doTask() on \"stop\" request.", ")", ":", "super", "(", "OrderedWorker", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "_tube_task_input", "=", "input_tube", "self", ".", "_tubes_result_output", "=", "output_tubes", "self", ".", "_num_workers", "=", "num_workers", "# Serializes reading from input tube.", "self", ".", "_lock_prev_input", "=", "None", "self", ".", "_lock_next_input", "=", "None", "# Serializes writing to output tube.", "self", ".", "_lock_prev_output", "=", "None", "self", ".", "_lock_next_output", "=", "None", "self", ".", "_disable_result", "=", "disable_result", "self", ".", "_do_stop_task", "=", "do_stop_task" ]

[ "Create", "*", "num_workers", "*", "worker", "objects", "with", "*", "input_tube", "*", "and", "an", "iterable", "of", "*", "output_tubes", "*", ".", "The", "worker", "reads", "a", "task", "from", "*", "input_tube", "*", "and", "writes", "the", "result", "to", "*", "output_tubes", "*", "." ]

[ "def", "assemble", "(", "cls", ",", "args", ",", "input_tube", ",", "output_tubes", ",", "size", ",", "disable_result", "=", "False", ",", "do_stop_task", "=", "False", ",", ")", ":", "# Create the workers.", "workers", "=", "[", "]", "for", "ii", "in", "range", "(", "size", ")", ":", "worker", "=", "cls", "(", "*", "*", "args", ")", "worker", ".", "init2", "(", "input_tube", ",", "output_tubes", ",", "size", ",", "disable_result", ",", "do_stop_task", ",", ")", "workers", ".", "append", "(", "worker", ")", "# Connect the workers.", "for", "ii", "in", "range", "(", "size", ")", ":", "worker_this", "=", "workers", "[", "ii", "]", "worker_prev", "=", "workers", "[", "ii", "-", "1", "]", "worker_prev", ".", "_link", "(", "worker_this", ",", "next_is_first", "=", "(", "ii", "==", "0", ")", ",", "# Designate 0th worker as the first.", ")", "# Start the workers.", "for", "worker", "in", "workers", ":", "worker", ".", "start", "(", ")" ]

[ "Create", "assemble", "and", "start", "workers", ".", "Workers", "are", "created", "of", "class", "*", "cls", "*", "initialized", "with", "*", "args", "*", "and", "given", "task", "/", "result", "communication", "channels", "*", "input_tube", "*", "and", "*", "output_tubes", "*", ".", "The", "number", "of", "workers", "created", "is", "according", "to", "*", "size", "*", "parameter", ".", "*", "do_stop_task", "*", "indicates", "whether", "doTask", "()", "will", "be", "called", "for", "stop", "request", "." ]

[ "def", "_link", "(", "self", ",", "next_worker", ",", "next_is_first", "=", "False", ")", ":", "lock", "=", "multiprocessing", ".", "Lock", "(", ")", "next_worker", ".", "_lock_prev_input", "=", "lock", "self", ".", "_lock_next_input", "=", "lock", "lock", ".", "acquire", "(", ")", "lock", "=", "multiprocessing", ".", "Lock", "(", ")", "next_worker", ".", "_lock_prev_output", "=", "lock", "self", ".", "_lock_next_output", "=", "lock", "lock", ".", "acquire", "(", ")", "# If the next worker is the first one, trigger it now.", "if", "next_is_first", ":", "self", ".", "_lock_next_input", ".", "release", "(", ")", "self", ".", "_lock_next_output", ".", "release", "(", ")" ]

[ "Link", "the", "worker", "to", "the", "given", "next", "worker", "object", "connecting", "the", "two", "workers", "with", "communication", "tubes", "." ]

[ "def", "putResult", "(", "self", ",", "result", ")", ":", "self", ".", "_lock_prev_output", ".", "acquire", "(", ")", "for", "tube", "in", "self", ".", "_tubes_result_output", ":", "tube", ".", "put", "(", "(", "result", ",", "0", ")", ")", "self", ".", "_lock_next_output", ".", "release", "(", ")" ]

[ "Register", "the", "*", "result", "*", "by", "putting", "it", "on", "all", "the", "output", "tubes", "." ]

[ "def", "init2", "(", "self", ",", "input_tube", ",", "# Read task from the input tube.", "output_tubes", ",", "# Send result on all the output tubes.", "num_workers", ",", "# Total number of workers in the stage.", "disable_result", ",", "# Whether to override any result with None.", "do_stop_task", ",", "# Whether to call doTask() on \"stop\" request.", ")", ":", "super", "(", "UnorderedWorker", ",", "self", ")", ".", "__init__", "(", ")", "self", ".", "_tube_task_input", "=", "input_tube", "self", ".", "_tubes_result_output", "=", "output_tubes", "self", ".", "_num_workers", "=", "num_workers", "self", ".", "_disable_result", "=", "disable_result", "self", ".", "_do_stop_task", "=", "do_stop_task" ]

[ "Create", "*", "num_workers", "*", "worker", "objects", "with", "*", "input_tube", "*", "and", "an", "iterable", "of", "*", "output_tubes", "*", ".", "The", "worker", "reads", "a", "task", "from", "*", "input_tube", "*", "and", "writes", "the", "result", "to", "*", "output_tubes", "*", "." ]

[ "def", "assemble", "(", "cls", ",", "args", ",", "input_tube", ",", "output_tubes", ",", "size", ",", "disable_result", ",", "do_stop_task", ",", ")", ":", "# Create the workers.", "workers", "=", "[", "]", "for", "ii", "in", "range", "(", "size", ")", ":", "worker", "=", "cls", "(", "*", "*", "args", ")", "worker", ".", "init2", "(", "input_tube", ",", "output_tubes", ",", "size", ",", "disable_result", ",", "do_stop_task", ",", ")", "workers", ".", "append", "(", "worker", ")", "# Start the workers.", "for", "worker", "in", "workers", ":", "worker", ".", "start", "(", ")" ]

[ "Create", "assemble", "and", "start", "workers", ".", "Workers", "are", "created", "of", "class", "*", "cls", "*", "initialized", "with", "*", "args", "*", "and", "given", "task", "/", "result", "communication", "channels", "*", "input_tube", "*", "and", "*", "output_tubes", "*", ".", "The", "number", "of", "workers", "created", "is", "according", "to", "*", "size", "*", "parameter", ".", "*", "do_stop_task", "*", "indicates", "whether", "doTask", "()", "will", "be", "called", "for", "stop", "request", "." ]

[ "def", "show", "(", "self", ",", "index", "=", "True", ",", "*", "*", "kwargs", ")", ":", "print", "(", "self", ".", "_make_table", "(", "index", "=", "index", ",", "*", "*", "kwargs", ")", ")" ]

[ "Print", "the", "contents", "of", "the", "Series", ".", "This", "method", "uses", "the", "tabulate", "function", "from", "the", "tabulate", "package", ".", "Use", "the", "kwargs", "to", "pass", "along", "any", "arguments", "to", "the", "tabulate", "function", "." ]

[ "def", "get", "(", "self", ",", "indexes", ",", "as_list", "=", "False", ")", ":", "if", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", ":", "return", "self", ".", "get_rows", "(", "indexes", ",", "as_list", ")", "else", ":", "return", "self", ".", "get_cell", "(", "indexes", ")" ]

[ "Given", "indexes", "will", "return", "a", "sub", "-", "set", "of", "the", "Series", ".", "This", "method", "will", "direct", "to", "the", "specific", "methods", "based", "on", "what", "types", "are", "passed", "in", "for", "the", "indexes", ".", "The", "type", "of", "the", "return", "is", "determined", "by", "the", "types", "of", "the", "parameters", "." ]

[ "def", "get_cell", "(", "self", ",", "index", ")", ":", "i", "=", "sorted_index", "(", "self", ".", "_index", ",", "index", ")", "if", "self", ".", "_sort", "else", "self", ".", "_index", ".", "index", "(", "index", ")", "return", "self", ".", "_data", "[", "i", "]" ]

[ "For", "a", "single", "index", "and", "return", "the", "value" ]

[ "def", "get_rows", "(", "self", ",", "indexes", ",", "as_list", "=", "False", ")", ":", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "indexes", "]", ")", ":", "# boolean list", "if", "len", "(", "indexes", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'boolean index list must be same size of existing index'", ")", "if", "all", "(", "indexes", ")", ":", "# the entire column", "data", "=", "self", ".", "_data", "index", "=", "self", ".", "_index", "else", ":", "data", "=", "list", "(", "compress", "(", "self", ".", "_data", ",", "indexes", ")", ")", "index", "=", "list", "(", "compress", "(", "self", ".", "_index", ",", "indexes", ")", ")", "else", ":", "# index values list", "locations", "=", "[", "sorted_index", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "indexes", "]", "if", "self", ".", "_sort", "else", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "indexes", "]", "data", "=", "[", "self", ".", "_data", "[", "i", "]", "for", "i", "in", "locations", "]", "index", "=", "[", "self", ".", "_index", "[", "i", "]", "for", "i", "in", "locations", "]", "return", "data", "if", "as_list", "else", "Series", "(", "data", "=", "data", ",", "index", "=", "index", ",", "data_name", "=", "self", ".", "_data_name", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ")" ]

[ "For", "a", "list", "of", "indexes", "return", "the", "values", "of", "the", "indexes", "in", "that", "column", "." ]

[ "def", "get_location", "(", "self", ",", "location", ")", ":", "return", "{", "self", ".", "index_name", ":", "self", ".", "_index", "[", "location", "]", ",", "self", ".", "data_name", ":", "self", ".", "_data", "[", "location", "]", "}" ]

[ "For", "an", "index", "location", "return", "a", "dict", "of", "the", "index", "and", "value", ".", "This", "is", "optimized", "for", "speed", "because", "it", "does", "not", "need", "to", "lookup", "the", "index", "location", "with", "a", "search", ".", "Also", "can", "accept", "relative", "indexing", "from", "the", "end", "of", "the", "SEries", "in", "standard", "python", "notation", "[", "-", "3", "-", "2", "-", "1", "]" ]

[ "def", "get_locations", "(", "self", ",", "locations", ",", "as_list", "=", "False", ")", ":", "indexes", "=", "[", "self", ".", "_index", "[", "x", "]", "for", "x", "in", "locations", "]", "return", "self", ".", "get", "(", "indexes", ",", "as_list", ")" ]

[ "For", "list", "of", "locations", "return", "a", "Series", "or", "list", "of", "the", "values", "." ]

[ "def", "get_slice", "(", "self", ",", "start_index", "=", "None", ",", "stop_index", "=", "None", ",", "as_list", "=", "False", ")", ":", "if", "not", "self", ".", "_sort", ":", "raise", "RuntimeError", "(", "'Can only use get_slice on sorted Series'", ")", "start_location", "=", "bisect_left", "(", "self", ".", "_index", ",", "start_index", ")", "if", "start_index", "is", "not", "None", "else", "None", "stop_location", "=", "bisect_right", "(", "self", ".", "_index", ",", "stop_index", ")", "if", "stop_index", "is", "not", "None", "else", "None", "index", "=", "self", ".", "_index", "[", "start_location", ":", "stop_location", "]", "data", "=", "self", ".", "_data", "[", "start_location", ":", "stop_location", "]", "if", "as_list", ":", "return", "index", ",", "data", "else", ":", "return", "Series", "(", "data", "=", "data", ",", "index", "=", "index", ",", "data_name", "=", "self", ".", "_data_name", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ")" ]

[ "For", "sorted", "Series", "will", "return", "either", "a", "Series", "or", "list", "of", "all", "of", "the", "rows", "where", "the", "index", "is", "greater", "than", "or", "equal", "to", "the", "start_index", "if", "provided", "and", "less", "than", "or", "equal", "to", "the", "stop_index", "if", "provided", ".", "If", "either", "the", "start", "or", "stop", "index", "is", "None", "then", "will", "include", "from", "the", "first", "or", "last", "element", "similar", "to", "standard", "python", "slide", "of", "[", ":", "5", "]", "or", "[", ":", "5", "]", ".", "Both", "end", "points", "are", "considered", "inclusive", "." ]

[ "def", "to_dict", "(", "self", ",", "index", "=", "True", ",", "ordered", "=", "False", ")", ":", "result", "=", "OrderedDict", "(", ")", "if", "ordered", "else", "dict", "(", ")", "if", "index", ":", "result", ".", "update", "(", "{", "self", ".", "_index_name", ":", "self", ".", "_index", "}", ")", "if", "ordered", ":", "data_dict", "=", "[", "(", "self", ".", "_data_name", ",", "self", ".", "_data", ")", "]", "else", ":", "data_dict", "=", "{", "self", ".", "_data_name", ":", "self", ".", "_data", "}", "result", ".", "update", "(", "data_dict", ")", "return", "result" ]

[ "Returns", "a", "dict", "where", "the", "keys", "are", "the", "data", "and", "index", "names", "and", "the", "values", "are", "list", "of", "the", "data", "and", "index", "." ]

[ "def", "head", "(", "self", ",", "rows", ")", ":", "rows_bool", "=", "[", "True", "]", "*", "min", "(", "rows", ",", "len", "(", "self", ".", "_index", ")", ")", "rows_bool", ".", "extend", "(", "[", "False", "]", "*", "max", "(", "0", ",", "len", "(", "self", ".", "_index", ")", "-", "rows", ")", ")", "return", "self", ".", "get", "(", "indexes", "=", "rows_bool", ")" ]

[ "Return", "a", "Series", "of", "the", "first", "N", "rows" ]

[ "def", "select_index", "(", "self", ",", "compare", ",", "result", "=", "'boolean'", ")", ":", "if", "isinstance", "(", "compare", ",", "tuple", ")", ":", "# this crazy list comprehension will match all the tuples in the list with None being an * wildcard", "booleans", "=", "[", "all", "(", "[", "(", "compare", "[", "i", "]", "==", "w", "if", "compare", "[", "i", "]", "is", "not", "None", "else", "True", ")", "for", "i", ",", "w", "in", "enumerate", "(", "v", ")", "]", ")", "for", "x", ",", "v", "in", "enumerate", "(", "self", ".", "_index", ")", "]", "else", ":", "booleans", "=", "[", "False", "]", "*", "len", "(", "self", ".", "_index", ")", "if", "self", ".", "_sort", ":", "booleans", "[", "sorted_index", "(", "self", ".", "_index", ",", "compare", ")", "]", "=", "True", "else", ":", "booleans", "[", "self", ".", "_index", ".", "index", "(", "compare", ")", "]", "=", "True", "if", "result", "==", "'boolean'", ":", "return", "booleans", "elif", "result", "==", "'value'", ":", "return", "list", "(", "compress", "(", "self", ".", "_index", ",", "booleans", ")", ")", "else", ":", "raise", "ValueError", "(", "'only valid values for result parameter are: boolean or value.'", ")" ]

[ "Finds", "the", "elements", "in", "the", "index", "that", "match", "the", "compare", "parameter", "and", "returns", "either", "a", "list", "of", "the", "values", "that", "match", "of", "a", "boolean", "list", "the", "length", "of", "the", "index", "with", "True", "to", "each", "index", "that", "matches", ".", "If", "the", "indexes", "are", "tuples", "then", "the", "compare", "is", "a", "tuple", "where", "None", "in", "any", "field", "of", "the", "tuple", "will", "be", "treated", "as", "*", "and", "match", "all", "values", "." ]

[ "def", "equality", "(", "self", ",", "indexes", "=", "None", ",", "value", "=", "None", ")", ":", "indexes", "=", "[", "True", "]", "*", "len", "(", "self", ".", "_index", ")", "if", "indexes", "is", "None", "else", "indexes", "compare_list", "=", "self", ".", "get_rows", "(", "indexes", ",", "as_list", "=", "True", ")", "return", "[", "x", "==", "value", "for", "x", "in", "compare_list", "]" ]

[ "Math", "helper", "method", ".", "Given", "a", "column", "and", "optional", "indexes", "will", "return", "a", "list", "of", "booleans", "on", "the", "equality", "of", "the", "value", "for", "that", "index", "in", "the", "DataFrame", "to", "the", "value", "parameter", "." ]

[ "def", "_pad_data", "(", "self", ",", "index_len", ")", ":", "self", ".", "_data", ".", "extend", "(", "[", "None", "]", "*", "(", "index_len", "-", "len", "(", "self", ".", "_data", ")", ")", ")" ]

[ "Pad", "the", "data", "in", "Series", "with", "[", "None", "]", "to", "ensure", "that", "data", "is", "the", "same", "length", "as", "index" ]

[ "def", "sort_index", "(", "self", ")", ":", "sort", "=", "sorted_list_indexes", "(", "self", ".", "_index", ")", "# sort index", "self", ".", "_index", "=", "blist", "(", "[", "self", ".", "_index", "[", "x", "]", "for", "x", "in", "sort", "]", ")", "if", "self", ".", "_blist", "else", "[", "self", ".", "_index", "[", "x", "]", "for", "x", "in", "sort", "]", "# sort data", "self", ".", "_data", "=", "blist", "(", "[", "self", ".", "_data", "[", "x", "]", "for", "x", "in", "sort", "]", ")", "if", "self", ".", "_blist", "else", "[", "self", ".", "_data", "[", "x", "]", "for", "x", "in", "sort", "]" ]

[ "Sort", "the", "Series", "by", "the", "index", ".", "The", "sort", "modifies", "the", "Series", "inplace" ]

[ "def", "set", "(", "self", ",", "indexes", ",", "values", "=", "None", ")", ":", "if", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", ":", "self", ".", "set_rows", "(", "indexes", ",", "values", ")", "else", ":", "self", ".", "set_cell", "(", "indexes", ",", "values", ")" ]

[ "Given", "indexes", "will", "set", "a", "sub", "-", "set", "of", "the", "Series", "to", "the", "values", "provided", ".", "This", "method", "will", "direct", "to", "the", "below", "methods", "based", "on", "what", "types", "are", "passed", "in", "for", "the", "indexes", ".", "If", "the", "indexes", "contains", "values", "not", "in", "the", "Series", "then", "new", "rows", "or", "columns", "will", "be", "added", "." ]

[ "def", "_add_row", "(", "self", ",", "index", ")", ":", "self", ".", "_index", ".", "append", "(", "index", ")", "self", ".", "_data", ".", "append", "(", "None", ")" ]

[ "Add", "a", "new", "row", "to", "the", "Series" ]

[ "def", "_insert_row", "(", "self", ",", "i", ",", "index", ")", ":", "if", "i", "==", "len", "(", "self", ".", "_index", ")", ":", "self", ".", "_add_row", "(", "index", ")", "else", ":", "self", ".", "_index", ".", "insert", "(", "i", ",", "index", ")", "self", ".", "_data", ".", "insert", "(", "i", ",", "None", ")" ]

[ "Insert", "a", "new", "row", "in", "the", "Series", "." ]

[ "def", "_add_missing_rows", "(", "self", ",", "indexes", ")", ":", "new_indexes", "=", "[", "x", "for", "x", "in", "indexes", "if", "x", "not", "in", "self", ".", "_index", "]", "for", "x", "in", "new_indexes", ":", "self", ".", "_add_row", "(", "x", ")" ]

[ "Given", "a", "list", "of", "indexes", "find", "all", "the", "indexes", "that", "are", "not", "currently", "in", "the", "Series", "and", "make", "a", "new", "row", "for", "that", "index", "by", "appending", "to", "the", "Series", ".", "This", "does", "not", "maintain", "sorted", "order", "for", "the", "index", "." ]

[ "def", "_insert_missing_rows", "(", "self", ",", "indexes", ")", ":", "new_indexes", "=", "[", "x", "for", "x", "in", "indexes", "if", "x", "not", "in", "self", ".", "_index", "]", "for", "x", "in", "new_indexes", ":", "self", ".", "_insert_row", "(", "bisect_left", "(", "self", ".", "_index", ",", "x", ")", ",", "x", ")" ]

[ "Given", "a", "list", "of", "indexes", "find", "all", "the", "indexes", "that", "are", "not", "currently", "in", "the", "Series", "and", "make", "a", "new", "row", "for", "that", "index", "inserting", "into", "the", "index", ".", "This", "requires", "the", "Series", "to", "be", "sorted", "=", "True" ]

[ "def", "set_cell", "(", "self", ",", "index", ",", "value", ")", ":", "if", "self", ".", "_sort", ":", "exists", ",", "i", "=", "sorted_exists", "(", "self", ".", "_index", ",", "index", ")", "if", "not", "exists", ":", "self", ".", "_insert_row", "(", "i", ",", "index", ")", "else", ":", "try", ":", "i", "=", "self", ".", "_index", ".", "index", "(", "index", ")", "except", "ValueError", ":", "i", "=", "len", "(", "self", ".", "_index", ")", "self", ".", "_add_row", "(", "index", ")", "self", ".", "_data", "[", "i", "]", "=", "value" ]

[ "Sets", "the", "value", "of", "a", "single", "cell", ".", "If", "the", "index", "is", "not", "in", "the", "current", "index", "then", "a", "new", "index", "will", "be", "created", "." ]

[ "def", "set_rows", "(", "self", ",", "index", ",", "values", "=", "None", ")", ":", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "index", "]", ")", ":", "# boolean list", "if", "not", "isinstance", "(", "values", ",", "(", "list", ",", "blist", ")", ")", ":", "# single value provided, not a list, so turn values into list", "values", "=", "[", "values", "for", "x", "in", "index", "if", "x", "]", "if", "len", "(", "index", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'boolean index list must be same size of existing index'", ")", "if", "len", "(", "values", ")", "!=", "index", ".", "count", "(", "True", ")", ":", "raise", "ValueError", "(", "'length of values list must equal number of True entries in index list'", ")", "indexes", "=", "[", "i", "for", "i", ",", "x", "in", "enumerate", "(", "index", ")", "if", "x", "]", "for", "x", ",", "i", "in", "enumerate", "(", "indexes", ")", ":", "self", ".", "_data", "[", "i", "]", "=", "values", "[", "x", "]", "else", ":", "# list of index", "if", "not", "isinstance", "(", "values", ",", "(", "list", ",", "blist", ")", ")", ":", "# single value provided, not a list, so turn values into list", "values", "=", "[", "values", "for", "_", "in", "index", "]", "if", "len", "(", "values", ")", "!=", "len", "(", "index", ")", ":", "raise", "ValueError", "(", "'length of values and index must be the same.'", ")", "# insert or append indexes as needed", "if", "self", ".", "_sort", ":", "exists_tuples", "=", "list", "(", "zip", "(", "*", "[", "sorted_exists", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "index", "]", ")", ")", "exists", "=", "exists_tuples", "[", "0", "]", "indexes", "=", "exists_tuples", "[", "1", "]", "if", "not", "all", "(", "exists", ")", ":", "self", ".", "_insert_missing_rows", "(", "index", ")", "indexes", "=", "[", "sorted_index", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "index", "]", "else", ":", "try", ":", "# all index in current index", "indexes", "=", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "index", "]", "except", "ValueError", ":", "# new rows need to be added", "self", ".", "_add_missing_rows", "(", "index", ")", "indexes", "=", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "index", "]", "for", "x", ",", "i", "in", "enumerate", "(", "indexes", ")", ":", "self", ".", "_data", "[", "i", "]", "=", "values", "[", "x", "]" ]

[ "Set", "rows", "to", "a", "single", "value", "or", "list", "of", "values", ".", "If", "any", "of", "the", "index", "values", "are", "not", "in", "the", "current", "indexes", "then", "a", "new", "row", "will", "be", "created", "." ]

[ "def", "set_locations", "(", "self", ",", "locations", ",", "values", ")", ":", "indexes", "=", "[", "self", ".", "_index", "[", "x", "]", "for", "x", "in", "locations", "]", "self", ".", "set", "(", "indexes", ",", "values", ")" ]

[ "For", "a", "list", "of", "locations", "set", "the", "values", "." ]

[ "def", "append_row", "(", "self", ",", "index", ",", "value", ")", ":", "if", "index", "in", "self", ".", "_index", ":", "raise", "IndexError", "(", "'index already in Series'", ")", "self", ".", "_index", ".", "append", "(", "index", ")", "self", ".", "_data", ".", "append", "(", "value", ")" ]

[ "Appends", "a", "row", "of", "value", "to", "the", "end", "of", "the", "data", ".", "Be", "very", "careful", "with", "this", "function", "as", "for", "sorted", "Series", "it", "will", "not", "enforce", "sort", "order", ".", "Use", "this", "only", "for", "speed", "when", "needed", "be", "careful", "." ]

[ "def", "append_rows", "(", "self", ",", "indexes", ",", "values", ")", ":", "# check that the values data is less than or equal to the length of the indexes", "if", "len", "(", "values", ")", "!=", "len", "(", "indexes", ")", ":", "raise", "ValueError", "(", "'length of values is not equal to length of indexes'", ")", "# check the indexes are not duplicates", "combined_index", "=", "self", ".", "_index", "+", "indexes", "if", "len", "(", "set", "(", "combined_index", ")", ")", "!=", "len", "(", "combined_index", ")", ":", "raise", "IndexError", "(", "'duplicate indexes in Series'", ")", "# append index value", "self", ".", "_index", ".", "extend", "(", "indexes", ")", "self", ".", "_data", ".", "extend", "(", "values", ")" ]

[ "Appends", "values", "to", "the", "end", "of", "the", "data", ".", "Be", "very", "careful", "with", "this", "function", "as", "for", "sort", "DataFrames", "it", "will", "not", "enforce", "sort", "order", ".", "Use", "this", "only", "for", "speed", "when", "needed", "be", "careful", "." ]

[ "def", "delete", "(", "self", ",", "indexes", ")", ":", "indexes", "=", "[", "indexes", "]", "if", "not", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", "else", "indexes", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "indexes", "]", ")", ":", "# boolean list", "if", "len", "(", "indexes", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'boolean indexes list must be same size of existing indexes'", ")", "indexes", "=", "[", "i", "for", "i", ",", "x", "in", "enumerate", "(", "indexes", ")", "if", "x", "]", "else", ":", "indexes", "=", "[", "sorted_index", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "indexes", "]", "if", "self", ".", "_sort", "else", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "indexes", "]", "indexes", "=", "sorted", "(", "indexes", ",", "reverse", "=", "True", ")", "# need to sort and reverse list so deleting works", "for", "i", "in", "indexes", ":", "del", "self", ".", "_data", "[", "i", "]", "# now remove from index", "for", "i", "in", "indexes", ":", "del", "self", ".", "_index", "[", "i", "]" ]

[ "Delete", "rows", "from", "the", "DataFrame" ]

[ "def", "reset_index", "(", "self", ")", ":", "self", ".", "index", "=", "list", "(", "range", "(", "self", ".", "__len__", "(", ")", ")", ")", "self", ".", "index_name", "=", "'index'" ]

[ "Resets", "the", "index", "of", "the", "Series", "to", "simple", "integer", "list", "and", "the", "index", "name", "to", "index", "." ]

[ "def", "value", "(", "self", ",", "indexes", ",", "int_as_index", "=", "False", ")", ":", "# single integer value", "if", "isinstance", "(", "indexes", ",", "int", ")", ":", "if", "int_as_index", ":", "return", "self", ".", "get", "(", "indexes", ",", "as_list", "=", "True", ")", "else", ":", "indexes", "=", "indexes", "-", "self", ".", "_offset", "return", "self", ".", "_data", "[", "indexes", "]", "# slice", "elif", "isinstance", "(", "indexes", ",", "slice", ")", ":", "if", "isinstance", "(", "indexes", ".", "start", ",", "int", ")", "and", "not", "int_as_index", ":", "# treat as location", "start", "=", "indexes", ".", "start", "-", "self", ".", "_offset", "stop", "=", "indexes", ".", "stop", "-", "self", ".", "_offset", "+", "1", "# to capture the last value", "# check locations are valid and will not return empty", "if", "start", ">", "stop", ":", "raise", "IndexError", "(", "'end of slice is before start of slice'", ")", "if", "(", "start", ">", "0", ">", "stop", ")", "or", "(", "start", "<", "0", "<", "stop", ")", ":", "raise", "IndexError", "(", "'slide indexes invalid with given offset:%f'", "%", "self", ".", "_offset", ")", "# where end is the last element", "if", "(", "start", "<", "0", ")", "and", "stop", "==", "0", ":", "return", "self", ".", "_data", "[", "start", ":", "]", "return", "self", ".", "_data", "[", "start", ":", "stop", "]", "else", ":", "# treat as index", "indexes", "=", "self", ".", "_slice_index", "(", "indexes", ")", "return", "self", ".", "get", "(", "indexes", ",", "as_list", "=", "True", ")", "# list of booleans", "elif", "all", "(", "[", "isinstance", "(", "x", ",", "bool", ")", "for", "x", "in", "indexes", "]", ")", ":", "return", "self", ".", "get", "(", "indexes", ",", "as_list", "=", "True", ")", "# list of values", "elif", "isinstance", "(", "indexes", ",", "list", ")", ":", "if", "int_as_index", "or", "not", "isinstance", "(", "indexes", "[", "0", "]", ",", "int", ")", ":", "return", "self", ".", "get", "(", "indexes", ",", "as_list", "=", "True", ")", "else", ":", "indexes", "=", "[", "x", "-", "self", ".", "_offset", "for", "x", "in", "indexes", "]", "return", "self", ".", "get_locations", "(", "indexes", ",", "as_list", "=", "True", ")", "# just a single value", "else", ":", "return", "self", ".", "get", "(", "indexes", ")" ]

[ "Wrapper", "function", "for", "get", ".", "It", "will", "return", "a", "list", "no", "index", ".", "If", "the", "indexes", "are", "integers", "it", "will", "be", "assumed", "that", "they", "are", "locations", "unless", "int_as_index", "=", "True", ".", "If", "the", "indexes", "are", "locations", "then", "they", "will", "be", "rotated", "to", "the", "left", "by", "offset", "number", "of", "locations", "." ]

[ "def", "from_dataframe", "(", "cls", ",", "dataframe", ",", "column", ",", "offset", "=", "0", ")", ":", "return", "cls", "(", "data", "=", "dataframe", ".", "get_entire_column", "(", "column", ",", "as_list", "=", "True", ")", ",", "index", "=", "dataframe", ".", "index", ",", "data_name", "=", "column", ",", "index_name", "=", "dataframe", ".", "index_name", ",", "sort", "=", "dataframe", ".", "sort", ",", "offset", "=", "offset", ")" ]

[ "Creates", "and", "return", "a", "Series", "from", "a", "DataFrame", "and", "specific", "column" ]

[ "def", "from_series", "(", "cls", ",", "series", ",", "offset", "=", "0", ")", ":", "return", "cls", "(", "data", "=", "series", ".", "data", ",", "index", "=", "series", ".", "index", ",", "data_name", "=", "series", ".", "data_name", ",", "index_name", "=", "series", ".", "index_name", ",", "sort", "=", "series", ".", "sort", ",", "offset", "=", "offset", ")" ]

[ "Creates", "and", "return", "a", "Series", "from", "a", "Series" ]

[ "def", "get", "(", "self", ",", "timeout", "=", "None", ")", ":", "if", "timeout", ":", "try", ":", "result", "=", "self", ".", "_queue", ".", "get", "(", "True", ",", "timeout", ")", "except", "multiprocessing", ".", "Queue", ".", "Empty", ":", "return", "(", "False", ",", "None", ")", "return", "(", "True", ",", "result", ")", "return", "self", ".", "_queue", ".", "get", "(", ")" ]

[ "Return", "the", "next", "available", "item", "from", "the", "tube", "." ]

[ "def", "get", "(", "self", ",", "timeout", "=", "None", ")", ":", "valid", "=", "False", "result", "=", "None", "for", "tube", "in", "self", ".", "_output_tubes", ":", "if", "timeout", ":", "valid", ",", "result", "=", "tube", ".", "get", "(", "timeout", ")", "if", "valid", ":", "result", "=", "result", "[", "0", "]", "else", ":", "result", "=", "tube", ".", "get", "(", ")", "[", "0", "]", "if", "timeout", ":", "return", "valid", ",", "result", "return", "result" ]

[ "Retrieve", "results", "from", "all", "the", "output", "tubes", "." ]

[ "def", "link", "(", "self", ",", "next_stage", ")", ":", "if", "next_stage", "is", "self", ":", "raise", "ValueError", "(", "'cannot link stage to itself'", ")", "self", ".", "_output_tubes", ".", "append", "(", "next_stage", ".", "_input_tube", ")", "self", ".", "_next_stages", ".", "append", "(", "next_stage", ")", "return", "self" ]

[ "Link", "to", "the", "given", "downstream", "stage", "*", "next_stage", "*", "by", "adding", "its", "input", "tube", "to", "the", "list", "of", "this", "stage", "s", "output", "tubes", ".", "Return", "this", "stage", "." ]

[ "def", "getLeaves", "(", "self", ")", ":", "result", "=", "list", "(", ")", "if", "not", "self", ".", "_next_stages", ":", "result", ".", "append", "(", "self", ")", "else", ":", "for", "stage", "in", "self", ".", "_next_stages", ":", "leaves", "=", "stage", ".", "getLeaves", "(", ")", "result", "+=", "leaves", "return", "result" ]

[ "Return", "the", "downstream", "leaf", "stages", "of", "this", "stage", "." ]

[ "def", "build", "(", "self", ")", ":", "# If there's no output tube, it means that this stage", "# is at the end of a fork (hasn't been linked to any stage downstream).", "# Therefore, create one output tube.", "if", "not", "self", ".", "_output_tubes", ":", "self", ".", "_output_tubes", ".", "append", "(", "self", ".", "_worker_class", ".", "getTubeClass", "(", ")", "(", ")", ")", "self", ".", "_worker_class", ".", "assemble", "(", "self", ".", "_worker_args", ",", "self", ".", "_input_tube", ",", "self", ".", "_output_tubes", ",", "self", ".", "_size", ",", "self", ".", "_disable_result", ",", "self", ".", "_do_stop_task", ",", ")", "# Build all downstream stages.", "for", "stage", "in", "self", ".", "_next_stages", ":", "stage", ".", "build", "(", ")" ]

[ "Create", "and", "start", "up", "the", "internal", "workers", "." ]

[ "def", "get", "(", "self", ",", "timeout", "=", "None", ")", ":", "if", "timeout", ":", "# Todo: Consider locking the poll/recv block.", "# Otherwise, this method is not thread safe.", "if", "self", ".", "_conn1", ".", "poll", "(", "timeout", ")", ":", "return", "(", "True", ",", "self", ".", "_conn1", ".", "recv", "(", ")", ")", "else", ":", "return", "(", "False", ",", "None", ")", "return", "self", ".", "_conn1", ".", "recv", "(", ")" ]

[ "Return", "the", "next", "available", "item", "from", "the", "tube", "." ]

[ "def", "_sort_columns", "(", "self", ",", "columns_list", ")", ":", "if", "not", "(", "all", "(", "[", "x", "in", "columns_list", "for", "x", "in", "self", ".", "_columns", "]", ")", "and", "all", "(", "[", "x", "in", "self", ".", "_columns", "for", "x", "in", "columns_list", "]", ")", ")", ":", "raise", "ValueError", "(", "'columns_list must be all in current columns, and all current columns must be in columns_list'", ")", "new_sort", "=", "[", "self", ".", "_columns", ".", "index", "(", "x", ")", "for", "x", "in", "columns_list", "]", "self", ".", "_data", "=", "blist", "(", "[", "self", ".", "_data", "[", "x", "]", "for", "x", "in", "new_sort", "]", ")", "if", "self", ".", "_blist", "else", "[", "self", ".", "_data", "[", "x", "]", "for", "x", "in", "new_sort", "]", "self", ".", "_columns", "=", "blist", "(", "[", "self", ".", "_columns", "[", "x", "]", "for", "x", "in", "new_sort", "]", ")", "if", "self", ".", "_blist", "else", "[", "self", ".", "_columns", "[", "x", "]", "for", "x", "in", "new_sort", "]" ]

[ "Given", "a", "list", "of", "column", "names", "will", "sort", "the", "DataFrame", "columns", "to", "match", "the", "given", "order" ]

[ "def", "_pad_data", "(", "self", ",", "max_len", "=", "None", ")", ":", "if", "not", "max_len", ":", "max_len", "=", "max", "(", "[", "len", "(", "x", ")", "for", "x", "in", "self", ".", "_data", "]", ")", "for", "_", ",", "col", "in", "enumerate", "(", "self", ".", "_data", ")", ":", "col", ".", "extend", "(", "[", "None", "]", "*", "(", "max_len", "-", "len", "(", "col", ")", ")", ")" ]

[ "Pad", "the", "data", "in", "DataFrame", "with", "[", "None", "}", "to", "ensure", "that", "all", "columns", "have", "the", "same", "length", "." ]

[ "def", "get", "(", "self", ",", "indexes", "=", "None", ",", "columns", "=", "None", ",", "as_list", "=", "False", ",", "as_dict", "=", "False", ")", ":", "if", "(", "indexes", "is", "None", ")", "and", "(", "columns", "is", "not", "None", ")", "and", "(", "not", "isinstance", "(", "columns", ",", "(", "list", ",", "blist", ")", ")", ")", ":", "return", "self", ".", "get_entire_column", "(", "columns", ",", "as_list", ")", "if", "indexes", "is", "None", ":", "indexes", "=", "[", "True", "]", "*", "len", "(", "self", ".", "_index", ")", "if", "columns", "is", "None", ":", "columns", "=", "[", "True", "]", "*", "len", "(", "self", ".", "_columns", ")", "if", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", "and", "isinstance", "(", "columns", ",", "(", "list", ",", "blist", ")", ")", ":", "return", "self", ".", "get_matrix", "(", "indexes", ",", "columns", ")", "elif", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", "and", "(", "not", "isinstance", "(", "columns", ",", "(", "list", ",", "blist", ")", ")", ")", ":", "return", "self", ".", "get_rows", "(", "indexes", ",", "columns", ",", "as_list", ")", "elif", "(", "not", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", ")", "and", "isinstance", "(", "columns", ",", "(", "list", ",", "blist", ")", ")", ":", "return", "self", ".", "get_columns", "(", "indexes", ",", "columns", ",", "as_dict", ")", "else", ":", "return", "self", ".", "get_cell", "(", "indexes", ",", "columns", ")" ]

[ "Given", "indexes", "and", "columns", "will", "return", "a", "sub", "-", "set", "of", "the", "DataFrame", ".", "This", "method", "will", "direct", "to", "the", "below", "methods", "based", "on", "what", "types", "are", "passed", "in", "for", "the", "indexes", "and", "columns", ".", "The", "type", "of", "the", "return", "is", "determined", "by", "the", "types", "of", "the", "parameters", "." ]

[ "def", "get_cell", "(", "self", ",", "index", ",", "column", ")", ":", "i", "=", "sorted_index", "(", "self", ".", "_index", ",", "index", ")", "if", "self", ".", "_sort", "else", "self", ".", "_index", ".", "index", "(", "index", ")", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "return", "self", ".", "_data", "[", "c", "]", "[", "i", "]" ]

[ "For", "a", "single", "index", "and", "column", "value", "return", "the", "value", "of", "the", "cell" ]

[ "def", "get_rows", "(", "self", ",", "indexes", ",", "column", ",", "as_list", "=", "False", ")", ":", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "indexes", "]", ")", ":", "# boolean list", "if", "len", "(", "indexes", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'boolean index list must be same size of existing index'", ")", "if", "all", "(", "indexes", ")", ":", "# the entire column", "data", "=", "self", ".", "_data", "[", "c", "]", "index", "=", "self", ".", "_index", "else", ":", "data", "=", "list", "(", "compress", "(", "self", ".", "_data", "[", "c", "]", ",", "indexes", ")", ")", "index", "=", "list", "(", "compress", "(", "self", ".", "_index", ",", "indexes", ")", ")", "else", ":", "# index values list", "locations", "=", "[", "sorted_index", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "indexes", "]", "if", "self", ".", "_sort", "else", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "indexes", "]", "data", "=", "[", "self", ".", "_data", "[", "c", "]", "[", "i", "]", "for", "i", "in", "locations", "]", "index", "=", "[", "self", ".", "_index", "[", "i", "]", "for", "i", "in", "locations", "]", "return", "data", "if", "as_list", "else", "DataFrame", "(", "data", "=", "{", "column", ":", "data", "}", ",", "index", "=", "index", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ")" ]

[ "For", "a", "list", "of", "indexes", "and", "a", "single", "column", "name", "return", "the", "values", "of", "the", "indexes", "in", "that", "column", "." ]

[ "def", "get_columns", "(", "self", ",", "index", ",", "columns", "=", "None", ",", "as_dict", "=", "False", ")", ":", "i", "=", "sorted_index", "(", "self", ".", "_index", ",", "index", ")", "if", "self", ".", "_sort", "else", "self", ".", "_index", ".", "index", "(", "index", ")", "return", "self", ".", "get_location", "(", "i", ",", "columns", ",", "as_dict", ")" ]

[ "For", "a", "single", "index", "and", "list", "of", "column", "names", "return", "a", "DataFrame", "of", "the", "values", "in", "that", "index", "as", "either", "a", "dict", "or", "a", "DataFrame" ]

[ "def", "get_entire_column", "(", "self", ",", "column", ",", "as_list", "=", "False", ")", ":", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "data", "=", "self", ".", "_data", "[", "c", "]", "return", "data", "if", "as_list", "else", "DataFrame", "(", "data", "=", "{", "column", ":", "data", "}", ",", "index", "=", "self", ".", "_index", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ")" ]

[ "Shortcut", "method", "to", "retrieve", "a", "single", "column", "all", "rows", ".", "Since", "this", "is", "a", "common", "use", "case", "this", "method", "will", "be", "faster", "than", "the", "more", "general", "method", "." ]

[ "def", "get_matrix", "(", "self", ",", "indexes", ",", "columns", ")", ":", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "indexes", "]", ")", ":", "# boolean list", "is_bool_indexes", "=", "True", "if", "len", "(", "indexes", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'boolean index list must be same size of existing index'", ")", "bool_indexes", "=", "indexes", "indexes", "=", "list", "(", "compress", "(", "self", ".", "_index", ",", "indexes", ")", ")", "else", ":", "is_bool_indexes", "=", "False", "locations", "=", "[", "sorted_index", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "indexes", "]", "if", "self", ".", "_sort", "else", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "indexes", "]", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "columns", "]", ")", ":", "# boolean list", "if", "len", "(", "columns", ")", "!=", "len", "(", "self", ".", "_columns", ")", ":", "raise", "ValueError", "(", "'boolean column list must be same size of existing columns'", ")", "columns", "=", "list", "(", "compress", "(", "self", ".", "_columns", ",", "columns", ")", ")", "col_locations", "=", "[", "self", ".", "_columns", ".", "index", "(", "x", ")", "for", "x", "in", "columns", "]", "data_dict", "=", "dict", "(", ")", "for", "c", "in", "col_locations", ":", "data_dict", "[", "self", ".", "_columns", "[", "c", "]", "]", "=", "list", "(", "compress", "(", "self", ".", "_data", "[", "c", "]", ",", "bool_indexes", ")", ")", "if", "is_bool_indexes", "else", "[", "self", ".", "_data", "[", "c", "]", "[", "i", "]", "for", "i", "in", "locations", "]", "return", "DataFrame", "(", "data", "=", "data_dict", ",", "index", "=", "indexes", ",", "columns", "=", "columns", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ")" ]

[ "For", "a", "list", "of", "indexes", "and", "list", "of", "columns", "return", "a", "DataFrame", "of", "the", "values", "." ]

[ "def", "get_location", "(", "self", ",", "location", ",", "columns", "=", "None", ",", "as_dict", "=", "False", ",", "index", "=", "True", ")", ":", "if", "columns", "is", "None", ":", "columns", "=", "self", ".", "_columns", "elif", "not", "isinstance", "(", "columns", ",", "list", ")", ":", "# single value for columns", "c", "=", "self", ".", "_columns", ".", "index", "(", "columns", ")", "return", "self", ".", "_data", "[", "c", "]", "[", "location", "]", "elif", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "columns", "]", ")", ":", "if", "len", "(", "columns", ")", "!=", "len", "(", "self", ".", "_columns", ")", ":", "raise", "ValueError", "(", "'boolean column list must be same size of existing columns'", ")", "columns", "=", "list", "(", "compress", "(", "self", ".", "_columns", ",", "columns", ")", ")", "data", "=", "dict", "(", ")", "for", "column", "in", "columns", ":", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "data", "[", "column", "]", "=", "self", ".", "_data", "[", "c", "]", "[", "location", "]", "index_value", "=", "self", ".", "_index", "[", "location", "]", "if", "as_dict", ":", "if", "index", ":", "data", "[", "self", ".", "_index_name", "]", "=", "index_value", "return", "data", "else", ":", "data", "=", "{", "k", ":", "[", "data", "[", "k", "]", "]", "for", "k", "in", "data", "}", "# this makes the dict items lists", "return", "DataFrame", "(", "data", "=", "data", ",", "index", "=", "[", "index_value", "]", ",", "columns", "=", "columns", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ")" ]

[ "For", "an", "index", "location", "and", "either", "(", "1", ")", "list", "of", "columns", "return", "a", "DataFrame", "or", "dictionary", "of", "the", "values", "or", "(", "2", ")", "single", "column", "name", "and", "return", "the", "value", "of", "that", "cell", ".", "This", "is", "optimized", "for", "speed", "because", "it", "does", "not", "need", "to", "lookup", "the", "index", "location", "with", "a", "search", ".", "Also", "can", "accept", "relative", "indexing", "from", "the", "end", "of", "the", "DataFrame", "in", "standard", "python", "notation", "[", "-", "3", "-", "2", "-", "1", "]", ":", "param", "location", ":", "index", "location", "in", "standard", "python", "form", "of", "positive", "or", "negative", "number", ":", "param", "columns", ":", "list", "of", "columns", "single", "column", "name", "or", "None", "to", "include", "all", "columns", ":", "param", "as_dict", ":", "if", "True", "then", "return", "a", "dictionary", ":", "param", "index", ":", "if", "True", "then", "include", "the", "index", "in", "the", "dictionary", "if", "as_dict", "=", "True", ":", "return", ":", "DataFrame", "or", "dictionary", "if", "columns", "is", "a", "list", "or", "value", "if", "columns", "is", "a", "single", "column", "name" ]

[ "def", "get_locations", "(", "self", ",", "locations", ",", "columns", "=", "None", ",", "*", "*", "kwargs", ")", ":", "indexes", "=", "[", "self", ".", "_index", "[", "x", "]", "for", "x", "in", "locations", "]", "return", "self", ".", "get", "(", "indexes", ",", "columns", ",", "*", "*", "kwargs", ")" ]

[ "For", "list", "of", "locations", "and", "list", "of", "columns", "return", "a", "DataFrame", "of", "the", "values", "." ]

[ "def", "get_slice", "(", "self", ",", "start_index", "=", "None", ",", "stop_index", "=", "None", ",", "columns", "=", "None", ",", "as_dict", "=", "False", ")", ":", "if", "not", "self", ".", "_sort", ":", "raise", "RuntimeError", "(", "'Can only use get_slice on sorted DataFrames'", ")", "if", "columns", "is", "None", ":", "columns", "=", "self", ".", "_columns", "elif", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "columns", "]", ")", ":", "if", "len", "(", "columns", ")", "!=", "len", "(", "self", ".", "_columns", ")", ":", "raise", "ValueError", "(", "'boolean column list must be same size of existing columns'", ")", "columns", "=", "list", "(", "compress", "(", "self", ".", "_columns", ",", "columns", ")", ")", "start_location", "=", "bisect_left", "(", "self", ".", "_index", ",", "start_index", ")", "if", "start_index", "is", "not", "None", "else", "None", "stop_location", "=", "bisect_right", "(", "self", ".", "_index", ",", "stop_index", ")", "if", "stop_index", "is", "not", "None", "else", "None", "index", "=", "self", ".", "_index", "[", "start_location", ":", "stop_location", "]", "data", "=", "dict", "(", ")", "for", "column", "in", "columns", ":", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "data", "[", "column", "]", "=", "self", ".", "_data", "[", "c", "]", "[", "start_location", ":", "stop_location", "]", "if", "as_dict", ":", "return", "index", ",", "data", "else", ":", "data", "=", "data", "if", "data", "else", "None", "# if the dict is empty, convert to None", "return", "DataFrame", "(", "data", "=", "data", ",", "index", "=", "index", ",", "columns", "=", "columns", ",", "index_name", "=", "self", ".", "_index_name", ",", "sort", "=", "self", ".", "_sort", ",", "use_blist", "=", "self", ".", "_blist", ")" ]

[ "For", "sorted", "DataFrames", "will", "return", "either", "a", "DataFrame", "or", "dict", "of", "all", "of", "the", "rows", "where", "the", "index", "is", "greater", "than", "or", "equal", "to", "the", "start_index", "if", "provided", "and", "less", "than", "or", "equal", "to", "the", "stop_index", "if", "provided", ".", "If", "either", "the", "start", "or", "stop", "index", "is", "None", "then", "will", "include", "from", "the", "first", "or", "last", "element", "similar", "to", "standard", "python", "slide", "of", "[", ":", "5", "]", "or", "[", ":", "5", "]", ".", "Both", "end", "points", "are", "considered", "inclusive", ".", ":", "param", "start_index", ":", "lowest", "index", "value", "to", "include", "or", "None", "to", "start", "from", "the", "first", "row", ":", "param", "stop_index", ":", "highest", "index", "value", "to", "include", "or", "None", "to", "end", "at", "the", "last", "row", ":", "param", "columns", ":", "list", "of", "column", "names", "to", "include", "or", "None", "for", "all", "columns", ":", "param", "as_dict", ":", "if", "True", "then", "return", "a", "tuple", "of", "(", "list", "of", "index", "dict", "of", "column", "names", ":", "list", "data", "values", ")", ":", "return", ":", "DataFrame", "or", "tuple" ]

[ "def", "_insert_row", "(", "self", ",", "i", ",", "index", ")", ":", "if", "i", "==", "len", "(", "self", ".", "_index", ")", ":", "self", ".", "_add_row", "(", "index", ")", "else", ":", "self", ".", "_index", ".", "insert", "(", "i", ",", "index", ")", "for", "c", "in", "range", "(", "len", "(", "self", ".", "_columns", ")", ")", ":", "self", ".", "_data", "[", "c", "]", ".", "insert", "(", "i", ",", "None", ")" ]

[ "Insert", "a", "new", "row", "in", "the", "DataFrame", "." ]

[ "def", "_add_row", "(", "self", ",", "index", ")", ":", "self", ".", "_index", ".", "append", "(", "index", ")", "for", "c", ",", "_", "in", "enumerate", "(", "self", ".", "_columns", ")", ":", "self", ".", "_data", "[", "c", "]", ".", "append", "(", "None", ")" ]

[ "Add", "a", "new", "row", "to", "the", "DataFrame" ]

[ "def", "_add_column", "(", "self", ",", "column", ")", ":", "self", ".", "_columns", ".", "append", "(", "column", ")", "if", "self", ".", "_blist", ":", "self", ".", "_data", ".", "append", "(", "blist", "(", "[", "None", "]", "*", "len", "(", "self", ".", "_index", ")", ")", ")", "else", ":", "self", ".", "_data", ".", "append", "(", "[", "None", "]", "*", "len", "(", "self", ".", "_index", ")", ")" ]

[ "Add", "a", "new", "column", "to", "the", "DataFrame" ]

[ "def", "set", "(", "self", ",", "indexes", "=", "None", ",", "columns", "=", "None", ",", "values", "=", "None", ")", ":", "if", "(", "indexes", "is", "not", "None", ")", "and", "(", "columns", "is", "not", "None", ")", ":", "if", "isinstance", "(", "indexes", ",", "(", "list", ",", "blist", ")", ")", ":", "self", ".", "set_column", "(", "indexes", ",", "columns", ",", "values", ")", "else", ":", "self", ".", "set_cell", "(", "indexes", ",", "columns", ",", "values", ")", "elif", "(", "indexes", "is", "not", "None", ")", "and", "(", "columns", "is", "None", ")", ":", "self", ".", "set_row", "(", "indexes", ",", "values", ")", "elif", "(", "indexes", "is", "None", ")", "and", "(", "columns", "is", "not", "None", ")", ":", "self", ".", "set_column", "(", "indexes", ",", "columns", ",", "values", ")", "else", ":", "raise", "ValueError", "(", "'either or both of indexes or columns must be provided'", ")" ]

[ "Given", "indexes", "and", "columns", "will", "set", "a", "sub", "-", "set", "of", "the", "DataFrame", "to", "the", "values", "provided", ".", "This", "method", "will", "direct", "to", "the", "below", "methods", "based", "on", "what", "types", "are", "passed", "in", "for", "the", "indexes", "and", "columns", ".", "If", "the", "indexes", "or", "columns", "contains", "values", "not", "in", "the", "DataFrame", "then", "new", "rows", "or", "columns", "will", "be", "added", "." ]

[ "def", "set_cell", "(", "self", ",", "index", ",", "column", ",", "value", ")", ":", "if", "self", ".", "_sort", ":", "exists", ",", "i", "=", "sorted_exists", "(", "self", ".", "_index", ",", "index", ")", "if", "not", "exists", ":", "self", ".", "_insert_row", "(", "i", ",", "index", ")", "else", ":", "try", ":", "i", "=", "self", ".", "_index", ".", "index", "(", "index", ")", "except", "ValueError", ":", "i", "=", "len", "(", "self", ".", "_index", ")", "self", ".", "_add_row", "(", "index", ")", "try", ":", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "except", "ValueError", ":", "c", "=", "len", "(", "self", ".", "_columns", ")", "self", ".", "_add_column", "(", "column", ")", "self", ".", "_data", "[", "c", "]", "[", "i", "]", "=", "value" ]

[ "Sets", "the", "value", "of", "a", "single", "cell", ".", "If", "the", "index", "and", "/", "or", "column", "is", "not", "in", "the", "current", "index", "/", "columns", "then", "a", "new", "index", "and", "/", "or", "column", "will", "be", "created", "." ]

[ "def", "set_row", "(", "self", ",", "index", ",", "values", ")", ":", "if", "self", ".", "_sort", ":", "exists", ",", "i", "=", "sorted_exists", "(", "self", ".", "_index", ",", "index", ")", "if", "not", "exists", ":", "self", ".", "_insert_row", "(", "i", ",", "index", ")", "else", ":", "try", ":", "i", "=", "self", ".", "_index", ".", "index", "(", "index", ")", "except", "ValueError", ":", "# new row", "i", "=", "len", "(", "self", ".", "_index", ")", "self", ".", "_add_row", "(", "index", ")", "if", "isinstance", "(", "values", ",", "dict", ")", ":", "if", "not", "(", "set", "(", "values", ".", "keys", "(", ")", ")", ".", "issubset", "(", "self", ".", "_columns", ")", ")", ":", "raise", "ValueError", "(", "'keys of values are not all in existing columns'", ")", "for", "c", ",", "column", "in", "enumerate", "(", "self", ".", "_columns", ")", ":", "self", ".", "_data", "[", "c", "]", "[", "i", "]", "=", "values", ".", "get", "(", "column", ",", "self", ".", "_data", "[", "c", "]", "[", "i", "]", ")", "else", ":", "raise", "TypeError", "(", "'cannot handle values of this type.'", ")" ]

[ "Sets", "the", "values", "of", "the", "columns", "in", "a", "single", "row", "." ]

[ "def", "set_column", "(", "self", ",", "index", "=", "None", ",", "column", "=", "None", ",", "values", "=", "None", ")", ":", "try", ":", "c", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "except", "ValueError", ":", "# new column", "c", "=", "len", "(", "self", ".", "_columns", ")", "self", ".", "_add_column", "(", "column", ")", "if", "index", ":", "# index was provided", "if", "all", "(", "[", "isinstance", "(", "i", ",", "bool", ")", "for", "i", "in", "index", "]", ")", ":", "# boolean list", "if", "not", "isinstance", "(", "values", ",", "(", "list", ",", "blist", ")", ")", ":", "# single value provided, not a list, so turn values into list", "values", "=", "[", "values", "for", "x", "in", "index", "if", "x", "]", "if", "len", "(", "index", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'boolean index list must be same size of existing index'", ")", "if", "len", "(", "values", ")", "!=", "index", ".", "count", "(", "True", ")", ":", "raise", "ValueError", "(", "'length of values list must equal number of True entries in index list'", ")", "indexes", "=", "[", "i", "for", "i", ",", "x", "in", "enumerate", "(", "index", ")", "if", "x", "]", "for", "x", ",", "i", "in", "enumerate", "(", "indexes", ")", ":", "self", ".", "_data", "[", "c", "]", "[", "i", "]", "=", "values", "[", "x", "]", "else", ":", "# list of index", "if", "not", "isinstance", "(", "values", ",", "(", "list", ",", "blist", ")", ")", ":", "# single value provided, not a list, so turn values into list", "values", "=", "[", "values", "for", "_", "in", "index", "]", "if", "len", "(", "values", ")", "!=", "len", "(", "index", ")", ":", "raise", "ValueError", "(", "'length of values and index must be the same.'", ")", "# insert or append indexes as needed", "if", "self", ".", "_sort", ":", "exists_tuples", "=", "list", "(", "zip", "(", "*", "[", "sorted_exists", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "index", "]", ")", ")", "exists", "=", "exists_tuples", "[", "0", "]", "indexes", "=", "exists_tuples", "[", "1", "]", "if", "not", "all", "(", "exists", ")", ":", "self", ".", "_insert_missing_rows", "(", "index", ")", "indexes", "=", "[", "sorted_index", "(", "self", ".", "_index", ",", "x", ")", "for", "x", "in", "index", "]", "else", ":", "try", ":", "# all index in current index", "indexes", "=", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "index", "]", "except", "ValueError", ":", "# new rows need to be added", "self", ".", "_add_missing_rows", "(", "index", ")", "indexes", "=", "[", "self", ".", "_index", ".", "index", "(", "x", ")", "for", "x", "in", "index", "]", "for", "x", ",", "i", "in", "enumerate", "(", "indexes", ")", ":", "self", ".", "_data", "[", "c", "]", "[", "i", "]", "=", "values", "[", "x", "]", "else", ":", "# no index, only values", "if", "not", "isinstance", "(", "values", ",", "(", "list", ",", "blist", ")", ")", ":", "# values not a list, turn into one of length same as index", "values", "=", "[", "values", "for", "_", "in", "self", ".", "_index", "]", "if", "len", "(", "values", ")", "!=", "len", "(", "self", ".", "_index", ")", ":", "raise", "ValueError", "(", "'values list must be at same length as current index length.'", ")", "else", ":", "self", ".", "_data", "[", "c", "]", "=", "blist", "(", "values", ")", "if", "self", ".", "_blist", "else", "values" ]

[ "Set", "a", "column", "to", "a", "single", "value", "or", "list", "of", "values", ".", "If", "any", "of", "the", "index", "values", "are", "not", "in", "the", "current", "indexes", "then", "a", "new", "row", "will", "be", "created", "." ]

[ "def", "set_location", "(", "self", ",", "location", ",", "values", ",", "missing_to_none", "=", "False", ")", ":", "if", "missing_to_none", ":", "# populate the dict with None in any column missing", "for", "column", "in", "self", ".", "_columns", ":", "if", "column", "not", "in", "values", ":", "values", "[", "column", "]", "=", "None", "for", "column", "in", "values", ":", "i", "=", "self", ".", "_columns", ".", "index", "(", "column", ")", "self", ".", "_data", "[", "i", "]", "[", "location", "]", "=", "values", "[", "column", "]" ]

[ "Sets", "the", "column", "values", "as", "given", "by", "the", "keys", "of", "the", "values", "dict", "for", "the", "row", "at", "location", "to", "the", "values", "of", "the", "values", "dict", ".", "If", "missing_to_none", "is", "False", "then", "columns", "not", "in", "the", "values", "dict", "will", "be", "left", "unchanged", "if", "it", "is", "True", "then", "they", "are", "set", "to", "None", ".", "This", "method", "does", "not", "add", "new", "columns", "and", "raises", "an", "error", ".", ":", "param", "location", ":", "location", ":", "param", "values", ":", "dict", "of", "column", "names", "as", "keys", "and", "the", "value", "as", "the", "value", "to", "set", "the", "row", "for", "that", "column", "to", ":", "param", "missing_to_none", ":", "if", "True", "set", "any", "column", "missing", "in", "the", "values", "to", "None", "otherwise", "leave", "unchanged", ":", "return", ":", "nothing" ]

[ "def", "append_row", "(", "self", ",", "index", ",", "values", ",", "new_cols", "=", "True", ")", ":", "if", "index", "in", "self", ".", "_index", ":", "raise", "IndexError", "(", "'index already in DataFrame'", ")", "if", "new_cols", ":", "for", "col", "in", "values", ":", "if", "col", "not", "in", "self", ".", "_columns", ":", "self", ".", "_add_column", "(", "col", ")", "# append index value", "self", ".", "_index", ".", "append", "(", "index", ")", "# add data values, if not in values then use None", "for", "c", ",", "col", "in", "enumerate", "(", "self", ".", "_columns", ")", ":", "self", ".", "_data", "[", "c", "]", ".", "append", "(", "values", ".", "get", "(", "col", ",", "None", ")", ")" ]

[ "Appends", "a", "row", "of", "values", "to", "the", "end", "of", "the", "data", ".", "If", "there", "are", "new", "columns", "in", "the", "values", "and", "new_cols", "is", "True", "they", "will", "be", "added", ".", "Be", "very", "careful", "with", "this", "function", "as", "for", "sort", "DataFrames", "it", "will", "not", "enforce", "sort", "order", ".", "Use", "this", "only", "for", "speed", "when", "needed", "be", "careful", "." ]

[ "def", "append_rows", "(", "self", ",", "indexes", ",", "values", ",", "new_cols", "=", "True", ")", ":", "# check that the values data is less than or equal to the length of the indexes", "for", "column", "in", "values", ":", "if", "len", "(", "values", "[", "column", "]", ")", ">", "len", "(", "indexes", ")", ":", "raise", "ValueError", "(", "'length of %s column in values is longer than indexes'", "%", "column", ")", "# check the indexes are not duplicates", "combined_index", "=", "self", ".", "_index", "+", "indexes", "if", "len", "(", "set", "(", "combined_index", ")", ")", "!=", "len", "(", "combined_index", ")", ":", "raise", "IndexError", "(", "'duplicate indexes in DataFrames'", ")", "if", "new_cols", ":", "for", "col", "in", "values", ":", "if", "col", "not", "in", "self", ".", "_columns", ":", "self", ".", "_add_column", "(", "col", ")", "# append index value", "self", ".", "_index", ".", "extend", "(", "indexes", ")", "# add data values, if not in values then use None", "for", "c", ",", "col", "in", "enumerate", "(", "self", ".", "_columns", ")", ":", "self", ".", "_data", "[", "c", "]", ".", "extend", "(", "values", ".", "get", "(", "col", ",", "[", "None", "]", "*", "len", "(", "indexes", ")", ")", ")", "self", ".", "_pad_data", "(", ")" ]

[ "Appends", "rows", "of", "values", "to", "the", "end", "of", "the", "data", ".", "If", "there", "are", "new", "columns", "in", "the", "values", "and", "new_cols", "is", "True", "they", "will", "be", "added", ".", "Be", "very", "careful", "with", "this", "function", "as", "for", "sort", "DataFrames", "it", "will", "not", "enforce", "sort", "order", ".", "Use", "this", "only", "for", "speed", "when", "needed", "be", "careful", "." ]

[ "def", "to_dict", "(", "self", ",", "index", "=", "True", ",", "ordered", "=", "False", ")", ":", "result", "=", "OrderedDict", "(", ")", "if", "ordered", "else", "dict", "(", ")", "if", "index", ":", "result", ".", "update", "(", "{", "self", ".", "_index_name", ":", "self", ".", "_index", "}", ")", "if", "ordered", ":", "data_dict", "=", "[", "(", "column", ",", "self", ".", "_data", "[", "i", "]", ")", "for", "i", ",", "column", "in", "enumerate", "(", "self", ".", "_columns", ")", "]", "else", ":", "data_dict", "=", "{", "column", ":", "self", ".", "_data", "[", "i", "]", "for", "i", ",", "column", "in", "enumerate", "(", "self", ".", "_columns", ")", "}", "result", ".", "update", "(", "data_dict", ")", "return", "result" ]

[ "Returns", "a", "dict", "where", "the", "keys", "are", "the", "column", "names", "and", "the", "values", "are", "lists", "of", "the", "values", "for", "that", "column", "." ]

[ "def", "to_json", "(", "self", ")", ":", "input_dict", "=", "{", "'data'", ":", "self", ".", "to_dict", "(", "index", "=", "False", ")", ",", "'index'", ":", "list", "(", "self", ".", "_index", ")", "}", "# if blist, turn into lists", "if", "self", ".", "blist", ":", "input_dict", "[", "'index'", "]", "=", "list", "(", "input_dict", "[", "'index'", "]", ")", "for", "key", "in", "input_dict", "[", "'data'", "]", ":", "input_dict", "[", "'data'", "]", "[", "key", "]", "=", "list", "(", "input_dict", "[", "'data'", "]", "[", "key", "]", ")", "meta_data", "=", "dict", "(", ")", "for", "key", "in", "self", ".", "__slots__", ":", "if", "key", "not", "in", "[", "'_data'", ",", "'_index'", "]", ":", "value", "=", "self", ".", "__getattribute__", "(", "key", ")", "meta_data", "[", "key", ".", "lstrip", "(", "'_'", ")", "]", "=", "value", "if", "not", "isinstance", "(", "value", ",", "blist", ")", "else", "list", "(", "value", ")", "meta_data", "[", "'use_blist'", "]", "=", "meta_data", ".", "pop", "(", "'blist'", ")", "input_dict", "[", "'meta_data'", "]", "=", "meta_data", "return", "json", ".", "dumps", "(", "input_dict", ",", "default", "=", "repr", ")" ]

[ "Returns", "a", "JSON", "of", "the", "entire", "DataFrame", "that", "can", "be", "reconstructed", "back", "with", "raccoon", ".", "from_json", "(", "input", ")", ".", "Any", "object", "that", "cannot", "be", "serialized", "will", "be", "replaced", "with", "the", "representation", "of", "the", "object", "using", "repr", "()", ".", "In", "that", "instance", "the", "DataFrame", "will", "have", "a", "string", "representation", "in", "place", "of", "the", "object", "and", "will", "not", "reconstruct", "exactly", "." ]

[ "def", "rename_columns", "(", "self", ",", "rename_dict", ")", ":", "if", "not", "all", "(", "[", "x", "in", "self", ".", "_columns", "for", "x", "in", "rename_dict", ".", "keys", "(", ")", "]", ")", ":", "raise", "ValueError", "(", "'all dictionary keys must be in current columns'", ")", "for", "current", "in", "rename_dict", ".", "keys", "(", ")", ":", "self", ".", "_columns", "[", "self", ".", "_columns", ".", "index", "(", "current", ")", "]", "=", "rename_dict", "[", "current", "]" ]

[ "Renames", "the", "columns" ]

[ "def", "delete_all_rows", "(", "self", ")", ":", "del", "self", ".", "_index", "[", ":", "]", "for", "c", "in", "range", "(", "len", "(", "self", ".", "_columns", ")", ")", ":", "del", "self", ".", "_data", "[", "c", "]", "[", ":", "]" ]

[ "Deletes", "the", "contents", "of", "all", "rows", "in", "the", "DataFrame", ".", "This", "function", "is", "faster", "than", "delete_rows", "()", "to", "remove", "all", "information", "and", "at", "the", "same", "time", "it", "keeps", "the", "container", "lists", "for", "the", "columns", "and", "index", "so", "if", "there", "is", "another", "object", "that", "references", "this", "DataFrame", "like", "a", "ViewSeries", "the", "reference", "remains", "in", "tact", ".", ":", "return", ":", "nothing" ]