Datasets:

---

CM

/

codexglue_code2text_python

like 8

[ "def", "participation_policy_changed", "(", "ob", ",", "event", ")", ":", "workspace", "=", "IWorkspace", "(", "ob", ")", "old_group_name", "=", "workspace", ".", "group_for_policy", "(", "event", ".", "old_policy", ")", "old_group", "=", "api", ".", "group", ".", "get", "(", "old_group_name", ")", "for", "member", "in", "old_group", ".", "getAllGroupMembers", "(", ")", ":", "groups", "=", "workspace", ".", "get", "(", "member", ".", "getId", "(", ")", ")", ".", "groups", "groups", "-=", "set", "(", "[", "event", ".", "old_policy", ".", "title", "(", ")", "]", ")", "groups", ".", "add", "(", "event", ".", "new_policy", ".", "title", "(", ")", ")" ]

[ "Move", "all", "the", "existing", "users", "to", "a", "new", "group" ]

[ "def", "invitation_accepted", "(", "event", ")", ":", "request", "=", "getRequest", "(", ")", "storage", "=", "get_storage", "(", ")", "if", "event", ".", "token_id", "not", "in", "storage", ":", "return", "ws_uid", ",", "username", "=", "storage", "[", "event", ".", "token_id", "]", "storage", "[", "event", ".", "token_id", "]", "acl_users", "=", "api", ".", "portal", ".", "get_tool", "(", "'acl_users'", ")", "acl_users", ".", "updateCredentials", "(", "request", ",", "request", ".", "response", ",", "username", ",", "None", ")", "catalog", "=", "api", ".", "portal", ".", "get_tool", "(", "name", "=", "\"portal_catalog\"", ")", "brain", "=", "catalog", ".", "unrestrictedSearchResults", "(", "UID", "=", "ws_uid", ")", "[", "0", "]", "with", "api", ".", "env", ".", "adopt_roles", "(", "[", "\"Manager\"", "]", ")", ":", "ws", "=", "IWorkspace", "(", "brain", ".", "getObject", "(", ")", ")", "for", "name", "in", "ws", ".", "members", ":", "member", "=", "api", ".", "user", ".", "get", "(", "username", "=", "name", ")", "if", "member", "is", "not", "None", ":", "if", "member", ".", "getUserName", "(", ")", "==", "username", ":", "api", ".", "portal", ".", "show_message", "(", "_", "(", "'Oh boy, oh boy, you are already a member'", ")", ",", "request", ",", ")", "break", "else", ":", "ws", ".", "add_to_team", "(", "user", "=", "username", ")", "api", ".", "portal", ".", "show_message", "(", "_", "(", "'Welcome to our family, Stranger'", ")", ",", "request", ",", ")" ]

[ "When", "an", "invitation", "is", "accepted", "add", "the", "user", "to", "the", "team" ]

[ "def", "user_deleted_from_site_event", "(", "event", ")", ":", "userid", "=", "event", ".", "principal", "catalog", "=", "api", ".", "portal", ".", "get_tool", "(", "'portal_catalog'", ")", "query", "=", "{", "'object_provides'", ":", "WORKSPACE_INTERFACE", "}", "query", "[", "'workspace_members'", "]", "=", "userid", "workspaces", "=", "[", "IWorkspace", "(", "b", ".", "_unrestrictedGetObject", "(", ")", ")", "for", "b", "in", "catalog", ".", "unrestrictedSearchResults", "(", "query", ")", "]", "for", "workspace", "in", "workspaces", ":", "workspace", ".", "remove_from_team", "(", "userid", ")" ]

[ "Remove", "deleted", "user", "from", "all", "the", "workspaces", "where", "he", "is", "a", "member" ]

[ "def", "data_context_name", "(", "fn", ")", ":", "return", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ",", "\"template_data\"", ",", "fn", ")" ]

[ "Return", "the", "fn", "in", "absolute", "path", "in", "template_data", "directory", "." ]

[ "def", "data_context", "(", "fn", ",", "mode", "=", "\"r\"", ")", ":", "with", "open", "(", "data_context_name", "(", "fn", ")", ",", "mode", ")", "as", "f", ":", "return", "f", ".", "read", "(", ")" ]

[ "Return", "content", "fo", "the", "fn", "from", "the", "template_data", "directory", "." ]

[ "def", "tmp_context", "(", "fn", ",", "mode", "=", "\"r\"", ")", ":", "with", "open", "(", "tmp_context_name", "(", "fn", ")", ",", "mode", ")", "as", "f", ":", "return", "f", ".", "read", "(", ")" ]

[ "Return", "content", "fo", "the", "fn", "from", "the", "temporary", "directory", "." ]

[ "def", "cleanup_environment", "(", ")", ":", "SERV", ".", "terminate", "(", ")", "shutil", ".", "rmtree", "(", "TMP_PATH", ")", "if", "os", ".", "path", ".", "exists", "(", "TMP_PATH", ")", ":", "os", ".", "rmdir", "(", "TMP_PATH", ")", "global", "TMP_PATH", "TMP_PATH", "=", "None" ]

[ "Shutdown", "the", "ZEO", "server", "process", "running", "in", "another", "thread", "and", "cleanup", "the", "temporary", "directory", "." ]

[ "def", "stringify", "(", "obj", ")", ":", "out", "=", "obj", "if", "isinstance", "(", "obj", ",", "uuid", ".", "UUID", ")", ":", "out", "=", "str", "(", "obj", ")", "elif", "hasattr", "(", "obj", ",", "'strftime'", ")", ":", "out", "=", "obj", ".", "strftime", "(", "'%Y-%m-%dT%H:%M:%S.%f%z'", ")", "elif", "isinstance", "(", "obj", ",", "memoryview", ")", ":", "out", "=", "obj", ".", "tobytes", "(", ")", "elif", "isinstance", "(", "obj", ",", "bytearray", ")", ":", "out", "=", "bytes", "(", "obj", ")", "elif", "sys", ".", "version_info", "[", "0", "]", "<", "3", "and", "isinstance", "(", "obj", ",", "buffer", ")", ":", "out", "=", "bytes", "(", "obj", ")", "if", "isinstance", "(", "out", ",", "bytes", ")", ":", "out", "=", "out", ".", "decode", "(", "'utf-8'", ")", "return", "out" ]

[ "Return", "the", "string", "representation", "of", "an", "object", "." ]

[ "def", "normalize_collection", "(", "coll", ")", ":", "#", "# The recursive version of this algorithm is something like:", "#", "# if isinstance(coll, dict):", "# return dict((stringify(k), normalize_collection(v))", "# for k, v in coll.items())", "# if isinstance(obj, (list, tuple)):", "# return [normalize_collection(item) for item in obj]", "# raise RuntimeError('non-container root')", "#", "# Since this is NOT simply a tail-recursive function, unrolling", "# the recursion requires that we store intermediate \"frame info\"", "# somewhere while processing. I chose to use two stacks for", "# this:", "#", "# value_stack: contains the produced values. The while loop", "# appends a new container to this stack when it encounters a", "# container on the work stack. When the algorithm terminates,", "# we return the first (oldest) value on the stack.", "# work_stack: contains the items that need to be processed and", "# a function to call when the value is completed. Initially,", "# we place the input collection onto work stack without a", "# processing function.", "#", "# The algorithm starts with the input collection on the work", "# stack. Each iteration pops the top of the stack which contains", "# a value and a completion function (inserter). If the value is", "# a collection, then we push a new container onto the value stack,", "# iterate over the container, and push each item onto the work", "# stack with a function that will insert it into the new container.", "#", "value_stack", "=", "[", "]", "work_stack", "=", "[", "(", "coll", ",", "None", ")", "]", "def", "create_container", "(", "container_type", ",", "inserter", ")", ":", "clone", "=", "container_type", "(", ")", "if", "inserter", ":", "inserter", "(", "clone", ")", "value_stack", ".", "append", "(", "clone", ")", "return", "clone", "while", "work_stack", ":", "value", ",", "inserter", "=", "work_stack", ".", "pop", "(", ")", "if", "isinstance", "(", "value", ",", "(", "frozenset", ",", "list", ",", "set", ",", "tuple", ")", ")", ":", "target", "=", "create_container", "(", "list", ",", "inserter", ")", "inserter", "=", "functools", ".", "partial", "(", "target", ".", "insert", ",", "0", ")", "for", "item", "in", "value", ":", "work_stack", ".", "append", "(", "(", "item", ",", "inserter", ")", ")", "elif", "isinstance", "(", "value", ",", "dict", ")", ":", "target", "=", "create_container", "(", "dict", ",", "inserter", ")", "for", "key", ",", "item", "in", "value", ".", "items", "(", ")", ":", "inserter", "=", "functools", ".", "partial", "(", "target", ".", "__setitem__", ",", "stringify", "(", "key", ")", ")", "work_stack", ".", "append", "(", "(", "item", ",", "inserter", ")", ")", "else", ":", "if", "inserter", "is", "None", ":", "raise", "RuntimeError", "(", "'non-container root - type %r'", "%", "value", ".", "__class__", ")", "inserter", "(", "stringify", "(", "value", ")", ")", "return", "value_stack", "[", "0", "]" ]

[ "Normalize", "all", "elements", "in", "a", "collection", "." ]

[ "def", "available", "(", "self", ")", ":", "# Short-circuit", "if", "not", "self", ".", "_schema", ":", "return", "set", "(", ")", "# Build up the set of available versions", "avail", "=", "set", "(", "self", ".", "_schema", ".", "__vers_downgraders__", ".", "keys", "(", ")", ")", "avail", ".", "add", "(", "self", ".", "_schema", ".", "__version__", ")", "return", "avail" ]

[ "Returns", "a", "set", "of", "the", "available", "versions", "." ]

[ "def", "parse_args_to_dict", "(", "values_specs", ")", ":", "# values_specs for example: '-- --tag x y --key1 type=int value1'", "# -- is a pseudo argument", "values_specs_copy", "=", "values_specs", "[", ":", "]", "if", "values_specs_copy", "and", "values_specs_copy", "[", "0", "]", "==", "'--'", ":", "del", "values_specs_copy", "[", "0", "]", "# converted ArgumentParser arguments for each of the options", "_options", "=", "{", "}", "# the argument part for current option in _options", "current_arg", "=", "None", "# the string after remove meta info in values_specs", "# for example, '--tag x y --key1 value1'", "_values_specs", "=", "[", "]", "# record the count of values for an option", "# for example: for '--tag x y', it is 2, while for '--key1 value1', it is 1", "_value_number", "=", "0", "# list=true", "_list_flag", "=", "False", "# action=clear", "_clear_flag", "=", "False", "# the current item in values_specs", "current_item", "=", "None", "# the str after 'type='", "current_type_str", "=", "None", "for", "_item", "in", "values_specs_copy", ":", "if", "_item", ".", "startswith", "(", "'--'", ")", ":", "# Deal with previous argument if any", "_process_previous_argument", "(", "current_arg", ",", "_value_number", ",", "current_type_str", ",", "_list_flag", ",", "_values_specs", ",", "_clear_flag", ",", "values_specs", ")", "# Init variables for current argument", "current_item", "=", "_item", "_list_flag", "=", "False", "_clear_flag", "=", "False", "current_type_str", "=", "None", "if", "\"=\"", "in", "_item", ":", "_value_number", "=", "1", "_item", "=", "_item", ".", "split", "(", "'='", ")", "[", "0", "]", "else", ":", "_value_number", "=", "0", "if", "_item", "in", "_options", ":", "raise", "exceptions", ".", "CommandError", "(", "_", "(", "\"Duplicated options %s\"", ")", "%", "' '", ".", "join", "(", "values_specs", ")", ")", "else", ":", "_options", ".", "update", "(", "{", "_item", ":", "{", "}", "}", ")", "current_arg", "=", "_options", "[", "_item", "]", "_item", "=", "current_item", "elif", "_item", ".", "startswith", "(", "'type='", ")", ":", "if", "current_arg", "is", "None", ":", "raise", "exceptions", ".", "CommandError", "(", "_", "(", "\"Invalid values_specs %s\"", ")", "%", "' '", ".", "join", "(", "values_specs", ")", ")", "if", "'type'", "not", "in", "current_arg", ":", "current_type_str", "=", "_item", ".", "split", "(", "'='", ",", "2", ")", "[", "1", "]", "current_arg", ".", "update", "(", "{", "'type'", ":", "eval", "(", "current_type_str", ")", "}", ")", "if", "current_type_str", "==", "'bool'", ":", "current_arg", ".", "update", "(", "{", "'type'", ":", "utils", ".", "str2bool", "}", ")", "elif", "current_type_str", "==", "'dict'", ":", "current_arg", ".", "update", "(", "{", "'type'", ":", "utils", ".", "str2dict", "}", ")", "continue", "elif", "_item", "==", "'list=true'", ":", "_list_flag", "=", "True", "continue", "elif", "_item", "==", "'action=clear'", ":", "_clear_flag", "=", "True", "continue", "if", "not", "_item", ".", "startswith", "(", "'--'", ")", ":", "# All others are value items", "# Make sure '--' occurs first and allow minus value", "if", "(", "not", "current_item", "or", "'='", "in", "current_item", "or", "_item", ".", "startswith", "(", "'-'", ")", "and", "not", "is_number", "(", "_item", ")", ")", ":", "raise", "exceptions", ".", "CommandError", "(", "_", "(", "\"Invalid values_specs %s\"", ")", "%", "' '", ".", "join", "(", "values_specs", ")", ")", "_value_number", "+=", "1", "if", "_item", ".", "startswith", "(", "'---'", ")", ":", "raise", "exceptions", ".", "CommandError", "(", "_", "(", "\"Invalid values_specs %s\"", ")", "%", "' '", ".", "join", "(", "values_specs", ")", ")", "_values_specs", ".", "append", "(", "_item", ")", "# Deal with last one argument", "_process_previous_argument", "(", "current_arg", ",", "_value_number", ",", "current_type_str", ",", "_list_flag", ",", "_values_specs", ",", "_clear_flag", ",", "values_specs", ")", "# Populate the parser with arguments", "_parser", "=", "argparse", ".", "ArgumentParser", "(", "add_help", "=", "False", ")", "for", "opt", ",", "optspec", "in", "six", ".", "iteritems", "(", "_options", ")", ":", "_parser", ".", "add_argument", "(", "opt", ",", "*", "*", "optspec", ")", "_args", "=", "_parser", ".", "parse_args", "(", "_values_specs", ")", "result_dict", "=", "{", "}", "for", "opt", "in", "six", ".", "iterkeys", "(", "_options", ")", ":", "_opt", "=", "opt", ".", "split", "(", "'--'", ",", "2", ")", "[", "1", "]", "_opt", "=", "_opt", ".", "replace", "(", "'-'", ",", "'_'", ")", "_value", "=", "getattr", "(", "_args", ",", "_opt", ")", "result_dict", ".", "update", "(", "{", "_opt", ":", "_value", "}", ")", "return", "result_dict" ]

