Datasets:

---

CM

/

codexglue_code2text_python

like 8

[ "def", "nub", "(", "it", ")", ":", "seen", "=", "set", "(", ")", "for", "v", "in", "it", ":", "h", "=", "hash", "(", "v", ")", "if", "h", "in", "seen", ":", "continue", "seen", ".", "add", "(", "h", ")", "yield", "v" ]

[ "Dedups", "an", "iterable", "in", "arbitrary", "order", "." ]

[ "def", "folders", "(", "self", ",", "ann_id", "=", "None", ")", ":", "ann_id", "=", "self", ".", "_annotator", "(", "ann_id", ")", "if", "len", "(", "self", ".", "prefix", ")", ">", "0", ":", "prefix", "=", "'|'", ".", "join", "(", "[", "urllib", ".", "quote", "(", "self", ".", "prefix", ",", "safe", "=", "'~'", ")", ",", "'topic'", ",", "ann_id", ",", "''", "]", ")", "else", ":", "prefix", "=", "'|'", ".", "join", "(", "[", "'topic'", ",", "ann_id", ",", "''", "]", ")", "logger", ".", "info", "(", "'Scanning for folders with prefix %r'", ",", "prefix", ")", "return", "imap", "(", "lambda", "id", ":", "self", ".", "unwrap_folder_content_id", "(", "id", ")", "[", "'folder_id'", "]", ",", "self", ".", "store", ".", "scan_prefix_ids", "(", "prefix", ")", ")" ]

[ "Yields", "an", "unordered", "generator", "for", "all", "available", "folders", "." ]

[ "def", "subfolders", "(", "self", ",", "folder_id", ",", "ann_id", "=", "None", ")", ":", "self", ".", "assert_valid_folder_id", "(", "folder_id", ")", "ann_id", "=", "self", ".", "_annotator", "(", "ann_id", ")", "folder_cid", "=", "self", ".", "wrap_folder_content_id", "(", "ann_id", ",", "folder_id", ")", "if", "self", ".", "store", ".", "get", "(", "folder_cid", ")", "is", "None", ":", "raise", "KeyError", "(", "folder_id", ")", "all_labels", "=", "self", ".", "label_store", ".", "directly_connected", "(", "folder_cid", ")", "return", "nub", "(", "la", ".", "subtopic_for", "(", "folder_cid", ")", "for", "la", "in", "all_labels", ")" ]

[ "Yields", "an", "unodered", "generator", "of", "subfolders", "in", "a", "folder", "." ]

[ "def", "parent_subfolders", "(", "self", ",", "ident", ",", "ann_id", "=", "None", ")", ":", "ann_id", "=", "self", ".", "_annotator", "(", "ann_id", ")", "cid", ",", "_", "=", "normalize_ident", "(", "ident", ")", "for", "lab", "in", "self", ".", "label_store", ".", "directly_connected", "(", "ident", ")", ":", "folder_cid", "=", "lab", ".", "other", "(", "cid", ")", "subfolder_sid", "=", "lab", ".", "subtopic_for", "(", "folder_cid", ")", "if", "not", "folder_cid", ".", "startswith", "(", "'topic|'", ")", ":", "continue", "folder", "=", "self", ".", "unwrap_folder_content_id", "(", "folder_cid", ")", "subfolder", "=", "self", ".", "unwrap_subfolder_subtopic_id", "(", "subfolder_sid", ")", "if", "folder", "[", "'annotator_id'", "]", "!=", "ann_id", ":", "continue", "yield", "(", "folder", "[", "'folder_id'", "]", ",", "subfolder", ")" ]

[ "An", "unordered", "generator", "of", "parent", "subfolders", "for", "ident", "." ]

[ "def", "items", "(", "self", ",", "folder_id", ",", "subfolder_id", ",", "ann_id", "=", "None", ")", ":", "self", ".", "assert_valid_folder_id", "(", "folder_id", ")", "self", ".", "assert_valid_folder_id", "(", "subfolder_id", ")", "ann_id", "=", "self", ".", "_annotator", "(", "ann_id", ")", "folder_cid", "=", "self", ".", "wrap_folder_content_id", "(", "ann_id", ",", "folder_id", ")", "subfolder_sid", "=", "self", ".", "wrap_subfolder_subtopic_id", "(", "subfolder_id", ")", "ident", "=", "(", "folder_cid", ",", "subfolder_sid", ")", "if", "self", ".", "store", ".", "get", "(", "folder_cid", ")", "is", "None", ":", "raise", "KeyError", "(", "folder_id", ")", "for", "lab", "in", "self", ".", "label_store", ".", "directly_connected", "(", "ident", ")", ":", "cid", "=", "lab", ".", "other", "(", "folder_cid", ")", "subid", "=", "lab", ".", "subtopic_for", "(", "cid", ")", "yield", "(", "cid", ",", "subid", ")" ]

[ "Yields", "an", "unodered", "generator", "of", "items", "in", "a", "subfolder", "." ]

[ "def", "grouped_items", "(", "self", ",", "folder_id", ",", "subfolder_id", ",", "ann_id", "=", "None", ")", ":", "d", "=", "defaultdict", "(", "list", ")", "for", "cid", ",", "subid", "in", "self", ".", "items", "(", "folder_id", ",", "subfolder_id", ",", "ann_id", "=", "ann_id", ")", ":", "d", "[", "cid", "]", ".", "append", "(", "subid", ")", "return", "d" ]

[ "Returns", "a", "dictionary", "from", "content", "ids", "to", "subtopic", "ids", "." ]

[ "def", "add_folder", "(", "self", ",", "folder_id", ",", "ann_id", "=", "None", ")", ":", "self", ".", "assert_valid_folder_id", "(", "folder_id", ")", "ann_id", "=", "self", ".", "_annotator", "(", "ann_id", ")", "cid", "=", "self", ".", "wrap_folder_content_id", "(", "ann_id", ",", "folder_id", ")", "self", ".", "store", ".", "put", "(", "[", "(", "cid", ",", "FeatureCollection", "(", ")", ")", "]", ")", "logger", ".", "info", "(", "'Added folder %r with content id %r'", ",", "folder_id", ",", "cid", ")" ]

[ "Add", "a", "folder", "." ]

[ "def", "add_item", "(", "self", ",", "folder_id", ",", "subfolder_id", ",", "content_id", ",", "subtopic_id", "=", "None", ",", "ann_id", "=", "None", ")", ":", "self", ".", "assert_valid_folder_id", "(", "folder_id", ")", "self", ".", "assert_valid_folder_id", "(", "subfolder_id", ")", "ann_id", "=", "self", ".", "_annotator", "(", "ann_id", ")", "folder_cid", "=", "self", ".", "wrap_folder_content_id", "(", "ann_id", ",", "folder_id", ")", "subfolder_sid", "=", "self", ".", "wrap_subfolder_subtopic_id", "(", "subfolder_id", ")", "if", "self", ".", "store", ".", "get", "(", "folder_cid", ")", "is", "None", ":", "raise", "KeyError", "(", "folder_id", ")", "lab", "=", "Label", "(", "folder_cid", ",", "content_id", ",", "ann_id", ",", "CorefValue", ".", "Positive", ",", "subtopic_id1", "=", "subfolder_sid", ",", "subtopic_id2", "=", "subtopic_id", ")", "self", ".", "label_store", ".", "put", "(", "lab", ")", "logger", ".", "info", "(", "'Added subfolder item: %r'", ",", "lab", ")" ]

[ "Add", "an", "item", "to", "a", "subfolder", "." ]

[ "def", "generate_models", "(", "args", ")", ":", "data_table", "=", "get_data_table", "(", "args", ".", "filename", ")", "tables", "=", "to_tables", "(", "data_table", ".", "rows_to_dicts", "(", ")", ")", "attr_indent", "=", "\"\\n\"", "+", "args", ".", "indent", "*", "2", "attr_sep", "=", "\",\"", "+", "attr_indent", "for", "tname", ",", "cols", "in", "tables", ".", "items", "(", ")", ":", "model_name", "=", "table_to_model_name", "(", "tname", ",", "list", "(", "cols", ".", "values", "(", ")", ")", "[", "0", "]", "[", "\"table_schema\"", "]", ")", "pk_cols", ",", "oth_cols", "=", "split_pks", "(", "cols", ")", "timestamps", "=", "get_timestamps", "(", "cols", ",", "args", ".", "created_at_col_name", ",", "args", ".", "updated_at_col_name", ")", "is_auto", "=", "len", "(", "pk_cols", ")", "==", "1", "and", "cols", "[", "pk_cols", "[", "0", "]", "]", "[", "\"is_auto\"", "]", "==", "\"t\"", "attrs", "=", "OrderedDict", "(", ")", "for", "cname", "in", "oth_cols", ":", "if", "cname", "not", "in", "timestamps", ":", "attrs", "[", "cname", "]", "=", "None", "print", "(", "_MODEL_SOURCE", ".", "format", "(", "class_name", "=", "model_name", ",", "base_class_name", "=", "\"ModelBase\"", ",", "indent", "=", "args", ".", "indent", ",", "table_name", "=", "repr", "(", "tname", ")", ",", "pk_name", "=", "repr", "(", "pk_cols", "[", "0", "]", "if", "len", "(", "pk_cols", ")", "==", "1", "else", "pk_cols", ")", ",", "pk_is_auto", "=", "is_auto", ",", "timestamps", "=", "timestamps", ",", "attrs", "=", "\"dict(\"", "+", "attr_indent", "+", "attr_sep", ".", "join", "(", "\"{0}={1}\"", ".", "format", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "attrs", ".", "items", "(", ")", ")", "+", "\")\"", ")", ")", "print", "(", ")" ]

[ "Generates", "models", "from", "the", "script", "input", "." ]

[ "def", "get_data_table", "(", "filename", ")", ":", "with", "get_file_object", "(", "filename", ",", "\"r\"", ")", "as", "rf", ":", "return", "DataTable", "(", "list", "(", "csv", ".", "reader", "(", "rf", ")", ")", ")" ]

[ "Returns", "a", "DataTable", "instance", "built", "from", "either", "the", "filename", "or", "STDIN", "if", "filename", "is", "None", "." ]

[ "def", "to_tables", "(", "cols", ")", ":", "tables", "=", "OrderedDict", "(", ")", "for", "col", "in", "cols", ":", "tname", "=", "col", "[", "\"table_name\"", "]", "if", "tname", "not", "in", "tables", ":", "tables", "[", "tname", "]", "=", "OrderedDict", "(", ")", "tables", "[", "tname", "]", "[", "col", "[", "\"column_name\"", "]", "]", "=", "col", "return", "tables" ]

[ "Builds", "and", "returns", "a", "Dictionary", "whose", "keys", "are", "table", "names", "and", "values", "are", "OrderedDicts", "whose", "keys", "are", "column", "names", "and", "values", "are", "the", "col", "objects", "from", "which", "the", "definition", "is", "derived", "." ]

[ "def", "snake_to_pascal", "(", "name", ",", "singularize", "=", "False", ")", ":", "parts", "=", "name", ".", "split", "(", "\"_\"", ")", "if", "singularize", ":", "return", "\"\"", ".", "join", "(", "p", ".", "upper", "(", ")", "if", "p", "in", "_ALL_CAPS", "else", "to_singular", "(", "p", ".", "title", "(", ")", ")", "for", "p", "in", "parts", ")", "else", ":", "return", "\"\"", ".", "join", "(", "p", ".", "upper", "(", ")", "if", "p", "in", "_ALL_CAPS", "else", "p", ".", "title", "(", ")", "for", "p", "in", "parts", ")" ]

[ "Converts", "snake_case", "to", "PascalCase", ".", "If", "singularize", "is", "True", "an", "attempt", "is", "made", "at", "singularizing", "each", "part", "of", "the", "resulting", "name", "." ]

[ "def", "to_singular", "(", "word", ")", ":", "if", "word", "[", "-", "1", "]", "!=", "\"s\"", ":", "return", "word", "elif", "word", ".", "endswith", "(", "\"ies\"", ")", ":", "return", "word", "[", ":", "-", "3", "]", "+", "\"y\"", "elif", "word", ".", "endswith", "(", "\"ses\"", ")", ":", "return", "word", "[", ":", "-", "2", "]", "else", ":", "return", "word", "[", ":", "-", "1", "]" ]

[ "Attempts", "to", "singularize", "a", "word", "." ]

[ "def", "get_timestamps", "(", "cols", ",", "created_name", ",", "updated_name", ")", ":", "has_created", "=", "created_name", "in", "cols", "has_updated", "=", "updated_name", "in", "cols", "return", "(", "created_name", "if", "has_created", "else", "None", ",", "updated_name", "if", "has_updated", "else", "None", ")" ]

[ "Returns", "a", "2", "-", "tuple", "of", "the", "timestamp", "columns", "that", "were", "found", "on", "the", "table", "definition", "." ]

[ "def", "pull_from_origin", "(", "repo_path", ")", ":", "LOG", ".", "info", "(", "\"Pulling from origin at %s.\"", "%", "repo_path", ")", "command", "=", "GIT_PULL_CMD", ".", "format", "(", "repo_path", ")", "resp", "=", "envoy", ".", "run", "(", "command", ")", "if", "resp", ".", "status_code", "!=", "0", ":", "LOG", ".", "exception", "(", "\"Pull failed.\"", ")", "raise", "GitException", "(", "resp", ".", "std_err", ")", "else", ":", "LOG", ".", "info", "(", "\"Pull successful.\"", ")" ]

[ "Execute", "git", "pull", "at", "the", "provided", "repo_path", "." ]

[ "def", "read_remote_origin", "(", "repo_dir", ")", ":", "conf", "=", "ConfigParser", "(", ")", "conf", ".", "read", "(", "os", ".", "path", ".", "join", "(", "repo_dir", ",", "'.git/config'", ")", ")", "return", "conf", ".", "get", "(", "'remote \"origin\"'", ",", "'url'", ")" ]

