Datasets:

google

/

code_x_glue_tc_nl_code_search_adv

like 6

[ "def", "usage", "(", ")", ":", "l_bracket", "=", "clr", ".", "stringc", "(", "\"[\"", ",", "\"dark gray\"", ")", "r_bracket", "=", "clr", ".", "stringc", "(", "\"]\"", ",", "\"dark gray\"", ")", "pipe", "=", "clr", ".", "stringc", "(", "\"|\"", ",", "\"dark gray\"", ")", "app_name", "=", "clr", ".", "stringc", "(", "\"%prog\"", ",", "\"bright blue\"", ")", "commands", "=", "clr", ".", "stringc", "(", "\"{0}\"", ".", "format", "(", "pipe", ")", ".", "join", "(", "c", ".", "VALID_ACTIONS", ")", ",", "\"normal\"", ")", "help", "=", "clr", ".", "stringc", "(", "\"--help\"", ",", "\"green\"", ")", "options", "=", "clr", ".", "stringc", "(", "\"options\"", ",", "\"yellow\"", ")", "guide", "=", "\"\\n\\n\"", "for", "action", "in", "c", ".", "VALID_ACTIONS", ":", "guide", "+=", "command_name", "(", "app_name", ",", "action", ",", "c", ".", "MESSAGES", "[", "\"help_\"", "+", "action", "]", ")", "# remove the last line break", "guide", "=", "guide", "[", ":", "-", "1", "]", "return", "\"{0} {1}{2}{3} {1}{4}{3} {1}{5}{3}\\n{6}\"", ".", "format", "(", "app_name", ",", "l_bracket", ",", "commands", ",", "r_bracket", ",", "help", ",", "options", ",", "guide", ")" ]

[ "Return", "the", "usage", "for", "the", "help", "command", "." ]

[ "def", "epilogue", "(", "app_name", ")", ":", "app_name", "=", "clr", ".", "stringc", "(", "app_name", ",", "\"bright blue\"", ")", "command", "=", "clr", ".", "stringc", "(", "\"command\"", ",", "\"cyan\"", ")", "help", "=", "clr", ".", "stringc", "(", "\"--help\"", ",", "\"green\"", ")", "return", "\"\\n%s %s %s for more info on a command\\n\"", "%", "(", "app_name", ",", "command", ",", "help", ")" ]

[ "Return", "the", "epilogue", "for", "the", "help", "command", "." ]

[ "def", "command_name", "(", "app_name", ",", "command", ",", "help_text", ")", ":", "command", "=", "clr", ".", "stringc", "(", "command", ",", "\"cyan\"", ")", "help", "=", "clr", ".", "stringc", "(", "\"--help\"", ",", "\"green\"", ")", "return", "\"{0} {1} {2}\\n{3}\\n\\n\"", ".", "format", "(", "app_name", ",", "command", ",", "help", ",", "help_text", ")" ]

[ "Return", "a", "snippet", "of", "help", "text", "for", "this", "command", "." ]

[ "def", "role", "(", "name", ",", "report", ",", "role_name_length", ")", ":", "pad_role_name_by", "=", "11", "+", "role_name_length", "defaults", "=", "field_value", "(", "report", "[", "\"total_defaults\"", "]", ",", "\"defaults\"", ",", "\"blue\"", ",", "16", ")", "facts", "=", "field_value", "(", "report", "[", "\"total_facts\"", "]", ",", "\"facts\"", ",", "\"purple\"", ",", "16", ")", "files", "=", "field_value", "(", "report", "[", "\"total_files\"", "]", ",", "\"files\"", ",", "\"dark gray\"", ",", "16", ")", "lines", "=", "field_value", "(", "report", "[", "\"total_lines\"", "]", ",", "\"lines\"", ",", "\"normal\"", ",", "16", ")", "print", "\"{0:<{1}} {2} {3} {4} {5}\"", ".", "format", "(", "clr", ".", "stringc", "(", "name", ",", "c", ".", "LOG_COLOR", "[", "report", "[", "\"state\"", "]", "]", ")", ",", "pad_role_name_by", ",", "defaults", ",", "facts", ",", "files", ",", "lines", ")" ]

[ "Print", "the", "role", "information", "." ]

[ "def", "field_value", "(", "key", ",", "label", ",", "color", ",", "padding", ")", ":", "if", "not", "clr", ".", "has_colors", "and", "padding", ">", "0", ":", "padding", "=", "7", "if", "color", "==", "\"bright gray\"", "or", "color", "==", "\"dark gray\"", ":", "bright_prefix", "=", "\"\"", "else", ":", "bright_prefix", "=", "\"bright \"", "field", "=", "clr", ".", "stringc", "(", "key", ",", "\"{0}{1}\"", ".", "format", "(", "bright_prefix", ",", "color", ")", ")", "field_label", "=", "clr", ".", "stringc", "(", "label", ",", "color", ")", "return", "\"{0:>{1}} {2}\"", ".", "format", "(", "field", ",", "padding", ",", "field_label", ")" ]

[ "Print", "a", "specific", "field", "s", "stats", "." ]

[ "def", "totals", "(", "report", ",", "total_roles", ",", "role_name_length", ")", ":", "roles_len_string", "=", "len", "(", "str", "(", "total_roles", ")", ")", "roles_label_len", "=", "6", "# \"r\" \"o\" \"l\" \"e\" \"s\" \" \"", "if", "clr", ".", "has_colors", ":", "roles_count_offset", "=", "22", "else", ":", "roles_count_offset", "=", "13", "roles_count_offset", "+=", "role_name_length", "# no idea honestly but it fixes the formatting", "# it will probably break the formatting if you have 100+ roles", "if", "roles_len_string", ">", "1", ":", "roles_count_offset", "-=", "2", "pad_roles_by", "=", "roles_count_offset", "+", "roles_len_string", "+", "roles_label_len", "roles", "=", "field_value", "(", "total_roles", ",", "\"roles\"", ",", "\"normal\"", ",", "0", ")", "defaults", "=", "field_value", "(", "report", "[", "\"defaults\"", "]", ",", "\"defaults\"", ",", "\"blue\"", ",", "16", ")", "facts", "=", "field_value", "(", "report", "[", "\"facts\"", "]", ",", "\"facts\"", ",", "\"purple\"", ",", "16", ")", "files", "=", "field_value", "(", "report", "[", "\"files\"", "]", ",", "\"files\"", ",", "\"dark gray\"", ",", "16", ")", "lines", "=", "field_value", "(", "report", "[", "\"lines\"", "]", ",", "\"lines\"", ",", "\"normal\"", ",", "16", ")", "print", "\"\"", ".", "join", "(", "clr", ".", "stringc", "(", "\"-\"", ",", "\"black\"", ")", "*", "79", ")", "print", "\"{0} {2:>{1}} {3} {4} {5}\"", ".", "format", "(", "roles", ",", "pad_roles_by", ",", "defaults", ",", "facts", ",", "files", ",", "lines", ")" ]

[ "Print", "the", "totals", "for", "each", "role", "s", "stats", "." ]

[ "def", "gen_totals", "(", "report", ",", "file_type", ")", ":", "label", "=", "clr", ".", "stringc", "(", "file_type", "+", "\" files \"", ",", "\"bright purple\"", ")", "ok", "=", "field_value", "(", "report", "[", "\"ok_role\"", "]", ",", "\"ok\"", ",", "c", ".", "LOG_COLOR", "[", "\"ok\"", "]", ",", "0", ")", "skipped", "=", "field_value", "(", "report", "[", "\"skipped_role\"", "]", ",", "\"skipped\"", ",", "c", ".", "LOG_COLOR", "[", "\"skipped\"", "]", ",", "16", ")", "changed", "=", "field_value", "(", "report", "[", "\"changed_role\"", "]", ",", "\"changed\"", ",", "c", ".", "LOG_COLOR", "[", "\"changed\"", "]", ",", "16", ")", "# missing_meta = field_value(report[\"missing_meta_role\"],", "# \"missing meta(s)\",", "# c.LOG_COLOR[\"missing_meta\"], 16)", "# print \"\\n{0} {1} {2} {3}\".format(ok, skipped, changed, missing_meta)", "print", "\"\\n{0} {1} {2} {3}\"", ".", "format", "(", "label", ",", "ok", ",", "skipped", ",", "changed", ")" ]

[ "Print", "the", "gen", "totals", "." ]

[ "def", "scan_totals", "(", "report", ")", ":", "ok", "=", "field_value", "(", "report", "[", "\"ok_role\"", "]", ",", "\"ok\"", ",", "c", ".", "LOG_COLOR", "[", "\"ok\"", "]", ",", "0", ")", "missing_readme", "=", "field_value", "(", "report", "[", "\"missing_readme_role\"", "]", ",", "\"missing readme(s)\"", ",", "c", ".", "LOG_COLOR", "[", "\"missing_readme\"", "]", ",", "16", ")", "missing_meta", "=", "field_value", "(", "report", "[", "\"missing_meta_role\"", "]", ",", "\"missing meta(s)\"", ",", "c", ".", "LOG_COLOR", "[", "\"missing_meta\"", "]", ",", "16", ")", "print", "\"\\n{0} {1} {2}\"", ".", "format", "(", "ok", ",", "missing_readme", ",", "missing_meta", ")" ]

[ "Print", "the", "scan", "totals", "." ]

[ "def", "has_colors", "(", "stream", ")", ":", "if", "not", "hasattr", "(", "stream", ",", "\"isatty\"", ")", ":", "return", "False", "if", "not", "stream", ".", "isatty", "(", ")", ":", "return", "False", "# auto color only on TTYs", "try", ":", "import", "curses", "curses", ".", "setupterm", "(", ")", "return", "curses", ".", "tigetnum", "(", "\"colors\"", ")", ">", "2", "except", ":", "return", "False" ]

[ "Determine", "if", "the", "terminal", "supports", "ansi", "colors", "." ]

[ "def", "stringc", "(", "text", ",", "color", ")", ":", "if", "has_colors", ":", "text", "=", "str", "(", "text", ")", "return", "\"\\033[\"", "+", "codeCodes", "[", "color", "]", "+", "\"m\"", "+", "text", "+", "\"\\033[0m\"", "else", ":", "return", "text" ]

[ "Return", "a", "string", "with", "terminal", "colors", "." ]

[ "def", "execute_command", "(", "self", ")", ":", "stderr", "=", "\"\"", "role_count", "=", "0", "for", "role", "in", "utils", ".", "roles_dict", "(", "self", ".", "roles_path", ")", ":", "self", ".", "command", "=", "self", ".", "command", ".", "replace", "(", "\"%role_name\"", ",", "role", ")", "(", "_", ",", "err", ")", "=", "utils", ".", "capture_shell", "(", "\"cd {0} && {1}\"", ".", "format", "(", "os", ".", "path", ".", "join", "(", "self", ".", "roles_path", ",", "role", ")", ",", "self", ".", "command", ")", ")", "stderr", "=", "err", "role_count", "+=", "1", "utils", ".", "exit_if_no_roles", "(", "role_count", ",", "self", ".", "roles_path", ")", "if", "len", "(", "stderr", ")", ">", "0", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"run_error\"", "]", ",", "stderr", "[", ":", "-", "1", "]", ")", "else", ":", "if", "not", "self", ".", "config", "[", "\"options_quiet\"", "]", ":", "ui", ".", "ok", "(", "c", ".", "MESSAGES", "[", "\"run_success\"", "]", ".", "replace", "(", "\"%role_count\"", ",", "str", "(", "role_count", ")", ")", ",", "self", ".", "options", ".", "command", ")" ]

[ "Execute", "the", "shell", "command", "." ]