[ "It", "is", "used", "to", "analyze", "the", "extra", "command", "options", "to", "command", "." ]

[ "def", "_merge_args", "(", "qCmd", ",", "parsed_args", ",", "_extra_values", ",", "value_specs", ")", ":", "temp_values", "=", "_extra_values", ".", "copy", "(", ")", "for", "key", ",", "value", "in", "six", ".", "iteritems", "(", "temp_values", ")", ":", "if", "hasattr", "(", "parsed_args", ",", "key", ")", ":", "arg_value", "=", "getattr", "(", "parsed_args", ",", "key", ")", "if", "arg_value", "is", "not", "None", "and", "value", "is", "not", "None", ":", "if", "isinstance", "(", "arg_value", ",", "list", ")", ":", "if", "value", "and", "isinstance", "(", "value", ",", "list", ")", ":", "if", "(", "not", "arg_value", "or", "isinstance", "(", "arg_value", "[", "0", "]", ",", "type", "(", "value", "[", "0", "]", ")", ")", ")", ":", "arg_value", ".", "extend", "(", "value", ")", "_extra_values", ".", "pop", "(", "key", ")" ]

[ "Merge", "arguments", "from", "_extra_values", "into", "parsed_args", "." ]

[ "def", "update_dict", "(", "obj", ",", "dict", ",", "attributes", ")", ":", "for", "attribute", "in", "attributes", ":", "if", "hasattr", "(", "obj", ",", "attribute", ")", "and", "getattr", "(", "obj", ",", "attribute", ")", "is", "not", "None", ":", "dict", "[", "attribute", "]", "=", "getattr", "(", "obj", ",", "attribute", ")" ]

[ "Update", "dict", "with", "fields", "from", "obj", ".", "attributes", "." ]

[ "def", "retrieve_list", "(", "self", ",", "parsed_args", ")", ":", "neutron_client", "=", "self", ".", "get_client", "(", ")", "_extra_values", "=", "parse_args_to_dict", "(", "self", ".", "values_specs", ")", "_merge_args", "(", "self", ",", "parsed_args", ",", "_extra_values", ",", "self", ".", "values_specs", ")", "search_opts", "=", "self", ".", "args2search_opts", "(", "parsed_args", ")", "search_opts", ".", "update", "(", "_extra_values", ")", "if", "self", ".", "pagination_support", ":", "page_size", "=", "parsed_args", ".", "page_size", "if", "page_size", ":", "search_opts", ".", "update", "(", "{", "'limit'", ":", "page_size", "}", ")", "if", "self", ".", "sorting_support", ":", "keys", "=", "parsed_args", ".", "sort_key", "if", "keys", ":", "search_opts", ".", "update", "(", "{", "'sort_key'", ":", "keys", "}", ")", "dirs", "=", "parsed_args", ".", "sort_dir", "len_diff", "=", "len", "(", "keys", ")", "-", "len", "(", "dirs", ")", "if", "len_diff", ">", "0", ":", "dirs", "+=", "[", "'asc'", "]", "*", "len_diff", "elif", "len_diff", "<", "0", ":", "dirs", "=", "dirs", "[", ":", "len", "(", "keys", ")", "]", "if", "dirs", ":", "search_opts", ".", "update", "(", "{", "'sort_dir'", ":", "dirs", "}", ")", "data", "=", "self", ".", "call_server", "(", "neutron_client", ",", "search_opts", ",", "parsed_args", ")", "collection", "=", "_get_resource_plural", "(", "self", ".", "resource", ",", "neutron_client", ")", "return", "data", ".", "get", "(", "collection", ",", "[", "]", ")" ]

[ "Retrieve", "a", "list", "of", "resources", "from", "Neutron", "server", "." ]

[ "def", "lock_key", "(", "group_id", ",", "item_id", ",", "group_width", "=", "8", ")", ":", "if", "group_id", ">=", "(", "1", "<<", "group_width", ")", ":", "raise", "Exception", "(", "\"Group ID is too big\"", ")", "if", "item_id", ">=", "(", "1", "<<", "(", "63", "-", "group_width", ")", ")", "-", "1", ":", "raise", "Exception", "(", "\"Item ID is too big\"", ")", "return", "(", "item_id", "<<", "group_width", ")", "|", "group_id" ]

[ "Creates", "a", "lock", "ID", "where", "the", "lower", "bits", "are", "the", "group", "ID", "and", "the", "upper", "bits", "are", "the", "item", "ID", ".", "This", "allows", "the", "use", "of", "a", "bigint", "namespace", "for", "items", "with", "a", "limited", "space", "for", "grouping", "." ]

[ "def", "release_lock", "(", "dax", ",", "key", ",", "lock_mode", "=", "LockMode", ".", "wait", ")", ":", "lock_fxn", "=", "_lock_fxn", "(", "\"unlock\"", ",", "lock_mode", ",", "False", ")", "return", "dax", ".", "get_scalar", "(", "dax", ".", "callproc", "(", "lock_fxn", ",", "key", "if", "isinstance", "(", "key", ",", "(", "list", ",", "tuple", ")", ")", "else", "[", "key", "]", ")", "[", "0", "]", ")" ]

[ "Manually", "release", "a", "pg", "advisory", "lock", "." ]

[ "def", "advisory_lock", "(", "dax", ",", "key", ",", "lock_mode", "=", "LockMode", ".", "wait", ",", "xact", "=", "False", ")", ":", "if", "lock_mode", "==", "LockMode", ".", "wait", ":", "obtain_lock", "(", "dax", ",", "key", ",", "lock_mode", ",", "xact", ")", "else", ":", "got_lock", "=", "obtain_lock", "(", "dax", ",", "key", ",", "lock_mode", ",", "xact", ")", "if", "not", "got_lock", ":", "if", "lock_mode", "==", "LockMode", ".", "error", ":", "raise", "Exception", "(", "\"Unable to obtain advisory lock {}\"", ".", "format", "(", "key", ")", ")", "else", ":", "# lock_mode is skip", "yield", "False", "return", "# At this point we have the lock", "try", ":", "yield", "True", "finally", ":", "if", "not", "xact", ":", "release_lock", "(", "dax", ",", "key", ",", "lock_mode", ")" ]

[ "A", "context", "manager", "for", "obtaining", "a", "lock", "executing", "code", "and", "then", "releasing", "the", "lock", "." ]

[ "def", "_lock_fxn", "(", "direction", ",", "lock_mode", ",", "xact", ")", ":", "if", "direction", "==", "\"unlock\"", "or", "lock_mode", "==", "LockMode", ".", "wait", ":", "try_mode", "=", "\"\"", "else", ":", "try_mode", "=", "\"_try\"", "if", "direction", "==", "\"lock\"", "and", "xact", ":", "xact_mode", "=", "\"_xact\"", "else", ":", "xact_mode", "=", "\"\"", "return", "\"pg{}_advisory{}_{}\"", ".", "format", "(", "try_mode", ",", "xact_mode", ",", "direction", ")" ]

[ "Builds", "a", "pg", "advisory", "lock", "function", "name", "based", "on", "various", "options", "." ]

[ "def", "get_hash", "(", "fName", ",", "readSize", ",", "dire", "=", "pDir", "(", ")", ")", ":", "if", "not", "fileExists", "(", "fName", ",", "dire", ")", ":", "return", "-", "1", "readSize", "=", "readSize", "*", "1024", "# bytes to be read", "fName", "=", "os", ".", "path", ".", "join", "(", "dire", ",", "fName", ")", "# name coupled with path", "with", "open", "(", "fName", ",", "'rb'", ")", "as", "f", ":", "size", "=", "os", ".", "path", ".", "getsize", "(", "fName", ")", "if", "size", "<", "readSize", "*", "2", ":", "return", "-", "1", "data", "=", "f", ".", "read", "(", "readSize", ")", "f", ".", "seek", "(", "-", "readSize", ",", "os", ".", "SEEK_END", ")", "data", "+=", "f", ".", "read", "(", "readSize", ")", "return", "md5", "(", "data", ")", ".", "hexdigest", "(", ")" ]

[ "creates", "the", "required", "hash" ]

[ "def", "download_file", "(", "fName", ",", "time", ",", "dire", "=", "pDir", "(", ")", ")", ":", "# hash", "gen_hash", "=", "get_hash", "(", "fName", ",", "64", ",", "dire", ")", "if", "gen_hash", "==", "-", "1", ":", "return", "-", "1", "# making request", "user_agent", "=", "{", "'User-agent'", ":", "'SubDB/1.0 (sub/0.1; http://github.com/leosartaj/sub)'", "}", "param", "=", "{", "'action'", ":", "'download'", ",", "'hash'", ":", "gen_hash", ",", "'language'", ":", "'en'", "}", "# Specification for the request", "try", ":", "r", "=", "requests", ".", "get", "(", "\"http://api.thesubdb.com/\"", ",", "headers", "=", "user_agent", ",", "params", "=", "param", ",", "timeout", "=", "time", ")", "# Get Request", "except", "(", "requests", ".", "exceptions", ".", "Timeout", ",", "socket", ".", "error", ")", ":", "return", "'Timeout Error'", "if", "r", ".", "status_code", "!=", "200", ":", "return", "r", ".", "status_code", "# save file", "fName", ",", "fExt", "=", "os", ".", "path", ".", "splitext", "(", "fName", ")", "fName", "+=", "'.srt'", "# replace extension with srt", "fName", "=", "os", ".", "path", ".", "join", "(", "dire", ",", "fName", ")", "# name coupled with path", "with", "open", "(", "fName", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "r", ".", "text", ".", "encode", "(", "'ascii'", ",", "'ignore'", ")", ")", "return", "r", ".", "status_code" ]

[ "download", "the", "required", "subtitle" ]

[ "def", "file_downloaded", "(", "dwn", ",", "fName", ",", "verbose", "=", "False", ")", ":", "if", "verbose", ":", "if", "dwn", "==", "200", ":", "fName", ",", "fExt", "=", "os", ".", "path", ".", "splitext", "(", "fName", ")", "print", "'Downloaded '", "+", "fName", "+", "'.srt'", "return", "True", "elif", "dwn", "!=", "-", "1", ":", "print", "'Tried downloading got '", "+", "str", "(", "dwn", ")", "+", "' for '", "+", "fName", "return", "False" ]

[ "print", "for", "downloaded", "file" ]

[ "def", "download", "(", "name", ",", "options", ")", ":", "dire", "=", "os", ".", "path", ".", "dirname", "(", "name", ")", "# returns the directory name", "fName", "=", "os", ".", "path", ".", "basename", "(", "name", ")", "# returns the filename", "fNameOnly", ",", "fExt", "=", "os", ".", "path", ".", "splitext", "(", "fName", ")", "dwn", "=", "0", "if", "fileExists", "(", "fName", ",", "dire", ")", "and", "not", "fileExists", "(", "(", "fNameOnly", "+", "'.srt'", ")", ",", "dire", ")", ":", "# skip if already downloaded", "if", "file_downloaded", "(", "download_file", "(", "fName", ",", "options", ".", "timeout", ",", "dire", ")", ",", "fName", ",", "options", ".", "verbose", ")", ":", "dwn", "+=", "1", "elif", "dirExists", "(", "name", ")", ":", "for", "filename", "in", "os", ".", "listdir", "(", "name", ")", ":", "if", "options", ".", "recursive", ":", "dwn", "+=", "download", "(", "os", ".", "path", ".", "join", "(", "name", ",", "filename", ")", ",", "options", ")", "else", ":", "if", "file_downloaded", "(", "download_file", "(", "filename", ",", "options", ".", "timeout", ",", "name", ")", ",", "filename", ",", "options", ".", "verbose", ")", ":", "dwn", "+=", "1", "return", "dwn" ]