[ "Read", "the", "remote", "origin", "URL", "from", "the", "given", "git", "repo", "or", "None", "if", "unset", "." ]

[ "def", "clone_from", "(", "repo_url", ",", "repo_dir", ")", ":", "repo_url", "=", "_fix_repo_url", "(", "repo_url", ")", "LOG", ".", "info", "(", "\"Cloning %s into %s.\"", "%", "(", "repo_url", ",", "repo_dir", ")", ")", "cmd", "=", "GIT_CLONE_CMD", ".", "format", "(", "repo_url", ",", "repo_dir", ")", "resp", "=", "envoy", ".", "run", "(", "cmd", ")", "if", "resp", ".", "status_code", "!=", "0", ":", "LOG", ".", "error", "(", "\"Cloned failed: %s\"", "%", "resp", ".", "std_err", ")", "raise", "GitException", "(", "resp", ".", "std_err", ")", "LOG", ".", "info", "(", "\"Clone successful.\"", ")" ]

[ "Clone", "a", "remote", "git", "repo", "into", "a", "local", "directory", "." ]

[ "def", "route", "(", "method", ",", "pattern", ",", "handler", "=", "None", ")", ":", "if", "handler", "is", "None", ":", "return", "partial", "(", "route", ",", "method", ",", "pattern", ")", "return", "routes", ".", "append", "(", "method", ",", "pattern", ",", "handler", ")" ]

[ "register", "a", "routing", "rule" ]