[ "def", "mkdir_p", "(", "path", ")", ":", "try", ":", "os", ".", "makedirs", "(", "path", ")", "except", "OSError", "as", "err", ":", "if", "err", ".", "errno", "==", "errno", ".", "EEXIST", "and", "os", ".", "path", ".", "isdir", "(", "path", ")", ":", "pass", "else", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"path_unmakable\"", "]", ",", "err", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Emulate", "the", "behavior", "of", "mkdir", "-", "p", "." ]

[ "def", "string_to_file", "(", "path", ",", "input", ")", ":", "mkdir_p", "(", "os", ".", "path", ".", "dirname", "(", "path", ")", ")", "with", "codecs", ".", "open", "(", "path", ",", "\"w+\"", ",", "\"UTF-8\"", ")", "as", "file", ":", "file", ".", "write", "(", "input", ")" ]

[ "Write", "a", "file", "from", "a", "given", "string", "." ]

[ "def", "file_to_string", "(", "path", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"path_missing\"", "]", ",", "path", ")", "sys", ".", "exit", "(", "1", ")", "with", "codecs", ".", "open", "(", "path", ",", "\"r\"", ",", "\"UTF-8\"", ")", "as", "contents", ":", "return", "contents", ".", "read", "(", ")" ]

[ "Return", "the", "contents", "of", "a", "file", "when", "given", "a", "path", "." ]

[ "def", "file_to_list", "(", "path", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"path_missing\"", "]", ",", "path", ")", "sys", ".", "exit", "(", "1", ")", "with", "codecs", ".", "open", "(", "path", ",", "\"r\"", ",", "\"UTF-8\"", ")", "as", "contents", ":", "lines", "=", "contents", ".", "read", "(", ")", ".", "splitlines", "(", ")", "return", "lines" ]

[ "Return", "the", "contents", "of", "a", "file", "as", "a", "list", "when", "given", "a", "path", "." ]

[ "def", "url_to_string", "(", "url", ")", ":", "try", ":", "page", "=", "urllib2", ".", "urlopen", "(", "url", ")", "except", "(", "urllib2", ".", "HTTPError", ",", "urllib2", ".", "URLError", ")", "as", "err", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"url_unreachable\"", "]", ",", "err", ")", "sys", ".", "exit", "(", "1", ")", "return", "page" ]

[ "Return", "the", "contents", "of", "a", "web", "site", "url", "as", "a", "string", "." ]

[ "def", "template", "(", "path", ",", "extend_path", ",", "out", ")", ":", "files", "=", "[", "]", "# add the \"extender\" template when it exists", "if", "len", "(", "extend_path", ")", ">", "0", ":", "# determine the base readme path", "base_path", "=", "os", ".", "path", ".", "dirname", "(", "extend_path", ")", "new_base_path", "=", "os", ".", "path", ".", "join", "(", "base_path", ",", "\"README.{0}.j2\"", ".", "format", "(", "out", ")", ")", "if", "os", ".", "path", ".", "exists", "(", "new_base_path", ")", ":", "path", "=", "new_base_path", "if", "os", ".", "path", ".", "exists", "(", "extend_path", ")", ":", "files", "=", "[", "path", ",", "extend_path", "]", "else", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"template_extender_missing\"", "]", ")", "ui", ".", "error", "(", "extend_path", ")", "sys", ".", "exit", "(", "1", ")", "else", ":", "files", "=", "[", "path", "]", "try", ":", "# Use the subclassed relative environment class", "env", "=", "RelEnvironment", "(", "trim_blocks", "=", "True", ")", "# Add a unique dict filter, by key.", "# DEPRECATION WARNING: This is only used for backwards compatibility,", "# please use the unique filter instead.", "def", "unique_dict", "(", "items", ",", "key", ")", ":", "return", "{", "v", "[", "key", "]", ":", "v", "for", "v", "in", "items", "}", ".", "values", "(", ")", "env", ".", "filters", "[", "\"unique_dict\"", "]", "=", "unique_dict", "def", "unique", "(", "a", ")", ":", "# Don’t use the following commented out optimization which is used", "# in ansible/lib/ansible/plugins/filter/mathstuff.py in Ansigenome", "# as it resorts the role dependencies:", "# if isinstance(a,collections.Hashable):", "# c = set(a)", "c", "=", "[", "]", "for", "x", "in", "a", ":", "if", "x", "not", "in", "c", ":", "c", ".", "append", "(", "x", ")", "return", "c", "env", ".", "filters", "[", "\"unique\"", "]", "=", "unique", "# create a dictionary of templates", "templates", "=", "dict", "(", "(", "name", ",", "codecs", ".", "open", "(", "name", ",", "\"rb\"", ",", "'UTF-8'", ")", ".", "read", "(", ")", ")", "for", "name", "in", "files", ")", "env", ".", "loader", "=", "DictLoader", "(", "templates", ")", "# return the final result (the last template in the list)", "return", "env", ".", "get_template", "(", "files", "[", "len", "(", "files", ")", "-", "1", "]", ")", "except", "Exception", "as", "err", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"template_error\"", "]", ",", "err", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Return", "a", "jinja2", "template", "instance", "with", "extends", "support", "." ]

[ "def", "files_in_path", "(", "path", ")", ":", "aggregated_files", "=", "[", "]", "for", "dir_", ",", "_", ",", "files", "in", "os", ".", "walk", "(", "path", ")", ":", "for", "file", "in", "files", ":", "relative_dir", "=", "os", ".", "path", ".", "relpath", "(", "dir_", ",", "path", ")", "if", "\".git\"", "not", "in", "relative_dir", ":", "relative_file", "=", "os", ".", "path", ".", "join", "(", "relative_dir", ",", "file", ")", "aggregated_files", ".", "append", "(", "relative_file", ")", "return", "aggregated_files" ]

[ "Return", "a", "list", "of", "all", "files", "in", "a", "path", "but", "exclude", "git", "folders", "." ]

[ "def", "exit_if_path_not_found", "(", "path", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"path_missing\"", "]", ",", "path", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Exit", "if", "the", "path", "is", "not", "found", "." ]

[ "def", "yaml_load", "(", "path", ",", "input", "=", "\"\"", ",", "err_quit", "=", "False", ")", ":", "try", ":", "if", "len", "(", "input", ")", ">", "0", ":", "return", "yaml", ".", "safe_load", "(", "input", ")", "elif", "len", "(", "path", ")", ">", "0", ":", "return", "yaml", ".", "safe_load", "(", "file_to_string", "(", "path", ")", ")", "except", "Exception", "as", "err", ":", "file", "=", "os", ".", "path", ".", "basename", "(", "path", ")", "ui", ".", "error", "(", "\"\"", ",", "c", ".", "MESSAGES", "[", "\"yaml_error\"", "]", ".", "replace", "(", "\"%file\"", ",", "file", ")", ",", "err", ",", "\"\"", ")", "if", "err_quit", ":", "sys", ".", "exit", "(", "1", ")", "return", "False" ]

[ "Return", "a", "yaml", "dict", "from", "a", "file", "or", "string", "with", "error", "handling", "." ]

[ "def", "to_nice_yaml", "(", "yaml_input", ",", "indentation", "=", "2", ")", ":", "return", "yaml", ".", "safe_dump", "(", "yaml_input", ",", "indent", "=", "indentation", ",", "allow_unicode", "=", "True", ",", "default_flow_style", "=", "False", ")" ]

[ "Return", "condensed", "yaml", "into", "human", "readable", "yaml", "." ]

[ "def", "keys_in_dict", "(", "d", ",", "parent_key", ",", "keys", ")", ":", "for", "key", ",", "value", "in", "d", ".", "iteritems", "(", ")", ":", "if", "isinstance", "(", "value", ",", "dict", ")", ":", "keys_in_dict", "(", "value", ",", "key", ",", "keys", ")", "else", ":", "if", "parent_key", ":", "prefix", "=", "parent_key", "+", "\".\"", "else", ":", "prefix", "=", "\"\"", "keys", ".", "append", "(", "prefix", "+", "key", ")", "return", "keys" ]

[ "Create", "a", "list", "of", "keys", "from", "a", "dict", "recursively", "." ]

[ "def", "swap_yaml_string", "(", "file_path", ",", "swaps", ")", ":", "original_file", "=", "file_to_string", "(", "file_path", ")", "new_file", "=", "original_file", "changed", "=", "False", "for", "item", "in", "swaps", ":", "match", "=", "re", ".", "compile", "(", "r'(?<={0}: )([\"\\']?)(.*)\\1'", ".", "format", "(", "item", "[", "0", "]", ")", ",", "re", ".", "MULTILINE", ")", "new_file", "=", "re", ".", "sub", "(", "match", ",", "item", "[", "1", "]", ",", "new_file", ")", "if", "new_file", "!=", "original_file", ":", "changed", "=", "True", "string_to_file", "(", "file_path", ",", "new_file", ")", "return", "(", "new_file", ",", "changed", ")" ]

[ "Swap", "a", "string", "in", "a", "yaml", "file", "without", "touching", "the", "existing", "formatting", "." ]

[ "def", "exit_if_no_roles", "(", "roles_count", ",", "roles_path", ")", ":", "if", "roles_count", "==", "0", ":", "ui", ".", "warn", "(", "c", ".", "MESSAGES", "[", "\"empty_roles_path\"", "]", ",", "roles_path", ")", "sys", ".", "exit", "(", ")" ]

[ "Exit", "if", "there", "were", "no", "roles", "found", "." ]

[ "def", "roles_dict", "(", "path", ",", "repo_prefix", "=", "\"\"", ",", "repo_sub_dir", "=", "\"\"", ")", ":", "exit_if_path_not_found", "(", "path", ")", "aggregated_roles", "=", "{", "}", "roles", "=", "os", ".", "walk", "(", "path", ")", ".", "next", "(", ")", "[", "1", "]", "# First scan all directories", "for", "role", "in", "roles", ":", "for", "sub_role", "in", "roles_dict", "(", "path", "+", "\"/\"", "+", "role", ",", "repo_prefix", "=", "\"\"", ",", "repo_sub_dir", "=", "role", "+", "\"/\"", ")", ":", "aggregated_roles", "[", "role", "+", "\"/\"", "+", "sub_role", "]", "=", "role", "+", "\"/\"", "+", "sub_role", "# Then format them", "for", "role", "in", "roles", ":", "if", "is_role", "(", "os", ".", "path", ".", "join", "(", "path", ",", "role", ")", ")", ":", "if", "isinstance", "(", "role", ",", "basestring", ")", ":", "role_repo", "=", "\"{0}{1}\"", ".", "format", "(", "repo_prefix", ",", "role_name", "(", "role", ")", ")", "aggregated_roles", "[", "role", "]", "=", "role_repo", "return", "aggregated_roles" ]

[ "Return", "a", "dict", "of", "role", "names", "and", "repo", "paths", "." ]

[ "def", "is_role", "(", "path", ")", ":", "seems_legit", "=", "False", "for", "folder", "in", "c", ".", "ANSIBLE_FOLDERS", ":", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "path", ",", "folder", ")", ")", ":", "seems_legit", "=", "True", "return", "seems_legit" ]

[ "Determine", "if", "a", "path", "is", "an", "ansible", "role", "." ]

[ "def", "stripped_args", "(", "args", ")", ":", "stripped_args", "=", "[", "]", "for", "arg", "in", "args", ":", "stripped_args", ".", "append", "(", "arg", ".", "strip", "(", ")", ")", "return", "stripped_args" ]

[ "Return", "the", "stripped", "version", "of", "the", "arguments", "." ]

[ "def", "normalize_role", "(", "role", ",", "config", ")", ":", "if", "role", ".", "startswith", "(", "config", "[", "\"scm_repo_prefix\"", "]", ")", ":", "role_name", "=", "role", ".", "replace", "(", "config", "[", "\"scm_repo_prefix\"", "]", ",", "\"\"", ")", "else", ":", "if", "\".\"", "in", "role", ":", "galaxy_prefix", "=", "\"{0}.\"", ".", "format", "(", "config", "[", "\"scm_user\"", "]", ")", "role_name", "=", "role", ".", "replace", "(", "galaxy_prefix", ",", "\"\"", ")", "elif", "\"-\"", "in", "role", ":", "role_name", "=", "role", ".", "replace", "(", "\"-\"", ",", "\"_\"", ")", "else", ":", "role_name", "=", "role", "return", "role_name" ]

[ "Normalize", "a", "role", "name", "." ]

[ "def", "create_meta_main", "(", "create_path", ",", "config", ",", "role", ",", "categories", ")", ":", "meta_file", "=", "c", ".", "DEFAULT_META_FILE", ".", "replace", "(", "\"%author_name\"", ",", "config", "[", "\"author_name\"", "]", ")", "meta_file", "=", "meta_file", ".", "replace", "(", "\"%author_company\"", ",", "config", "[", "\"author_company\"", "]", ")", "meta_file", "=", "meta_file", ".", "replace", "(", "\"%license_type\"", ",", "config", "[", "\"license_type\"", "]", ")", "meta_file", "=", "meta_file", ".", "replace", "(", "\"%role_name\"", ",", "role", ")", "# Normalize the category so %categories always gets replaced.", "if", "not", "categories", ":", "categories", "=", "\"\"", "meta_file", "=", "meta_file", ".", "replace", "(", "\"%categories\"", ",", "categories", ")", "string_to_file", "(", "create_path", ",", "meta_file", ")" ]

[ "Create", "a", "meta", "template", "." ]

[ "def", "get_version", "(", "path", ",", "default", "=", "\"master\"", ")", ":", "version", "=", "default", "if", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "version_contents", "=", "file_to_string", "(", "path", ")", "if", "version_contents", ":", "version", "=", "version_contents", ".", "strip", "(", ")", "return", "version" ]

[ "Return", "the", "version", "from", "a", "VERSION", "file" ]

[ "def", "write_config", "(", "path", ",", "config", ")", ":", "config_as_string", "=", "to_nice_yaml", "(", "config", ")", "config_as_string", "=", "\"---\\n\"", "+", "config_as_string", "string_to_file", "(", "path", ",", "config_as_string", ")" ]

[ "Write", "the", "config", "with", "a", "little", "post", "-", "converting", "formatting", "." ]

[ "def", "limit_roles", "(", "self", ")", ":", "new_roles", "=", "{", "}", "roles", "=", "self", ".", "options", ".", "limit", ".", "split", "(", "\",\"", ")", "for", "key", ",", "value", "in", "self", ".", "roles", ".", "iteritems", "(", ")", ":", "for", "role", "in", "roles", ":", "role", "=", "role", ".", "strip", "(", ")", "if", "key", "==", "role", ":", "new_roles", "[", "key", "]", "=", "value", "self", ".", "roles", "=", "new_roles" ]

[ "Limit", "the", "roles", "being", "scanned", "." ]

[ "def", "scan_roles", "(", "self", ")", ":", "for", "key", ",", "value", "in", "sorted", "(", "self", ".", "roles", ".", "iteritems", "(", ")", ")", ":", "self", ".", "paths", "[", "\"role\"", "]", "=", "os", ".", "path", ".", "join", "(", "self", ".", "roles_path", ",", "key", ")", "self", ".", "paths", "[", "\"meta\"", "]", "=", "os", ".", "path", ".", "join", "(", "self", ".", "paths", "[", "\"role\"", "]", ",", "\"meta\"", ",", "\"main.yml\"", ")", "self", ".", "paths", "[", "\"readme\"", "]", "=", "os", ".", "path", ".", "join", "(", "self", ".", "paths", "[", "\"role\"", "]", ",", "\"README.{0}\"", ".", "format", "(", "self", ".", "readme_format", ")", ")", "self", ".", "paths", "[", "\"defaults\"", "]", "=", "os", ".", "path", ".", "join", "(", "self", ".", "paths", "[", "\"role\"", "]", ",", "\"defaults\"", ",", "\"main.yml\"", ")", "self", ".", "report", "[", "\"roles\"", "]", "[", "key", "]", "=", "self", ".", "report_role", "(", "key", ")", "# we are writing a readme file which means the state of the role", "# needs to be updated before it gets output by the ui", "if", "self", ".", "gendoc", ":", "if", "self", ".", "valid_meta", "(", "key", ")", ":", "self", ".", "make_meta_dict_consistent", "(", ")", "self", ".", "set_readme_template_vars", "(", "key", ",", "value", ")", "self", ".", "write_readme", "(", "key", ")", "# only load the meta file when generating meta files", "elif", "self", ".", "genmeta", ":", "self", ".", "make_or_augment_meta", "(", "key", ")", "if", "self", ".", "valid_meta", "(", "key", ")", ":", "self", ".", "make_meta_dict_consistent", "(", ")", "self", ".", "write_meta", "(", "key", ")", "else", ":", "self", ".", "update_scan_report", "(", "key", ")", "if", "not", "self", ".", "config", "[", "\"options_quiet\"", "]", "and", "not", "self", ".", "export", ":", "ui", ".", "role", "(", "key", ",", "self", ".", "report", "[", "\"roles\"", "]", "[", "key", "]", ",", "self", ".", "report", "[", "\"stats\"", "]", "[", "\"longest_role_name_length\"", "]", ")", "self", ".", "tally_role_columns", "(", ")", "# below this point is only UI output, so we can return", "if", "self", ".", "config", "[", "\"options_quiet\"", "]", "or", "self", ".", "export", ":", "return", "ui", ".", "totals", "(", "self", ".", "report", "[", "\"totals\"", "]", ",", "len", "(", "self", ".", "report", "[", "\"roles\"", "]", ".", "keys", "(", ")", ")", ",", "self", ".", "report", "[", "\"stats\"", "]", "[", "\"longest_role_name_length\"", "]", ")", "if", "self", ".", "gendoc", ":", "ui", ".", "gen_totals", "(", "self", ".", "report", "[", "\"state\"", "]", ",", "\"readme\"", ")", "elif", "self", ".", "genmeta", ":", "ui", ".", "gen_totals", "(", "self", ".", "report", "[", "\"state\"", "]", ",", "\"meta\"", ")", "else", ":", "ui", ".", "scan_totals", "(", "self", ".", "report", "[", "\"state\"", "]", ")" ]

[ "Iterate", "over", "each", "role", "and", "report", "its", "stats", "." ]

[ "def", "export_roles", "(", "self", ")", ":", "# prepare the report by removing unnecessary fields", "del", "self", ".", "report", "[", "\"state\"", "]", "del", "self", ".", "report", "[", "\"stats\"", "]", "for", "role", "in", "self", ".", "report", "[", "\"roles\"", "]", ":", "del", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "defaults_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "roles_path", ",", "role", ",", "\"defaults\"", ",", "\"main.yml\"", ")", "if", "os", ".", "path", ".", "exists", "(", "defaults_path", ")", ":", "defaults", "=", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"defaults\"", "]", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"defaults\"", "]", "=", "utils", ".", "yaml_load", "(", "\"\"", ",", "defaults", ")", "Export", "(", "self", ".", "roles_path", ",", "self", ".", "report", ",", "self", ".", "config", ",", "self", ".", "options", ")" ]

[ "Export", "the", "roles", "to", "one", "of", "the", "export", "types", "." ]

[ "def", "report_role", "(", "self", ",", "role", ")", ":", "self", ".", "yaml_files", "=", "[", "]", "fields", "=", "{", "\"state\"", ":", "\"skipped\"", ",", "\"total_files\"", ":", "self", ".", "gather_files", "(", ")", ",", "\"total_lines\"", ":", "self", ".", "gather_lines", "(", ")", ",", "\"total_facts\"", ":", "self", ".", "gather_facts", "(", ")", ",", "\"total_defaults\"", ":", "self", ".", "gather_defaults", "(", ")", ",", "\"facts\"", ":", "self", ".", "facts", ",", "\"defaults\"", ":", "self", ".", "defaults", ",", "\"meta\"", ":", "self", ".", "gather_meta", "(", ")", ",", "\"readme\"", ":", "self", ".", "gather_readme", "(", ")", ",", "\"dependencies\"", ":", "self", ".", "dependencies", ",", "\"total_dependencies\"", ":", "len", "(", "self", ".", "dependencies", ")", "}", "return", "fields" ]

[ "Return", "the", "fields", "gathered", "." ]

[ "def", "gather_meta", "(", "self", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")", ":", "return", "\"\"", "meta_dict", "=", "utils", ".", "yaml_load", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")", "# gather the dependencies", "if", "meta_dict", "and", "\"dependencies\"", "in", "meta_dict", ":", "# create a simple list of each role that is a dependency", "dep_list", "=", "[", "]", "for", "dependency", "in", "meta_dict", "[", "\"dependencies\"", "]", ":", "if", "type", "(", "dependency", ")", "is", "dict", ":", "dep_list", ".", "append", "(", "dependency", "[", "\"role\"", "]", ")", "else", ":", "dep_list", ".", "append", "(", "dependency", ")", "# unique set of dependencies", "meta_dict", "[", "\"dependencies\"", "]", "=", "list", "(", "set", "(", "dep_list", ")", ")", "self", ".", "dependencies", "=", "meta_dict", "[", "\"dependencies\"", "]", "else", ":", "self", ".", "dependencies", "=", "[", "]", "return", "utils", ".", "file_to_string", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")" ]

[ "Return", "the", "meta", "file", "." ]

[ "def", "gather_readme", "(", "self", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "\"readme\"", "]", ")", ":", "return", "\"\"", "return", "utils", ".", "file_to_string", "(", "self", ".", "paths", "[", "\"readme\"", "]", ")" ]

[ "Return", "the", "readme", "file", "." ]

[ "def", "gather_defaults", "(", "self", ")", ":", "total_defaults", "=", "0", "defaults_lines", "=", "[", "]", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "\"defaults\"", "]", ")", ":", "# reset the defaults if no defaults were found", "self", ".", "defaults", "=", "\"\"", "return", "0", "file", "=", "open", "(", "self", ".", "paths", "[", "\"defaults\"", "]", ",", "\"r\"", ")", "for", "line", "in", "file", ":", "if", "len", "(", "line", ")", ">", "0", ":", "first_char", "=", "line", "[", "0", "]", "else", ":", "first_char", "=", "\"\"", "defaults_lines", ".", "append", "(", "line", ")", "if", "(", "first_char", "!=", "\"#\"", "and", "first_char", "!=", "\"-\"", "and", "first_char", "!=", "\" \"", "and", "first_char", "!=", "\"\\r\"", "and", "first_char", "!=", "\"\\n\"", "and", "first_char", "!=", "\"\\t\"", ")", ":", "total_defaults", "+=", "1", "file", ".", "close", "(", ")", "self", ".", "defaults", "=", "\"\"", ".", "join", "(", "defaults_lines", ")", "return", "total_defaults" ]

[ "Return", "the", "number", "of", "default", "variables", "." ]

[ "def", "gather_facts", "(", "self", ")", ":", "facts", "=", "[", "]", "for", "file", "in", "self", ".", "yaml_files", ":", "facts", "+=", "self", ".", "gather_facts_list", "(", "file", ")", "unique_facts", "=", "list", "(", "set", "(", "facts", ")", ")", "self", ".", "facts", "=", "unique_facts", "return", "len", "(", "unique_facts", ")" ]

[ "Return", "the", "number", "of", "facts", "." ]

[ "def", "gather_facts_list", "(", "self", ",", "file", ")", ":", "facts", "=", "[", "]", "contents", "=", "utils", ".", "file_to_string", "(", "os", ".", "path", ".", "join", "(", "self", ".", "paths", "[", "\"role\"", "]", ",", "file", ")", ")", "contents", "=", "re", ".", "sub", "(", "r\"\\s+\"", ",", "\"\"", ",", "contents", ")", "matches", "=", "self", ".", "regex_facts", ".", "findall", "(", "contents", ")", "for", "match", "in", "matches", ":", "facts", ".", "append", "(", "match", ".", "split", "(", "\":\"", ")", "[", "1", "]", ")", "return", "facts" ]

[ "Return", "a", "list", "of", "facts", "." ]

[ "def", "gather_files", "(", "self", ")", ":", "self", ".", "all_files", "=", "utils", ".", "files_in_path", "(", "self", ".", "paths", "[", "\"role\"", "]", ")", "return", "len", "(", "self", ".", "all_files", ")" ]

[ "Return", "the", "number", "of", "files", "." ]

[ "def", "gather_lines", "(", "self", ")", ":", "total_lines", "=", "0", "for", "file", "in", "self", ".", "all_files", ":", "full_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "paths", "[", "\"role\"", "]", ",", "file", ")", "with", "open", "(", "full_path", ",", "\"r\"", ")", "as", "f", ":", "for", "line", "in", "f", ":", "total_lines", "+=", "1", "if", "full_path", ".", "endswith", "(", "\".yml\"", ")", ":", "self", ".", "yaml_files", ".", "append", "(", "full_path", ")", "return", "total_lines" ]

[ "Return", "the", "number", "of", "lines", "." ]

[ "def", "tally_role_columns", "(", "self", ")", ":", "totals", "=", "self", ".", "report", "[", "\"totals\"", "]", "roles", "=", "self", ".", "report", "[", "\"roles\"", "]", "totals", "[", "\"dependencies\"", "]", "=", "sum", "(", "roles", "[", "item", "]", "[", "\"total_dependencies\"", "]", "for", "item", "in", "roles", ")", "totals", "[", "\"defaults\"", "]", "=", "sum", "(", "roles", "[", "item", "]", "[", "\"total_defaults\"", "]", "for", "item", "in", "roles", ")", "totals", "[", "\"facts\"", "]", "=", "sum", "(", "roles", "[", "item", "]", "[", "\"total_facts\"", "]", "for", "item", "in", "roles", ")", "totals", "[", "\"files\"", "]", "=", "sum", "(", "roles", "[", "item", "]", "[", "\"total_files\"", "]", "for", "item", "in", "roles", ")", "totals", "[", "\"lines\"", "]", "=", "sum", "(", "roles", "[", "item", "]", "[", "\"total_lines\"", "]", "for", "item", "in", "roles", ")" ]

[ "Sum", "up", "all", "of", "the", "stat", "columns", "." ]

[ "def", "valid_meta", "(", "self", ",", "role", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")", ":", "self", ".", "meta_dict", "=", "utils", ".", "yaml_load", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")", "else", ":", "self", ".", "report", "[", "\"state\"", "]", "[", "\"missing_meta_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"missing_meta\"", "return", "False", "is_valid", "=", "True", "# utils.yaml_load returns False when the file is invalid", "if", "isinstance", "(", "self", ".", "meta_dict", ",", "bool", ")", ":", "is_valid", "=", "False", "sys", ".", "exit", "(", "1", ")", "return", "is_valid" ]

[ "Return", "whether", "or", "not", "the", "meta", "file", "being", "read", "is", "valid", "." ]

[ "def", "make_or_augment_meta", "(", "self", ",", "role", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")", ":", "utils", ".", "create_meta_main", "(", "self", ".", "paths", "[", "\"meta\"", "]", ",", "self", ".", "config", ",", "role", ",", "\"\"", ")", "self", ".", "report", "[", "\"state\"", "]", "[", "\"ok_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"ok\"", "# swap values in place to use the config values", "swaps", "=", "[", "(", "\"author\"", ",", "self", ".", "config", "[", "\"author_name\"", "]", ")", ",", "(", "\"company\"", ",", "self", ".", "config", "[", "\"author_company\"", "]", ")", ",", "(", "\"license\"", ",", "self", ".", "config", "[", "\"license_type\"", "]", ")", ",", "]", "(", "new_meta", ",", "_", ")", "=", "utils", ".", "swap_yaml_string", "(", "self", ".", "paths", "[", "\"meta\"", "]", ",", "swaps", ")", "# normalize the --- at the top of the file by removing it first", "new_meta", "=", "new_meta", ".", "replace", "(", "\"---\"", ",", "\"\"", ")", "new_meta", "=", "new_meta", ".", "lstrip", "(", ")", "# augment missing main keys", "augments", "=", "[", "(", "\"ansigenome_info\"", ",", "\"{}\"", ")", ",", "(", "\"galaxy_info\"", ",", "\"{}\"", ")", ",", "(", "\"dependencies\"", ",", "\"[]\"", ")", ",", "]", "new_meta", "=", "self", ".", "augment_main_keys", "(", "augments", ",", "new_meta", ")", "# re-attach the ---", "new_meta", "=", "\"---\\n\\n\"", "+", "new_meta", "travis_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "paths", "[", "\"role\"", "]", ",", "\".travis.yml\"", ")", "if", "os", ".", "path", ".", "exists", "(", "travis_path", ")", ":", "new_meta", "=", "new_meta", ".", "replace", "(", "\"travis: False\"", ",", "\"travis: True\"", ")", "utils", ".", "string_to_file", "(", "self", ".", "paths", "[", "\"meta\"", "]", ",", "new_meta", ")" ]

[ "Create", "or", "augment", "a", "meta", "file", "." ]

[ "def", "write_readme", "(", "self", ",", "role", ")", ":", "j2_out", "=", "self", ".", "readme_template", ".", "render", "(", "self", ".", "readme_template_vars", ")", "self", ".", "update_gen_report", "(", "role", ",", "\"readme\"", ",", "j2_out", ")" ]

[ "Write", "out", "a", "new", "readme", "file", "." ]

[ "def", "write_meta", "(", "self", ",", "role", ")", ":", "meta_file", "=", "utils", ".", "file_to_string", "(", "self", ".", "paths", "[", "\"meta\"", "]", ")", "self", ".", "update_gen_report", "(", "role", ",", "\"meta\"", ",", "meta_file", ")" ]

[ "Write", "out", "a", "new", "meta", "file", "." ]

[ "def", "update_scan_report", "(", "self", ",", "role", ")", ":", "state", "=", "self", ".", "report", "[", "\"state\"", "]", "# ensure the missing meta state is colored up and the ok count is good", "if", "self", ".", "gendoc", ":", "if", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "==", "\"missing_meta\"", ":", "return", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "\"readme\"", "]", ")", ":", "state", "[", "\"ok_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"ok\"", "else", ":", "state", "[", "\"missing_readme_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"missing_readme\"" ]

[ "Update", "the", "role", "state", "and", "adjust", "the", "scan", "totals", "." ]

[ "def", "update_gen_report", "(", "self", ",", "role", ",", "file", ",", "original", ")", ":", "state", "=", "self", ".", "report", "[", "\"state\"", "]", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "paths", "[", "file", "]", ")", ":", "state", "[", "\"ok_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"ok\"", "elif", "(", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "file", "]", "!=", "original", "and", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "!=", "\"ok\"", ")", ":", "state", "[", "\"changed_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"changed\"", "elif", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "file", "]", "==", "original", ":", "state", "[", "\"skipped_role\"", "]", "+=", "1", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"state\"", "]", "=", "\"skipped\"", "return", "utils", ".", "string_to_file", "(", "self", ".", "paths", "[", "file", "]", ",", "original", ")" ]

[ "Update", "the", "role", "state", "and", "adjust", "the", "gen", "totals", "." ]

[ "def", "make_meta_dict_consistent", "(", "self", ")", ":", "if", "self", ".", "meta_dict", "is", "None", ":", "self", ".", "meta_dict", "=", "{", "}", "if", "\"galaxy_info\"", "not", "in", "self", ".", "meta_dict", ":", "self", ".", "meta_dict", "[", "\"galaxy_info\"", "]", "=", "{", "}", "if", "\"dependencies\"", "not", "in", "self", ".", "meta_dict", ":", "self", ".", "meta_dict", "[", "\"dependencies\"", "]", "=", "[", "]", "if", "\"ansigenome_info\"", "not", "in", "self", ".", "meta_dict", ":", "self", ".", "meta_dict", "[", "\"ansigenome_info\"", "]", "=", "{", "}" ]

[ "Remove", "the", "possibility", "of", "the", "main", "keys", "being", "undefined", "." ]

[ "def", "set_readme_template_vars", "(", "self", ",", "role", ",", "repo_name", ")", ":", "# normalize and expose a bunch of fields to the template", "authors", "=", "[", "]", "author", "=", "{", "\"name\"", ":", "self", ".", "config", "[", "\"author_name\"", "]", ",", "\"company\"", ":", "self", ".", "config", "[", "\"author_company\"", "]", ",", "\"url\"", ":", "self", ".", "config", "[", "\"author_url\"", "]", ",", "\"email\"", ":", "self", ".", "config", "[", "\"author_email\"", "]", ",", "\"twitter\"", ":", "self", ".", "config", "[", "\"author_twitter\"", "]", ",", "}", "scm", "=", "{", "\"host\"", ":", "self", ".", "config", "[", "\"scm_host\"", "]", ",", "\"repo_prefix\"", ":", "self", ".", "config", "[", "\"scm_repo_prefix\"", "]", ",", "\"type\"", ":", "self", ".", "config", "[", "\"scm_type\"", "]", ",", "\"user\"", ":", "self", ".", "config", "[", "\"scm_user\"", "]", ",", "}", "license", "=", "{", "\"type\"", ":", "self", ".", "config", "[", "\"license_type\"", "]", ",", "\"url\"", ":", "self", ".", "config", "[", "\"license_url\"", "]", ",", "}", "role_name", "=", "utils", ".", "normalize_role", "(", "role", ",", "self", ".", "config", ")", "normalized_role", "=", "{", "\"name\"", ":", "role_name", ",", "\"galaxy_name\"", ":", "\"{0}.{1}\"", ".", "format", "(", "self", ".", "config", "[", "\"scm_user\"", "]", ",", "role_name", ")", ",", "\"slug\"", ":", "\"{0}{1}\"", ".", "format", "(", "self", ".", "config", "[", "\"scm_repo_prefix\"", "]", ",", "role_name", ")", ",", "}", "if", "\"authors\"", "in", "self", ".", "meta_dict", "[", "\"ansigenome_info\"", "]", ":", "authors", "=", "self", ".", "meta_dict", "[", "\"ansigenome_info\"", "]", "[", "\"authors\"", "]", "else", ":", "authors", "=", "[", "author", "]", "if", "\"github\"", "in", "self", ".", "config", "[", "\"scm_host\"", "]", ":", "self", ".", "config", "[", "\"author_github\"", "]", "=", "\"{0}/{1}\"", ".", "format", "(", "self", ".", "config", "[", "\"scm_host\"", "]", ",", "self", ".", "config", "[", "\"scm_user\"", "]", ")", "self", ".", "readme_template_vars", "=", "{", "\"authors\"", ":", "authors", ",", "\"scm\"", ":", "scm", ",", "\"role\"", ":", "normalized_role", ",", "\"license\"", ":", "license", ",", "\"galaxy_info\"", ":", "self", ".", "meta_dict", "[", "\"galaxy_info\"", "]", ",", "\"dependencies\"", ":", "self", ".", "meta_dict", "[", "\"dependencies\"", "]", ",", "\"ansigenome_info\"", ":", "self", ".", "meta_dict", "[", "\"ansigenome_info\"", "]", "}", "# add the defaults and facts", "r_defaults", "=", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"defaults\"", "]", "self", ".", "readme_template_vars", "[", "\"ansigenome_info\"", "]", "[", "\"defaults\"", "]", "=", "r_defaults", "facts", "=", "\"\\n\"", ".", "join", "(", "self", ".", "report", "[", "\"roles\"", "]", "[", "role", "]", "[", "\"facts\"", "]", ")", "self", ".", "readme_template_vars", "[", "\"ansigenome_info\"", "]", "[", "\"facts\"", "]", "=", "facts" ]

[ "Set", "the", "readme", "template", "variables", "." ]

[ "def", "exit_if_path_exists", "(", "self", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "output_path", ")", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"path_exists\"", "]", ",", "self", ".", "output_path", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Exit", "early", "if", "the", "path", "cannot", "be", "found", "." ]

[ "def", "create_skeleton", "(", "self", ")", ":", "utils", ".", "string_to_file", "(", "os", ".", "path", ".", "join", "(", "self", ".", "output_path", ",", "\"VERSION\"", ")", ",", "\"master\\n\"", ")", "for", "folder", "in", "c", ".", "ANSIBLE_FOLDERS", ":", "create_folder_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "output_path", ",", "folder", ")", "utils", ".", "mkdir_p", "(", "create_folder_path", ")", "mainyml_template", "=", "default_mainyml_template", ".", "replace", "(", "\"%role_name\"", ",", "self", ".", "role_name", ")", "mainyml_template", "=", "mainyml_template", ".", "replace", "(", "\"%values\"", ",", "folder", ")", "out_path", "=", "os", ".", "path", ".", "join", "(", "create_folder_path", ",", "\"main.yml\"", ")", "if", "folder", "not", "in", "(", "\"templates\"", ",", "\"meta\"", ",", "\"tests\"", ",", "\"files\"", ")", ":", "utils", ".", "string_to_file", "(", "out_path", ",", "mainyml_template", ")", "if", "folder", "==", "\"meta\"", ":", "utils", ".", "create_meta_main", "(", "out_path", ",", "self", ".", "config", ",", "self", ".", "role_name", ",", "self", ".", "options", ".", "galaxy_categories", ")" ]

[ "Create", "the", "role", "s", "directory", "and", "file", "structure", "." ]

[ "def", "create_travis_config", "(", "self", ")", ":", "test_runner", "=", "self", ".", "config", "[", "\"options_test_runner\"", "]", "role_url", "=", "\"{0}\"", ".", "format", "(", "os", ".", "path", ".", "join", "(", "self", ".", "config", "[", "\"scm_host\"", "]", ",", "self", ".", "config", "[", "\"scm_user\"", "]", ",", "self", ".", "config", "[", "\"scm_repo_prefix\"", "]", "+", "self", ".", "normalized_role", ")", ")", "travisyml_template", "=", "default_travisyml_template", ".", "replace", "(", "\"%test_runner\"", ",", "test_runner", ")", "travisyml_template", "=", "travisyml_template", ".", "replace", "(", "\"%basename\"", ",", "test_runner", ".", "split", "(", "\"/\"", ")", "[", "-", "1", "]", ")", "travisyml_template", "=", "travisyml_template", ".", "replace", "(", "\"%role_url\"", ",", "role_url", ")", "utils", ".", "string_to_file", "(", "os", ".", "path", ".", "join", "(", "self", ".", "output_path", ",", "\".travis.yml\"", ")", ",", "travisyml_template", ")" ]

[ "Create", "a", "travis", "test", "setup", "." ]

[ "def", "set_format", "(", "self", ",", "format", ")", ":", "if", "self", ".", "options", ".", "format", ":", "self", ".", "format", "=", "self", ".", "options", ".", "format", "else", ":", "self", ".", "format", "=", "self", ".", "config", "[", "\"default_format_\"", "+", "format", "]" ]

[ "Pick", "the", "correct", "default", "format", "." ]

[ "def", "validate_format", "(", "self", ",", "allowed_formats", ")", ":", "if", "self", ".", "format", "in", "allowed_formats", ":", "return", "ui", ".", "error", "(", "\"Export type '{0}' does not accept '{1}' format, only: \"", "\"{2}\"", ".", "format", "(", "self", ".", "type", ",", "self", ".", "format", ",", "allowed_formats", ")", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "Validate", "the", "allowed", "formats", "for", "a", "specific", "type", "." ]

[ "def", "graph_dot", "(", "self", ")", ":", "default_graphviz_template", "=", "\"\"\"\ndigraph role_dependencies {\n size=\"%size\"\n dpi=%dpi\n ratio=\"fill\"\n landscape=false\n rankdir=\"BT\";\n\n node [shape = \"box\",\n style = \"rounded,filled\",\n fillcolor = \"lightgrey\",\n fontsize = 20];\n\n edge [style = \"dashed\",\n dir = \"forward\",\n penwidth = 1.5];\n\n%roles_list\n\n%dependencies\n}\n\"\"\"", "roles_list", "=", "\"\"", "edges", "=", "\"\"", "# remove the darkest and brightest colors, still have 100+ colors", "adjusted_colors", "=", "c", ".", "X11_COLORS", "[", "125", ":", "-", "325", "]", "random", ".", "shuffle", "(", "adjusted_colors", ")", "backup_colors", "=", "adjusted_colors", "[", ":", "]", "for", "role", ",", "fields", "in", "sorted", "(", "self", ".", "report", "[", "\"roles\"", "]", ".", "iteritems", "(", ")", ")", ":", "name", "=", "utils", ".", "normalize_role", "(", "role", ",", "self", ".", "config", ")", "color_length", "=", "len", "(", "adjusted_colors", ")", "-", "1", "# reset the colors if we run out", "if", "color_length", "==", "0", ":", "adjusted_colors", "=", "backup_colors", "[", ":", "]", "color_length", "=", "len", "(", "adjusted_colors", ")", "-", "1", "random_index", "=", "random", ".", "randint", "(", "1", ",", "color_length", ")", "roles_list", "+=", "\" role_{0} [label = \\\"{1}\\\"]\\n\"", ".", "format", "(", "re", ".", "sub", "(", "r'[.-/]'", ",", "'_'", ",", "name", ")", ",", "name", ")", "edge", "=", "'\\n edge [color = \"{0}\"];\\n'", ".", "format", "(", "adjusted_colors", "[", "random_index", "]", ")", "del", "adjusted_colors", "[", "random_index", "]", "if", "fields", "[", "\"dependencies\"", "]", ":", "dependencies", "=", "\"\"", "for", "dependency", "in", "sorted", "(", "fields", "[", "\"dependencies\"", "]", ")", ":", "dependency_name", "=", "utils", ".", "role_name", "(", "dependency", ")", "dependencies", "+=", "\" role_{0} -> role_{1}\\n\"", ".", "format", "(", "re", ".", "sub", "(", "r'[.-/]'", ",", "'_'", ",", "name", ")", ",", "re", ".", "sub", "(", "r'[.-/]'", ",", "'_'", ",", "utils", ".", "normalize_role", "(", "dependency_name", ",", "self", ".", "config", ")", ")", ")", "edges", "+=", "\"{0}{1}\\n\"", ".", "format", "(", "edge", ",", "dependencies", ")", "graphviz_template", "=", "default_graphviz_template", ".", "replace", "(", "\"%roles_list\"", ",", "roles_list", ")", "graphviz_template", "=", "graphviz_template", ".", "replace", "(", "\"%dependencies\"", ",", "edges", ")", "graphviz_template", "=", "graphviz_template", ".", "replace", "(", "\"%size\"", ",", "self", ".", "size", ")", "graphviz_template", "=", "graphviz_template", ".", "replace", "(", "\"%dpi\"", ",", "str", "(", "self", ".", "dpi", ")", ")", "if", "self", ".", "out_file", ":", "utils", ".", "string_to_file", "(", "self", ".", "out_file", ",", "graphviz_template", ")", "else", ":", "print", "graphviz_template" ]

[ "Export", "a", "graph", "of", "the", "data", "in", "dot", "format", "." ]

[ "def", "exit_if_missing_graphviz", "(", "self", ")", ":", "(", "out", ",", "err", ")", "=", "utils", ".", "capture_shell", "(", "\"which dot\"", ")", "if", "\"dot\"", "not", "in", "out", ":", "ui", ".", "error", "(", "c", ".", "MESSAGES", "[", "\"dot_missing\"", "]", ")" ]

[ "Detect", "the", "presence", "of", "the", "dot", "utility", "to", "make", "a", "png", "graph", "." ]

[ "def", "reqs_txt", "(", "self", ")", ":", "role_lines", "=", "\"\"", "for", "role", "in", "sorted", "(", "self", ".", "report", "[", "\"roles\"", "]", ")", ":", "name", "=", "utils", ".", "normalize_role", "(", "role", ",", "self", ".", "config", ")", "galaxy_name", "=", "\"{0}.{1}\"", ".", "format", "(", "self", ".", "config", "[", "\"scm_user\"", "]", ",", "name", ")", "version_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "roles_path", ",", "role", ",", "\"VERSION\"", ")", "version", "=", "utils", ".", "get_version", "(", "version_path", ")", "role_lines", "+=", "\"{0},{1}\\n\"", ".", "format", "(", "galaxy_name", ",", "version", ")", "if", "self", ".", "out_file", ":", "utils", ".", "string_to_file", "(", "self", ".", "out_file", ",", "role_lines", ")", "else", ":", "print", "role_lines" ]

[ "Export", "a", "requirements", "file", "in", "txt", "format", "." ]

[ "def", "reqs_yml", "(", "self", ")", ":", "default_yml_item", "=", "\"\"\"\n- src: '%src'\n name: '%name'\n scm: '%scm'\n version: '%version'\n\"\"\"", "role_lines", "=", "\"---\\n\"", "for", "role", "in", "sorted", "(", "self", ".", "report", "[", "\"roles\"", "]", ")", ":", "name", "=", "utils", ".", "normalize_role", "(", "role", ",", "self", ".", "config", ")", "galaxy_name", "=", "\"{0}.{1}\"", ".", "format", "(", "self", ".", "config", "[", "\"scm_user\"", "]", ",", "name", ")", "yml_item", "=", "default_yml_item", "if", "self", ".", "config", "[", "\"scm_host\"", "]", ":", "yml_item", "=", "yml_item", ".", "replace", "(", "\"%name\"", ",", "\"{0}\"", ".", "format", "(", "galaxy_name", ")", ")", "if", "self", ".", "config", "[", "\"scm_repo_prefix\"", "]", ":", "role", "=", "self", ".", "config", "[", "\"scm_repo_prefix\"", "]", "+", "name", "src", "=", "os", ".", "path", ".", "join", "(", "self", ".", "config", "[", "\"scm_host\"", "]", ",", "self", ".", "config", "[", "\"scm_user\"", "]", ",", "role", ")", "else", ":", "src", "=", "galaxy_name", "yml_item", "=", "yml_item", ".", "replace", "(", "\" name: '%name'\\n\"", ",", "\"\"", ")", "yml_item", "=", "yml_item", ".", "replace", "(", "\" scm: '%scm'\\n\"", ",", "\"\"", ")", "yml_item", "=", "yml_item", ".", "replace", "(", "\"%src\"", ",", "src", ")", "if", "self", ".", "config", "[", "\"scm_type\"", "]", ":", "yml_item", "=", "yml_item", ".", "replace", "(", "\"%scm\"", ",", "self", ".", "config", "[", "\"scm_type\"", "]", ")", "else", ":", "yml_item", "=", "yml_item", ".", "replace", "(", "\" scm: '%scm'\\n\"", ",", "\"\"", ")", "version_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "roles_path", ",", "role", ",", "\"VERSION\"", ")", "version", "=", "utils", ".", "get_version", "(", "version_path", ")", "yml_item", "=", "yml_item", ".", "replace", "(", "\"%version\"", ",", "version", ")", "role_lines", "+=", "\"{0}\"", ".", "format", "(", "yml_item", ")", "if", "self", ".", "out_file", ":", "utils", ".", "string_to_file", "(", "self", ".", "out_file", ",", "role_lines", ")", "else", ":", "print", "role_lines" ]

[ "Export", "a", "requirements", "file", "in", "yml", "format", "." ]

[ "def", "dump", "(", "self", ")", ":", "report_as_json_string", "=", "utils", ".", "dict_to_json", "(", "self", ".", "report", ")", "if", "self", ".", "out_file", ":", "utils", ".", "string_to_file", "(", "self", ".", "out_file", ",", "report_as_json_string", ")", "else", ":", "print", "report_as_json_string" ]

[ "Dump", "the", "output", "to", "json", "." ]

[ "def", "fast_float", "(", "x", ",", "key", "=", "lambda", "x", ":", "x", ",", "nan", "=", "None", ",", "_uni", "=", "unicodedata", ".", "numeric", ",", "_nan_inf", "=", "NAN_INF", ",", "_first_char", "=", "POTENTIAL_FIRST_CHAR", ",", ")", ":", "if", "x", "[", "0", "]", "in", "_first_char", "or", "x", ".", "lstrip", "(", ")", "[", ":", "3", "]", "in", "_nan_inf", ":", "try", ":", "x", "=", "float", "(", "x", ")", "return", "nan", "if", "nan", "is", "not", "None", "and", "x", "!=", "x", "else", "x", "except", "ValueError", ":", "try", ":", "return", "_uni", "(", "x", ",", "key", "(", "x", ")", ")", "if", "len", "(", "x", ")", "==", "1", "else", "key", "(", "x", ")", "except", "TypeError", ":", "# pragma: no cover", "return", "key", "(", "x", ")", "else", ":", "try", ":", "return", "_uni", "(", "x", ",", "key", "(", "x", ")", ")", "if", "len", "(", "x", ")", "==", "1", "else", "key", "(", "x", ")", "except", "TypeError", ":", "# pragma: no cover", "return", "key", "(", "x", ")" ]

[ "Convert", "a", "string", "to", "a", "float", "quickly", "return", "input", "as", "-", "is", "if", "not", "possible", "." ]

[ "def", "fast_int", "(", "x", ",", "key", "=", "lambda", "x", ":", "x", ",", "_uni", "=", "unicodedata", ".", "digit", ",", "_first_char", "=", "POTENTIAL_FIRST_CHAR", ",", ")", ":", "if", "x", "[", "0", "]", "in", "_first_char", ":", "try", ":", "return", "long", "(", "x", ")", "except", "ValueError", ":", "try", ":", "return", "_uni", "(", "x", ",", "key", "(", "x", ")", ")", "if", "len", "(", "x", ")", "==", "1", "else", "key", "(", "x", ")", "except", "TypeError", ":", "# pragma: no cover", "return", "key", "(", "x", ")", "else", ":", "try", ":", "return", "_uni", "(", "x", ",", "key", "(", "x", ")", ")", "if", "len", "(", "x", ")", "==", "1", "else", "key", "(", "x", ")", "except", "TypeError", ":", "# pragma: no cover", "return", "key", "(", "x", ")" ]

[ "Convert", "a", "string", "to", "a", "int", "quickly", "return", "input", "as", "-", "is", "if", "not", "possible", "." ]

[ "def", "check_filters", "(", "filters", ")", ":", "if", "not", "filters", ":", "return", "None", "try", ":", "return", "[", "range_check", "(", "f", "[", "0", "]", ",", "f", "[", "1", "]", ")", "for", "f", "in", "filters", "]", "except", "ValueError", "as", "err", ":", "raise", "ValueError", "(", "\"Error in --filter: \"", "+", "py23_str", "(", "err", ")", ")" ]

[ "Execute", "range_check", "for", "every", "element", "of", "an", "iterable", "." ]

[ "def", "keep_entry_range", "(", "entry", ",", "lows", ",", "highs", ",", "converter", ",", "regex", ")", ":", "return", "any", "(", "low", "<=", "converter", "(", "num", ")", "<=", "high", "for", "num", "in", "regex", ".", "findall", "(", "entry", ")", "for", "low", ",", "high", "in", "zip", "(", "lows", ",", "highs", ")", ")" ]

[ "Check", "if", "an", "entry", "falls", "into", "a", "desired", "range", "." ]

[ "def", "keep_entry_value", "(", "entry", ",", "values", ",", "converter", ",", "regex", ")", ":", "return", "not", "any", "(", "converter", "(", "num", ")", "in", "values", "for", "num", "in", "regex", ".", "findall", "(", "entry", ")", ")" ]

[ "Check", "if", "an", "entry", "does", "not", "match", "a", "given", "value", "." ]

[ "def", "sort_and_print_entries", "(", "entries", ",", "args", ")", ":", "# Extract the proper number type.", "is_float", "=", "args", ".", "number_type", "in", "(", "\"float\"", ",", "\"real\"", ",", "\"f\"", ",", "\"r\"", ")", "signed", "=", "args", ".", "signed", "or", "args", ".", "number_type", "in", "(", "\"real\"", ",", "\"r\"", ")", "alg", "=", "(", "natsort", ".", "ns", ".", "FLOAT", "*", "is_float", "|", "natsort", ".", "ns", ".", "SIGNED", "*", "signed", "|", "natsort", ".", "ns", ".", "NOEXP", "*", "(", "not", "args", ".", "exp", ")", "|", "natsort", ".", "ns", ".", "PATH", "*", "args", ".", "paths", "|", "natsort", ".", "ns", ".", "LOCALE", "*", "args", ".", "locale", ")", "# Pre-remove entries that don't pass the filtering criteria", "# Make sure we use the same searching algorithm for filtering", "# as for sorting.", "do_filter", "=", "args", ".", "filter", "is", "not", "None", "or", "args", ".", "reverse_filter", "is", "not", "None", "if", "do_filter", "or", "args", ".", "exclude", ":", "inp_options", "=", "(", "natsort", ".", "ns", ".", "FLOAT", "*", "is_float", "|", "natsort", ".", "ns", ".", "SIGNED", "*", "signed", "|", "natsort", ".", "ns", ".", "NOEXP", "*", "(", "not", "args", ".", "exp", ")", ")", "regex", "=", "regex_chooser", "(", "inp_options", ")", "if", "args", ".", "filter", "is", "not", "None", ":", "lows", ",", "highs", "=", "(", "[", "f", "[", "0", "]", "for", "f", "in", "args", ".", "filter", "]", ",", "[", "f", "[", "1", "]", "for", "f", "in", "args", ".", "filter", "]", ")", "entries", "=", "[", "entry", "for", "entry", "in", "entries", "if", "keep_entry_range", "(", "entry", ",", "lows", ",", "highs", ",", "float", ",", "regex", ")", "]", "if", "args", ".", "reverse_filter", "is", "not", "None", ":", "lows", ",", "highs", "=", "(", "[", "f", "[", "0", "]", "for", "f", "in", "args", ".", "reverse_filter", "]", ",", "[", "f", "[", "1", "]", "for", "f", "in", "args", ".", "reverse_filter", "]", ",", ")", "entries", "=", "[", "entry", "for", "entry", "in", "entries", "if", "not", "keep_entry_range", "(", "entry", ",", "lows", ",", "highs", ",", "float", ",", "regex", ")", "]", "if", "args", ".", "exclude", ":", "exclude", "=", "set", "(", "args", ".", "exclude", ")", "entries", "=", "[", "entry", "for", "entry", "in", "entries", "if", "keep_entry_value", "(", "entry", ",", "exclude", ",", "float", ",", "regex", ")", "]", "# Print off the sorted results", "for", "entry", "in", "natsort", ".", "natsorted", "(", "entries", ",", "reverse", "=", "args", ".", "reverse", ",", "alg", "=", "alg", ")", ":", "print", "(", "entry", ")" ]

[ "Sort", "the", "entries", "applying", "the", "filters", "first", "if", "necessary", "." ]

[ "def", "regex_chooser", "(", "alg", ")", ":", "if", "alg", "&", "ns", ".", "FLOAT", ":", "alg", "&=", "ns", ".", "FLOAT", "|", "ns", ".", "SIGNED", "|", "ns", ".", "NOEXP", "else", ":", "alg", "&=", "ns", ".", "INT", "|", "ns", ".", "SIGNED", "return", "{", "ns", ".", "INT", ":", "NumericalRegularExpressions", ".", "int_nosign", "(", ")", ",", "ns", ".", "FLOAT", ":", "NumericalRegularExpressions", ".", "float_nosign_exp", "(", ")", ",", "ns", ".", "INT", "|", "ns", ".", "SIGNED", ":", "NumericalRegularExpressions", ".", "int_sign", "(", ")", ",", "ns", ".", "FLOAT", "|", "ns", ".", "SIGNED", ":", "NumericalRegularExpressions", ".", "float_sign_exp", "(", ")", ",", "ns", ".", "FLOAT", "|", "ns", ".", "NOEXP", ":", "NumericalRegularExpressions", ".", "float_nosign_noexp", "(", ")", ",", "ns", ".", "FLOAT", "|", "ns", ".", "SIGNED", "|", "ns", ".", "NOEXP", ":", "NumericalRegularExpressions", ".", "float_sign_noexp", "(", ")", ",", "}", "[", "alg", "]" ]

[ "Select", "an", "appropriate", "regex", "for", "the", "type", "of", "number", "of", "interest", "." ]

[ "def", "_normalize_input_factory", "(", "alg", ")", ":", "normalization_form", "=", "\"NFKD\"", "if", "alg", "&", "ns", ".", "COMPATIBILITYNORMALIZE", "else", "\"NFD\"", "wrapped", "=", "partial", "(", "normalize", ",", "normalization_form", ")", "if", "NEWPY", ":", "return", "wrapped", "else", ":", "return", "lambda", "x", ",", "_f", "=", "wrapped", ":", "_f", "(", "x", ")", "if", "isinstance", "(", "x", ",", "py23_str", ")", "else", "x" ]

[ "Create", "a", "function", "that", "will", "normalize", "unicode", "input", "data", "." ]

[ "def", "natsort_key", "(", "val", ",", "key", ",", "string_func", ",", "bytes_func", ",", "num_func", ")", ":", "# Apply key if needed", "if", "key", "is", "not", "None", ":", "val", "=", "key", "(", "val", ")", "# Assume the input are strings, which is the most common case", "try", ":", "return", "string_func", "(", "val", ")", "except", "(", "TypeError", ",", "AttributeError", ")", ":", "# If bytes type, use the bytes_func", "if", "type", "(", "val", ")", "in", "(", "bytes", ",", ")", ":", "return", "bytes_func", "(", "val", ")", "# Otherwise, assume it is an iterable that must be parsed recursively.", "# Do not apply the key recursively.", "try", ":", "return", "tuple", "(", "natsort_key", "(", "x", ",", "None", ",", "string_func", ",", "bytes_func", ",", "num_func", ")", "for", "x", "in", "val", ")", "# If that failed, it must be a number.", "except", "TypeError", ":", "return", "num_func", "(", "val", ")" ]

[ "Key", "to", "sort", "strings", "and", "numbers", "naturally", "." ]

[ "def", "parse_number_factory", "(", "alg", ",", "sep", ",", "pre_sep", ")", ":", "nan_replace", "=", "float", "(", "\"+inf\"", ")", "if", "alg", "&", "ns", ".", "NANLAST", "else", "float", "(", "\"-inf\"", ")", "def", "func", "(", "val", ",", "_nan_replace", "=", "nan_replace", ",", "_sep", "=", "sep", ")", ":", "\"\"\"Given a number, place it in a tuple with a leading null string.\"\"\"", "return", "_sep", ",", "_nan_replace", "if", "val", "!=", "val", "else", "val", "# Return the function, possibly wrapping in tuple if PATH is selected.", "if", "alg", "&", "ns", ".", "PATH", "and", "alg", "&", "ns", ".", "UNGROUPLETTERS", "and", "alg", "&", "ns", ".", "LOCALEALPHA", ":", "return", "lambda", "x", ":", "(", "(", "(", "pre_sep", ",", ")", ",", "func", "(", "x", ")", ")", ",", ")", "elif", "alg", "&", "ns", ".", "UNGROUPLETTERS", "and", "alg", "&", "ns", ".", "LOCALEALPHA", ":", "return", "lambda", "x", ":", "(", "(", "pre_sep", ",", ")", ",", "func", "(", "x", ")", ")", "elif", "alg", "&", "ns", ".", "PATH", ":", "return", "lambda", "x", ":", "(", "func", "(", "x", ")", ",", ")", "else", ":", "return", "func" ]

[ "Create", "a", "function", "that", "will", "format", "a", "number", "into", "a", "tuple", "." ]

[ "def", "sep_inserter", "(", "iterable", ",", "sep", ")", ":", "try", ":", "# Get the first element. A StopIteration indicates an empty iterable.", "# Since we are controlling the types of the input, 'type' is used", "# instead of 'isinstance' for the small speed advantage it offers.", "types", "=", "(", "int", ",", "float", ",", "long", ")", "first", "=", "next", "(", "iterable", ")", "if", "type", "(", "first", ")", "in", "types", ":", "yield", "sep", "yield", "first", "# Now, check if pair of elements are both numbers. If so, add ''.", "second", "=", "next", "(", "iterable", ")", "if", "type", "(", "first", ")", "in", "types", "and", "type", "(", "second", ")", "in", "types", ":", "yield", "sep", "yield", "second", "# Now repeat in a loop.", "for", "x", "in", "iterable", ":", "first", ",", "second", "=", "second", ",", "x", "if", "type", "(", "first", ")", "in", "types", "and", "type", "(", "second", ")", "in", "types", ":", "yield", "sep", "yield", "second", "except", "StopIteration", ":", "# Catch StopIteration per deprecation in PEP 479:", "# \"Change StopIteration handling inside generators\"", "return" ]

[ "Insert", "between", "numbers", "in", "an", "iterable", "." ]

[ "def", "input_string_transform_factory", "(", "alg", ")", ":", "# Shortcuts.", "lowfirst", "=", "alg", "&", "ns", ".", "LOWERCASEFIRST", "dumb", "=", "alg", "&", "NS_DUMB", "# Build the chain of functions to execute in order.", "function_chain", "=", "[", "]", "if", "(", "dumb", "and", "not", "lowfirst", ")", "or", "(", "lowfirst", "and", "not", "dumb", ")", ":", "function_chain", ".", "append", "(", "methodcaller", "(", "\"swapcase\"", ")", ")", "if", "alg", "&", "ns", ".", "IGNORECASE", ":", "if", "NEWPY", ":", "function_chain", ".", "append", "(", "methodcaller", "(", "\"casefold\"", ")", ")", "else", ":", "function_chain", ".", "append", "(", "methodcaller", "(", "\"lower\"", ")", ")", "if", "alg", "&", "ns", ".", "LOCALENUM", ":", "# Create a regular expression that will remove thousands separators.", "strip_thousands", "=", "r\"\"\"\n (?<=[0-9]{{1}}) # At least 1 number\n (?<![0-9]{{4}}) # No more than 3 numbers\n {nodecimal} # Cannot follow decimal\n {thou} # The thousands separator\n (?=[0-9]{{3}} # Three numbers must follow\n ([^0-9]|$) # But a non-number after that\n )\n \"\"\"", "nodecimal", "=", "r\"\"", "if", "alg", "&", "ns", ".", "FLOAT", ":", "# Make a regular expression component that will ensure no", "# separators are removed after a decimal point.", "d", "=", "get_decimal_point", "(", ")", "d", "=", "r\"\\.\"", "if", "d", "==", "r\".\"", "else", "d", "nodecimal", "+=", "r\"(?<!\"", "+", "d", "+", "r\"[0-9])\"", "nodecimal", "+=", "r\"(?<!\"", "+", "d", "+", "r\"[0-9]{2})\"", "nodecimal", "+=", "r\"(?<!\"", "+", "d", "+", "r\"[0-9]{3})\"", "strip_thousands", "=", "strip_thousands", ".", "format", "(", "thou", "=", "get_thousands_sep", "(", ")", ",", "nodecimal", "=", "nodecimal", ")", "strip_thousands", "=", "re", ".", "compile", "(", "strip_thousands", ",", "flags", "=", "re", ".", "VERBOSE", ")", "function_chain", ".", "append", "(", "partial", "(", "strip_thousands", ".", "sub", ",", "\"\"", ")", ")", "# Create a regular expression that will change the decimal point to", "# a period if not already a period.", "decimal", "=", "get_decimal_point", "(", ")", "if", "alg", "&", "ns", ".", "FLOAT", "and", "decimal", "!=", "\".\"", ":", "switch_decimal", "=", "r\"(?<=[0-9]){decimal}|{decimal}(?=[0-9])\"", "switch_decimal", "=", "switch_decimal", ".", "format", "(", "decimal", "=", "decimal", ")", "switch_decimal", "=", "re", ".", "compile", "(", "switch_decimal", ")", "function_chain", ".", "append", "(", "partial", "(", "switch_decimal", ".", "sub", ",", "\".\"", ")", ")", "# Return the chained functions.", "return", "chain_functions", "(", "function_chain", ")" ]

[ "Create", "a", "function", "to", "transform", "a", "string", "." ]

[ "def", "string_component_transform_factory", "(", "alg", ")", ":", "# Shortcuts.", "use_locale", "=", "alg", "&", "ns", ".", "LOCALEALPHA", "dumb", "=", "alg", "&", "NS_DUMB", "group_letters", "=", "(", "alg", "&", "ns", ".", "GROUPLETTERS", ")", "or", "(", "use_locale", "and", "dumb", ")", "nan_val", "=", "float", "(", "\"+inf\"", ")", "if", "alg", "&", "ns", ".", "NANLAST", "else", "float", "(", "\"-inf\"", ")", "# Build the chain of functions to execute in order.", "func_chain", "=", "[", "]", "if", "group_letters", ":", "func_chain", ".", "append", "(", "groupletters", ")", "if", "use_locale", ":", "func_chain", ".", "append", "(", "get_strxfrm", "(", ")", ")", "kwargs", "=", "{", "\"key\"", ":", "chain_functions", "(", "func_chain", ")", "}", "if", "func_chain", "else", "{", "}", "# Return the correct chained functions.", "if", "alg", "&", "ns", ".", "FLOAT", ":", "# noinspection PyTypeChecker", "kwargs", "[", "\"nan\"", "]", "=", "nan_val", "return", "partial", "(", "fast_float", ",", "*", "*", "kwargs", ")", "else", ":", "return", "partial", "(", "fast_int", ",", "*", "*", "kwargs", ")" ]

[ "Create", "a", "function", "to", "either", "transform", "a", "string", "or", "convert", "to", "a", "number", "." ]

[ "def", "final_data_transform_factory", "(", "alg", ",", "sep", ",", "pre_sep", ")", ":", "if", "alg", "&", "ns", ".", "UNGROUPLETTERS", "and", "alg", "&", "ns", ".", "LOCALEALPHA", ":", "swap", "=", "alg", "&", "NS_DUMB", "and", "alg", "&", "ns", ".", "LOWERCASEFIRST", "transform", "=", "methodcaller", "(", "\"swapcase\"", ")", "if", "swap", "else", "_no_op", "def", "func", "(", "split_val", ",", "val", ",", "_transform", "=", "transform", ",", "_sep", "=", "sep", ",", "_pre_sep", "=", "pre_sep", ")", ":", "\"\"\"\n Return a tuple with the first character of the first element\n of the return value as the first element, and the return value\n as the second element. This will be used to perform gross sorting\n by the first letter.\n \"\"\"", "split_val", "=", "tuple", "(", "split_val", ")", "if", "not", "split_val", ":", "return", "(", ")", ",", "(", ")", "elif", "split_val", "[", "0", "]", "==", "_sep", ":", "return", "(", "_pre_sep", ",", ")", ",", "split_val", "else", ":", "return", "(", "_transform", "(", "val", "[", "0", "]", ")", ",", ")", ",", "split_val", "return", "func", "else", ":", "return", "lambda", "split_val", ",", "val", ":", "tuple", "(", "split_val", ")" ]

[ "Create", "a", "function", "to", "transform", "a", "tuple", "." ]

[ "def", "groupletters", "(", "x", ",", "_low", "=", "lower_function", ")", ":", "return", "\"\"", ".", "join", "(", "ichain", ".", "from_iterable", "(", "(", "_low", "(", "y", ")", ",", "y", ")", "for", "y", "in", "x", ")", ")" ]

[ "Double", "all", "characters", "making", "doubled", "letters", "lowercase", "." ]

[ "def", "chain_functions", "(", "functions", ")", ":", "functions", "=", "list", "(", "functions", ")", "if", "not", "functions", ":", "return", "_no_op", "elif", "len", "(", "functions", ")", "==", "1", ":", "return", "functions", "[", "0", "]", "else", ":", "# See https://stackoverflow.com/a/39123400/1399279", "return", "partial", "(", "reduce", ",", "lambda", "res", ",", "f", ":", "f", "(", "res", ")", ",", "functions", ")" ]

[ "Chain", "a", "list", "of", "single", "-", "argument", "functions", "together", "and", "return", "." ]

[ "def", "path_splitter", "(", "s", ",", "_d_match", "=", "re", ".", "compile", "(", "r\"\\.\\d\"", ")", ".", "match", ")", ":", "if", "has_pathlib", "and", "isinstance", "(", "s", ",", "PurePath", ")", ":", "s", "=", "py23_str", "(", "s", ")", "path_parts", "=", "deque", "(", ")", "p_appendleft", "=", "path_parts", ".", "appendleft", "# Continue splitting the path from the back until we have reached", "# '..' or '.', or until there is nothing left to split.", "path_location", "=", "s", "while", "path_location", "!=", "os_curdir", "and", "path_location", "!=", "os_pardir", ":", "parent_path", "=", "path_location", "path_location", ",", "child_path", "=", "path_split", "(", "parent_path", ")", "if", "path_location", "==", "parent_path", ":", "break", "p_appendleft", "(", "child_path", ")", "# This last append is the base path.", "# Only append if the string is non-empty.", "# Make sure the proper path separator for this OS is used", "# no matter what was actually given.", "if", "path_location", ":", "p_appendleft", "(", "py23_str", "(", "os_sep", ")", ")", "# Now, split off the file extensions using a similar method to above.", "# Continue splitting off file extensions until we reach a decimal number", "# or there are no more extensions.", "# We are not using built-in functionality of PathLib here because of", "# the recursive splitting up to a decimal.", "base", "=", "path_parts", ".", "pop", "(", ")", "base_parts", "=", "deque", "(", ")", "b_appendleft", "=", "base_parts", ".", "appendleft", "while", "True", ":", "front", "=", "base", "base", ",", "ext", "=", "path_splitext", "(", "front", ")", "if", "_d_match", "(", "ext", ")", "or", "not", "ext", ":", "# Reset base to before the split if the split is invalid.", "base", "=", "front", "break", "b_appendleft", "(", "ext", ")", "b_appendleft", "(", "base", ")", "# Return the split parent paths and then the split basename.", "return", "ichain", "(", "path_parts", ",", "base_parts", ")" ]

[ "Split", "a", "string", "into", "its", "path", "components", "." ]

[ "def", "_construct_regex", "(", "cls", ",", "fmt", ")", ":", "return", "re", ".", "compile", "(", "fmt", ".", "format", "(", "*", "*", "vars", "(", "cls", ")", ")", ",", "flags", "=", "re", ".", "U", ")" ]

[ "Given", "a", "format", "string", "construct", "the", "regex", "with", "class", "attributes", "." ]

[ "def", "natsort_keygen", "(", "key", "=", "None", ",", "alg", "=", "ns", ".", "DEFAULT", ")", ":", "try", ":", "ns", ".", "DEFAULT", "|", "alg", "except", "TypeError", ":", "msg", "=", "\"natsort_keygen: 'alg' argument must be from the enum 'ns'\"", "raise", "ValueError", "(", "msg", "+", "\", got {}\"", ".", "format", "(", "py23_str", "(", "alg", ")", ")", ")", "# Add the NS_DUMB option if the locale library is broken.", "if", "alg", "&", "ns", ".", "LOCALEALPHA", "and", "natsort", ".", "compat", ".", "locale", ".", "dumb_sort", "(", ")", ":", "alg", "|=", "NS_DUMB", "# Set some variables that will be passed to the factory functions", "if", "alg", "&", "ns", ".", "NUMAFTER", ":", "if", "alg", "&", "ns", ".", "LOCALEALPHA", ":", "sep", "=", "natsort", ".", "compat", ".", "locale", ".", "null_string_locale_max", "else", ":", "sep", "=", "natsort", ".", "compat", ".", "locale", ".", "null_string_max", "pre_sep", "=", "natsort", ".", "compat", ".", "locale", ".", "null_string_max", "else", ":", "if", "alg", "&", "ns", ".", "LOCALEALPHA", ":", "sep", "=", "natsort", ".", "compat", ".", "locale", ".", "null_string_locale", "else", ":", "sep", "=", "natsort", ".", "compat", ".", "locale", ".", "null_string", "pre_sep", "=", "natsort", ".", "compat", ".", "locale", ".", "null_string", "regex", "=", "utils", ".", "regex_chooser", "(", "alg", ")", "# Create the functions that will be used to split strings.", "input_transform", "=", "utils", ".", "input_string_transform_factory", "(", "alg", ")", "component_transform", "=", "utils", ".", "string_component_transform_factory", "(", "alg", ")", "final_transform", "=", "utils", ".", "final_data_transform_factory", "(", "alg", ",", "sep", ",", "pre_sep", ")", "# Create the high-level parsing functions for strings, bytes, and numbers.", "string_func", "=", "utils", ".", "parse_string_factory", "(", "alg", ",", "sep", ",", "regex", ".", "split", ",", "input_transform", ",", "component_transform", ",", "final_transform", ")", "if", "alg", "&", "ns", ".", "PATH", ":", "string_func", "=", "utils", ".", "parse_path_factory", "(", "string_func", ")", "bytes_func", "=", "utils", ".", "parse_bytes_factory", "(", "alg", ")", "num_func", "=", "utils", ".", "parse_number_factory", "(", "alg", ",", "sep", ",", "pre_sep", ")", "# Return the natsort key with the parsing path pre-chosen.", "return", "partial", "(", "utils", ".", "natsort_key", ",", "key", "=", "key", ",", "string_func", "=", "string_func", ",", "bytes_func", "=", "bytes_func", ",", "num_func", "=", "num_func", ",", ")" ]

[ "Generate", "a", "key", "to", "sort", "strings", "and", "numbers", "naturally", "." ]

[ "def", "natsorted", "(", "seq", ",", "key", "=", "None", ",", "reverse", "=", "False", ",", "alg", "=", "ns", ".", "DEFAULT", ")", ":", "key", "=", "natsort_keygen", "(", "key", ",", "alg", ")", "return", "sorted", "(", "seq", ",", "reverse", "=", "reverse", ",", "key", "=", "key", ")" ]

[ "Sorts", "an", "iterable", "naturally", "." ]

[ "def", "humansorted", "(", "seq", ",", "key", "=", "None", ",", "reverse", "=", "False", ",", "alg", "=", "ns", ".", "DEFAULT", ")", ":", "return", "natsorted", "(", "seq", ",", "key", ",", "reverse", ",", "alg", "|", "ns", ".", "LOCALE", ")" ]

[ "Convenience", "function", "to", "properly", "sort", "non", "-", "numeric", "characters", "." ]

[ "def", "realsorted", "(", "seq", ",", "key", "=", "None", ",", "reverse", "=", "False", ",", "alg", "=", "ns", ".", "DEFAULT", ")", ":", "return", "natsorted", "(", "seq", ",", "key", ",", "reverse", ",", "alg", "|", "ns", ".", "REAL", ")" ]

[ "Convenience", "function", "to", "properly", "sort", "signed", "floats", "." ]

[ "def", "index_natsorted", "(", "seq", ",", "key", "=", "None", ",", "reverse", "=", "False", ",", "alg", "=", "ns", ".", "DEFAULT", ")", ":", "if", "key", "is", "None", ":", "newkey", "=", "itemgetter", "(", "1", ")", "else", ":", "def", "newkey", "(", "x", ")", ":", "return", "key", "(", "itemgetter", "(", "1", ")", "(", "x", ")", ")", "# Pair the index and sequence together, then sort by element", "index_seq_pair", "=", "[", "[", "x", ",", "y", "]", "for", "x", ",", "y", "in", "enumerate", "(", "seq", ")", "]", "index_seq_pair", ".", "sort", "(", "reverse", "=", "reverse", ",", "key", "=", "natsort_keygen", "(", "newkey", ",", "alg", ")", ")", "return", "[", "x", "for", "x", ",", "_", "in", "index_seq_pair", "]" ]

[ "Determine", "the", "list", "of", "the", "indexes", "used", "to", "sort", "the", "input", "sequence", "." ]

[ "def", "order_by_index", "(", "seq", ",", "index", ",", "iter", "=", "False", ")", ":", "return", "(", "seq", "[", "i", "]", "for", "i", "in", "index", ")", "if", "iter", "else", "[", "seq", "[", "i", "]", "for", "i", "in", "index", "]" ]

[ "Order", "a", "given", "sequence", "by", "an", "index", "sequence", "." ]

[ "def", "_iterOutFiles", "(", "self", ")", ":", "out", "=", "StringIO", "(", ")", "self", ".", "callgrind", "(", "out", ",", "relative_path", "=", "True", ")", "yield", "(", "'cachegrind.out.pprofile'", ",", "out", ".", "getvalue", "(", ")", ",", "'application/x-kcachegrind'", ",", ")", "for", "name", ",", "lines", "in", "self", ".", "iterSource", "(", ")", ":", "lines", "=", "''", ".", "join", "(", "lines", ")", "if", "lines", ":", "if", "isinstance", "(", "lines", ",", "unicode", ")", ":", "lines", "=", "lines", ".", "encode", "(", "'utf-8'", ")", "yield", "(", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "splitdrive", "(", "name", ")", "[", "1", "]", ")", ".", "lstrip", "(", "_ALLSEP", ")", ",", "lines", ",", "'text/x-python'", ",", ")", "sql_name_template", "=", "'query_%%0%ii-%%i_hits_%%6fs.sql'", "%", "len", "(", "str", "(", "len", "(", "self", ".", "sql_dict", ")", ")", ",", ")", "for", "index", ",", "(", "query", ",", "time_list", ")", "in", "enumerate", "(", "sorted", "(", "self", ".", "sql_dict", ".", "iteritems", "(", ")", ",", "key", "=", "lambda", "x", ":", "(", "sum", "(", "x", "[", "1", "]", ")", ",", "len", "(", "x", "[", "1", "]", ")", ")", ",", "reverse", "=", "True", ",", ")", ",", ")", ":", "yield", "(", "sql_name_template", "%", "(", "index", ",", "len", "(", "time_list", ")", ",", "sum", "(", "time_list", ")", ",", ")", ",", "b'\\n'", ".", "join", "(", "b'-- %10.6fs'", "%", "x", "for", "x", "in", "time_list", ")", "+", "b'\\n'", "+", "query", ",", "'application/sql'", ",", ")", "if", "self", ".", "zodb_dict", ":", "yield", "(", "'ZODB_setstate.txt'", ",", "'\\n\\n'", ".", "join", "(", "(", "'%s (%fs)\\n'", "%", "(", "db_name", ",", "sum", "(", "sum", "(", "x", ")", "for", "x", "in", "oid_dict", ".", "itervalues", "(", ")", ")", ",", ")", ")", "+", "'\\n'", ".", "join", "(", "'%s (%i): %s'", "%", "(", "oid", ".", "encode", "(", "'hex'", ")", ",", "len", "(", "time_list", ")", ",", "', '", ".", "join", "(", "'%fs'", "%", "x", "for", "x", "in", "time_list", ")", ",", ")", "for", "oid", ",", "time_list", "in", "oid_dict", ".", "iteritems", "(", ")", ")", "for", "db_name", ",", "oid_dict", "in", "self", ".", "zodb_dict", ".", "iteritems", "(", ")", ")", ",", "'text/plain'", ",", ")", "if", "self", ".", "traverse_dict", ":", "yield", "(", "'unrestrictedTraverse_pathlist.txt'", ",", "tabulate", "(", "(", "'self'", ",", "'path'", ",", "'hit'", ",", "'total duration'", ")", ",", "sorted", "(", "(", "(", "context", ",", "path", ",", "len", "(", "duration_list", ")", ",", "sum", "(", "duration_list", ")", ")", "for", "(", "context", ",", "path", ")", ",", "duration_list", "in", "self", ".", "traverse_dict", ".", "iteritems", "(", ")", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "3", "]", ",", "reverse", "=", "True", ",", ")", ",", ")", ",", "'text/plain'", ",", ")" ]

[ "Yields", "path", "data", "mimetype", "for", "each", "file", "involved", "on", "or", "produced", "by", "profiling", "." ]

[ "def", "run", "(", "cmd", ",", "filename", "=", "None", ",", "threads", "=", "True", ",", "verbose", "=", "False", ")", ":", "_run", "(", "threads", ",", "verbose", ",", "'run'", ",", "filename", ",", "cmd", ")" ]

[ "Similar", "to", "profile", ".", "run", "." ]

[ "def", "runctx", "(", "cmd", ",", "globals", ",", "locals", ",", "filename", "=", "None", ",", "threads", "=", "True", ",", "verbose", "=", "False", ")", ":", "_run", "(", "threads", ",", "verbose", ",", "'runctx'", ",", "filename", ",", "cmd", ",", "globals", ",", "locals", ")" ]

[ "Similar", "to", "profile", ".", "runctx", "." ]

[ "def", "runfile", "(", "fd", ",", "argv", ",", "fd_name", "=", "'<unknown>'", ",", "compile_flags", "=", "0", ",", "dont_inherit", "=", "1", ",", "filename", "=", "None", ",", "threads", "=", "True", ",", "verbose", "=", "False", ")", ":", "_run", "(", "threads", ",", "verbose", ",", "'runfile'", ",", "filename", ",", "fd", ",", "argv", ",", "fd_name", ",", "compile_flags", ",", "dont_inherit", ")" ]

[ "Run", "code", "from", "given", "file", "descriptor", "with", "profiling", "enabled", ".", "Closes", "fd", "before", "executing", "contained", "code", "." ]

[ "def", "runpath", "(", "path", ",", "argv", ",", "filename", "=", "None", ",", "threads", "=", "True", ",", "verbose", "=", "False", ")", ":", "_run", "(", "threads", ",", "verbose", ",", "'runpath'", ",", "filename", ",", "path", ",", "argv", ")" ]

[ "Run", "code", "from", "open", "-", "accessible", "file", "path", "with", "profiling", "enabled", "." ]

[ "def", "pprofile", "(", "line", ",", "cell", "=", "None", ")", ":", "if", "cell", "is", "None", ":", "# TODO: detect and use arguments (statistical profiling, ...) ?", "return", "run", "(", "line", ")", "return", "_main", "(", "[", "'%%pprofile'", ",", "'-m'", ",", "'-'", "]", "+", "shlex", ".", "split", "(", "line", ")", ",", "io", ".", "StringIO", "(", "cell", ")", ",", ")" ]

[ "Profile", "line", "execution", "." ]

[ "def", "hit", "(", "self", ",", "code", ",", "line", ",", "duration", ")", ":", "entry", "=", "self", ".", "line_dict", "[", "line", "]", "[", "code", "]", "entry", "[", "0", "]", "+=", "1", "entry", "[", "1", "]", "+=", "duration" ]

[ "A", "line", "has", "finished", "executing", "." ]

[ "def", "call", "(", "self", ",", "code", ",", "line", ",", "callee_file_timing", ",", "callee", ",", "duration", ",", "frame", ")", ":", "try", ":", "entry", "=", "self", ".", "call_dict", "[", "(", "code", ",", "line", ",", "callee", ")", "]", "except", "KeyError", ":", "self", ".", "call_dict", "[", "(", "code", ",", "line", ",", "callee", ")", "]", "=", "[", "callee_file_timing", ",", "1", ",", "duration", "]", "else", ":", "entry", "[", "1", "]", "+=", "1", "entry", "[", "2", "]", "+=", "duration" ]

[ "A", "call", "originating", "from", "this", "file", "returned", "." ]

[ "def", "dump_stats", "(", "self", ",", "filename", ")", ":", "if", "_isCallgrindName", "(", "filename", ")", ":", "with", "open", "(", "filename", ",", "'w'", ")", "as", "out", ":", "self", ".", "callgrind", "(", "out", ")", "else", ":", "with", "io", ".", "open", "(", "filename", ",", "'w'", ",", "errors", "=", "'replace'", ")", "as", "out", ":", "self", ".", "annotate", "(", "out", ")" ]

[ "Similar", "to", "profile", ".", "Profile", ".", "dump_stats", "-", "but", "different", "output", "format", "!" ]

[ "def", "runctx", "(", "self", ",", "cmd", ",", "globals", ",", "locals", ")", ":", "with", "self", "(", ")", ":", "exec", "(", "cmd", ",", "globals", ",", "locals", ")", "return", "self" ]

[ "Similar", "to", "profile", ".", "Profile", ".", "runctx", "." ]

[ "def", "enable", "(", "self", ")", ":", "if", "self", ".", "enabled_start", ":", "warn", "(", "'Duplicate \"enable\" call'", ")", "else", ":", "self", ".", "_enable", "(", ")", "sys", ".", "settrace", "(", "self", ".", "_global_trace", ")" ]

[ "Enable", "profiling", "." ]

[ "def", "_disable", "(", "self", ")", ":", "self", ".", "total_time", "+=", "time", "(", ")", "-", "self", ".", "enabled_start", "self", ".", "enabled_start", "=", "None", "del", "self", ".", "stack" ]

[ "Overload", "this", "method", "when", "subclassing", ".", "Called", "after", "actually", "disabling", "trace", "." ]

[ "def", "_make_expanded_field_serializer", "(", "self", ",", "name", ",", "nested_expand", ",", "nested_fields", ",", "nested_omit", ")", ":", "field_options", "=", "self", ".", "expandable_fields", "[", "name", "]", "serializer_class", "=", "field_options", "[", "0", "]", "serializer_settings", "=", "copy", ".", "deepcopy", "(", "field_options", "[", "1", "]", ")", "if", "name", "in", "nested_expand", ":", "serializer_settings", "[", "\"expand\"", "]", "=", "nested_expand", "[", "name", "]", "if", "name", "in", "nested_fields", ":", "serializer_settings", "[", "\"fields\"", "]", "=", "nested_fields", "[", "name", "]", "if", "name", "in", "nested_omit", ":", "serializer_settings", "[", "\"omit\"", "]", "=", "nested_omit", "[", "name", "]", "if", "serializer_settings", ".", "get", "(", "\"source\"", ")", "==", "name", ":", "del", "serializer_settings", "[", "\"source\"", "]", "if", "type", "(", "serializer_class", ")", "==", "str", ":", "serializer_class", "=", "self", ".", "_import_serializer_class", "(", "serializer_class", ")", "return", "serializer_class", "(", "*", "*", "serializer_settings", ")" ]

[ "Returns", "an", "instance", "of", "the", "dynamically", "created", "nested", "serializer", "." ]

[ "def", "_clean_fields", "(", "self", ",", "omit_fields", ",", "sparse_fields", ",", "next_level_omits", ")", ":", "sparse", "=", "len", "(", "sparse_fields", ")", ">", "0", "to_remove", "=", "[", "]", "if", "not", "sparse", "and", "len", "(", "omit_fields", ")", "==", "0", ":", "return", "for", "field_name", "in", "self", ".", "fields", ":", "is_present", "=", "self", ".", "_should_field_exist", "(", "field_name", ",", "omit_fields", ",", "sparse_fields", ",", "next_level_omits", ")", "if", "not", "is_present", ":", "to_remove", ".", "append", "(", "field_name", ")", "for", "remove_field", "in", "to_remove", ":", "self", ".", "fields", ".", "pop", "(", "remove_field", ")" ]

[ "Remove", "fields", "that", "are", "found", "in", "omit", "list", "and", "if", "sparse", "names", "are", "passed", "remove", "any", "fields", "not", "found", "in", "that", "list", "." ]

[ "def", "_can_access_request", "(", "self", ")", ":", "if", "self", ".", "parent", ":", "return", "False", "if", "not", "hasattr", "(", "self", ",", "\"context\"", ")", "or", "not", "self", ".", "context", ".", "get", "(", "\"request\"", ",", "None", ")", ":", "return", "False", "return", "self", ".", "context", "[", "\"request\"", "]", ".", "method", "==", "\"GET\"" ]

[ "Can", "access", "current", "request", "object", "if", "all", "are", "true", "-", "The", "serializer", "is", "the", "root", ".", "-", "A", "request", "context", "was", "passed", "in", ".", "-", "The", "request", "method", "is", "GET", "." ]