[ "download", "a", "file", "or", "all", "files", "in", "a", "directory" ]

[ "def", "clean_dateobject_to_string", "(", "x", ")", ":", "import", "numpy", "as", "np", "import", "pandas", "as", "pd", "def", "proc_elem", "(", "e", ")", ":", "try", ":", "return", "e", ".", "strftime", "(", "\"%Y-%m-%d\"", ")", "except", "Exception", "as", "e", ":", "print", "(", "e", ")", "return", "None", "def", "proc_list", "(", "x", ")", ":", "return", "[", "proc_elem", "(", "e", ")", "for", "e", "in", "x", "]", "def", "proc_ndarray", "(", "x", ")", ":", "tmp", "=", "proc_list", "(", "list", "(", "x", ".", "reshape", "(", "(", "x", ".", "size", ",", ")", ")", ")", ")", "return", "np", ".", "array", "(", "tmp", ")", ".", "reshape", "(", "x", ".", "shape", ")", "# transform string, list/tuple, numpy array, pandas dataframe", "if", "\"strftime\"", "in", "dir", "(", "x", ")", ":", "return", "proc_elem", "(", "x", ")", "elif", "isinstance", "(", "x", ",", "(", "list", ",", "tuple", ")", ")", ":", "return", "proc_list", "(", "x", ")", "elif", "isinstance", "(", "x", ",", "np", ".", "ndarray", ")", ":", "return", "proc_ndarray", "(", "x", ")", "elif", "isinstance", "(", "x", ",", "pd", ".", "DataFrame", ")", ":", "return", "pd", ".", "DataFrame", "(", "proc_ndarray", "(", "x", ".", "values", ")", ",", "columns", "=", "x", ".", "columns", ",", "index", "=", "x", ".", "index", ")", "else", ":", "return", "None" ]

[ "Convert", "a", "Pandas", "Timestamp", "object", "or", "datetime", "object", "to", "YYYY", "-", "MM", "-", "DD", "string" ]

[ "def", "AND", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "for", "arg", "in", "args", ":", "try", ":", "arg", "(", ")", "except", "CertifierError", "as", "e", ":", "exc", "=", "kwargs", ".", "get", "(", "'exc'", ",", "None", ")", "if", "exc", "is", "not", "None", ":", "raise", "exc", "(", "e", ")", "raise" ]

[ "ALL", "args", "must", "not", "raise", "an", "exception", "when", "called", "incrementally", ".", "If", "an", "exception", "is", "specified", "raise", "it", "otherwise", "raise", "the", "callable", "s", "exception", "." ]

[ "def", "NAND", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "errors", "=", "[", "]", "for", "arg", "in", "args", ":", "try", ":", "arg", "(", ")", "except", "CertifierError", "as", "e", ":", "errors", ".", "append", "(", "e", ")", "if", "(", "len", "(", "errors", ")", "!=", "len", "(", "args", ")", ")", "and", "len", "(", "args", ")", ">", "1", ":", "exc", "=", "kwargs", ".", "get", "(", "'exc'", ",", "CertifierValueError", "(", "'Expecting no certified values'", ")", ",", ")", "if", "exc", "is", "not", "None", ":", "raise", "exc" ]

[ "ALL", "args", "must", "raise", "an", "exception", "when", "called", "overall", ".", "Raise", "the", "specified", "exception", "on", "failure", "OR", "the", "first", "exception", "." ]

[ "def", "XOR", "(", "a", ",", "b", ",", "exc", "=", "CertifierValueError", "(", "'Expected at least one certified value'", ")", ")", ":", "errors", "=", "[", "]", "for", "certifier", "in", "[", "a", ",", "b", "]", ":", "try", ":", "certifier", "(", ")", "except", "CertifierError", "as", "e", ":", "errors", ".", "append", "(", "e", ")", "if", "len", "(", "errors", ")", "!=", "1", ":", "if", "exc", "is", "not", "None", ":", "raise", "exc" ]

[ "Only", "one", "arg", "must", "not", "raise", "a", "Certifier", "exception", "when", "called", "overall", ".", "Raise", "the", "specified", "exception", "on", "failure", "." ]

[ "def", "cli", "(", "ctx", ",", "verbose", ",", "config", ")", ":", "assert", "isinstance", "(", "ctx", ",", "Context", ")", "# Set up the logger", "verbose", "=", "verbose", "if", "(", "verbose", "<=", "3", ")", "else", "3", "log_levels", "=", "{", "1", ":", "logging", ".", "WARN", ",", "2", ":", "logging", ".", "INFO", ",", "3", ":", "logging", ".", "DEBUG", "}", "log_level", "=", "log_levels", "[", "verbose", "]", "ctx", ".", "log", "=", "logging", ".", "getLogger", "(", "'ipsv'", ")", "ctx", ".", "log", ".", "setLevel", "(", "log_level", ")", "# Console logger", "console_format", "=", "logging", ".", "Formatter", "(", "\"[%(levelname)s] %(name)s: %(message)s\"", ")", "ch", "=", "logging", ".", "StreamHandler", "(", ")", "ch", ".", "setLevel", "(", "log_level", ")", "ch", ".", "setFormatter", "(", "console_format", ")", "ctx", ".", "log", ".", "addHandler", "(", "ch", ")", "# File logger", "file_format", "=", "logging", ".", "Formatter", "(", "\"[%(asctime)s] [%(levelname)s] %(name)s: %(message)s\"", ")", "file_logger", "=", "logging", ".", "FileHandler", "(", "os", ".", "path", ".", "join", "(", "ctx", ".", "config", ".", "get", "(", "'Paths'", ",", "'Log'", ")", ",", "'ipsv.log'", ")", ")", "file_logger", ".", "setLevel", "(", "log_level", ")", "file_logger", ".", "setFormatter", "(", "file_format", ")", "ctx", ".", "log", ".", "addHandler", "(", "file_logger", ")", "# Load the configuration", "if", "os", ".", "path", ".", "isfile", "(", "config", ")", ":", "ctx", ".", "config_path", "=", "config", "ctx", ".", "log", ".", "debug", "(", "'Loading configuration: %s'", ",", "ctx", ".", "config_path", ")", "ctx", ".", "load_config", "(", "config", ")", "else", ":", "ctx", ".", "config_path", "=", "os", ".", "path", ".", "join", "(", "ctx", ".", "basedir", ",", "'config'", ",", "'ipsv.conf'", ")", "ctx", ".", "log", ".", "debug", "(", "'Loading default configuration: %s'", ",", "ctx", ".", "config_path", ")", "ctx", ".", "setup", "(", ")" ]

[ "IPS", "Vagrant", "Management", "Utility" ]

[ "def", "db", "(", "self", ")", ":", "if", "self", ".", "database", "is", "NotImplemented", ":", "self", ".", "database", "=", "Session", "return", "self", ".", "database" ]

[ "Get", "a", "loaded", "database", "session" ]

[ "def", "get_login", "(", "self", ",", "use_session", "=", "True", ")", ":", "# Should we try and return an existing login session?", "if", "use_session", "and", "self", ".", "_login", ".", "check", "(", ")", ":", "self", ".", "cookiejar", "=", "self", ".", "_login", ".", "cookiejar", "return", "self", ".", "cookiejar", "# Prompt the user for their login credentials", "username", "=", "click", ".", "prompt", "(", "'IPS Username'", ")", "password", "=", "click", ".", "prompt", "(", "'IPS Password'", ",", "hide_input", "=", "True", ")", "remember", "=", "click", ".", "confirm", "(", "'Save login session?'", ",", "True", ")", "# Process the login", "cookiejar", "=", "self", ".", "_login", ".", "process", "(", "username", ",", "password", ",", "remember", ")", "if", "remember", ":", "self", ".", "cookiejar", "=", "cookiejar", "return", "cookiejar" ]

[ "Get", "an", "active", "login", "session" ]

[ "def", "list_commands", "(", "self", ",", "ctx", ")", ":", "commands_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "realpath", "(", "__file__", ")", ")", ",", "'commands'", ")", "command_list", "=", "[", "name", "for", "__", ",", "name", ",", "ispkg", "in", "pkgutil", ".", "iter_modules", "(", "[", "commands_path", "]", ")", "if", "ispkg", "]", "command_list", ".", "sort", "(", ")", "return", "command_list" ]

[ "List", "CLI", "commands" ]

[ "def", "get_command", "(", "self", ",", "ctx", ",", "name", ")", ":", "try", ":", "mod", "=", "importlib", ".", "import_module", "(", "'ips_vagrant.commands.{name}'", ".", "format", "(", "name", "=", "name", ")", ")", "return", "mod", ".", "cli", "except", "(", "ImportError", ",", "AttributeError", ")", ":", "return" ]

[ "Get", "a", "bound", "command", "method" ]

[ "def", "_patched_pep257", "(", ")", ":", "import", "pep257", "if", "getattr", "(", "pep257", ",", "\"log\"", ",", "None", ")", ":", "def", "_dummy", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "del", "args", "del", "kwargs", "old_log_info", "=", "pep257", ".", "log", ".", "info", "pep257", ".", "log", ".", "info", "=", "_dummy", "# suppress(unused-attribute)", "try", ":", "yield", "finally", ":", "if", "getattr", "(", "pep257", ",", "\"log\"", ",", "None", ")", ":", "pep257", ".", "log", ".", "info", "=", "old_log_info" ]

[ "Monkey", "-", "patch", "pep257", "after", "imports", "to", "avoid", "info", "logging", "." ]