[ "def", "spawn", "(", "self", ",", "owner", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "(", "self", ".", "_spawn", "(", "owner", ",", "self", ".", "factory", ",", "*", "args", ",", "*", "*", "kwargs", ")", "if", "self", ".", "factory", "else", "self", ".", "_spawn", "(", "owner", ",", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Spawns", "a", "new", "subordinate", "actor", "of", "owner", "and", "stores", "it", "in", "this", "container", "." ]

[ "def", "watch", "(", "ctx", ")", ":", "vcs", "=", "ctx", ".", "obj", "[", "'vcs'", "]", "event_handler", "=", "TestsEventHandler", "(", "vcs", ")", "observer", "=", "Observer", "(", ")", "observer", ".", "schedule", "(", "event_handler", ",", "vcs", ".", "path", ",", "recursive", "=", "True", ")", "observer", ".", "start", "(", ")", "click", ".", "echo", "(", "'Watching directory `{path}`. Use ctrl-c to stop.'", ".", "format", "(", "path", "=", "vcs", ".", "path", ")", ")", "while", "observer", ".", "isAlive", "(", ")", ":", "observer", ".", "join", "(", "timeout", "=", "1", ")" ]

[ "Watch", "the", "directory", "for", "changes", ".", "Automatically", "run", "tests", "." ]

[ "def", "settings", "(", "request", "=", "None", ")", ":", "from", "yacms", ".", "conf", "import", "settings", "allowed_settings", "=", "settings", ".", "TEMPLATE_ACCESSIBLE_SETTINGS", "template_settings", "=", "TemplateSettings", "(", "settings", ",", "allowed_settings", ")", "template_settings", ".", "update", "(", "DEPRECATED", ")", "# This is basically the same as the old ADMIN_MEDIA_PREFIX setting,", "# we just use it in a few spots in the admin to optionally load a", "# file from either grappelli or Django admin if grappelli isn't", "# installed. We don't call it ADMIN_MEDIA_PREFIX in order to avoid", "# any confusion.", "admin_prefix", "=", "\"grappelli/\"", "if", "settings", ".", "GRAPPELLI_INSTALLED", "else", "\"admin/\"", "template_settings", "[", "\"YACMS_ADMIN_PREFIX\"", "]", "=", "admin_prefix", "return", "{", "\"settings\"", ":", "template_settings", "}" ]

[ "Add", "the", "settings", "object", "to", "the", "template", "context", "." ]

[ "def", "list", "(", "options", ")", ":", "configuration", "=", "config", ".", "get_default", "(", ")", "app_url", "=", "configuration", "[", "'app_url'", "]", "if", "options", ".", "deployment", "!=", "None", ":", "deployment_name", "=", "options", ".", "deployment", "else", ":", "deployment_name", "=", "configuration", "[", "'deployment_name'", "]", "client_id", "=", "configuration", "[", "'client_id'", "]", "client_secret", "=", "configuration", "[", "'client_secret'", "]", "token_manager", "=", "auth", ".", "TokenManager", "(", "client_id", "=", "client_id", ",", "client_secret", "=", "client_secret", ",", "app_url", "=", "app_url", ")", "if", "options", ".", "all", "==", "True", ":", "account_id", "=", "None", "else", ":", "account_id", "=", "accounts", ".", "get_logged_in_account_id", "(", "token_manager", "=", "token_manager", ",", "app_url", "=", "app_url", ")", "programs_details", "=", "programs", ".", "get_programs", "(", "deployment_name", ",", "token_manager", "=", "token_manager", ",", "created_by", "=", "account_id", ",", "app_url", "=", "app_url", ")", "account_ids", "=", "set", "(", ")", "for", "program", "in", "programs_details", ":", "account_ids", ".", "add", "(", "program", "[", "'createdBy'", "]", ")", "accounts_details", "=", "accounts", ".", "get_accounts", "(", "account_ids", ",", "token_manager", "=", "token_manager", ",", "app_url", "=", "app_url", ")", "account_lookup", "=", "{", "}", "for", "account", "in", "accounts_details", "[", "'accounts'", "]", ":", "account_lookup", "[", "account", "[", "'id'", "]", "]", "=", "account", "headers", "=", "[", "'Name'", ",", "'Last Saved'", ",", "'Created By'", "]", "table", "=", "[", "]", "for", "program", "in", "programs_details", ":", "username", "=", "account_lookup", "[", "program", "[", "'createdBy'", "]", "]", "[", "'username'", "]", "program_name", "=", "program", "[", "'name'", "]", "last_edited", "=", "program", "[", "'lastEdited'", "]", "table", ".", "append", "(", "[", "program_name", ",", "last_edited", ",", "username", "]", ")", "if", "options", ".", "format", "==", "'table'", ":", "info", "(", "tabulate", ".", "tabulate", "(", "table", ",", "headers", ",", "tablefmt", "=", "'orgtbl'", ")", ")", "elif", "options", ".", "format", "==", "'text'", ":", "info", "(", "tabulate", ".", "tabulate", "(", "table", ",", "headers", ",", "tablefmt", "=", "'orgtbl'", ",", "stralign", "=", "'center'", ")", ")", "else", ":", "raise", "JutException", "(", "'Unsupported format \"%s\"'", "%", "options", ".", "format", ")" ]

[ "list", "programs", "that", "belong", "to", "the", "authenticated", "user" ]

[ "def", "m", "(", "self", ",", "msg", ",", "state", "=", "False", ",", "more", "=", "None", ",", "cmdd", "=", "None", ",", "critical", "=", "True", ",", "verbose", "=", "None", ")", ":", "if", "verbose", "is", "None", ":", "verbose", "=", "self", ".", "__verbose", "res", "=", "dict", "(", ")", "if", "more", ":", "res", ".", "update", "(", "more", "if", "isinstance", "(", "more", ",", "dict", ")", "else", "dict", "(", "more", "=", "more", ")", ")", "if", "cmdd", "and", "isinstance", "(", "cmdd", ",", "dict", ")", "and", "cmdd", ".", "get", "(", "'cmd'", ")", ":", "res", ".", "update", "(", "shell_run", "(", "cmdd", ".", "get", "(", "'cmd'", ")", ",", "cin", "=", "cmdd", ".", "get", "(", "'cin'", ")", ",", "cwd", "=", "cmdd", ".", "get", "(", "'cwd'", ")", ",", "timeout", "=", "cmdd", ".", "get", "(", "'timeout'", ",", "120", ")", ",", "critical", "=", "False", ",", "verbose", "=", "cmdd", ".", "get", "(", "'verbose'", ",", "verbose", ")", ")", ")", "if", "res", ".", "get", "(", "'returncode'", ",", "-", "1", ")", "!=", "0", ":", "res", ".", "update", "(", "dict", "(", "failed", "=", "True", ")", ")", "if", "state", "or", "critical", "and", "res", ".", "get", "(", "'failed'", ")", ":", "self", ".", "meta", ".", "log", "=", "dict", "(", "message", "=", "msg", ",", "more", "=", "res", ",", "verbose", "=", "verbose", ")", "shell_notify", "(", "msg", ",", "more", "=", "res", ",", "state", "=", "True", ")", "self", ".", "meta", ".", "log", "=", "shell_notify", "(", "msg", ",", "more", "=", "res", ",", "state", "=", "state", ",", "verbose", "=", "verbose", ")", "return", "res" ]

[ "Mysterious", "mega", "method", "managing", "multiple", "meshed", "modules", "magically" ]

[ "def", "s2m", "(", "self", ")", ":", "m", "=", "'%s settings'", "%", "(", "IDENT", ")", "self", ".", "meta", ".", "load", "(", "m", ",", "'import %s'", "%", "(", "m", ")", ",", "mdict", "=", "self", ".", "settings", ".", "get", ")" ]

[ "Imports", "settings", "to", "meta" ]

[ "def", "file_to_base64", "(", "path_or_obj", ",", "max_mb", "=", "None", ")", ":", "if", "not", "hasattr", "(", "path_or_obj", ",", "'read'", ")", ":", "rt", "=", "read_file", "(", "path_or_obj", ")", "else", ":", "rt", "=", "path_or_obj", ".", "read", "(", ")", "if", "max_mb", ":", "len_mb", "=", "len", "(", "rt", ")", "/", "(", "10024.0", "*", "1000", ")", "if", "len_mb", ">", "max_mb", ":", "raise", "ErrorFileTooBig", "(", "\"File is too big ({.2f} MBytes)\"", "(", "len_mb", ")", ")", "return", "b64encode", "(", "rt", ")" ]

[ "converts", "contents", "of", "a", "file", "to", "base64", "encoding" ]

[ "def", "dict_clip", "(", "a_dict", ",", "inlude_keys_lst", "=", "[", "]", ")", ":", "return", "dict", "(", "[", "[", "i", "[", "0", "]", ",", "i", "[", "1", "]", "]", "for", "i", "in", "list", "(", "a_dict", ".", "items", "(", ")", ")", "if", "i", "[", "0", "]", "in", "inlude_keys_lst", "]", ")" ]

[ "returns", "a", "new", "dict", "with", "keys", "not", "in", "included", "in", "inlude_keys_lst", "clipped", "off" ]

[ "def", "list_pp", "(", "ll", ",", "separator", "=", "'|'", ",", "header_line", "=", "True", ",", "autonumber", "=", "True", ")", ":", "if", "autonumber", ":", "for", "cnt", ",", "i", "in", "enumerate", "(", "ll", ")", ":", "i", ".", "insert", "(", "0", ",", "cnt", "if", "cnt", ">", "0", "or", "not", "header_line", "else", "'#'", ")", "def", "lenlst", "(", "l", ")", ":", "return", "[", "len", "(", "str", "(", "i", ")", ")", "for", "i", "in", "l", "]", "lst_len", "=", "[", "lenlst", "(", "i", ")", "for", "i", "in", "ll", "]", "lst_rot", "=", "zip", "(", "*", "lst_len", "[", ":", ":", "-", "1", "]", ")", "lst_len", "=", "[", "max", "(", "i", ")", "for", "i", "in", "lst_rot", "]", "frmt", "=", "separator", "+", "separator", ".", "join", "(", "[", "\"{!s:\"", "+", "str", "(", "i", ")", "+", "\"}\"", "for", "i", "in", "lst_len", "]", ")", "+", "separator", "if", "header_line", ":", "header_line", "=", "'-'", "*", "len", "(", "frmt", ".", "format", "(", "*", "ll", "[", "0", "]", ")", ")", "for", "cnt", ",", "l", "in", "enumerate", "(", "ll", ")", ":", "if", "cnt", "<", "2", "and", "header_line", ":", "print", "(", "header_line", ")", "print", "(", "frmt", ".", "format", "(", "*", "l", ")", ")", "if", "header_line", ":", "print", "(", "header_line", ")", "return", "lst_len" ]

[ "pretty", "print", "list", "of", "lists", "ll" ]

[ "def", "signal_terminate", "(", "on_terminate", ")", ":", "for", "i", "in", "[", "signal", ".", "SIGINT", ",", "signal", ".", "SIGQUIT", ",", "signal", ".", "SIGUSR1", ",", "signal", ".", "SIGUSR2", ",", "signal", ".", "SIGTERM", "]", ":", "signal", ".", "signal", "(", "i", ",", "on_terminate", ")" ]

[ "a", "common", "case", "program", "termination", "signal" ]

[ "def", "_safe_mkdir", "(", "directory", ")", ":", "try", ":", "os", ".", "makedirs", "(", "directory", ")", "except", "OSError", "as", "error", ":", "if", "error", ".", "errno", "!=", "errno", ".", "EEXIST", ":", "raise", "error" ]

[ "Create", "a", "directory", "ignoring", "errors", "if", "it", "already", "exists", "." ]

[ "def", "_stamp_and_update_hook", "(", "method", ",", "# suppress(too-many-arguments)", "dependencies", ",", "stampfile", ",", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "result", "=", "_stamp", "(", "stampfile", ",", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", "method", ".", "update_stampfile_hook", "(", "dependencies", ")", "return", "result" ]

[ "Write", "stamp", "and", "call", "update_stampfile_hook", "on", "method", "." ]

[ "def", "_sha1_for_file", "(", "filename", ")", ":", "with", "open", "(", "filename", ",", "\"rb\"", ")", "as", "fileobj", ":", "contents", "=", "fileobj", ".", "read", "(", ")", "return", "hashlib", ".", "sha1", "(", "contents", ")", ".", "hexdigest", "(", ")" ]

[ "Return", "sha1", "for", "contents", "of", "filename", "." ]

[ "def", "check_dependency", "(", "self", ",", "dependency_path", ")", ":", "stored_hash", "=", "self", ".", "_stamp_file_hashes", ".", "get", "(", "dependency_path", ")", "# This file was newly added, or we don't have a file", "# with stored hashes yet. Assume out of date.", "if", "not", "stored_hash", ":", "return", "False", "return", "stored_hash", "==", "_sha1_for_file", "(", "dependency_path", ")" ]

[ "Check", "if", "mtime", "of", "dependency_path", "is", "greater", "than", "stored", "mtime", "." ]

[ "def", "update_stampfile_hook", "(", "self", ",", "dependencies", ")", ":", "# suppress(no-self-use)", "hashes", "=", "{", "d", ":", "_sha1_for_file", "(", "d", ")", "for", "d", "in", "dependencies", "if", "os", ".", "path", ".", "exists", "(", "d", ")", "}", "with", "open", "(", "self", ".", "_stamp_file_hashes_path", ",", "\"wb\"", ")", "as", "hashes_file", ":", "hashes_file", ".", "write", "(", "json", ".", "dumps", "(", "hashes", ")", ".", "encode", "(", "\"utf-8\"", ")", ")" ]

[ "Loop", "over", "all", "dependencies", "and", "store", "hash", "for", "each", "of", "them", "." ]

[ "def", "unicode_value", "(", "self", ",", "string", ")", ":", "result", "=", "0", "# don't accept strings that contain numbers", "if", "self", ".", "regex_has_numbers", ".", "search", "(", "string", ")", ":", "raise", "AbnumException", "(", "error_msg", "%", "string", ")", "else", ":", "num_str", "=", "self", ".", "regex_values", ".", "sub", "(", "lambda", "x", ":", "'%s '", "%", "self", ".", "values", "[", "x", ".", "group", "(", ")", "]", ",", "string", ")", "# don't accept strings, that contains letters which haven't been be converted to numbers", "try", ":", "result", "=", "sum", "(", "[", "int", "(", "i", ")", "for", "i", "in", "num_str", ".", "split", "(", ")", "]", ")", "except", "Exception", "as", "e", ":", "raise", "AbnumException", "(", "error_msg", "%", "string", ")", "return", "result" ]

[ "String", "argument", "must", "be", "in", "unicode", "format", "." ]

[ "def", "import_from_string", "(", "value", ")", ":", "value", "=", "value", ".", "replace", "(", "'-'", ",", "'_'", ")", "try", ":", "module_path", ",", "class_name", "=", "value", ".", "rsplit", "(", "'.'", ",", "1", ")", "module", "=", "import_module", "(", "module_path", ")", "return", "getattr", "(", "module", ",", "class_name", ")", "except", "(", "ImportError", ",", "AttributeError", ")", "as", "ex", ":", "raise", "ImportError", "(", "\"Could not import '{}'. {}: {}.\"", ".", "format", "(", "value", ",", "ex", ".", "__class__", ".", "__name__", ",", "ex", ")", ")" ]

[ "Copy", "of", "rest_framework", ".", "settings", ".", "import_from_string" ]

[ "def", "_parse_args", "(", "args", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "prog", "=", "'nibble'", ",", "description", "=", "'Speed, distance and time '", "'calculations around '", "'quantities of digital '", "'information.'", ")", "parser", ".", "add_argument", "(", "'-V'", ",", "'--version'", ",", "action", "=", "'version'", ",", "version", "=", "'%(prog)s '", "+", "nibble", ".", "__version__", ")", "parser", ".", "add_argument", "(", "'-v'", ",", "'--verbosity'", ",", "help", "=", "'increase output verbosity'", ",", "action", "=", "'count'", ",", "default", "=", "0", ")", "parser", ".", "add_argument", "(", "'expression'", ",", "type", "=", "util", ".", "decode_cli_arg", ",", "nargs", "=", "'+'", ",", "help", "=", "'the calculation to execute'", ")", "return", "parser", ".", "parse_args", "(", "args", "[", "1", ":", "]", ")" ]

[ "Interpret", "command", "line", "arguments", "." ]

[ "def", "main", "(", "args", ")", ":", "args", "=", "_parse_args", "(", "args", ")", "# sort out logging output and level", "level", "=", "util", ".", "log_level_from_vebosity", "(", "args", ".", "verbosity", ")", "root", "=", "logging", ".", "getLogger", "(", ")", "root", ".", "setLevel", "(", "level", ")", "handler", "=", "logging", ".", "StreamHandler", "(", "sys", ".", "stdout", ")", "handler", ".", "setLevel", "(", "level", ")", "handler", ".", "setFormatter", "(", "logging", ".", "Formatter", "(", "'%(levelname)s %(message)s'", ")", ")", "root", ".", "addHandler", "(", "handler", ")", "logger", ".", "debug", "(", "args", ")", "expression", "=", "' '", ".", "join", "(", "args", ".", "expression", ")", "try", ":", "print", "(", "Parser", "(", ")", ".", "parse", "(", "expression", ")", ")", "except", "(", "LexingError", ",", "ParsingError", ")", "as", "e", ":", "util", ".", "print_error", "(", "e", ")", "return", "1", "return", "0" ]

[ "Nibble", "s", "entry", "point", "." ]

[ "def", "run", "(", "self", ",", "conn", ",", "tmp", ",", "module_name", ",", "module_args", ",", "inject", ")", ":", "# shell and command are the same module", "if", "module_name", "==", "'shell'", ":", "module_name", "=", "'command'", "module_args", "+=", "\" #USE_SHELL\"", "vv", "(", "\"REMOTE_MODULE %s %s\"", "%", "(", "module_name", ",", "module_args", ")", ",", "host", "=", "conn", ".", "host", ")", "return", "self", ".", "runner", ".", "_execute_module", "(", "conn", ",", "tmp", ",", "module_name", ",", "module_args", ",", "inject", "=", "inject", ")" ]

[ "transfer", "&", "execute", "a", "module", "that", "is", "not", "copy", "or", "template" ]

[ "def", "get_models", "(", "args", ")", ":", "if", "args", ":", "models", "=", "[", "]", "for", "arg", "in", "args", ":", "match_found", "=", "False", "for", "model", "in", "registry", ".", "get_models", "(", ")", ":", "if", "model", ".", "_meta", ".", "app_label", "==", "arg", ":", "models", ".", "append", "(", "model", ")", "match_found", "=", "True", "elif", "'%s.%s'", "%", "(", "model", ".", "_meta", ".", "app_label", ",", "model", ".", "_meta", ".", "model_name", ")", "==", "arg", ":", "models", ".", "append", "(", "model", ")", "match_found", "=", "True", "if", "not", "match_found", ":", "raise", "ValueError", "(", "\"No model or app named %s\"", "%", "arg", ")", "else", ":", "models", "=", "registry", ".", "get_models", "(", ")", "return", "set", "(", "models", ")" ]

[ "Parse", "a", "list", "of", "ModelName", "appname", "or", "appname", ".", "ModelName", "list", "and", "return", "the", "list", "of", "model", "classes", "in", "the", "IndexRegistry", ".", "If", "the", "list", "if", "falsy", "return", "all", "the", "models", "in", "the", "registry", "." ]

[ "def", "plot_dives", "(", "dv0", ",", "dv1", ",", "p", ",", "dp", ",", "t_on", ",", "t_off", ")", ":", "fig", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "2", ",", "1", ",", "sharex", "=", "True", ")", "x0", "=", "t_on", "[", "dv0", ":", "dv1", "]", "-", "t_on", "[", "dv0", "]", "x1", "=", "t_off", "[", "dv0", ":", "dv1", "]", "-", "t_on", "[", "dv0", "]", "# Extract start end depths", "y0_p", "=", "p", "[", "t_on", "[", "dv0", ":", "dv1", "]", "]", "y1_p", "=", "p", "[", "t_off", "[", "dv0", ":", "dv1", "]", "]", "# Extract start end delta depths", "y0_dp", "=", "dp", "[", "t_on", "[", "dv0", ":", "dv1", "]", "]", "y1_dp", "=", "dp", "[", "t_off", "[", "dv0", ":", "dv1", "]", "]", "start", "=", "t_on", "[", "dv0", "]", "stop", "=", "t_off", "[", "dv1", "]", "ax1", ".", "title", ".", "set_text", "(", "'Dives depths'", ")", "ax1", ".", "plot", "(", "range", "(", "len", "(", "p", "[", "start", ":", "stop", "]", ")", ")", ",", "p", "[", "start", ":", "stop", "]", ")", "ax1", ".", "scatter", "(", "x0", ",", "y0_p", ",", "label", "=", "'start'", ")", "ax1", ".", "scatter", "(", "x1", ",", "y1_p", ",", "label", "=", "'stop'", ")", "ax1", ".", "set_ylabel", "(", "'depth (m)'", ")", "ax1", ".", "title", ".", "set_text", "(", "'Depth rate of change'", ")", "ax2", ".", "plot", "(", "range", "(", "len", "(", "dp", "[", "start", ":", "stop", "]", ")", ")", ",", "dp", "[", "start", ":", "stop", "]", ")", "ax2", ".", "scatter", "(", "x0", ",", "y0_dp", ",", "label", "=", "'start'", ")", "ax2", ".", "scatter", "(", "x1", ",", "y1_dp", ",", "label", "=", "'stop'", ")", "ax2", ".", "set_ylabel", "(", "'depth (dm/t)'", ")", "ax2", ".", "set_xlabel", "(", "'sample'", ")", "for", "ax", "in", "[", "ax1", ",", "ax2", "]", ":", "ax", ".", "legend", "(", "loc", "=", "'upper right'", ")", "ax", ".", "set_xlim", "(", "[", "-", "50", ",", "len", "(", "dp", "[", "start", ":", "stop", "]", ")", "+", "50", "]", ")", "plt", ".", "show", "(", ")", "return", "None" ]

[ "Plots", "depths", "and", "delta", "depths", "with", "dive", "start", "stop", "markers" ]

[ "def", "plot_dives_pitch", "(", "depths", ",", "dive_mask", ",", "des", ",", "asc", ",", "pitch", ",", "pitch_lf", ")", ":", "import", "copy", "import", "numpy", "from", ".", "import", "plotutils", "fig", ",", "(", "ax1", ",", "ax2", ")", "=", "plt", ".", "subplots", "(", "2", ",", "1", ",", "sharex", "=", "True", ")", "des_ind", "=", "numpy", ".", "where", "(", "dive_mask", "&", "des", ")", "[", "0", "]", "asc_ind", "=", "numpy", ".", "where", "(", "dive_mask", "&", "asc", ")", "[", "0", "]", "ax1", ".", "title", ".", "set_text", "(", "'Dive descents and ascents'", ")", "ax1", "=", "plotutils", ".", "plot_noncontiguous", "(", "ax1", ",", "depths", ",", "des_ind", ",", "_colors", "[", "0", "]", ",", "'descents'", ")", "ax1", "=", "plotutils", ".", "plot_noncontiguous", "(", "ax1", ",", "depths", ",", "asc_ind", ",", "_colors", "[", "1", "]", ",", "'ascents'", ")", "ax1", ".", "legend", "(", "loc", "=", "'upper right'", ")", "ax1", ".", "invert_yaxis", "(", ")", "ax1", ".", "yaxis", ".", "label", ".", "set_text", "(", "'depth (m)'", ")", "ax1", ".", "xaxis", ".", "label", ".", "set_text", "(", "'samples'", ")", "ax2", ".", "title", ".", "set_text", "(", "'Pitch and Low-pass filtered pitch'", ")", "ax2", ".", "plot", "(", "range", "(", "len", "(", "pitch", ")", ")", ",", "pitch", ",", "color", "=", "_colors", "[", "2", "]", ",", "linewidth", "=", "_linewidth", ",", "label", "=", "'pitch'", ")", "ax2", ".", "plot", "(", "range", "(", "len", "(", "pitch_lf", ")", ")", ",", "pitch_lf", ",", "color", "=", "_colors", "[", "3", "]", ",", "linewidth", "=", "_linewidth", ",", "label", "=", "'pitch filtered'", ")", "ax2", ".", "legend", "(", "loc", "=", "'upper right'", ")", "ax2", ".", "yaxis", ".", "label", ".", "set_text", "(", "'Radians'", ")", "ax2", ".", "yaxis", ".", "label", ".", "set_text", "(", "'Samples'", ")", "plt", ".", "show", "(", ")", "return", "None" ]

[ "Plot", "dives", "with", "phase", "and", "associated", "pitch", "angle", "with", "HF", "signal" ]

[ "def", "plot_depth_descent_ascent", "(", "depths", ",", "dive_mask", ",", "des", ",", "asc", ")", ":", "import", "numpy", "from", ".", "import", "plotutils", "# Indices where depths are descents or ascents", "des_ind", "=", "numpy", ".", "where", "(", "dive_mask", "&", "des", ")", "[", "0", "]", "asc_ind", "=", "numpy", ".", "where", "(", "dive_mask", "&", "asc", ")", "[", "0", "]", "fig", ",", "ax1", "=", "plt", ".", "subplots", "(", ")", "ax1", ".", "title", ".", "set_text", "(", "'Dive descents and ascents'", ")", "ax1", "=", "plotutils", ".", "plot_noncontiguous", "(", "ax1", ",", "depths", ",", "des_ind", ",", "_colors", "[", "0", "]", ",", "'descents'", ")", "ax1", "=", "plotutils", ".", "plot_noncontiguous", "(", "ax1", ",", "depths", ",", "asc_ind", ",", "_colors", "[", "1", "]", ",", "'ascents'", ")", "ax1", ".", "legend", "(", "loc", "=", "'upper right'", ")", "ax1", ".", "invert_yaxis", "(", ")", "ax1", ".", "yaxis", ".", "label", ".", "set_text", "(", "'depth (m)'", ")", "ax1", ".", "xaxis", ".", "label", ".", "set_text", "(", "'samples'", ")", "plt", ".", "show", "(", ")", "return", "None" ]

[ "Plot", "depth", "data", "for", "whole", "deployment", "descents", "and", "ascents" ]

[ "def", "_update_docstrings", "(", "self", ")", ":", "ops", "=", "self", ".", "_details", ".", "resource_data", "[", "'operations'", "]", "for", "method_name", "in", "ops", ".", "keys", "(", ")", ":", "meth", "=", "getattr", "(", "self", ".", "__class__", ",", "method_name", ",", "None", ")", "if", "not", "meth", ":", "continue", "if", "meth", ".", "__doc__", "!=", "DEFAULT_DOCSTRING", ":", "# It already has a custom docstring. Leave it alone.", "continue", "# Needs updating. So there's at least *something* vaguely useful", "# there, use the docstring from the underlying ``Connection``", "# method.", "# FIXME: We need to figure out a way to make this more useful, if", "# possible.", "api_name", "=", "ops", "[", "method_name", "]", "[", "'api_name'", "]", "conn_meth", "=", "getattr", "(", "self", ".", "_connection", ",", "to_snake_case", "(", "api_name", ")", ")", "# We need to do detection here, because Py2 treats ``.__doc__``", "# as a special read-only attribute. :/", "if", "six", ".", "PY3", ":", "meth", ".", "__doc__", "=", "conn_meth", ".", "__doc__", "else", ":", "meth", ".", "__func__", ".", "__doc__", "=", "conn_meth", ".", "__doc__" ]

[ "Runs", "through", "the", "operation", "methods", "&", "updates", "their", "docstrings", "if", "necessary", "." ]

[ "def", "build_relation", "(", "self", ",", "name", ",", "klass", "=", "None", ")", ":", "try", ":", "rel_data", "=", "self", ".", "_details", ".", "relations", "[", "name", "]", "except", "KeyError", ":", "msg", "=", "\"No such relation named '{0}'.\"", ".", "format", "(", "name", ")", "raise", "NoRelation", "(", "msg", ")", "if", "klass", "is", "None", ":", "# This is the typical case, where we're not explicitly given a", "# class to build with. Hit the session & look up what we should", "# be loading.", "if", "rel_data", "[", "'class_type'", "]", "==", "'collection'", ":", "klass", "=", "self", ".", "_details", ".", "session", ".", "get_collection", "(", "self", ".", "_details", ".", "service_name", ",", "rel_data", "[", "'class'", "]", ")", "elif", "rel_data", "[", "'class_type'", "]", "==", "'resource'", ":", "klass", "=", "self", ".", "_details", ".", "session", ".", "get_resource", "(", "self", ".", "_details", ".", "service_name", ",", "rel_data", "[", "'class'", "]", ")", "else", ":", "msg", "=", "\"Unknown class '{0}' for '{1}'.\"", ".", "format", "(", "rel_data", "[", "'class_type'", "]", ",", "name", ")", "raise", "NoRelation", "(", "msg", ")", "# Instantiate & return it.", "kwargs", "=", "{", "}", "# Just populating identifiers is enough for the 1-M case.", "kwargs", ".", "update", "(", "self", ".", "get_identifiers", "(", ")", ")", "if", "rel_data", ".", "get", "(", "'rel_type'", ",", "'1-M'", ")", "==", "'1-1'", ":", "# FIXME: If it's not a collection, we might have some instance data", "# (i.e. ``bucket``) in ``self._data`` to populate as well.", "# This seems like a can of worms, so ignore for the moment.", "pass", "return", "klass", "(", "connection", "=", "self", ".", "_connection", ",", "*", "*", "kwargs", ")" ]

[ "Constructs", "a", "related", "Resource", "or", "Collection", "." ]

[ "def", "post_process_get", "(", "self", ",", "result", ")", ":", "if", "not", "hasattr", "(", "result", ",", "'items'", ")", ":", "# If it's not a dict, give up & just return whatever you get.", "return", "result", "# We need to possibly drill into the response & get out the data here.", "# Check for a result key.", "result_key", "=", "self", ".", "_details", ".", "result_key_for", "(", "'get'", ")", "if", "not", "result_key", ":", "# There's no result_key. Just use the top-level data.", "data", "=", "result", "else", ":", "data", "=", "result", "[", "result_key", "]", "for", "key", ",", "value", "in", "data", ".", "items", "(", ")", ":", "self", ".", "_data", "[", "to_snake_case", "(", "key", ")", "]", "=", "value", "return", "result" ]

[ "Given", "an", "object", "with", "identifiers", "fetches", "the", "data", "for", "that", "object", "from", "the", "service", "." ]

[ "def", "construct_for", "(", "self", ",", "service_name", ",", "resource_name", ",", "base_class", "=", "None", ")", ":", "details", "=", "self", ".", "details_class", "(", "self", ".", "session", ",", "service_name", ",", "resource_name", ",", "loader", "=", "self", ".", "loader", ")", "attrs", "=", "{", "'_details'", ":", "details", ",", "}", "# Determine what we should call it.", "klass_name", "=", "self", ".", "_build_class_name", "(", "resource_name", ")", "# Construct what the class ought to have on it.", "attrs", ".", "update", "(", "self", ".", "_build_methods", "(", "details", ")", ")", "if", "base_class", "is", "None", ":", "base_class", "=", "self", ".", "base_resource_class", "# Create the class.", "return", "type", "(", "klass_name", ",", "(", "base_class", ",", ")", ",", "attrs", ")" ]

[ "Builds", "a", "new", "specialized", "Resource", "subclass", "as", "part", "of", "a", "given", "service", "." ]

[ "def", "filter_headers", "(", "criterion", ")", ":", "ip", "=", "get_ipython", "(", ")", "for", "headerkind", "in", "[", "'processed'", ",", "'raw'", "]", ":", "for", "h", "in", "ip", ".", "user_ns", "[", "'_headers'", "]", "[", "headerkind", "]", "[", ":", "]", ":", "if", "not", "criterion", "(", "h", ")", ":", "ip", ".", "user_ns", "[", "'_headers'", "]", "[", "headerkind", "]", ".", "remove", "(", "h", ")", "ip", ".", "user_ns", "[", "'allsamplenames'", "]", "=", "{", "h", ".", "title", "for", "h", "in", "ip", ".", "user_ns", "[", "'_headers'", "]", "[", "'processed'", "]", "}" ]

[ "Filter", "already", "loaded", "headers", "against", "some", "criterion", "." ]

[ "def", "load_headers", "(", "fsns", ":", "List", "[", "int", "]", ")", ":", "ip", "=", "get_ipython", "(", ")", "ip", ".", "user_ns", "[", "'_headers'", "]", "=", "{", "}", "for", "type_", "in", "[", "'raw'", ",", "'processed'", "]", ":", "print", "(", "\"Loading %d headers (%s)\"", "%", "(", "len", "(", "fsns", ")", ",", "type_", ")", ",", "flush", "=", "True", ")", "processed", "=", "type_", "==", "'processed'", "headers", "=", "[", "]", "for", "f", "in", "fsns", ":", "for", "l", "in", "[", "l_", "for", "l_", "in", "ip", ".", "user_ns", "[", "'_loaders'", "]", "if", "l_", ".", "processed", "==", "processed", "]", ":", "try", ":", "headers", ".", "append", "(", "l", ".", "loadheader", "(", "f", ")", ")", "break", "except", "FileNotFoundError", ":", "continue", "allsamplenames", "=", "{", "h", ".", "title", "for", "h", "in", "headers", "}", "if", "not", "headers", ":", "print", "(", "'NO HEADERS READ FOR TYPE \"%s\"'", "%", "type_", ")", "else", ":", "print", "(", "\"%d headers (%s) out of %d have been loaded successfully.\"", "%", "(", "len", "(", "headers", ")", ",", "type_", ",", "len", "(", "fsns", ")", ")", ")", "print", "(", "'Read FSN range:'", ",", "min", "(", "[", "h", ".", "fsn", "for", "h", "in", "headers", "]", ")", ",", "'to'", ",", "max", "(", "[", "h", ".", "fsn", "for", "h", "in", "headers", "]", ")", ")", "print", "(", "\"Samples covered by these headers:\"", ")", "print", "(", "\" \"", "+", "\"\\n \"", ".", "join", "(", "sorted", "(", "allsamplenames", ")", ")", ",", "flush", "=", "True", ")", "if", "processed", ":", "ip", ".", "user_ns", "[", "'allsamplenames'", "]", "=", "allsamplenames", "ip", ".", "user_ns", "[", "'_headers'", "]", "[", "type_", "]", "=", "headers" ]

[ "Load", "header", "files" ]

[ "def", "get_size", "(", "path", ")", ":", "size", "=", "os", ".", "path", ".", "getsize", "(", "path", ")", "for", "item", "in", "os", ".", "walk", "(", "path", ")", ":", "for", "file", "in", "item", "[", "2", "]", ":", "size", "+=", "os", ".", "path", ".", "getsize", "(", "os", ".", "path", ".", "join", "(", "item", "[", "0", "]", ",", "file", ")", ")", "return", "size" ]

[ "Return", "the", "size", "of", "path", "in", "bytes", "if", "it", "exists", "and", "can", "be", "determined", "." ]

[ "def", "local_data", "(", "path", ")", ":", "dirs", "=", "[", "os", ".", "path", ".", "join", "(", "path", ",", "item", ")", "for", "item", "in", "os", ".", "listdir", "(", "path", ")", "]", "names", ",", "sizes", ",", "files", "=", "zip", "(", "*", "[", "(", "dir", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", ",", "str", "(", "get_size", "(", "dir", ")", ")", ",", "'##'", ".", "join", "(", "[", "file", "for", "file", "in", "os", ".", "listdir", "(", "dir", ")", "]", ")", ")", "for", "dir", "in", "dirs", "]", ")", "return", "zip", "(", "names", ",", "dirs", ",", "sizes", ",", "files", ")" ]