[ "def", "_stamped_deps", "(", "stamp_directory", ",", "func", ",", "dependencies", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "not", "isinstance", "(", "dependencies", ",", "list", ")", ":", "jobstamps_dependencies", "=", "[", "dependencies", "]", "else", ":", "jobstamps_dependencies", "=", "dependencies", "kwargs", ".", "update", "(", "{", "\"jobstamps_cache_output_directory\"", ":", "stamp_directory", ",", "\"jobstamps_dependencies\"", ":", "jobstamps_dependencies", "}", ")", "return", "jobstamp", ".", "run", "(", "func", ",", "dependencies", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Run", "func", "assumed", "to", "have", "dependencies", "as", "its", "first", "argument", "." ]

[ "def", "_debug_linter_status", "(", "linter", ",", "filename", ",", "show_lint_files", ")", ":", "if", "show_lint_files", ":", "print", "(", "\"{linter}: {filename}\"", ".", "format", "(", "linter", "=", "linter", ",", "filename", "=", "filename", ")", ")" ]

[ "Indicate", "that", "we", "are", "running", "this", "linter", "if", "required", "." ]

[ "def", "_run_flake8", "(", "filename", ",", "stamp_file_name", ",", "show_lint_files", ")", ":", "_debug_linter_status", "(", "\"flake8\"", ",", "filename", ",", "show_lint_files", ")", "return", "_stamped_deps", "(", "stamp_file_name", ",", "_run_flake8_internal", ",", "filename", ")" ]

[ "Run", "flake8", "cached", "by", "stamp_file_name", "." ]

[ "def", "_run_prospector_on", "(", "filenames", ",", "tools", ",", "disabled_linters", ",", "show_lint_files", ",", "ignore_codes", "=", "None", ")", ":", "from", "prospector", ".", "run", "import", "Prospector", ",", "ProspectorConfig", "assert", "tools", "tools", "=", "list", "(", "set", "(", "tools", ")", "-", "set", "(", "disabled_linters", ")", ")", "return_dict", "=", "dict", "(", ")", "ignore_codes", "=", "ignore_codes", "or", "list", "(", ")", "# Early return if all tools were filtered out", "if", "not", "tools", ":", "return", "return_dict", "# pylint doesn't like absolute paths, so convert to relative.", "all_argv", "=", "(", "[", "\"-F\"", ",", "\"-D\"", ",", "\"-M\"", ",", "\"--no-autodetect\"", ",", "\"-s\"", ",", "\"veryhigh\"", "]", "+", "(", "\"-t \"", "+", "\" -t \"", ".", "join", "(", "tools", ")", ")", ".", "split", "(", "\" \"", ")", ")", "for", "filename", "in", "filenames", ":", "_debug_linter_status", "(", "\"prospector\"", ",", "filename", ",", "show_lint_files", ")", "with", "_custom_argv", "(", "all_argv", "+", "[", "os", ".", "path", ".", "relpath", "(", "f", ")", "for", "f", "in", "filenames", "]", ")", ":", "prospector", "=", "Prospector", "(", "ProspectorConfig", "(", ")", ")", "prospector", ".", "execute", "(", ")", "messages", "=", "prospector", ".", "get_messages", "(", ")", "or", "list", "(", ")", "for", "message", "in", "messages", ":", "message", ".", "to_absolute_path", "(", "os", ".", "getcwd", "(", ")", ")", "loc", "=", "message", ".", "location", "code", "=", "message", ".", "code", "if", "code", "in", "ignore_codes", ":", "continue", "key", "=", "_Key", "(", "loc", ".", "path", ",", "loc", ".", "line", ",", "code", ")", "return_dict", "[", "key", "]", "=", "message", "return", "return_dict" ]

[ "Run", "prospector", "on", "filename", "using", "the", "specified", "tools", "." ]

[ "def", "_run_prospector", "(", "filename", ",", "stamp_file_name", ",", "disabled_linters", ",", "show_lint_files", ")", ":", "linter_tools", "=", "[", "\"pep257\"", ",", "\"pep8\"", ",", "\"pyflakes\"", "]", "if", "can_run_pylint", "(", ")", ":", "linter_tools", ".", "append", "(", "\"pylint\"", ")", "# Run prospector on tests. There are some errors we don't care about:", "# - invalid-name: This is often triggered because test method names", "# can be quite long. Descriptive test method names are", "# good, so disable this warning.", "# - super-on-old-class: unittest.TestCase is a new style class, but", "# pylint detects an old style class.", "# - too-many-public-methods: TestCase subclasses by definition have", "# lots of methods.", "test_ignore_codes", "=", "[", "\"invalid-name\"", ",", "\"super-on-old-class\"", ",", "\"too-many-public-methods\"", "]", "kwargs", "=", "dict", "(", ")", "if", "_file_is_test", "(", "filename", ")", ":", "kwargs", "[", "\"ignore_codes\"", "]", "=", "test_ignore_codes", "else", ":", "if", "can_run_frosted", "(", ")", ":", "linter_tools", "+=", "[", "\"frosted\"", "]", "return", "_stamped_deps", "(", "stamp_file_name", ",", "_run_prospector_on", ",", "[", "filename", "]", ",", "linter_tools", ",", "disabled_linters", ",", "show_lint_files", ",", "*", "*", "kwargs", ")" ]

[ "Run", "prospector", "." ]

[ "def", "_run_pyroma", "(", "setup_file", ",", "show_lint_files", ")", ":", "from", "pyroma", "import", "projectdata", ",", "ratings", "from", "prospector", ".", "message", "import", "Message", ",", "Location", "_debug_linter_status", "(", "\"pyroma\"", ",", "setup_file", ",", "show_lint_files", ")", "return_dict", "=", "dict", "(", ")", "data", "=", "projectdata", ".", "get_data", "(", "os", ".", "getcwd", "(", ")", ")", "all_tests", "=", "ratings", ".", "ALL_TESTS", "for", "test", "in", "[", "mod", "(", ")", "for", "mod", "in", "[", "t", ".", "__class__", "for", "t", "in", "all_tests", "]", "]", ":", "if", "test", ".", "test", "(", "data", ")", "is", "False", ":", "class_name", "=", "test", ".", "__class__", ".", "__name__", "key", "=", "_Key", "(", "setup_file", ",", "0", ",", "class_name", ")", "loc", "=", "Location", "(", "setup_file", ",", "None", ",", "None", ",", "0", ",", "0", ")", "msg", "=", "test", ".", "message", "(", ")", "return_dict", "[", "key", "]", "=", "Message", "(", "\"pyroma\"", ",", "class_name", ",", "loc", ",", "msg", ")", "return", "return_dict" ]

[ "Run", "pyroma", "." ]

[ "def", "_run_polysquare_style_linter", "(", "matched_filenames", ",", "cache_dir", ",", "show_lint_files", ")", ":", "from", "polysquarelinter", "import", "linter", "as", "lint", "from", "prospector", ".", "message", "import", "Message", ",", "Location", "return_dict", "=", "dict", "(", ")", "def", "_custom_reporter", "(", "error", ",", "file_path", ")", ":", "key", "=", "_Key", "(", "file_path", ",", "error", "[", "1", "]", ".", "line", ",", "error", "[", "0", "]", ")", "loc", "=", "Location", "(", "file_path", ",", "None", ",", "None", ",", "error", "[", "1", "]", ".", "line", ",", "0", ")", "return_dict", "[", "key", "]", "=", "Message", "(", "\"polysquare-generic-file-linter\"", ",", "error", "[", "0", "]", ",", "loc", ",", "error", "[", "1", "]", ".", "description", ")", "for", "filename", "in", "matched_filenames", ":", "_debug_linter_status", "(", "\"style-linter\"", ",", "filename", ",", "show_lint_files", ")", "# suppress(protected-access,unused-attribute)", "lint", ".", "_report_lint_error", "=", "_custom_reporter", "lint", ".", "main", "(", "[", "\"--spellcheck-cache=\"", "+", "os", ".", "path", ".", "join", "(", "cache_dir", ",", "\"spelling\"", ")", ",", "\"--stamp-file-path=\"", "+", "os", ".", "path", ".", "join", "(", "cache_dir", ",", "\"jobstamps\"", ",", "\"polysquarelinter\"", ")", ",", "\"--log-technical-terms-to=\"", "+", "os", ".", "path", ".", "join", "(", "cache_dir", ",", "\"technical-terms\"", ")", ",", "]", "+", "matched_filenames", "+", "[", "\"--block-regexps\"", "]", "+", "_BLOCK_REGEXPS", ")", "return", "return_dict" ]

[ "Run", "polysquare", "-", "generic", "-", "file", "-", "linter", "on", "matched_filenames", "." ]

[ "def", "_run_spellcheck_linter", "(", "matched_filenames", ",", "cache_dir", ",", "show_lint_files", ")", ":", "from", "polysquarelinter", "import", "lint_spelling_only", "as", "lint", "from", "prospector", ".", "message", "import", "Message", ",", "Location", "for", "filename", "in", "matched_filenames", ":", "_debug_linter_status", "(", "\"spellcheck-linter\"", ",", "filename", ",", "show_lint_files", ")", "return_dict", "=", "dict", "(", ")", "def", "_custom_reporter", "(", "error", ",", "file_path", ")", ":", "line", "=", "error", ".", "line_offset", "+", "1", "key", "=", "_Key", "(", "file_path", ",", "line", ",", "\"file/spelling_error\"", ")", "loc", "=", "Location", "(", "file_path", ",", "None", ",", "None", ",", "line", ",", "0", ")", "# suppress(protected-access)", "desc", "=", "lint", ".", "_SPELLCHECK_MESSAGES", "[", "error", ".", "error_type", "]", ".", "format", "(", "error", ".", "word", ")", "return_dict", "[", "key", "]", "=", "Message", "(", "\"spellcheck-linter\"", ",", "\"file/spelling_error\"", ",", "loc", ",", "desc", ")", "# suppress(protected-access,unused-attribute)", "lint", ".", "_report_spelling_error", "=", "_custom_reporter", "lint", ".", "main", "(", "[", "\"--spellcheck-cache=\"", "+", "os", ".", "path", ".", "join", "(", "cache_dir", ",", "\"spelling\"", ")", ",", "\"--stamp-file-path=\"", "+", "os", ".", "path", ".", "join", "(", "cache_dir", ",", "\"jobstamps\"", ",", "\"polysquarelinter\"", ")", ",", "\"--technical-terms=\"", "+", "os", ".", "path", ".", "join", "(", "cache_dir", ",", "\"technical-terms\"", ")", ",", "]", "+", "matched_filenames", ")", "return", "return_dict" ]

[ "Run", "spellcheck", "-", "linter", "on", "matched_filenames", "." ]

[ "def", "_run_markdownlint", "(", "matched_filenames", ",", "show_lint_files", ")", ":", "from", "prospector", ".", "message", "import", "Message", ",", "Location", "for", "filename", "in", "matched_filenames", ":", "_debug_linter_status", "(", "\"mdl\"", ",", "filename", ",", "show_lint_files", ")", "try", ":", "proc", "=", "subprocess", ".", "Popen", "(", "[", "\"mdl\"", "]", "+", "matched_filenames", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "lines", "=", "proc", ".", "communicate", "(", ")", "[", "0", "]", ".", "decode", "(", ")", ".", "splitlines", "(", ")", "except", "OSError", "as", "error", ":", "if", "error", ".", "errno", "==", "errno", ".", "ENOENT", ":", "return", "[", "]", "lines", "=", "[", "re", ".", "match", "(", "r\"([\\w\\-.\\/\\\\ ]+)\\:([0-9]+)\\: (\\w+) (.+)\"", ",", "l", ")", ".", "groups", "(", "1", ")", "for", "l", "in", "lines", "]", "return_dict", "=", "dict", "(", ")", "for", "filename", ",", "lineno", ",", "code", ",", "msg", "in", "lines", ":", "key", "=", "_Key", "(", "filename", ",", "int", "(", "lineno", ")", ",", "code", ")", "loc", "=", "Location", "(", "filename", ",", "None", ",", "None", ",", "int", "(", "lineno", ")", ",", "0", ")", "return_dict", "[", "key", "]", "=", "Message", "(", "\"markdownlint\"", ",", "code", ",", "loc", ",", "msg", ")", "return", "return_dict" ]

[ "Run", "markdownlint", "on", "matched_filenames", "." ]

[ "def", "_get_cache_dir", "(", "candidate", ")", ":", "if", "candidate", ":", "return", "candidate", "import", "distutils", ".", "dist", "# suppress(import-error)", "import", "distutils", ".", "command", ".", "build", "# suppress(import-error)", "build_cmd", "=", "distutils", ".", "command", ".", "build", ".", "build", "(", "distutils", ".", "dist", ".", "Distribution", "(", ")", ")", "build_cmd", ".", "finalize_options", "(", ")", "cache_dir", "=", "os", ".", "path", ".", "abspath", "(", "build_cmd", ".", "build_temp", ")", "# Make sure that it is created before anyone tries to use it", "try", ":", "os", ".", "makedirs", "(", "cache_dir", ")", "except", "OSError", "as", "error", ":", "if", "error", ".", "errno", "!=", "errno", ".", "EEXIST", ":", "raise", "error", "return", "cache_dir" ]

[ "Get", "the", "current", "cache", "directory", "." ]

[ "def", "_is_excluded", "(", "filename", ",", "exclusions", ")", ":", "for", "exclusion", "in", "exclusions", ":", "if", "fnmatch", "(", "filename", ",", "exclusion", ")", ":", "return", "True", "return", "False" ]

[ "Return", "true", "if", "filename", "matches", "any", "of", "exclusions", "." ]

[ "def", "_file_lines", "(", "self", ",", "filename", ")", ":", "try", ":", "return", "self", ".", "_file_lines_cache", "[", "filename", "]", "except", "KeyError", ":", "if", "os", ".", "path", ".", "isfile", "(", "filename", ")", ":", "with", "open", "(", "filename", ")", "as", "python_file", ":", "self", ".", "_file_lines_cache", "[", "filename", "]", "=", "python_file", ".", "readlines", "(", ")", "else", ":", "self", ".", "_file_lines_cache", "[", "filename", "]", "=", "\"\"", "return", "self", ".", "_file_lines_cache", "[", "filename", "]" ]

[ "Get", "lines", "for", "filename", "caching", "opened", "files", "." ]

[ "def", "_suppressed", "(", "self", ",", "filename", ",", "line", ",", "code", ")", ":", "if", "code", "in", "self", ".", "suppress_codes", ":", "return", "True", "lines", "=", "self", ".", "_file_lines", "(", "filename", ")", "# File is zero length, cannot be suppressed", "if", "not", "lines", ":", "return", "False", "# Handle errors which appear after the end of the document.", "while", "line", ">", "len", "(", "lines", ")", ":", "line", "=", "line", "-", "1", "relevant_line", "=", "lines", "[", "line", "-", "1", "]", "try", ":", "suppressions_function", "=", "relevant_line", ".", "split", "(", "\"#\"", ")", "[", "1", "]", ".", "strip", "(", ")", "if", "suppressions_function", ".", "startswith", "(", "\"suppress(\"", ")", ":", "return", "code", "in", "_parse_suppressions", "(", "suppressions_function", ")", "except", "IndexError", ":", "above_line", "=", "lines", "[", "max", "(", "0", ",", "line", "-", "2", ")", "]", "suppressions_function", "=", "above_line", ".", "strip", "(", ")", "[", "1", ":", "]", ".", "strip", "(", ")", "if", "suppressions_function", ".", "startswith", "(", "\"suppress(\"", ")", ":", "return", "code", "in", "_parse_suppressions", "(", "suppressions_function", ")", "finally", ":", "pass" ]

[ "Return", "true", "if", "linter", "error", "code", "is", "suppressed", "inline", "." ]

[ "def", "_get_md_files", "(", "self", ")", ":", "all_f", "=", "_all_files_matching_ext", "(", "os", ".", "getcwd", "(", ")", ",", "\"md\"", ")", "exclusions", "=", "[", "\"*.egg/*\"", ",", "\"*.eggs/*\"", ",", "\"*build/*\"", "]", "+", "self", ".", "exclusions", "return", "sorted", "(", "[", "f", "for", "f", "in", "all_f", "if", "not", "_is_excluded", "(", "f", ",", "exclusions", ")", "]", ")" ]

[ "Get", "all", "markdown", "files", "." ]

[ "def", "_get_files_to_lint", "(", "self", ",", "external_directories", ")", ":", "all_f", "=", "[", "]", "for", "external_dir", "in", "external_directories", ":", "all_f", ".", "extend", "(", "_all_files_matching_ext", "(", "external_dir", ",", "\"py\"", ")", ")", "packages", "=", "self", ".", "distribution", ".", "packages", "or", "list", "(", ")", "for", "package", "in", "packages", ":", "all_f", ".", "extend", "(", "_all_files_matching_ext", "(", "package", ",", "\"py\"", ")", ")", "py_modules", "=", "self", ".", "distribution", ".", "py_modules", "or", "list", "(", ")", "for", "filename", "in", "py_modules", ":", "all_f", ".", "append", "(", "os", ".", "path", ".", "realpath", "(", "filename", "+", "\".py\"", ")", ")", "all_f", ".", "append", "(", "os", ".", "path", ".", "join", "(", "os", ".", "getcwd", "(", ")", ",", "\"setup.py\"", ")", ")", "# Remove duplicates which may exist due to symlinks or repeated", "# packages found by /setup.py", "all_f", "=", "list", "(", "set", "(", "[", "os", ".", "path", ".", "realpath", "(", "f", ")", "for", "f", "in", "all_f", "]", ")", ")", "exclusions", "=", "[", "\"*.egg/*\"", ",", "\"*.eggs/*\"", "]", "+", "self", ".", "exclusions", "return", "sorted", "(", "[", "f", "for", "f", "in", "all_f", "if", "not", "_is_excluded", "(", "f", ",", "exclusions", ")", "]", ")" ]

[ "Get", "files", "to", "lint", "." ]

[ "def", "initialize_options", "(", "self", ")", ":", "# suppress(unused-function)", "self", ".", "_file_lines_cache", "=", "dict", "(", ")", "self", ".", "suppress_codes", "=", "list", "(", ")", "self", ".", "exclusions", "=", "list", "(", ")", "self", ".", "cache_directory", "=", "\"\"", "self", ".", "stamp_directory", "=", "\"\"", "self", ".", "disable_linters", "=", "list", "(", ")", "self", ".", "show_lint_files", "=", "0" ]

[ "Set", "all", "options", "to", "their", "initial", "values", "." ]

[ "def", "normalize_pattern", "(", "pattern", ")", ":", "if", "not", "(", "pattern", ".", "startswith", "(", "'RE:'", ")", "or", "pattern", ".", "startswith", "(", "'!RE:'", ")", ")", ":", "pattern", "=", "_slashes", ".", "sub", "(", "'/'", ",", "pattern", ")", "if", "len", "(", "pattern", ")", ">", "1", ":", "pattern", "=", "pattern", ".", "rstrip", "(", "'/'", ")", "return", "pattern" ]

[ "Converts", "backslashes", "in", "path", "patterns", "to", "forward", "slashes", "." ]

[ "def", "add", "(", "self", ",", "pat", ",", "fun", ")", ":", "self", ".", "_pat", "=", "None", "self", ".", "_pats", ".", "append", "(", "pat", ")", "self", ".", "_funs", ".", "append", "(", "fun", ")" ]

[ "r", "Add", "a", "pattern", "and", "replacement", "." ]

[ "def", "add_replacer", "(", "self", ",", "replacer", ")", ":", "self", ".", "_pat", "=", "None", "self", ".", "_pats", ".", "extend", "(", "replacer", ".", "_pats", ")", "self", ".", "_funs", ".", "extend", "(", "replacer", ".", "_funs", ")" ]

[ "r", "Add", "all", "patterns", "from", "another", "replacer", "." ]

[ "def", "is_pattern_valid", "(", "pattern", ")", ":", "result", "=", "True", "translator", "=", "Globster", ".", "pattern_info", "[", "Globster", ".", "identify", "(", "pattern", ")", "]", "[", "\"translator\"", "]", "tpattern", "=", "'(%s)'", "%", "translator", "(", "pattern", ")", "try", ":", "re_obj", "=", "lazy_regex", ".", "lazy_compile", "(", "tpattern", ",", "re", ".", "UNICODE", ")", "re_obj", ".", "search", "(", "\"\"", ")", "# force compile", "except", "Exception", "as", "e", ":", "result", "=", "False", "return", "result" ]

[ "Returns", "True", "if", "pattern", "is", "valid", "." ]

[ "def", "put", "(", "self", ",", "device_id", ":", "int", ")", "->", "Device", ":", "device", "=", "self", ".", "_get_or_abort", "(", "device_id", ")", "self", ".", "update", "(", "device", ")", "session", ".", "commit", "(", ")", "session", ".", "add", "(", "device", ")", "return", "device" ]

[ "Updates", "the", "Device", "Resource", "with", "the", "name", "." ]

[ "def", "xross_listener", "(", "http_method", "=", "None", ",", "*", "*", "xross_attrs", ")", ":", "handler", "=", "currentframe", "(", ")", ".", "f_back", ".", "f_locals", "[", "'request'", "]", ".", "_xross_handler", "handler", ".", "set_attrs", "(", "*", "*", "xross_attrs", ")", "if", "http_method", "is", "not", "None", ":", "handler", ".", "http_method", "=", "http_method", "handler", ".", "dispatch", "(", ")" ]

[ "Instructs", "xross", "to", "handle", "AJAX", "calls", "right", "from", "the", "moment", "it", "is", "called", "." ]

[ "def", "xross_view", "(", "*", "op_functions", ")", ":", "operations_dict", "=", "construct_operations_dict", "(", "*", "op_functions", ")", "def", "get_request", "(", "src", ")", ":", "return", "src", "if", "isinstance", "(", "src", ",", "HttpRequest", ")", "else", "None", "def", "dec_wrapper", "(", "func", ")", ":", "def", "func_wrapper", "(", "*", "fargs", ",", "*", "*", "fkwargs", ")", ":", "request_idx", "=", "getattr", "(", "func", ",", "'_req_idx'", ",", "None", ")", "if", "request_idx", "is", "None", ":", "request", "=", "get_request", "(", "fargs", "[", "0", "]", ")", "request_idx", "=", "0", "if", "not", "request", ":", "# Possibly a class-based view where 0-attr is `self`.", "request", "=", "get_request", "(", "fargs", "[", "1", "]", ")", "request_idx", "=", "1", "func", ".", "_req_idx", "=", "request_idx", "else", ":", "request", "=", "fargs", "[", "request_idx", "]", "if", "hasattr", "(", "request", ",", "'_xross_handler'", ")", ":", "request", ".", "_xross_handler", ".", "_op_bindings", ".", "update", "(", "operations_dict", "[", "'_op_bindings'", "]", ")", "else", ":", "request", ".", "_xross_handler", "=", "build_handler_class", "(", "operations_dict", ")", "(", "request", ",", "func", ")", "try", ":", "response", "=", "func", "(", "*", "fargs", ",", "*", "*", "fkwargs", ")", "except", "HandlerException", "as", "e", ":", "return", "HttpResponseBadRequest", "(", "e", "if", "settings", ".", "DEBUG", "else", "b''", ")", "except", "ResponseEmpty", "as", "e", ":", "return", "HttpResponseNotFound", "(", "e", "if", "settings", ".", "DEBUG", "else", "b''", ")", "except", "ResponseReady", "as", "r", ":", "response", "=", "r", ".", "response", "if", "response", "is", "None", ":", "response", "=", "''", "if", "isinstance", "(", "response", ",", "str", ")", ":", "response", "=", "HttpResponse", "(", "response", ")", "elif", "isinstance", "(", "response", ",", "dict", ")", ":", "response", "=", "HttpResponse", "(", "json", ".", "dumps", "(", "response", ")", ",", "content_type", "=", "'application/json'", ")", "return", "response", "return", "func_wrapper", "return", "dec_wrapper" ]

[ "This", "decorator", "should", "be", "used", "to", "decorate", "application", "views", "that", "require", "xross", "functionality", "." ]

[ "def", "intercept", "(", "actions", ":", "dict", "=", "{", "}", ")", ":", "for", "action", "in", "actions", ".", "values", "(", ")", ":", "if", "type", "(", "action", ")", "is", "not", "returns", "and", "type", "(", "action", ")", "is", "not", "raises", ":", "raise", "InterceptorError", "(", "'Actions must be declared as `returns` or `raises`'", ")", "def", "decorated", "(", "f", ")", ":", "def", "wrapped", "(", "*", "args", ",", "*", "*", "kargs", ")", ":", "try", ":", "return", "f", "(", "*", "args", ",", "*", "*", "kargs", ")", "except", "Exception", "as", "e", ":", "if", "e", ".", "__class__", "in", "actions", ":", "return", "actions", "[", "e", ".", "__class__", "]", "(", "e", ")", "else", ":", "raise", "return", "wrapped", "return", "decorated" ]

[ "Decorates", "a", "function", "and", "handles", "any", "exceptions", "that", "may", "rise", "." ]

[ "def", "extend", "(", "self", ",", "*", "bindings", ")", ":", "self", ".", "_bindings", ".", "extend", "(", "self", ".", "_preprocess", "(", "bindings", ")", ")", "return", "self" ]

[ "Append", "the", "given", "bindings", "to", "this", "keymap", "." ]

[ "def", "when", "(", "self", ",", "key", ")", ":", "ctx", "=", "Context", "(", "key", ",", "self", ")", "self", ".", "context", ".", "append", "(", "ctx", ")", "return", "ctx" ]

[ "Specify", "context", "i", ".", "e", ".", "condition", "that", "must", "be", "met", "." ]

[ "def", "_split_source_page", "(", "self", ",", "path", ")", ":", "with", "codecs", ".", "open", "(", "path", ",", "\"rb\"", ",", "\"utf-8\"", ")", "as", "fd", ":", "textlist", "=", "fd", ".", "readlines", "(", ")", "metadata_notation", "=", "\"---\\n\"", "if", "textlist", "[", "0", "]", "!=", "metadata_notation", ":", "logging", ".", "error", "(", "\"{} first line must be triple-dashed!\"", ".", "format", "(", "path", ")", ")", "sys", ".", "exit", "(", "1", ")", "metadata_textlist", "=", "[", "]", "metadata_end_flag", "=", "False", "idx", "=", "1", "max_idx", "=", "len", "(", "textlist", ")", "# TODO(crow): BE PYTHONIC!!!", "while", "not", "metadata_end_flag", ":", "metadata_textlist", ".", "append", "(", "textlist", "[", "idx", "]", ")", "idx", "+=", "1", "if", "idx", ">=", "max_idx", ":", "logging", ".", "error", "(", "\"{} doesn't have end triple-dashed!\"", ".", "format", "(", "path", ")", ")", "sys", ".", "exit", "(", "1", ")", "if", "textlist", "[", "idx", "]", "==", "metadata_notation", ":", "metadata_end_flag", "=", "True", "content", "=", "textlist", "[", "idx", "+", "1", ":", "]", "return", "metadata_textlist", ",", "content" ]

[ "Split", "the", "source", "file", "texts", "by", "triple", "-", "dashed", "lines", "." ]

[ "def", "_get_feed_data", "(", "self", ",", "file_paths", ")", ":", "rv", "=", "{", "}", "for", "i", "in", "file_paths", ":", "# TODO(crow): only support first category", "_", "=", "i", ".", "split", "(", "'/'", ")", "category", "=", "_", "[", "-", "2", "]", "name", "=", "_", "[", "-", "1", "]", ".", "split", "(", "'.'", ")", "[", "0", "]", "page_config", ",", "md", "=", "self", ".", "_get_config_and_content", "(", "i", ")", "parsed_md", "=", "tools", ".", "parse_markdown", "(", "md", ",", "self", ".", "site_config", ")", "rv", ".", "setdefault", "(", "category", ",", "{", "}", ")", "rv", "[", "category", "]", ".", "update", "(", "{", "i", ":", "{", "'title'", ":", "page_config", ".", "get", "(", "'title'", ",", "''", ")", ",", "'name'", ":", "name", ".", "decode", "(", "'utf-8'", ")", ",", "'content'", ":", "parsed_md", ",", "'date'", ":", "page_config", ".", "get", "(", "'date'", ",", "''", ")", "}", "}", ")", "return", "rv" ]

[ "get", "data", "to", "display", "in", "feed", "file" ]

[ "def", "_generate_feed", "(", "self", ",", "feed_data", ")", ":", "atom_feed", "=", "self", ".", "_render_html", "(", "'atom.xml'", ",", "feed_data", ")", "feed_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "getcwd", "(", ")", ",", "'public'", ",", "'atom.xml'", ")", "with", "codecs", ".", "open", "(", "feed_path", ",", "'wb'", ",", "'utf-8'", ")", "as", "f", ":", "f", ".", "write", "(", "atom_feed", ")" ]

[ "render", "feed", "file", "with", "data" ]

[ "def", "_normalize_tz", "(", "val", ")", ":", "match", "=", "_TZ_RE", ".", "match", "(", "val", ")", "if", "match", ":", "ts", ",", "tz", "=", "match", ".", "groups", "(", ")", "if", "len", "(", "tz", ")", "==", "5", ":", "# If the length of the tz is 5 then it is of the form (+|-)dddd, which is exactly what python", "# wants, so just return it.", "return", "ts", "+", "tz", "if", "len", "(", "tz", ")", "==", "6", ":", "# If the length of the tz is 6 then it is of the form (+|-)dd:dd, just remove the colon", "return", "ts", "+", "tz", "[", ":", "3", "]", "+", "tz", "[", "4", ":", "]", "if", "tz", "==", "\"Z\"", "or", "tz", "==", "\"z\"", ":", "# If the tz is \"Z\" or 'z', return a timezone of +0000", "return", "ts", "+", "\"+0000\"", "else", ":", "# Otherwise, the timzone must be of the format (+|-)dd, in which case we just need to add two", "# \"0\" to it, and it will be in the proper format.", "return", "ts", "+", "tz", "+", "\"00\"", "else", ":", "return", "val" ]

[ "Normalizes", "all", "valid", "ISO8601", "time", "zone", "variants", "to", "the", "one", "python", "will", "parse", "." ]

[ "def", "node", "(", "self", ",", "nodeid", ")", ":", "_assert_valid_nodeid", "(", "nodeid", ")", "# addr = 'tcp://' + nodeid", "# insock = MockInSocket(addEndpoints=lambda endpoints: self.bind(addr, insock, endpoints))", "# outsock = lambda: MockOutSocket(addr, self)", "return", "Node", "(", "hub", "=", "Hub", "(", "nodeid", "=", "nodeid", ")", ")" ]

[ "Creates", "a", "new", "node", "with", "the", "specified", "name", "with", "MockSocket", "instances", "as", "incoming", "and", "outgoing", "sockets", "." ]

[ "def", "do_label", "(", "self", ")", ":", "outputdict", "=", "self", ".", "outputdict", "xlabel_options", "=", "self", ".", "kwargs", ".", "get", "(", "\"xlabel_options\"", ",", "{", "}", ")", "self", ".", "subplot", ".", "set_xlabel", "(", "self", ".", "kwargs", ".", "get", "(", "\"xlabel\"", ",", "\"\"", ")", ".", "format", "(", "*", "*", "outputdict", ")", ",", "*", "*", "xlabel_options", ")", "ylabel_options", "=", "self", ".", "kwargs", ".", "get", "(", "\"ylabel_options\"", ",", "{", "}", ")", "self", ".", "subplot", ".", "set_ylabel", "(", "self", ".", "kwargs", ".", "get", "(", "\"ylabel\"", ",", "\"\"", ")", ".", "format", "(", "*", "*", "outputdict", ")", ",", "*", "*", "ylabel_options", ")", "suptitle", "=", "self", ".", "kwargs", ".", "get", "(", "\"suptitle\"", ",", "None", ")", "if", "suptitle", "is", "not", "None", ":", "suptitle_options", "=", "self", ".", "kwargs", ".", "get", "(", "\"suptitle_options\"", ",", "{", "}", ")", "self", ".", "figure", ".", "suptitle", "(", "suptitle", ".", "format", "(", "*", "*", "outputdict", ")", ",", "fontsize", "=", "int", "(", "self", ".", "kwargs", ".", "get", "(", "\"suptitle_fontsize\"", ",", "15", ")", ")", ",", "*", "*", "suptitle_options", ")", "title", "=", "self", ".", "kwargs", ".", "get", "(", "\"title\"", ",", "None", ")", "if", "title", "is", "not", "None", ":", "title_options", "=", "self", ".", "kwargs", ".", "get", "(", "\"title_options\"", ",", "{", "}", ")", "self", ".", "subplot", ".", "set_title", "(", "title", ".", "format", "(", "*", "*", "outputdict", ")", ",", "fontsize", "=", "int", "(", "self", ".", "kwargs", ".", "get", "(", "\"title_fontsize\"", ",", "12", ")", ")", ",", "*", "*", "title_options", ")", "xlim", "=", "self", ".", "kwargs", ".", "get", "(", "\"xlim\"", ",", "None", ")", "ylim", "=", "self", ".", "kwargs", ".", "get", "(", "\"ylim\"", ",", "None", ")", "if", "xlim", "is", "not", "None", ":", "self", ".", "subplot", ".", "set_xlim", "(", "xlim", ")", "if", "ylim", "is", "not", "None", ":", "self", ".", "subplot", ".", "set_ylim", "(", "ylim", ")", "# axis format", "self", ".", "subplot", ".", "ticklabel_format", "(", "style", "=", "\"sci\"", ",", "useOffset", "=", "False", ",", "scilimits", "=", "self", ".", "kwargs", ".", "get", "(", "\"scilimits\"", ",", "(", "-", "4", ",", "4", ")", ")", ")", "return", "self" ]

[ "Create", "label", "for", "x", "and", "y", "axis", "title", "and", "suptitle" ]

[ "def", "extant_item", "(", "arg", ",", "arg_type", ")", ":", "if", "arg_type", "==", "\"file\"", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "arg", ")", ":", "raise", "argparse", ".", "ArgumentError", "(", "None", ",", "\"The file {arg} does not exist.\"", ".", "format", "(", "arg", "=", "arg", ")", ")", "else", ":", "# File exists so return the filename", "return", "arg", "elif", "arg_type", "==", "\"directory\"", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "arg", ")", ":", "raise", "argparse", ".", "ArgumentError", "(", "None", ",", "\"The directory {arg} does not exist.\"", ".", "format", "(", "arg", "=", "arg", ")", ")", "else", ":", "# Directory exists so return the directory name", "return", "arg" ]

[ "Determine", "if", "parser", "argument", "is", "an", "existing", "file", "or", "directory", "." ]

[ "def", "parse_config_input_output", "(", "args", "=", "sys", ".", "argv", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Process the input files using the given config'", ")", "parser", ".", "add_argument", "(", "'config_file'", ",", "help", "=", "'Configuration file.'", ",", "metavar", "=", "'FILE'", ",", "type", "=", "extant_file", ")", "parser", ".", "add_argument", "(", "'input_dir'", ",", "help", "=", "'Directory containing the input files.'", ",", "metavar", "=", "'DIR'", ",", "type", "=", "extant_dir", ")", "parser", ".", "add_argument", "(", "'output_dir'", ",", "help", "=", "'Directory where the output files should be saved.'", ",", "metavar", "=", "'DIR'", ",", "type", "=", "extant_dir", ")", "return", "parser", ".", "parse_args", "(", "args", "[", "1", ":", "]", ")" ]

[ "Parse", "the", "args", "using", "the", "config_file", "input_dir", "output_dir", "pattern" ]

[ "def", "parse_config", "(", "args", "=", "sys", ".", "argv", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Read in the config file'", ")", "parser", ".", "add_argument", "(", "'config_file'", ",", "help", "=", "'Configuration file.'", ",", "metavar", "=", "'FILE'", ",", "type", "=", "extant_file", ")", "return", "parser", ".", "parse_args", "(", "args", "[", "1", ":", "]", ")" ]

[ "Parse", "the", "args", "using", "the", "config_file", "pattern" ]

[ "def", "cache", "(", "self", ",", "CachableItem", ")", ":", "_cachedItem", "=", "self", ".", "get", "(", "CachableItem", ")", "if", "not", "_cachedItem", ":", "_dirtyCachedItem", "=", "self", ".", "mapper", ".", "get", "(", "CachableItem", ")", "logger", ".", "debug", "(", "\"new cachable item added to sql cache area {id: %s, type: %s}\"", ",", "str", "(", "_dirtyCachedItem", ".", "getId", "(", ")", ")", ",", "str", "(", "_dirtyCachedItem", ".", "__class__", ")", ")", "cached_item", "=", "self", ".", "session", ".", "merge", "(", "_dirtyCachedItem", ")", "notify", "(", "CacheObjectCreatedEvent", "(", "cached_item", ",", "self", ")", ")", "return", "cached_item", "else", ":", "_newCacheItem", "=", "self", ".", "mapper", ".", "get", "(", "CachableItem", ")", "if", "_cachedItem", "!=", "_newCacheItem", ":", "logger", ".", "debug", "(", "\"Cachable item modified in sql cache area {id: %s, type: %s}\"", ",", "str", "(", "_newCacheItem", ".", "getId", "(", ")", ")", ",", "str", "(", "_newCacheItem", ".", "__class__", ")", ")", "cached_item", "=", "self", ".", "session", ".", "merge", "(", "_newCacheItem", ")", "notify", "(", "CacheObjectModifiedEvent", "(", "cached_item", ",", "self", ")", ")", "return", "cached_item", "return", "False" ]

[ "Updates", "cache", "area", "with", "latest", "information" ]

[ "def", "format_json", "(", "item", ",", "*", "*", "kwargs", ")", ":", "try", ":", "json", ".", "dumps", "(", "item", ".", "value", ")", "return", "item", ".", "value", "except", "TypeError", ":", "if", "'time'", "in", "item", ".", "class_type", ".", "lower", "(", ")", "or", "'date'", "in", "item", ".", "class_type", ".", "lower", "(", ")", ":", "return", "item", ".", "value", ".", "isoformat", "(", ")", "raise" ]

[ "formats", "a", "datatype", "object", "to", "a", "json", "value" ]

[ "def", "format_sparql", "(", "item", ",", "dt_format", "=", "'turtle'", ",", "*", "*", "kwargs", ")", ":", "try", ":", "rtn_val", "=", "json", ".", "dumps", "(", "item", ".", "value", ")", "rtn_val", "=", "item", ".", "value", "except", ":", "if", "'time'", "in", "item", ".", "class_type", ".", "lower", "(", ")", "or", "'date'", "in", "item", ".", "class_type", ".", "lower", "(", ")", ":", "rtn_val", "=", "item", ".", "value", ".", "isoformat", "(", ")", "else", ":", "rtn_val", "=", "str", "(", "item", ".", "value", ")", "if", "hasattr", "(", "item", ",", "\"datatype\"", ")", ":", "if", "hasattr", "(", "item", ",", "\"lang\"", ")", "and", "item", ".", "lang", ":", "rtn_val", "=", "'%s@%s'", "%", "(", "json", ".", "dumps", "(", "rtn_val", ")", ",", "item", ".", "lang", ")", "else", ":", "dt", "=", "item", ".", "datatype", "if", "dt_format", "==", "\"uri\"", ":", "dt", "=", "item", ".", "datatype", ".", "sparql_uri", "if", "item", ".", "datatype", "in", "[", "\"xsd_string\"", ",", "\"xsd_dateTime\"", ",", "\"xsd_time\"", ",", "\"xsd_date\"", "]", ":", "rtn_val", "=", "json", ".", "dumps", "(", "rtn_val", ")", "else", ":", "rtn_val", "=", "'\"%s\"'", "%", "json", ".", "dumps", "(", "rtn_val", ")", "rtn_val", "=", "'%s^^%s'", "%", "(", "rtn_val", ",", "dt", ".", "sparql", ")", "return", "rtn_val" ]

[ "Formats", "a", "datatype", "value", "to", "a", "SPARQL", "representation" ]

[ "def", "_format", "(", "self", ",", "method", "=", "\"sparql\"", ",", "dt_format", "=", "\"turtle\"", ")", ":", "try", ":", "return", "__FORMAT_OPTIONS__", "[", "method", "]", "(", "self", ",", "dt_format", "=", "dt_format", ")", "except", "KeyError", ":", "raise", "NotImplementedError", "(", "\"'{}' is not a valid format method\"", "\"\"", ".", "format", "(", "method", ")", ")" ]

[ "Rormats", "the", "value", "in", "various", "formats" ]

[ "def", "bind", "(", "self", ",", "prefix", ",", "namespace", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# RdfNamespace(prefix, namespace, **kwargs)", "setattr", "(", "self", ",", "prefix", ",", "RdfNamespace", "(", "prefix", ",", "namespace", ",", "*", "*", "kwargs", ")", ")", "if", "kwargs", ".", "pop", "(", "'calc'", ",", "True", ")", ":", "self", ".", "__make_dicts__" ]

[ "Extends", "the", "function", "to", "add", "an", "attribute", "to", "the", "class", "for", "each", "added", "namespace", "to", "allow", "for", "use", "of", "dot", "notation", ".", "All", "prefixes", "are", "converted", "to", "lowercase" ]

[ "def", "prefix", "(", "self", ",", "format", "=", "\"sparql\"", ")", ":", "lg", "=", "logging", ".", "getLogger", "(", "\"%s.%s\"", "%", "(", "self", ".", "ln", ",", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ")", ")", "lg", ".", "setLevel", "(", "self", ".", "log_level", ")", "_return_str", "=", "\"\"", "if", "format", ".", "lower", "(", ")", "==", "\"sparql\"", ":", "return", "\"\\n\"", ".", "join", "(", "[", "ns", ".", "_sparql_", "for", "ns", "in", "self", ".", "namespaces", "]", ")", "elif", "format", ".", "lower", "(", ")", "in", "[", "\"turtle\"", ",", "\"ttl\"", "]", ":", "return", "\"\\n\"", ".", "join", "(", "[", "ns", ".", "_ttl_", "for", "ns", "in", "self", ".", "namespaces", "]", ")", "elif", "format", ".", "lower", "(", ")", "in", "[", "\"rdf\"", ",", "\"xml\"", ",", "\"rdf/xml\"", "]", ":", "return", "\"<rdf:RDF %s>\"", "%", "\" \"", ".", "join", "(", "[", "ns", ".", "_xml_", "for", "ns", "in", "self", ".", "namespaces", "]", ")", "else", ":", "raise", "NotImplementedError", "(", "\"'%s' is not a valid prefix type.\"", "%", "format", ")" ]

[ "Generates", "a", "string", "of", "the", "rdf", "namespaces", "listed", "used", "in", "the", "framework" ]

[ "def", "load", "(", "self", ",", "filepath", ",", "file_encoding", "=", "None", ")", ":", "with", "open", "(", "filepath", ",", "encoding", "=", "file_encoding", ")", "as", "inf", ":", "for", "line", "in", "inf", ":", "current_line", "=", "str", "(", "line", ")", ".", "strip", "(", ")", "if", "current_line", ".", "startswith", "(", "\"@prefix\"", ")", ":", "self", ".", "_add_ttl_ns", "(", "current_line", ".", "replace", "(", "\"\\n\"", ",", "\"\"", ")", ")", "elif", "len", "(", "current_line", ")", ">", "10", ":", "break", "self", ".", "__make_dicts__" ]

[ "Reads", "the", "the", "beginning", "of", "a", "turtle", "file", "and", "sets", "the", "prefix", "s", "used", "in", "that", "file", "and", "sets", "the", "prefix", "attribute" ]

[ "def", "dict_load", "(", "self", ",", "ns_dict", ")", ":", "for", "prefix", ",", "uri", "in", "ns_dict", ".", "items", "(", ")", ":", "self", ".", "bind", "(", "prefix", ",", "uri", ",", "override", "=", "False", ",", "calc", "=", "False", ")", "self", ".", "__make_dicts__" ]

[ "Reads", "a", "dictionary", "of", "namespaces", "and", "binds", "them", "to", "the", "manager" ]

[ "def", "_add_ttl_ns", "(", "self", ",", "line", ")", ":", "lg", "=", "logging", ".", "getLogger", "(", "\"%s.%s\"", "%", "(", "self", ".", "ln", ",", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ")", ")", "lg", ".", "setLevel", "(", "self", ".", "log_level", ")", "lg", ".", "debug", "(", "\"line:\\n%s\"", ",", "line", ")", "line", "=", "str", "(", "line", ")", ".", "strip", "(", ")", "# if the line is not a prefix line exit", "if", "line", "is", "None", "or", "line", "==", "'none'", "or", "line", "==", "''", "or", "not", "line", ".", "lower", "(", ")", ".", "startswith", "(", "'@prefix'", ")", ":", "return", "# parse the turtle line", "line", "=", "line", ".", "replace", "(", "\"@prefix\"", ",", "\"\"", ",", "1", ")", ".", "strip", "(", ")", "if", "line", ".", "endswith", "(", "\".\"", ")", ":", "line", "=", "line", "[", ":", "-", "1", "]", "prefix", "=", "line", "[", ":", "line", ".", "find", "(", "\":\"", ")", "]", ".", "strip", "(", ")", "uri", "=", "self", ".", "clean_iri", "(", "line", "[", "line", ".", "find", "(", "\":\"", ")", "+", "1", ":", "]", ".", "strip", "(", ")", ")", "# add the namespace to the class", "lg", ".", "debug", "(", "\"\\nprefix: %s uri: %s\"", ",", "prefix", ",", "uri", ")", "self", ".", "bind", "(", "prefix", ",", "uri", ",", "override", "=", "False", ",", "calc", "=", "False", ")" ]

[ "takes", "one", "prefix", "line", "from", "the", "turtle", "file", "and", "binds", "the", "namespace", "to", "the", "class" ]

[ "def", "del_ns", "(", "self", ",", "namespace", ")", ":", "# remove the item from the namespace dict", "namespace", "=", "str", "(", "namespace", ")", "attr_name", "=", "None", "if", "hasattr", "(", "self", ",", "namespace", ")", ":", "delattr", "(", "self", ",", "namespace", ")" ]

[ "will", "remove", "a", "namespace", "ref", "from", "the", "manager", ".", "either", "Arg", "is", "optional", "." ]

[ "def", "convert_to_uri", "(", "self", ",", "value", ",", "strip_iri", "=", "True", ")", ":", "parsed", "=", "self", ".", "parse_uri", "(", "str", "(", "value", ")", ")", "try", ":", "new_uri", "=", "\"%s%s\"", "%", "(", "self", ".", "ns_dict", "[", "parsed", "[", "0", "]", "]", ",", "parsed", "[", "1", "]", ")", "if", "not", "strip_iri", ":", "return", "self", ".", "iri", "(", "new_uri", ")", "return", "new_uri", "except", "KeyError", ":", "return", "self", ".", "rpyhttp", "(", "value", ")" ]

[ "converts", "a", "prefixed", "rdf", "ns", "equivalent", "value", "to", "its", "uri", "form", ".", "If", "not", "found", "returns", "the", "value", "as", "is" ]

[ "def", "get_uri_parts", "(", "self", ",", "value", ")", ":", "if", "value", ".", "startswith", "(", "'pyuri_'", ")", ":", "value", "=", "self", ".", "rpyhttp", "(", "value", ")", "parts", "=", "self", ".", "parse_uri", "(", "value", ")", "try", ":", "return", "(", "self", ".", "ns_dict", "[", "parts", "[", "0", "]", "]", ",", "parts", "[", "1", "]", ")", "except", "KeyError", ":", "try", ":", "return", "(", "self", ".", "ns_dict", "[", "parts", "[", "0", "]", ".", "lower", "(", ")", "]", ",", "parts", "[", "1", "]", ")", "except", "KeyError", ":", "return", "(", "(", "None", ",", "parts", "[", "0", "]", ")", ",", "parts", "[", "1", "]", ")" ]

[ "takes", "an", "value", "and", "returns", "a", "tuple", "of", "the", "parts" ]

[ "def", "rpyhttp", "(", "value", ")", ":", "if", "value", ".", "startswith", "(", "\"http\"", ")", ":", "return", "value", "try", ":", "parts", "=", "value", ".", "split", "(", "\"_\"", ")", "del", "parts", "[", "0", "]", "_uri", "=", "base64", ".", "b64decode", "(", "parts", ".", "pop", "(", "0", ")", ")", ".", "decode", "(", ")", "return", "_uri", "+", "\"_\"", ".", "join", "(", "parts", ")", "except", "(", "IndexError", ",", "UnicodeDecodeError", ",", "binascii", ".", "Error", ")", ":", "# if the value is not a pyuri return the value", "return", "value" ]

[ "converts", "a", "no", "namespace", "pyuri", "back", "to", "a", "standard", "uri" ]

[ "def", "pyhttp", "(", "self", ",", "value", ")", ":", "if", "value", ".", "startswith", "(", "\"pyuri_\"", ")", ":", "return", "value", "parts", "=", "self", ".", "parse_uri", "(", "value", ")", "return", "\"pyuri_%s_%s\"", "%", "(", "base64", ".", "b64encode", "(", "bytes", "(", "parts", "[", "0", "]", ",", "\"utf-8\"", ")", ")", ".", "decode", "(", ")", ",", "parts", "[", "1", "]", ")" ]

[ "converts", "a", "no", "namespaces", "uri", "to", "a", "python", "excessable", "name" ]

[ "def", "iri", "(", "uri_string", ")", ":", "uri_string", "=", "str", "(", "uri_string", ")", "if", "uri_string", "[", ":", "1", "]", "==", "\"?\"", ":", "return", "uri_string", "if", "uri_string", "[", ":", "1", "]", "==", "\"[\"", ":", "return", "uri_string", "if", "uri_string", "[", ":", "1", "]", "!=", "\"<\"", ":", "uri_string", "=", "\"<{}\"", ".", "format", "(", "uri_string", ".", "strip", "(", ")", ")", "if", "uri_string", "[", "len", "(", "uri_string", ")", "-", "1", ":", "]", "!=", "\">\"", ":", "uri_string", "=", "\"{}>\"", ".", "format", "(", "uri_string", ".", "strip", "(", ")", ")", "return", "uri_string" ]

[ "converts", "a", "string", "to", "an", "IRI", "or", "returns", "an", "IRI", "if", "already", "formated" ]

[ "def", "convert_to_ttl", "(", "self", ",", "value", ")", ":", "parsed", "=", "self", ".", "parse_uri", "(", "value", ")", "try", ":", "rtn_val", "=", "\"%s:%s\"", "%", "(", "self", ".", "uri_dict", "[", "parsed", "[", "0", "]", "]", ",", "parsed", "[", "1", "]", ")", "except", "KeyError", ":", "rtn_val", "=", "self", ".", "iri", "(", "self", ".", "rpyhttp", "(", "value", ")", ")", "return", "rtn_val" ]

[ "converts", "a", "value", "to", "the", "prefixed", "rdf", "ns", "equivalent", ".", "If", "not", "found", "returns", "the", "value", "as", "is", "." ]

[ "def", "convert_to_ns", "(", "self", ",", "value", ")", ":", "parsed", "=", "self", ".", "parse_uri", "(", "value", ")", "try", ":", "rtn_val", "=", "\"%s_%s\"", "%", "(", "self", ".", "uri_dict", "[", "parsed", "[", "0", "]", "]", ",", "parsed", "[", "1", "]", ")", "except", "KeyError", ":", "rtn_val", "=", "self", ".", "pyhttp", "(", "value", ")", "return", "rtn_val" ]

[ "converts", "a", "value", "to", "the", "prefixed", "rdf", "ns", "equivalent", ".", "If", "not", "found", "returns", "the", "value", "as", "is" ]

[ "def", "_get_stack_frame", "(", "stacklevel", ")", ":", "stacklevel", "=", "stacklevel", "+", "1", "if", "stacklevel", "<=", "1", "or", "_is_internal_frame", "(", "sys", ".", "_getframe", "(", "1", ")", ")", ":", "# If frame is too small to care or if the warning originated in", "# internal code, then do not try to hide any frames.", "frame", "=", "sys", ".", "_getframe", "(", "stacklevel", ")", "else", ":", "frame", "=", "sys", ".", "_getframe", "(", "1", ")", "# Look for one frame less since the above line starts us off.", "for", "x", "in", "range", "(", "stacklevel", "-", "1", ")", ":", "frame", "=", "_next_external_frame", "(", "frame", ")", "if", "frame", "is", "None", ":", "raise", "ValueError", "return", "frame" ]

[ "utility", "functions", "to", "get", "a", "stackframe", "skipping", "internal", "frames", "." ]

[ "def", "warn", "(", "message", ",", "category", "=", "None", ",", "stacklevel", "=", "1", ",", "emitstacklevel", "=", "1", ")", ":", "# Check if message is already a Warning object", "####################", "### Get category ###", "####################", "if", "isinstance", "(", "message", ",", "Warning", ")", ":", "category", "=", "message", ".", "__class__", "# Check category argument", "if", "category", "is", "None", ":", "category", "=", "UserWarning", "if", "not", "(", "isinstance", "(", "category", ",", "type", ")", "and", "issubclass", "(", "category", ",", "Warning", ")", ")", ":", "raise", "TypeError", "(", "\"category must be a Warning subclass, \"", "\"not '{:s}'\"", ".", "format", "(", "type", "(", "category", ")", ".", "__name__", ")", ")", "# Get context information", "try", ":", "frame", "=", "_get_stack_frame", "(", "stacklevel", ")", "except", "ValueError", ":", "globals", "=", "sys", ".", "__dict__", "lineno", "=", "1", "else", ":", "globals", "=", "frame", ".", "f_globals", "lineno", "=", "frame", ".", "f_lineno", "try", ":", "eframe", "=", "_get_stack_frame", "(", "emitstacklevel", ")", "except", "ValueError", ":", "eglobals", "=", "sys", ".", "__dict__", "else", ":", "eglobals", "=", "eframe", ".", "f_globals", "if", "'__name__'", "in", "eglobals", ":", "emodule", "=", "eglobals", "[", "'__name__'", "]", "else", ":", "emodule", "=", "\"<string>\"", "####################", "### Get Filename ###", "####################", "if", "'__name__'", "in", "globals", ":", "module", "=", "globals", "[", "'__name__'", "]", "else", ":", "module", "=", "\"<string>\"", "####################", "### Get Filename ###", "####################", "filename", "=", "globals", ".", "get", "(", "'__file__'", ")", "if", "filename", ":", "fnl", "=", "filename", ".", "lower", "(", ")", "if", "fnl", ".", "endswith", "(", "\".pyc\"", ")", ":", "filename", "=", "filename", "[", ":", "-", "1", "]", "else", ":", "if", "module", "==", "\"__main__\"", ":", "try", ":", "filename", "=", "sys", ".", "argv", "[", "0", "]", "except", "AttributeError", ":", "# embedded interpreters don't have sys.argv, see bug #839151", "filename", "=", "'__main__'", "if", "not", "filename", ":", "filename", "=", "module", "registry", "=", "globals", ".", "setdefault", "(", "\"__warningregistry__\"", ",", "{", "}", ")", "warn_explicit", "(", "message", ",", "category", ",", "filename", ",", "lineno", ",", "module", ",", "registry", ",", "globals", ",", "emit_module", "=", "emodule", ")" ]

[ "Issue", "a", "warning", "or", "maybe", "ignore", "it", "or", "raise", "an", "exception", "." ]

[ "def", "_set_proxy_filter", "(", "warningstuple", ")", ":", "if", "len", "(", "warningstuple", ")", ">", "5", ":", "key", "=", "len", "(", "_proxy_map", ")", "+", "1", "_proxy_map", "[", "key", "]", "=", "warningstuple", "# always is pass-through further in the code.", "return", "(", "'always'", ",", "re_matchall", ",", "ProxyWarning", ",", "re_matchall", ",", "key", ")", "else", ":", "return", "warningstuple" ]

[ "set", "up", "a", "proxy", "that", "store", "too", "long", "warnings", "in", "a", "separate", "map" ]

[ "def", "release", "(", "ctx", ",", "deploy", "=", "False", ",", "test", "=", "False", ",", "version", "=", "''", ")", ":", "if", "test", ":", "run", "(", "\"python setup.py check\"", ")", "run", "(", "\"python setup.py register sdist upload --dry-run\"", ")", "if", "deploy", ":", "run", "(", "\"python setup.py check\"", ")", "if", "version", ":", "run", "(", "\"git checkout master\"", ")", "run", "(", "\"git tag -a v{ver} -m 'v{ver}'\"", ".", "format", "(", "ver", "=", "version", ")", ")", "run", "(", "\"git push\"", ")", "run", "(", "\"git push origin --tags\"", ")", "run", "(", "\"python setup.py sdist bdist_wheel\"", ")", "run", "(", "\"twine upload --skip-existing dist/*\"", ")", "else", ":", "print", "(", "\"- Have you updated the version?\"", ")", "print", "(", "\"- Have you updated CHANGELOG.md, README.md, and AUTHORS.md?\"", ")", "print", "(", "\"- Have you fixed any last minute bugs?\"", ")", "print", "(", "\"- Have you merged changes for release into the master branch?\"", ")", "print", "(", "\"If you answered yes to all of the above questions,\"", ")", "print", "(", "\"then run `inv release --deploy -vX.YY.ZZ` to:\"", ")", "print", "(", "\"- Checkout master\"", ")", "print", "(", "\"- Tag the git release with provided vX.YY.ZZ version\"", ")", "print", "(", "\"- Push the master branch and tags to repo\"", ")" ]

[ "Tag", "release", "run", "Travis", "-", "CI", "and", "deploy", "to", "PyPI" ]

[ "def", "squarify_table", "(", "table", ")", ":", "max_length", "=", "0", "min_length", "=", "maxsize", "for", "row", "in", "table", ":", "row_len", "=", "len", "(", "row", ")", "if", "row_len", ">", "max_length", ":", "max_length", "=", "row_len", "if", "row_len", "<", "min_length", ":", "min_length", "=", "row_len", "if", "max_length", "!=", "min_length", ":", "for", "row", "in", "table", ":", "row_len", "=", "len", "(", "row", ")", "if", "row_len", "<", "max_length", ":", "row", ".", "extend", "(", "[", "None", "]", "*", "(", "max_length", "-", "row_len", ")", ")" ]

[ "Updates", "a", "table", "so", "that", "all", "rows", "are", "the", "same", "length", "by", "filling", "smaller", "rows", "with", "None", "objects", "up", "to", "the", "length", "of", "the", "largest", "row", "." ]

[ "def", "_get_process_cwd", "(", "pid", ")", ":", "cmd", "=", "'lsof -a -p {0} -d cwd -Fn'", ".", "format", "(", "pid", ")", "data", "=", "common", ".", "shell_process", "(", "cmd", ")", "if", "not", "data", "is", "None", ":", "lines", "=", "str", "(", "data", ")", ".", "split", "(", "'\\n'", ")", "# the cwd is the second line with 'n' prefix removed from value", "if", "len", "(", "lines", ")", ">", "1", ":", "return", "lines", "[", "1", "]", "[", "1", ":", "]", "or", "None", "return", "None" ]

[ "Returns", "the", "working", "directory", "for", "the", "provided", "process", "identifier", "." ]

[ "def", "_get_checksum", "(", "path", ")", ":", "# md5 uses a 512-bit digest blocks, let's scale by defined block_size", "_md5", "=", "hashlib", ".", "md5", "(", ")", "chunk_size", "=", "128", "*", "_md5", ".", "block_size", "try", ":", "with", "open", "(", "path", ",", "'rb'", ")", "as", "_file", ":", "for", "chunk", "in", "iter", "(", "lambda", ":", "_file", ".", "read", "(", "chunk_size", ")", ",", "''", ")", ":", "_md5", ".", "update", "(", "chunk", ")", "return", "_md5", ".", "hexdigest", "(", ")", "except", "IOError", ":", "return", "None" ]

[ "Generates", "a", "md5", "checksum", "of", "the", "file", "at", "the", "specified", "path", "." ]

[ "def", "_get_user_processes", "(", ")", ":", "uid", "=", "os", ".", "getuid", "(", ")", "for", "proc", "in", "psutil", ".", "process_iter", "(", ")", ":", "try", ":", "# yield processes that match current user", "if", "proc", ".", "uids", ".", "real", "==", "uid", ":", "yield", "(", "proc", ",", "proc", ".", "exe", ")", "except", "psutil", ".", "AccessDenied", ":", "# work around for suid/sguid processes and MacOS X restrictions", "try", ":", "path", "=", "common", ".", "which", "(", "proc", ".", "name", ")", "# psutil doesn't support MacOS X relative paths,", "# let's use a workaround to merge working directory with", "# process relative path", "if", "not", "path", "and", "common", ".", "IS_MACOSX", ":", "cwd", "=", "_get_process_cwd", "(", "proc", ".", "pid", ")", "if", "not", "cwd", ":", "continue", "path", "=", "os", ".", "path", ".", "join", "(", "cwd", ",", "proc", ".", "cmdline", "[", "0", "]", ")", "yield", "(", "proc", ",", "path", ")", "except", "(", "psutil", ".", "AccessDenied", ",", "OSError", ")", ":", "pass", "except", "psutil", ".", "NoSuchProcess", ":", "pass" ]

[ "Gets", "process", "information", "owned", "by", "the", "current", "user", "." ]

[ "def", "_stop_processes", "(", "paths", ")", ":", "def", "cache_checksum", "(", "path", ")", ":", "\"\"\" Checksum provided path, cache, and return value.\n \"\"\"", "if", "not", "path", ":", "return", "None", "if", "not", "path", "in", "_process_checksums", ":", "checksum", "=", "_get_checksum", "(", "path", ")", "_process_checksums", "[", "path", "]", "=", "checksum", "return", "_process_checksums", "[", "path", "]", "if", "not", "paths", ":", "return", "target_checksums", "=", "dict", "(", "(", "cache_checksum", "(", "p", ")", ",", "1", ")", "for", "p", "in", "paths", ")", "if", "not", "target_checksums", ":", "return", "for", "proc", ",", "path", "in", "_get_user_processes", "(", ")", ":", "# path's checksum matches targets, attempt to terminate", "if", "cache_checksum", "(", "path", ")", "in", "target_checksums", ":", "try", ":", "proc", ".", "terminate", "(", ")", "except", "(", "psutil", ".", "AccessDenied", ",", "psutil", ".", "NoSuchProcess", ")", ":", "pass" ]

[ "Scans", "process", "list", "trying", "to", "terminate", "processes", "matching", "paths", "specified", ".", "Uses", "checksums", "to", "identify", "processes", "that", "are", "duplicates", "of", "those", "specified", "to", "terminate", "." ]

[ "def", "_run_apps", "(", "self", ",", "paths", ")", ":", "for", "path", "in", "paths", ":", "common", ".", "shell_process", "(", "path", ",", "background", "=", "True", ")", "time", ".", "sleep", "(", "0.2", ")" ]

[ "Runs", "apps", "for", "the", "provided", "paths", "." ]

[ "def", "norm_mle", "(", "data", ",", "algorithm", "=", "'Nelder-Mead'", ",", "debug", "=", "False", ")", ":", "import", "scipy", ".", "stats", "as", "sstat", "import", "scipy", ".", "optimize", "as", "sopt", "def", "objective_nll_norm_uni", "(", "theta", ",", "data", ")", ":", "return", "-", "1.0", "*", "sstat", ".", "norm", ".", "logpdf", "(", "data", ",", "loc", "=", "theta", "[", "0", "]", ",", "scale", "=", "theta", "[", "1", "]", ")", ".", "sum", "(", ")", "# check eligible algorithm", "if", "algorithm", "not", "in", "(", "'Nelder-Mead'", ",", "'CG'", ",", "'BFGS'", ")", ":", "raise", "Exception", "(", "'Optimization Algorithm not supported.'", ")", "# set start values", "theta0", "=", "[", "1.0", ",", "1.0", "]", "# mu and sigma", "# run solver", "results", "=", "sopt", ".", "minimize", "(", "objective_nll_norm_uni", ",", "theta0", ",", "args", "=", "(", "data", ")", ",", "method", "=", "algorithm", ",", "options", "=", "{", "'disp'", ":", "False", "}", ")", "# debug?", "if", "debug", ":", "return", "results", "# done", "return", "results", ".", "x", "[", "0", "]", ",", "results", ".", "x", "[", "1", "]" ]

[ "Estimate", "Mean", "and", "Std", ".", "Dev", ".", "of", "the", "Normal", "Distribution" ]

[ "def", "get", "(", "self", ",", "status_item", ")", ":", "lg", "=", "logging", ".", "getLogger", "(", "\"%s.%s\"", "%", "(", "self", ".", "ln", ",", "inspect", ".", "stack", "(", ")", "[", "0", "]", "[", "3", "]", ")", ")", "lg", ".", "setLevel", "(", "self", ".", "log_level", ")", "sparql", "=", "'''\n SELECT ?loaded\n WHERE {{\n kdr:{0} kds:{1} ?loaded .\n }}'''", "value", "=", "self", ".", "conn", ".", "query", "(", "sparql", "=", "sparql", ".", "format", "(", "self", ".", "group", ",", "status_item", ")", ")", "if", "len", "(", "value", ")", ">", "0", "and", "cbool", "(", "value", "[", "0", "]", ".", "get", "(", "'loaded'", ",", "{", "}", ")", ".", "get", "(", "\"value\"", ",", "False", ")", ")", ":", "return", "True", "else", ":", "return", "False" ]

[ "queries", "the", "database", "and", "returns", "that", "status", "of", "the", "item", "." ]

[ "def", "local_machine_uuid", "(", ")", ":", "result", "=", "subprocess", ".", "check_output", "(", "'hal-get-property --udi '", "'/org/freedesktop/Hal/devices/computer '", "'--key system.hardware.uuid'", ".", "split", "(", ")", ")", ".", "strip", "(", ")", "return", "uuid", ".", "UUID", "(", "hex", "=", "result", ")" ]

[ "Return", "local", "machine", "unique", "identifier", "." ]

[ "def", "read", "(", "self", ",", "required", "=", "False", ")", ":", "self", ".", "_pristine_cache", "=", "{", "}", "self", ".", "_cache", "=", "{", "}", "try", ":", "data", ",", "stat", "=", "yield", "self", ".", "_client", ".", "get", "(", "self", ".", "_path", ")", "data", "=", "yaml", ".", "load", "(", "data", ")", "if", "data", ":", "self", ".", "_pristine_cache", "=", "data", "self", ".", "_cache", "=", "data", ".", "copy", "(", ")", "except", "NoNodeException", ":", "if", "required", ":", "raise", "StateNotFound", "(", "self", ".", "_path", ")" ]

[ "Read", "Zookeeper", "state", "." ]

[ "def", "write", "(", "self", ")", ":", "self", ".", "_check", "(", ")", "cache", "=", "self", ".", "_cache", "pristine_cache", "=", "self", ".", "_pristine_cache", "self", ".", "_pristine_cache", "=", "cache", ".", "copy", "(", ")", "# Used by `apply_changes` function to return the changes to", "# this scope.", "changes", "=", "[", "]", "def", "apply_changes", "(", "content", ",", "stat", ")", ":", "\"\"\"Apply the local state to the Zookeeper node state.\"\"\"", "del", "changes", "[", ":", "]", "current", "=", "yaml", ".", "load", "(", "content", ")", "if", "content", "else", "{", "}", "missing", "=", "object", "(", ")", "for", "key", "in", "set", "(", "pristine_cache", ")", ".", "union", "(", "cache", ")", ":", "old_value", "=", "pristine_cache", ".", "get", "(", "key", ",", "missing", ")", "new_value", "=", "cache", ".", "get", "(", "key", ",", "missing", ")", "if", "old_value", "!=", "new_value", ":", "if", "new_value", "!=", "missing", ":", "current", "[", "key", "]", "=", "new_value", "if", "old_value", "!=", "missing", ":", "changes", ".", "append", "(", "ModifiedItem", "(", "key", ",", "old_value", ",", "new_value", ")", ")", "else", ":", "changes", ".", "append", "(", "AddedItem", "(", "key", ",", "new_value", ")", ")", "elif", "key", "in", "current", ":", "del", "current", "[", "key", "]", "changes", ".", "append", "(", "DeletedItem", "(", "key", ",", "old_value", ")", ")", "return", "yaml", ".", "safe_dump", "(", "current", ")", "# Apply the change till it takes.", "yield", "retry_change", "(", "self", ".", "_client", ",", "self", ".", "_path", ",", "apply_changes", ")", "returnValue", "(", "changes", ")" ]

[ "Write", "object", "state", "to", "Zookeeper", "." ]

[ "def", "printif", "(", "self", ",", "obj_print", ",", "tipo_print", "=", "None", ")", ":", "if", "self", ".", "verbose", ":", "print", "(", "obj_print", ")", "if", "tipo_print", "==", "'ok'", ":", "logging", ".", "info", "(", "obj_print", ")", "elif", "tipo_print", "==", "'error'", ":", "logging", ".", "error", "(", "obj_print", ")", "elif", "tipo_print", "==", "'warning'", ":", "logging", ".", "warning", "(", "obj_print", ")" ]

[ "Color", "output", "&", "logging", "." ]