[ "Return", "tuples", "of", "names", "directories", "total", "sizes", "and", "files", ".", "Each", "directory", "represents", "a", "single", "film", "and", "the", "files", "are", "the", "files", "contained", "in", "the", "directory", "such", "as", "video", "audio", "and", "subtitle", "files", "." ]

[ "def", "create", "(", ")", ":", "if", "not", "all", "(", "map", "(", "os", ".", "path", ".", "isdir", ",", "ARGS", ".", "directory", ")", ")", ":", "exit", "(", "'Error: One or more of the specified directories does not exist.'", ")", "with", "sqlite3", ".", "connect", "(", "ARGS", ".", "database", ")", "as", "connection", ":", "connection", ".", "text_factory", "=", "str", "cursor", "=", "connection", ".", "cursor", "(", ")", "cursor", ".", "execute", "(", "'DROP TABLE IF EXISTS Movies'", ")", "cursor", ".", "execute", "(", "'''CREATE TABLE Movies(name TEXT, path TEXT, size TEXT,\n files BLOB)'''", ")", "for", "dir", "in", "ARGS", ".", "directory", ":", "cursor", ".", "executemany", "(", "'INSERT INTO Movies VALUES(?, ?, ?, ?)'", ",", "local_data", "(", "dir", ")", ")" ]

[ "Create", "a", "new", "database", "with", "information", "about", "the", "films", "in", "the", "specified", "directory", "or", "directories", "." ]

[ "def", "ls", "(", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "ARGS", ".", "database", ")", ":", "exit", "(", "'Error: The database does not exist; you must create it first.'", ")", "with", "sqlite3", ".", "connect", "(", "ARGS", ".", "database", ")", "as", "connection", ":", "connection", ".", "text_factory", "=", "str", "cursor", "=", "connection", ".", "cursor", "(", ")", "if", "ARGS", ".", "pattern", ":", "if", "not", "ARGS", ".", "strict", ":", "ARGS", ".", "pattern", "=", "'%{0}%'", ".", "format", "(", "ARGS", ".", "pattern", ")", "cursor", ".", "execute", "(", "'SELECT * FROM Movies WHERE Name LIKE (?)'", ",", "[", "ARGS", ".", "pattern", "]", ")", "else", ":", "cursor", ".", "execute", "(", "'SELECT * FROM Movies'", ")", "movies", "=", "sorted", "(", "[", "row", "for", "row", "in", "cursor", "]", ")", "if", "ARGS", ".", "name", ":", "print", "'\\n'", ".", "join", "(", "[", "movie", "[", "0", "]", "for", "movie", "in", "movies", "]", ")", "elif", "ARGS", ".", "location", ":", "print", "'\\n'", ".", "join", "(", "[", "movie", "[", "1", "]", "for", "movie", "in", "movies", "]", ")", "elif", "ARGS", ".", "size", ":", "print", "'\\n'", ".", "join", "(", "[", "prefix_size", "(", "int", "(", "movie", "[", "2", "]", ")", ")", "for", "movie", "in", "movies", "]", ")", "elif", "ARGS", ".", "files", ":", "for", "movie", "in", "movies", ":", "print", "', '", ".", "join", "(", "movie", "[", "3", "]", ".", "split", "(", "'##'", ")", ")", "else", ":", "for", "i", ",", "movie", "in", "enumerate", "(", "movies", ")", ":", "print", "'Name:\\t\\t{0}'", ".", "format", "(", "movie", "[", "0", "]", ")", "print", "'Location:\\t{0}'", ".", "format", "(", "movie", "[", "1", "]", ")", "print", "'Size:\\t\\t{0}'", ".", "format", "(", "prefix_size", "(", "int", "(", "movie", "[", "2", "]", ")", ")", ")", "print", "'Files:\\t\\t{0}'", ".", "format", "(", "', '", ".", "join", "(", "movie", "[", "3", "]", ".", "split", "(", "'##'", ")", ")", ")", "if", "not", "i", "==", "len", "(", "movies", ")", "-", "1", ":", "print" ]

[ "List", "all", "items", "in", "the", "database", "in", "a", "predefined", "format", "." ]

[ "def", "play", "(", ")", ":", "with", "sqlite3", ".", "connect", "(", "ARGS", ".", "database", ")", "as", "connection", ":", "connection", ".", "text_factory", "=", "str", "cursor", "=", "connection", ".", "cursor", "(", ")", "if", "ARGS", ".", "pattern", ":", "if", "not", "ARGS", ".", "strict", ":", "ARGS", ".", "pattern", "=", "'%{0}%'", ".", "format", "(", "ARGS", ".", "pattern", ")", "cursor", ".", "execute", "(", "'SELECT * FROM Movies WHERE Name LIKE (?)'", ",", "[", "ARGS", ".", "pattern", "]", ")", "try", ":", "path", "=", "sorted", "(", "[", "row", "for", "row", "in", "cursor", "]", ")", "[", "0", "]", "[", "1", "]", "replace_map", "=", "{", "' '", ":", "'\\\\ '", ",", "'\"'", ":", "'\\\\\"'", ",", "\"'\"", ":", "\"\\\\'\"", "}", "for", "key", ",", "val", "in", "replace_map", ".", "iteritems", "(", ")", ":", "path", "=", "path", ".", "replace", "(", "key", ",", "val", ")", "os", ".", "system", "(", "'{0} {1} &'", ".", "format", "(", "ARGS", ".", "player", ",", "path", ")", ")", "except", "IndexError", ":", "exit", "(", "'Error: Movie not found.'", ")" ]

[ "Open", "the", "matched", "movie", "with", "a", "media", "player", "." ]

[ "def", "random_string", "(", "length", ",", "numeric_only", "=", "False", ")", ":", "choices", "=", "string", ".", "digits", "if", "numeric_only", "else", "string", ".", "ascii_uppercase", "+", "string", ".", "digits", "return", "''", ".", "join", "(", "random", ".", "choice", "(", "choices", ")", "for", "_", "in", "range", "(", "length", ")", ")" ]

[ "Generates", "a", "random", "string", "of", "length", "equal", "to", "the", "length", "parameter" ]

[ "def", "random_date", "(", "start_year", "=", "2000", ",", "end_year", "=", "2020", ")", ":", "return", "date", "(", "random", ".", "randint", "(", "start_year", ",", "end_year", ")", ",", "random", ".", "randint", "(", "1", ",", "12", ")", ",", "random", ".", "randint", "(", "1", ",", "28", ")", ")" ]

[ "Generates", "a", "random", "sensible", "date", "for", "use", "in", "things", "like", "issue", "dates", "and", "maturities" ]

[ "def", "_finite_well_energy", "(", "P", ",", "n", "=", "1", ",", "atol", "=", "1e-6", ")", ":", "assert", "n", ">", "0", "and", "n", "<=", "_finite_well_states", "(", "P", ")", "pi_2", "=", "pi", "/", "2.", "r", "=", "(", "1", "/", "(", "P", "+", "pi_2", ")", ")", "*", "(", "n", "*", "pi_2", ")", "eta", "=", "n", "*", "pi_2", "-", "arcsin", "(", "r", ")", "-", "r", "*", "P", "w", "=", "1", "# relaxation parameter (for succesive relaxation)", "while", "True", ":", "assert", "r", "<=", "1", "if", "abs", "(", "eta", ")", "<", "atol", ":", "break", "r2", "=", "r", "**", "2.", "sqrt_1mr2", "=", "sqrt", "(", "1.", "-", "r2", ")", "denom", "=", "(", "1.", "+", "P", "*", "sqrt_1mr2", ")", "t1", "=", "P", "*", "sqrt_1mr2", "/", "denom", "*", "eta", "# t2 = -r * P / (2 * (1. + P * sqrt_1mr2) ** 3) * eta ** 2", "while", "True", ":", "next_r", "=", "(", "1", "-", "w", ")", "*", "r", "+", "w", "*", "(", "r", "+", "t1", ")", "# next_r = (1 - w) * r + w * (r + t1 + t2)", "next_eta", "=", "n", "*", "pi_2", "-", "arcsin", "(", "next_r", ")", "-", "next_r", "*", "P", "# decrease w until eta is converging", "if", "abs", "(", "next_eta", "/", "eta", ")", "<", "1", ":", "r", "=", "next_r", "eta", "=", "next_eta", "break", "else", ":", "w", "*=", "0.5", "alpha", "=", "P", "*", "r", "E", "=", "2", "*", "(", "alpha", ")", "**", "2", "# hbar**2 / (m * L**2)", "return", "E" ]

[ "Returns", "the", "nth", "bound", "-", "state", "energy", "for", "a", "finite", "-", "potential", "quantum", "well", "with", "the", "given", "well", "-", "strength", "parameter", "P", "." ]

[ "def", "top", "(", "self", ",", "n", "=", "10", ",", "cache", "=", "None", ",", "prefetch", "=", "False", ")", ":", "use_cache", "=", "self", ".", "_use_cache", "(", "cache", ")", "if", "use_cache", "and", "len", "(", "self", ".", "_top_cache", ")", ">=", "n", ":", "return", "self", ".", "_top_cache", "[", ":", "n", "]", "soup", "=", "get", "(", "TOP", ")", ".", "soup", "links", "=", "soup", ".", "find_all", "(", "\"a\"", ",", "class_", "=", "\"detLink\"", ")", "[", ":", "n", "]", "urls", "=", "[", "urlparse", ".", "urljoin", "(", "TOP", ",", "link", ".", "get", "(", "'href'", ")", ")", "for", "link", "in", "links", "]", "torrents", "=", "[", "self", ".", "torrent_from_url", "(", "url", ",", "use_cache", ",", "prefetch", ")", "for", "url", "in", "urls", "]", "if", "use_cache", ":", "self", ".", "_top_cache", "=", "torrents", "self", ".", "_add_to_torrent_cache", "(", "torrents", ")", "return", "torrents" ]

[ "Find", "the", "most", "popular", "torrents", "." ]

[ "def", "torrent_from_url", "(", "self", ",", "url", ",", "cache", "=", "True", ",", "prefetch", "=", "False", ")", ":", "if", "self", ".", "_use_cache", "(", "cache", ")", "and", "url", "in", "self", ".", "_torrent_cache", ":", "return", "self", ".", "_torrent_cache", "[", "url", "]", "torrent", "=", "Torrent", "(", "url", ",", "cache", ",", "prefetch", ")", "if", "cache", ":", "self", ".", "_torrent_cache", "[", "url", "]", "=", "torrent", "return", "torrent" ]

[ "Create", "a", "Torrent", "object", "from", "a", "given", "URL", "." ]

[ "def", "_send_command", "(", "self", ",", "command", ",", "immediate", "=", "False", ",", "timeout", "=", "1.0", ",", "check_echo", "=", "None", ")", ":", "# Use the default echo checking if None was given.", "if", "check_echo", "is", "None", ":", "check_echo", "=", "self", ".", "_check_echo", "# Convert to bytes and then strip comments, whitespace, and", "# newlines.", "if", "sys", ".", "hexversion", ">=", "0x03000000", ":", "c", "=", "bytes", "(", "command", ",", "encoding", "=", "'ASCII'", ")", "else", ":", "c", "=", "command", "c", "=", "c", ".", "split", "(", "b';'", ")", "[", "0", "]", ".", "strip", "(", ")", "# If the command is supposed to be immediate, insure that it", "# starts with an '!'.", "if", "immediate", "and", "not", "c", ".", "startswith", "(", "b'!'", ")", ":", "c", "=", "b'!'", "+", "c", "# Read out any junk on the serial port before we start.", "self", ".", "_ser", ".", "read", "(", "self", ".", "_ser", ".", "inWaiting", "(", ")", ")", "# The command needs to be written a character at a time with", "# pauses between them to make sure nothing gets lost or", "# corrupted. This is a simple loop if we are not checking the", "# echo. If we are, it is more complicated.", "if", "not", "check_echo", ":", "for", "i", "in", "range", "(", "0", ",", "len", "(", "c", ")", ")", ":", "self", ".", "_ser", ".", "write", "(", "bytes", "(", "[", "c", "[", "i", "]", "]", ")", ")", "time", ".", "sleep", "(", "0.01", ")", "else", ":", "# Infinite timeouts need to be converted to None. Finite", "# ones need to be checked to make sure they are not too big,", "# which is threading.TIMEOUT_MAX on Python 3.x and not", "# specified on Python 2.x (lets use a week).", "if", "timeout", "is", "None", "or", "timeout", "<=", "0", ":", "timeout", "=", "None", "else", ":", "if", "sys", ".", "hexversion", ">=", "0x03000000", ":", "maxtimeout", "=", "threading", ".", "TIMEOUT_MAX", "else", ":", "maxtimeout", "=", "7", "*", "24", "*", "3600", "timeout", "=", "min", "(", "timeout", ",", "maxtimeout", ")", "# A timer will be made that takes timeout to finish. Then,", "# it is a matter of checking whether it is alive or not to", "# know whether the timeout was exceeded or not. Then, the", "# timer is started.", "tm", "=", "threading", ".", "Timer", "(", "timeout", ",", "lambda", ":", "None", ")", "tm", ".", "start", "(", ")", "# Each character needs to be written one by one while the", "# echo is collected. If any mistakes occur, they need to be", "# corrected with backspaces b'\\x08'. The echo starts out", "# empty. We go until either the echo is identical to the", "# command or the timeout is exceeded.", "echo", "=", "b''", "while", "c", "!=", "echo", "and", "tm", ".", "is_alive", "(", ")", ":", "# If there are no mistakes, then echo will be the", "# beginning of c meaning the next character can be", "# written. Otherwise, there is a mistake and a backspace", "# needs to be written.", "if", "c", ".", "startswith", "(", "echo", ")", ":", "self", ".", "_ser", ".", "write", "(", "bytes", "(", "[", "c", "[", "len", "(", "echo", ")", "]", "]", ")", ")", "else", ":", "self", ".", "_ser", ".", "write", "(", "b'\\x08'", ")", "# Pause for a bit to make sure nothing gets lost. Then", "# read the drive's output add it to the echo.", "time", ".", "sleep", "(", "0.01", ")", "echo", "+=", "self", ".", "_ser", ".", "read", "(", "self", ".", "_ser", ".", "inWaiting", "(", ")", ")", "# All backspaces in echo need to be processed. Each", "# backspace deletes itself and the character before it", "# (if any).", "while", "b'\\x08'", "in", "echo", ":", "index", "=", "echo", ".", "index", "(", "b'\\x08'", ")", "if", "index", "==", "0", ":", "echo", "=", "echo", "[", "1", ":", "]", "else", ":", "echo", "=", "echo", "[", "0", ":", "(", "index", "-", "1", ")", "]", "+", "echo", "[", "(", "index", "+", "1", ")", ":", "]", "# Turn off the timer in the case that it is still running", "# (command completely written before timeout).", "tm", ".", "cancel", "(", ")", "# Write the carriage return to enter the command and then return", "# the sanitized command.", "self", ".", "_ser", ".", "write", "(", "b'\\r'", ")", "if", "sys", ".", "hexversion", ">=", "0x03000000", ":", "return", "c", ".", "decode", "(", "errors", "=", "'replace'", ")", "else", ":", "return", "c" ]

[ "Send", "a", "single", "command", "to", "the", "drive", "after", "sanitizing", "it", "." ]

[ "def", "_get_response", "(", "self", ",", "timeout", "=", "1.0", ",", "eor", "=", "(", "'\\n'", ",", "'\\n- '", ")", ")", ":", "# If no timeout is given or it is invalid and we are using '\\n'", "# as the eor, use the wrapper to read a line with an infinite", "# timeout. Otherwise, the reading and timeout must be", "# implemented manually.", "if", "(", "timeout", "is", "None", "or", "timeout", "<", "0", ")", "and", "eor", "==", "'\\n'", ":", "return", "self", ".", "_sio", ".", "readline", "(", ")", "else", ":", "# A timer will be made that takes timeout to finish. Then,", "# it is a matter of checking whether it is alive or not to", "# know whether the timeout was exceeded or not. They need to", "# be checked to make sure they are not too big, which is", "# threading.TIMEOUT_MAX on Python 3.x and not specified on", "# Python 2.x (lets use a week). Then, the timer is started.", "if", "sys", ".", "hexversion", ">=", "0x03000000", ":", "maxtimeout", "=", "threading", ".", "TIMEOUT_MAX", "else", ":", "maxtimeout", "=", "7", "*", "24", "*", "3600", "timeout", "=", "min", "(", "timeout", ",", "maxtimeout", ")", "tm", "=", "threading", ".", "Timer", "(", "timeout", ",", "lambda", ":", "None", ")", "tm", ".", "start", "(", ")", "# eor needs to be converted to bytes. If it is just an str,", "# it needs to be wrapped in a tuple.", "if", "isinstance", "(", "eor", ",", "str", ")", ":", "eor", "=", "tuple", "(", "[", "eor", "]", ")", "if", "sys", ".", "hexversion", ">=", "0x03000000", ":", "eor", "=", "[", "s", ".", "encode", "(", "encoding", "=", "'ASCII'", ")", "for", "s", "in", "eor", "]", "# Read from the serial port into buf until the EOR is found", "# or the timer has stopped. A small pause is done each time", "# so that this thread doesn't hog the CPU.", "buf", "=", "b''", "while", "not", "any", "(", "[", "(", "x", "in", "buf", ")", "for", "x", "in", "eor", "]", ")", "and", "tm", ".", "is_alive", "(", ")", ":", "time", ".", "sleep", "(", "0.001", ")", "buf", "+=", "self", ".", "_ser", ".", "read", "(", "self", ".", "_ser", ".", "inWaiting", "(", ")", ")", "# Just in case the timer has not stopped (EOR was found),", "# stop it.", "tm", ".", "cancel", "(", ")", "# Remove anything after the EOR if there is one. First, a", "# set of matches (index, eor_str) for each string in eor", "# needs to be constructed. Sorting the matches by their", "# index puts all the ones that were not found (index of -1)", "# at the front. Then a list of bools that are True for each", "# index that isn't -1 is made, converted to a bytes (True", "# goes to b'\\x01' and False goes to b'\\x00'), and then the", "# index of the first True value found. If it is not -1, then", "# there was a successful match and all the characters are", "# dropped after that eor_str.", "matches", "=", "[", "(", "buf", ".", "find", "(", "x", ")", ",", "x", ")", "for", "x", "in", "eor", "]", "matches", ".", "sort", "(", "key", "=", "lambda", "x", ":", "x", "[", "0", "]", ")", "index", "=", "bytes", "(", "[", "x", "[", "0", "]", "!=", "-", "1", "for", "x", "in", "matches", "]", ")", ".", "find", "(", "b'\\x01'", ")", "if", "index", "!=", "-", "1", ":", "buf", "=", "buf", "[", ":", "(", "matches", "[", "index", "]", "[", "0", "]", "+", "len", "(", "matches", "[", "index", "]", "[", "1", "]", ")", ")", "]", "# Convert to an str before returning.", "if", "sys", ".", "hexversion", ">=", "0x03000000", ":", "return", "buf", ".", "decode", "(", "errors", "=", "'replace'", ")", "else", ":", "return", "buf" ]

[ "Reads", "a", "response", "from", "the", "drive", "." ]

[ "def", "_process_response", "(", "self", ",", "response", ")", ":", "# Strip the trailing newline and split the response into lines", "# by carriage returns.", "rsp_lines", "=", "response", ".", "rstrip", "(", "'\\r\\n'", ")", ".", "split", "(", "'\\r'", ")", "# If we have at least one line, the first one is the echoed", "# command. If available, it needs to be grabbed and that line", "# removed from rsp_lines since it is just the echoing, not the", "# actual response to the command. None will be used to denote a", "# non-existent echo.", "if", "len", "(", "rsp_lines", ")", ">", "0", ":", "echoed_command", "=", "rsp_lines", "[", "0", "]", "del", "rsp_lines", "[", "0", "]", "else", ":", "echoed_command", "=", "None", "# If the next line is one of the different possible error", "# strings, then there was an error that must be grabbed (leading", "# '*' is stripped). If there was an error, remove that line from", "# the response. None will be used to denote the lack of an error.", "if", "len", "(", "rsp_lines", ")", ">", "0", "and", "rsp_lines", "[", "0", "]", "in", "(", "'*INVALID_ADDRESS'", ",", "'*INVALID_DATA'", ",", "'*INVALID_DATA_HIGH'", ",", "'*INVALID_DATA_LOW'", ",", "'*UNDEFINED_LABEL'", ")", ":", "err", "=", "rsp_lines", "[", "0", "]", "[", "1", ":", "]", "del", "rsp_lines", "[", "0", "]", "else", ":", "err", "=", "None", "return", "[", "response", ",", "echoed_command", ",", "err", ",", "rsp_lines", "]" ]

[ "Processes", "a", "response", "from", "the", "drive", "." ]

[ "def", "send_command", "(", "self", ",", "command", ",", "immediate", "=", "False", ",", "timeout", "=", "1.0", ",", "max_retries", "=", "0", ",", "eor", "=", "(", "'\\n'", ",", "'\\n- '", ")", ")", ":", "# Execute the command till it either doesn't have an error or", "# the maximum number of retries is exceeded.", "for", "i", "in", "range", "(", "0", ",", "max_retries", "+", "1", ")", ":", "# Send the command and stuff the sanitized version in a", "# list. Then process the response and add it to the list.", "response", "=", "[", "self", ".", "_send_command", "(", "command", ",", "immediate", "=", "immediate", ")", "]", "output", "=", "self", ".", "_get_response", "(", "timeout", "=", "timeout", ",", "eor", "=", "eor", ")", "# If echo checking was done, the echo was already grabbed,", "# is identical to the command, and needs to be placed back", "# in front of the output so that it can be processed", "# properly.", "if", "self", ".", "_check_echo", ":", "output", "=", "response", "[", "0", "]", "+", "output", "response", ".", "extend", "(", "self", ".", "_process_response", "(", "output", ")", ")", "# We are done if there is no error.", "if", "not", "self", ".", "command_error", "(", "response", ")", ":", "break", "# Put in a slight pause so the drive has a bit of breathing", "# time between retries.", "time", ".", "sleep", "(", "0.25", ")", "return", "response" ]

[ "Sends", "a", "single", "command", "to", "the", "drive", "and", "returns", "output", "." ]

[ "def", "send_commands", "(", "self", ",", "commands", ",", "timeout", "=", "1.0", ",", "max_retries", "=", "1", ",", "eor", "=", "(", "'\\n'", ",", "'\\n- '", ")", ")", ":", "# If eor is not a list, make a list of it replicated enough for", "# every command.", "if", "not", "isinstance", "(", "eor", ",", "list", ")", ":", "eor", "=", "[", "eor", "]", "*", "len", "(", "commands", ")", "# Do every command one by one, collecting the responses and", "# stuffing them in a list. Commands that failed are retried, and", "# we stop if the last retry is exhausted.", "responses", "=", "[", "]", "for", "i", ",", "command", "in", "enumerate", "(", "commands", ")", ":", "rsp", "=", "self", ".", "send_command", "(", "command", ",", "timeout", "=", "timeout", ",", "max_retries", "=", "max_retries", ",", "eor", "=", "eor", "[", "i", "]", ")", "responses", ".", "append", "(", "rsp", ")", "if", "self", ".", "command_error", "(", "rsp", ")", ":", "break", "# Put in a slight pause so the drive has a bit of breathing", "# time between commands.", "time", ".", "sleep", "(", "0.25", ")", "return", "responses" ]

[ "Send", "a", "sequence", "of", "commands", "to", "the", "drive", "and", "collect", "output", "." ]

[ "def", "low_level_scan", "(", "self", ",", "verification_resource", ",", "scan_profile_resource", ",", "path_list", ",", "notification_resource_list", ")", ":", "data", "=", "{", "\"verification_href\"", ":", "verification_resource", ".", "href", ",", "\"profile_href\"", ":", "scan_profile_resource", ".", "href", ",", "\"start_time\"", ":", "\"now\"", ",", "\"email_notifications_href\"", ":", "[", "n", ".", "href", "for", "n", "in", "notification_resource_list", "]", ",", "\"path_list\"", ":", "path_list", "}", "url", "=", "self", ".", "build_full_url", "(", "'/scans/'", ")", "return", "self", ".", "create_resource", "(", "url", ",", "data", ")" ]

[ "Low", "level", "implementation", "of", "the", "scan", "launch", "which", "allows", "you", "to", "start", "a", "new", "scan", "when", "you", "already", "know", "the", "ids", "for", "the", "required", "resources", "." ]

[ "def", "setAsApplication", "(", "myappid", ")", ":", "if", "os", ".", "name", "==", "'nt'", ":", "import", "ctypes", "ctypes", ".", "windll", ".", "shell32", ".", "SetCurrentProcessExplicitAppUserModelID", "(", "myappid", ")" ]

[ "Tells", "Windows", "this", "is", "an", "independent", "application", "with", "an", "unique", "icon", "on", "task", "bar", "." ]

[ "def", "getBestTranslation", "(", "basedir", ",", "lang", "=", "None", ")", ":", "if", "not", "lang", ":", "lang", "=", "QtCore", ".", "QLocale", ".", "system", "(", ")", ".", "uiLanguages", "(", ")", "for", "l", "in", "lang", ":", "l", "=", "l", ".", "translate", "(", "{", "ord", "(", "'_'", ")", ":", "'-'", "}", ")", "f", "=", "os", ".", "path", ".", "join", "(", "basedir", ",", "l", "+", "'.qm'", ")", "if", "os", ".", "path", ".", "isfile", "(", "f", ")", ":", "break", "l", "=", "l", ".", "translate", "(", "{", "ord", "(", "'-'", ")", ":", "'_'", "}", ")", "f", "=", "os", ".", "path", ".", "join", "(", "basedir", ",", "l", "+", "'.qm'", ")", "if", "os", ".", "path", ".", "isfile", "(", "f", ")", ":", "break", "l", "=", "l", ".", "split", "(", "'_'", ")", "[", "0", "]", "f", "=", "os", ".", "path", ".", "join", "(", "basedir", ",", "l", "+", "'.qm'", ")", "if", "os", ".", "path", ".", "isfile", "(", "f", ")", ":", "break", "else", ":", "return", "None", "translator", "=", "QtCore", ".", "QTranslator", "(", ")", "translator", ".", "load", "(", "f", ")", "return", "translator" ]

[ "Find", "inside", "basedir", "the", "best", "translation", "available", "." ]

[ "def", "normalize", "(", "cls", ",", "name", ")", ":", "name", "=", "name", ".", "lower", "(", ")", "# lower-case", "for", "_replace", "in", "[", "' '", ",", "'-'", ",", "'('", ",", "')'", ",", "'?'", "]", ":", "name", "=", "name", ".", "replace", "(", "_replace", ",", "''", ")", "return", "name" ]

[ "Return", "string", "in", "all", "lower", "case", "with", "spaces", "and", "question", "marks", "removed" ]

[ "def", "nein", "(", "x", ")", ":", "if", "not", "isinstance", "(", "x", ",", "(", "bool", ",", "ThreeVL", ")", ")", ":", "raise", "TypeError", "(", "type", "(", "x", ")", ")", "return", "not", "x", "if", "isinstance", "(", "x", ",", "bool", ")", "else", "ThreeVL", "(", "dict", "(", "t", "=", "'f'", ",", "f", "=", "'t'", ",", "u", "=", "'u'", ")", "[", "x", ".", "value", "]", ")" ]

[ "this", "is", "not", "but", "not", "is", "a", "keyword", "so", "it", "s", "nein" ]

[ "def", "compare", "(", "operator", ",", "a", ",", "b", ")", ":", "# todo(awinter): what about nested 3vl like \"(a=b)=(c=d)\". is that allowed by sql? It will choke here if there's a null involved.", "f", "=", "(", "{", "'='", ":", "lambda", "a", ",", "b", ":", "a", "==", "b", ",", "'!='", ":", "lambda", "a", ",", "b", ":", "a", "!=", "b", ",", "'>'", ":", "lambda", "a", ",", "b", ":", "a", ">", "b", ",", "'<'", ":", "lambda", "a", ",", "b", ":", "a", "<", "b", "}", "[", "operator", "]", ")", "return", "ThreeVL", "(", "'u'", ")", "if", "None", "in", "(", "a", ",", "b", ")", "else", "f", "(", "a", ",", "b", ")" ]

[ "this", "could", "be", "replaced", "by", "overloading", "but", "I", "want", "==", "to", "return", "a", "bool", "for", "in", "use" ]

[ "def", "login", "(", "request", ",", "signature", ")", ":", "signer", "=", "TimestampSigner", "(", ")", "try", ":", "pk", "=", "signer", ".", "unsign", "(", "signature", ",", "max_age", "=", "MAX_AGE_OF_SIGNATURE_IN_SECONDS", ")", "except", "(", "BadSignature", ",", "SignatureExpired", ")", "as", "e", ":", "return", "HttpResponseForbidden", "(", "\"Can't log you in\"", ")", "user", "=", "get_object_or_404", "(", "get_user_model", "(", ")", ",", "pk", "=", "pk", ")", "# we *have* to set the backend for this user, so we just use the first one", "user", ".", "backend", "=", "settings", ".", "AUTHENTICATION_BACKENDS", "[", "0", "]", "django_login", "(", "request", ",", "user", ")", "return", "HttpResponseRedirect", "(", "settings", ".", "LOGIN_REDIRECT_URL", ")" ]

[ "Automatically", "logs", "in", "a", "user", "based", "on", "a", "signed", "PK", "of", "a", "user", "object", ".", "The", "signature", "should", "be", "generated", "with", "the", "login", "management", "command", "." ]

[ "def", "cloak", "(", "request", ",", "pk", "=", "None", ")", ":", "pk", "=", "request", ".", "POST", ".", "get", "(", "'pk'", ",", "pk", ")", "if", "pk", "is", "None", ":", "return", "HttpResponse", "(", "\"You need to pass a pk POST parameter, or include it in the URL\"", ")", "user", "=", "get_object_or_404", "(", "get_user_model", "(", ")", ",", "pk", "=", "pk", ")", "if", "not", "can_cloak_as", "(", "request", ".", "user", ",", "user", ")", ":", "return", "HttpResponseForbidden", "(", "\"You are not allowed to cloak as this user\"", ")", "request", ".", "session", "[", "SESSION_USER_KEY", "]", "=", "user", ".", "pk", "# save the referer information so when uncloaking, we can redirect the user", "# back to where they were", "request", ".", "session", "[", "SESSION_REDIRECT_KEY", "]", "=", "request", ".", "META", ".", "get", "(", "\"HTTP_REFERER\"", ",", "settings", ".", "LOGIN_REDIRECT_URL", ")", "# redirect the cloaked user to the URL specified in the \"next\" parameter,", "# or to the default redirect URL", "return", "HttpResponseRedirect", "(", "request", ".", "POST", ".", "get", "(", "REDIRECT_FIELD_NAME", ",", "settings", ".", "LOGIN_REDIRECT_URL", ")", ")" ]

[ "Masquerade", "as", "a", "particular", "user", "and", "redirect", "based", "on", "the", "REDIRECT_FIELD_NAME", "parameter", "or", "the", "LOGIN_REDIRECT_URL", "." ]

[ "def", "select_template_from_string", "(", "arg", ")", ":", "if", "','", "in", "arg", ":", "tpl", "=", "loader", ".", "select_template", "(", "[", "tn", ".", "strip", "(", ")", "for", "tn", "in", "arg", ".", "split", "(", "','", ")", "]", ")", "else", ":", "tpl", "=", "loader", ".", "get_template", "(", "arg", ")", "return", "tpl" ]

[ "Select", "a", "template", "from", "a", "string", "which", "can", "include", "multiple", "template", "paths", "separated", "by", "commas", "." ]

[ "def", "_get_package_path", "(", "self", ")", ":", "if", "not", "self", ".", "package", ":", "return", "[", "]", "if", "not", "hasattr", "(", "self", ",", "'package_path'", ")", ":", "m", "=", "__import__", "(", "self", ".", "package", ")", "parts", "=", "self", ".", "package", ".", "split", "(", "'.'", ")", "[", "1", ":", "]", "self", ".", "package_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "m", ".", "__file__", ")", ",", "*", "parts", ")", "return", "[", "self", ".", "package_path", "]" ]

[ "Gets", "the", "path", "of", "a", "Python", "package" ]

[ "def", "_get_paths", "(", "self", ")", ":", "ret", "=", "[", "]", "ret", "+=", "[", "'%s/library/'", "%", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ")", "]", "ret", "+=", "self", ".", "_extra_dirs", "for", "basedir", "in", "_basedirs", ":", "fullpath", "=", "os", ".", "path", ".", "join", "(", "basedir", ",", "self", ".", "subdir", ")", "if", "fullpath", "not", "in", "ret", ":", "ret", ".", "append", "(", "fullpath", ")", "ret", "+=", "self", ".", "config", ".", "split", "(", "os", ".", "pathsep", ")", "ret", "+=", "self", ".", "_get_package_path", "(", ")", "return", "ret" ]

[ "Return", "a", "list", "of", "paths", "to", "search", "for", "plugins", "in" ]

[ "def", "print_paths", "(", "self", ")", ":", "# Uses a list to get the order right", "ret", "=", "[", "]", "for", "i", "in", "self", ".", "_get_paths", "(", ")", ":", "if", "i", "not", "in", "ret", ":", "ret", ".", "append", "(", "i", ")", "return", "os", ".", "pathsep", ".", "join", "(", "ret", ")" ]

[ "Returns", "a", "string", "suitable", "for", "printing", "of", "the", "search", "path" ]

[ "def", "find_plugin", "(", "self", ",", "name", ")", ":", "suffix", "=", "\".py\"", "if", "not", "self", ".", "class_name", ":", "suffix", "=", "\"\"", "for", "i", "in", "self", ".", "_get_paths", "(", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "i", ",", "\"%s%s\"", "%", "(", "name", ",", "suffix", ")", ")", "if", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "return", "path", "return", "None" ]

[ "Find", "a", "plugin", "named", "name" ]

[ "def", "get_fieldsets", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "result", "=", "super", "(", "EventAdmin", ",", "self", ")", ".", "get_fieldsets", "(", "*", "args", ",", "*", "*", "kwargs", ")", "result", "=", "list", "(", "result", ")", "fields", "=", "list", "(", "result", "[", "0", "]", "[", "1", "]", "[", "'fields'", "]", ")", "for", "name", "in", "(", "'content'", ",", "'start'", ",", "'end'", ",", "'repeat'", ",", "'repeat_until'", ",", "'external_link'", ",", "'calendars'", ")", ":", "fields", ".", "remove", "(", "name", ")", "fields", ".", "append", "(", "name", ")", "result", "[", "0", "]", "[", "1", "]", "[", "'fields'", "]", "=", "tuple", "(", "fields", ")", "return", "tuple", "(", "result", ")" ]

[ "Re", "-", "order", "fields" ]

[ "def", "utc_offset_by_timezone", "(", "timezone_name", ")", ":", "return", "int", "(", "pytz", ".", "timezone", "(", "timezone_name", ")", ".", "utcoffset", "(", "utc_time", "(", ")", ")", ".", "total_seconds", "(", ")", "/", "SECONDS_IN_HOUR", ")" ]

[ "Returns", "the", "UTC", "offset", "of", "the", "given", "timezone", "in", "hours", "." ]

[ "def", "localize_datetime", "(", "datetime_obj", ",", "timezone_name", ")", ":", "return", "datetime_obj", ".", "replace", "(", "tzinfo", "=", "pytz", ".", "utc", ")", ".", "astimezone", "(", "pytz", ".", "timezone", "(", "timezone_name", ")", ")" ]

[ "Localizes", "the", "given", "UTC", "-", "aligned", "datetime", "by", "the", "given", "timezone", "." ]

[ "def", "_load_build", "(", "self", ")", ":", "# if the ctor. function (penultimate on the stack) is the `Ref` class...", "if", "isinstance", "(", "self", ".", "stack", "[", "-", "2", "]", ",", "Ref", ")", ":", "# Ref.__setstate__ will know it's a remote ref if the state is a tuple", "self", ".", "stack", "[", "-", "1", "]", "=", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "self", ".", "node", ")", "self", ".", "load_build", "(", ")", "# continue with the default implementation", "# detect our own refs sent back to us", "ref", "=", "self", ".", "stack", "[", "-", "1", "]", "if", "ref", ".", "uri", ".", "node", "==", "self", ".", "node", ".", "nid", ":", "ref", ".", "is_local", "=", "True", "ref", ".", "_cell", "=", "self", ".", "node", ".", "guardian", ".", "lookup_cell", "(", "ref", ".", "uri", ")", "# dbg((\"dead \" if not ref._cell else \"\") + \"local ref detected\")", "del", "ref", ".", "node", "# local refs never need access to the node", "else", ":", "# pragma: no cover", "self", ".", "load_build", "(", ")" ]

[ "See", "pickle", ".", "py", "in", "Python", "s", "source", "code", "." ]

[ "def", "path_to_zip", "(", "path", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "raise", "IOError", "(", "\"%s doesn't exists!\"", "%", "path", ")", "with", "tempfile", ".", "NamedTemporaryFile", "(", "delete", "=", "False", ")", "as", "ntf", ":", "zip_fn", "=", "ntf", ".", "name", "with", "zipfile", ".", "ZipFile", "(", "zip_fn", ",", "mode", "=", "\"w\"", ")", "as", "zip_file", ":", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "path", ")", ":", "for", "fn", "in", "files", ":", "zip_file", ".", "write", "(", "os", ".", "path", ".", "join", "(", "root", ",", "fn", ")", ")", "return", "zip_fn" ]

[ "Compress", "path", "to", "the", "ZIP", "." ]

[ "def", "read_as_base64", "(", "fn", ")", ":", "with", "open", "(", "fn", ")", "as", "unpacked_file", ":", "with", "tempfile", ".", "TemporaryFile", "(", ")", "as", "b64_file", ":", "base64", ".", "encode", "(", "unpacked_file", ",", "b64_file", ")", "b64_file", ".", "flush", "(", ")", "b64_file", ".", "seek", "(", "0", ")", "return", "b64_file", ".", "read", "(", ")" ]

[ "Convert", "given", "fn", "to", "base64", "and", "return", "it", ".", "This", "method", "does", "the", "process", "in", "not", "-", "so", "-", "much", "memory", "consuming", "way", "." ]

[ "def", "_pad_input", "(", "incoming", ")", ":", "incoming_expanded", "=", "incoming", ".", "replace", "(", "'{'", ",", "'{{'", ")", ".", "replace", "(", "'}'", ",", "'}}'", ")", "for", "key", "in", "_BASE_CODES", ":", "before", ",", "after", "=", "'{{%s}}'", "%", "key", ",", "'{%s}'", "%", "key", "if", "before", "in", "incoming_expanded", ":", "incoming_expanded", "=", "incoming_expanded", ".", "replace", "(", "before", ",", "after", ")", "return", "incoming_expanded" ]

[ "Avoid", "IndexError", "and", "KeyError", "by", "ignoring", "un", "-", "related", "fields", "." ]

[ "def", "_parse_input", "(", "incoming", ")", ":", "codes", "=", "dict", "(", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "_AutoCodes", "(", ")", ".", "items", "(", ")", "if", "'{%s}'", "%", "k", "in", "incoming", ")", "color_codes", "=", "dict", "(", "(", "k", ",", "''", "if", "_AutoCodes", ".", "DISABLE_COLORS", "else", "'\\033[{0}m'", ".", "format", "(", "v", ")", ")", "for", "k", ",", "v", "in", "codes", ".", "items", "(", ")", ")", "incoming_padded", "=", "_pad_input", "(", "incoming", ")", "output_colors", "=", "incoming_padded", ".", "format", "(", "*", "*", "color_codes", ")", "# Simplify: '{b}{red}' -> '\\033[1m\\033[31m' -> '\\033[1;31m'", "groups", "=", "sorted", "(", "set", "(", "_RE_GROUP_SEARCH", ".", "findall", "(", "output_colors", ")", ")", ",", "key", "=", "len", ",", "reverse", "=", "True", ")", "# Get codes, grouped adjacent.", "groups_simplified", "=", "[", "[", "x", "for", "n", "in", "_RE_NUMBER_SEARCH", ".", "findall", "(", "i", ")", "for", "x", "in", "n", ".", "split", "(", "';'", ")", "]", "for", "i", "in", "groups", "]", "groups_compiled", "=", "[", "'\\033[{0}m'", ".", "format", "(", "';'", ".", "join", "(", "g", ")", ")", "for", "g", "in", "groups_simplified", "]", "# Final codes.", "assert", "len", "(", "groups_compiled", ")", "==", "len", "(", "groups", ")", "# For testing.", "output_colors_simplified", "=", "output_colors", "for", "i", "in", "range", "(", "len", "(", "groups", ")", ")", ":", "output_colors_simplified", "=", "output_colors_simplified", ".", "replace", "(", "groups", "[", "i", "]", ",", "groups_compiled", "[", "i", "]", ")", "output_no_colors", "=", "_RE_SPLIT", ".", "sub", "(", "''", ",", "output_colors_simplified", ")", "# Strip any remaining color codes.", "if", "_AutoCodes", ".", "DISABLE_COLORS", ":", "output_colors_simplified", "=", "_RE_NUMBER_SEARCH", ".", "sub", "(", "''", ",", "output_colors_simplified", ")", "return", "output_colors_simplified", ",", "output_no_colors" ]

[ "Performs", "the", "actual", "conversion", "of", "tags", "to", "ANSI", "escaped", "codes", "." ]

[ "def", "list_tags", "(", ")", ":", "codes", "=", "_AutoCodes", "(", ")", "grouped", "=", "set", "(", "[", "(", "k", ",", "'/{0}'", ".", "format", "(", "k", ")", ",", "codes", "[", "k", "]", ",", "codes", "[", "'/{0}'", ".", "format", "(", "k", ")", "]", ")", "for", "k", "in", "codes", "if", "not", "k", ".", "startswith", "(", "'/'", ")", "]", ")", "# Add half-tags like /all.", "found", "=", "[", "c", "for", "r", "in", "grouped", "for", "c", "in", "r", "[", ":", "2", "]", "]", "missing", "=", "set", "(", "[", "(", "''", ",", "r", "[", "0", "]", ",", "None", ",", "r", "[", "1", "]", ")", "if", "r", "[", "0", "]", ".", "startswith", "(", "'/'", ")", "else", "(", "r", "[", "0", "]", ",", "''", ",", "r", "[", "1", "]", ",", "None", ")", "for", "r", "in", "_AutoCodes", "(", ")", ".", "items", "(", ")", "if", "r", "[", "0", "]", "not", "in", "found", "]", ")", "grouped", "|=", "missing", "# Sort.", "payload", "=", "sorted", "(", "[", "i", "for", "i", "in", "grouped", "if", "i", "[", "2", "]", "is", "None", "]", ",", "key", "=", "lambda", "x", ":", "x", "[", "3", "]", ")", "# /all /fg /bg", "grouped", "-=", "set", "(", "payload", ")", "payload", ".", "extend", "(", "sorted", "(", "[", "i", "for", "i", "in", "grouped", "if", "i", "[", "2", "]", "<", "10", "]", ",", "key", "=", "lambda", "x", ":", "x", "[", "2", "]", ")", ")", "# b i u flash", "grouped", "-=", "set", "(", "payload", ")", "payload", ".", "extend", "(", "sorted", "(", "[", "i", "for", "i", "in", "grouped", "if", "i", "[", "0", "]", ".", "startswith", "(", "'auto'", ")", "]", ",", "key", "=", "lambda", "x", ":", "x", "[", "2", "]", ")", ")", "# auto colors", "grouped", "-=", "set", "(", "payload", ")", "payload", ".", "extend", "(", "sorted", "(", "[", "i", "for", "i", "in", "grouped", "if", "not", "i", "[", "0", "]", ".", "startswith", "(", "'hi'", ")", "]", ",", "key", "=", "lambda", "x", ":", "x", "[", "2", "]", ")", ")", "# dark colors", "grouped", "-=", "set", "(", "payload", ")", "payload", ".", "extend", "(", "sorted", "(", "grouped", ",", "key", "=", "lambda", "x", ":", "x", "[", "2", "]", ")", ")", "# light colors", "return", "tuple", "(", "payload", ")" ]

[ "Lists", "the", "available", "tags", "." ]

[ "def", "_set_color", "(", "self", ",", "color_code", ")", ":", "# Get current color code.", "current_fg", ",", "current_bg", "=", "self", ".", "_get_colors", "(", ")", "# Handle special negative codes. Also determine the final color code.", "if", "color_code", "==", "-", "39", ":", "final_color_code", "=", "self", ".", "default_fg", "|", "current_bg", "# Reset the foreground only.", "elif", "color_code", "==", "-", "49", ":", "final_color_code", "=", "current_fg", "|", "self", ".", "default_bg", "# Reset the background only.", "elif", "color_code", "==", "-", "33", ":", "final_color_code", "=", "self", ".", "default_fg", "|", "self", ".", "default_bg", "# Reset both.", "elif", "color_code", "==", "-", "8", ":", "final_color_code", "=", "current_fg", "# Black background.", "else", ":", "new_is_bg", "=", "color_code", "in", "self", ".", "ALL_BG_CODES", "final_color_code", "=", "color_code", "|", "(", "current_fg", "if", "new_is_bg", "else", "current_bg", ")", "# Set new code.", "_WindowsCSBI", ".", "WINDLL", ".", "kernel32", ".", "SetConsoleTextAttribute", "(", "self", ".", "win32_stream_handle", ",", "final_color_code", ")" ]

[ "Changes", "the", "foreground", "and", "background", "colors", "for", "subsequently", "printed", "characters", "." ]

[ "def", "get_mimetype", "(", "self", ")", ":", "template_name", "=", "self", ".", "get_template_names", "(", ")", "[", "0", "]", "for", "extension", ",", "mimetype", "in", "turrentine_settings", ".", "TURRENTINE_MIMETYPE_EXTENSIONS", ":", "if", "template_name", ".", "endswith", "(", "extension", ")", ":", "return", "mimetype", "return", "'text/html'" ]

[ "Use", "the", "ending", "of", "the", "template", "name", "to", "infer", "response", "s", "Content", "-", "Type", "header", "." ]

[ "def", "get", "(", "self", ",", "request", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "page", "=", "self", ".", "object", "=", "self", ".", "get_object", "(", ")", "except", "Http404", ":", "# If APPEND_SLASH is set and our url has no trailing slash,", "# look for a CMS page at the alternate url:", "if", "settings", ".", "APPEND_SLASH", "and", "not", "self", ".", "kwargs", ".", "get", "(", "'path'", ",", "'/'", ")", ".", "endswith", "(", "'/'", ")", ":", "return", "self", ".", "_try_url_with_appended_slash", "(", ")", "else", ":", "raise", "Http404", "# Check request.user's credentials in accessing this page:", "if", "page", ".", "staff_only", "and", "not", "request", ".", "user", ".", "is_staff", ":", "# Block out non-staff users on restricted pages.", "# Django 1.4 will introduce better HTTP 403 support, but until then", "# we'll just render a plain \"permission denied\" template (which can be overridden):", "return", "render", "(", "request", ",", "'turrentine/403.html'", ",", "status", "=", "403", ")", "if", "page", ".", "login_required", "and", "request", ".", "user", ".", "is_anonymous", "(", ")", ":", "redirect_url", "=", "'%s?next=%s'", "%", "(", "settings", ".", "LOGIN_URL", ",", "self", ".", "kwargs", ".", "get", "(", "'path'", ",", "''", ")", ")", "return", "HttpResponseRedirect", "(", "redirect_url", ")", "else", ":", "self", ".", "object", "=", "self", ".", "_mark_html_fields_as_safe", "(", "self", ".", "object", ")", "context", "=", "self", ".", "get_context_data", "(", "object", "=", "self", ".", "object", ")", "return", "self", ".", "render_to_response", "(", "context", ",", "content_type", "=", "self", ".", "get_mimetype", "(", ")", ")" ]

[ "Check", "user", "authentication", "if", "the", "page", "requires", "a", "login", "." ]

[ "def", "_try_url_with_appended_slash", "(", "self", ")", ":", "new_url_to_try", "=", "self", ".", "kwargs", ".", "get", "(", "'path'", ",", "''", ")", "+", "'/'", "if", "not", "new_url_to_try", ".", "startswith", "(", "'/'", ")", ":", "new_url_to_try", "=", "'/'", "+", "new_url_to_try", "if", "CMSPage", ".", "objects", ".", "published", "(", ")", ".", "filter", "(", "url", "=", "new_url_to_try", ")", ".", "exists", "(", ")", ":", "return", "HttpResponsePermanentRedirect", "(", "new_url_to_try", ")", "else", ":", "raise", "Http404" ]

[ "Try", "our", "URL", "with", "an", "appended", "slash", ".", "If", "a", "CMS", "page", "is", "found", "at", "that", "URL", "redirect", "to", "it", ".", "If", "no", "page", "is", "found", "at", "that", "URL", "raise", "Http404", "." ]

[ "def", "validate_rule_name", "(", "self", ",", "name", ")", ":", "if", "not", "name", ":", "raise", "SerializerError", "(", "\"Rule name is empty\"", ".", "format", "(", "name", ")", ")", "if", "name", "[", "0", "]", "not", "in", "RULE_ALLOWED_START", ":", "msg", "=", "\"Rule name '{}' must starts with a letter\"", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "for", "item", "in", "name", ":", "if", "item", "not", "in", "RULE_ALLOWED_CHARS", ":", "msg", "=", "(", "\"Invalid rule name '{}': it must only contains \"", "\"letters, numbers and '_' character\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "return", "True" ]

[ "Validate", "rule", "name", "." ]

[ "def", "validate_variable_name", "(", "self", ",", "name", ")", ":", "if", "not", "name", ":", "raise", "SerializerError", "(", "\"Variable name is empty\"", ".", "format", "(", "name", ")", ")", "if", "name", "[", "0", "]", "not", "in", "PROPERTY_ALLOWED_START", ":", "msg", "=", "\"Variable name '{}' must starts with a letter\"", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "for", "item", "in", "name", ":", "if", "item", "not", "in", "PROPERTY_ALLOWED_CHARS", ":", "msg", "=", "(", "\"Invalid variable name '{}': it must only contains \"", "\"letters, numbers and '_' character\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "return", "True" ]

[ "Validate", "variable", "name", "." ]

[ "def", "value_splitter", "(", "self", ",", "reference", ",", "prop", ",", "value", ",", "mode", ")", ":", "items", "=", "[", "]", "if", "mode", "==", "'json-list'", ":", "try", ":", "items", "=", "json", ".", "loads", "(", "value", ")", "except", "json", ".", "JSONDecodeError", "as", "e", ":", "print", "(", "value", ")", "msg", "=", "(", "\"Reference '{ref}' raised JSON decoder error when \"", "\"splitting values from '{prop}': {err}'\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "ref", "=", "reference", ",", "prop", "=", "prop", ",", "err", "=", "e", ")", ")", "else", ":", "if", "len", "(", "value", ")", ">", "0", ":", "items", "=", "value", ".", "split", "(", "\" \"", ")", "return", "items" ]

[ "Split", "a", "string", "into", "a", "list", "items", "." ]

[ "def", "serialize_to_json", "(", "self", ",", "name", ",", "datas", ")", ":", "data_object", "=", "datas", ".", "get", "(", "'object'", ",", "None", ")", "if", "data_object", "is", "None", ":", "msg", "=", "(", "\"JSON reference '{}' lacks of required 'object' variable\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "try", ":", "content", "=", "json", ".", "loads", "(", "data_object", ",", "object_pairs_hook", "=", "OrderedDict", ")", "except", "json", ".", "JSONDecodeError", "as", "e", ":", "msg", "=", "\"JSON reference '{}' raised error from JSON decoder: {}\"", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ",", "e", ")", ")", "else", ":", "return", "content" ]

[ "Serialize", "given", "datas", "to", "any", "object", "from", "assumed", "JSON", "string", "." ]

[ "def", "serialize_to_list", "(", "self", ",", "name", ",", "datas", ")", ":", "items", "=", "datas", ".", "get", "(", "'items'", ",", "None", ")", "splitter", "=", "datas", ".", "get", "(", "'splitter'", ",", "self", ".", "_DEFAULT_SPLITTER", ")", "if", "items", "is", "None", ":", "msg", "=", "(", "\"List reference '{}' lacks of required 'items' variable \"", "\"or is empty\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "else", ":", "items", "=", "self", ".", "value_splitter", "(", "name", ",", "'items'", ",", "items", ",", "mode", "=", "splitter", ")", "return", "items" ]

[ "Serialize", "given", "datas", "to", "a", "list", "structure", "." ]

[ "def", "serialize_to_string", "(", "self", ",", "name", ",", "datas", ")", ":", "value", "=", "datas", ".", "get", "(", "'value'", ",", "None", ")", "if", "value", "is", "None", ":", "msg", "=", "(", "\"String reference '{}' lacks of required 'value' variable \"", "\"or is empty\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "return", "value" ]

[ "Serialize", "given", "datas", "to", "a", "string", "." ]

[ "def", "get_meta_references", "(", "self", ",", "datas", ")", ":", "rule", "=", "datas", ".", "get", "(", "RULE_META_REFERENCES", ",", "{", "}", ")", "if", "not", "rule", ":", "msg", "=", "\"Manifest lacks of '.{}' or is empty\"", "raise", "SerializerError", "(", "msg", ".", "format", "(", "RULE_META_REFERENCES", ")", ")", "else", ":", "if", "rule", ".", "get", "(", "'names'", ",", "None", ")", ":", "names", "=", "rule", ".", "get", "(", "'names'", ")", ".", "split", "(", "\" \"", ")", "elif", "rule", ".", "get", "(", "'auto'", ",", "None", ")", ":", "names", "=", "self", ".", "get_available_references", "(", "datas", ")", "else", ":", "msg", "=", "(", "\"'.{}' either require '--names' or '--auto' variable \"", "\"to be defined\"", ")", "raise", "SerializerError", "(", "msg", ".", "format", "(", "RULE_META_REFERENCES", ")", ")", "for", "item", "in", "names", ":", "self", ".", "validate_rule_name", "(", "item", ")", "return", "names" ]

[ "Get", "manifest", "enabled", "references", "declaration" ]

[ "def", "get_reference", "(", "self", ",", "datas", ",", "name", ")", ":", "rule_name", "=", "'-'", ".", "join", "(", "(", "RULE_REFERENCE", ",", "name", ")", ")", "structure_mode", "=", "'nested'", "if", "rule_name", "not", "in", "datas", ":", "msg", "=", "\"Unable to find enabled reference '{}'\"", "raise", "SerializerError", "(", "msg", ".", "format", "(", "name", ")", ")", "properties", "=", "datas", ".", "get", "(", "rule_name", ")", "# Search for \"structure\" variable", "if", "'structure'", "in", "properties", ":", "if", "properties", "[", "'structure'", "]", "==", "'flat'", ":", "structure_mode", "=", "'flat'", "elif", "properties", "[", "'structure'", "]", "==", "'list'", ":", "structure_mode", "=", "'list'", "elif", "properties", "[", "'structure'", "]", "==", "'string'", ":", "structure_mode", "=", "'string'", "elif", "properties", "[", "'structure'", "]", "==", "'json'", ":", "structure_mode", "=", "'json'", "elif", "properties", "[", "'structure'", "]", "==", "'nested'", ":", "pass", "else", ":", "msg", "=", "\"Invalid structure mode name '{}' for reference '{}'\"", "raise", "SerializerError", "(", "msg", ".", "format", "(", "structure_mode", ",", "name", ")", ")", "del", "properties", "[", "'structure'", "]", "# Validate variable names", "for", "item", "in", "properties", ".", "keys", "(", ")", ":", "self", ".", "validate_variable_name", "(", "item", ")", "# Perform serialize according to structure mode", "if", "structure_mode", "==", "'flat'", ":", "context", "=", "self", ".", "serialize_to_flat", "(", "name", ",", "properties", ")", "elif", "structure_mode", "==", "'list'", ":", "context", "=", "self", ".", "serialize_to_list", "(", "name", ",", "properties", ")", "elif", "structure_mode", "==", "'string'", ":", "context", "=", "self", ".", "serialize_to_string", "(", "name", ",", "properties", ")", "elif", "structure_mode", "==", "'nested'", ":", "context", "=", "self", ".", "serialize_to_nested", "(", "name", ",", "properties", ")", "elif", "structure_mode", "==", "'json'", ":", "context", "=", "self", ".", "serialize_to_json", "(", "name", ",", "properties", ")", "return", "context" ]

[ "Get", "serialized", "reference", "datas" ]

[ "def", "get_available_references", "(", "self", ",", "datas", ")", ":", "names", "=", "[", "]", "for", "k", ",", "v", "in", "datas", ".", "items", "(", ")", ":", "if", "k", ".", "startswith", "(", "RULE_REFERENCE", ")", ":", "names", ".", "append", "(", "k", "[", "len", "(", "RULE_REFERENCE", ")", "+", "1", ":", "]", ")", "return", "names" ]

[ "Get", "available", "manifest", "reference", "names", "." ]

[ "def", "get_enabled_references", "(", "self", ",", "datas", ",", "meta_references", ")", ":", "references", "=", "OrderedDict", "(", ")", "for", "section", "in", "meta_references", ":", "references", "[", "section", "]", "=", "self", ".", "get_reference", "(", "datas", ",", "section", ")", "return", "references" ]

[ "Get", "enabled", "manifest", "references", "declarations", "." ]

[ "def", "serialize", "(", "self", ",", "datas", ")", ":", "self", ".", "_metas", "=", "OrderedDict", "(", "{", "'references'", ":", "self", ".", "get_meta_references", "(", "datas", ")", ",", "}", ")", "return", "self", ".", "get_enabled_references", "(", "datas", ",", "self", ".", "_metas", "[", "'references'", "]", ")" ]

[ "Serialize", "datas", "to", "manifest", "structure", "with", "metas", "and", "references", "." ]