Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "history_previous", "(", "self", ",", "substring", "=", "''", ",", "as_prefix", "=", "True", ")", ":", "index", "=", "self", ".", "_history_index", "replace", "=", "False", "while", "index", ">", "0", ":", "index", "-=", "1", "history", "=", "self", ".", "_get_edited_history", "(", "index", ")", "if", "(", "as_prefix", "and", "history", ".", "startswith", "(", "substring", ")", ")", "or", "(", "not", "as_prefix", "and", "substring", "in", "history", ")", ":", "replace", "=", "True", "break", "if", "replace", ":", "self", ".", "_store_edits", "(", ")", "self", ".", "_history_index", "=", "index", "self", ".", "input_buffer", "=", "history", "return", "replace" ]

[ "If", "possible", "set", "the", "input", "buffer", "to", "a", "previous", "history", "item", "." ]

[ "def", "get_main_activity", "(", "self", ")", ":", "x", "=", "set", "(", ")", "y", "=", "set", "(", ")", "for", "i", "in", "self", ".", "xml", ":", "activities_and_aliases", "=", "self", ".", "xml", "[", "i", "]", ".", "getElementsByTagName", "(", "\"activity\"", ")", "+", "self", ".", "xml", "[", "i", "]", ".", "getElementsByTagName", "(", "\"activity-alias\"", ")", "for", "item", "in", "activities_and_aliases", ":", "# Some applications have more than one MAIN activity.", "# For example: paid and free content", "activityEnabled", "=", "item", ".", "getAttributeNS", "(", "NS_ANDROID_URI", ",", "\"enabled\"", ")", "if", "activityEnabled", "is", "not", "None", "and", "activityEnabled", "!=", "\"\"", "and", "activityEnabled", "==", "\"false\"", ":", "continue", "for", "sitem", "in", "item", ".", "getElementsByTagName", "(", "\"action\"", ")", ":", "val", "=", "sitem", ".", "getAttributeNS", "(", "NS_ANDROID_URI", ",", "\"name\"", ")", "if", "val", "==", "\"android.intent.action.MAIN\"", ":", "x", ".", "add", "(", "item", ".", "getAttributeNS", "(", "NS_ANDROID_URI", ",", "\"name\"", ")", ")", "for", "sitem", "in", "item", ".", "getElementsByTagName", "(", "\"category\"", ")", ":", "val", "=", "sitem", ".", "getAttributeNS", "(", "NS_ANDROID_URI", ",", "\"name\"", ")", "if", "val", "==", "\"android.intent.category.LAUNCHER\"", ":", "y", ".", "add", "(", "item", ".", "getAttributeNS", "(", "NS_ANDROID_URI", ",", "\"name\"", ")", ")", "z", "=", "x", ".", "intersection", "(", "y", ")", "if", "len", "(", "z", ")", ">", "0", ":", "return", "self", ".", "format_value", "(", "z", ".", "pop", "(", ")", ")", "return", "None" ]

[ "Return", "the", "name", "of", "the", "main", "activity" ]

[ "def", "all_files_exist", "(", "file_list", ")", ":", "all_exist", "=", "True", "for", "filename", "in", "file_list", ":", "all_exist", "=", "all_exist", "and", "os", ".", "path", ".", "isfile", "(", "filename", ")", "return", "all_exist" ]

[ "Check", "if", "all", "files", "exist", "." ]

[ "def", "callback", "(", "self", ",", "sources", ")", ":", "enable", "=", "bool", "(", "sources", ")", "if", "not", "enable", ":", "self", ".", "plot_widget", ".", "value", "=", "False", "enable_widget", "(", "self", ".", "plot_widget", ",", "enable", ")", "if", "self", ".", "done_callback", ":", "self", ".", "done_callback", "(", "sources", ")" ]

[ "When", "a", "source", "is", "selected", "enable", "widgets", "that", "depend", "on", "that", "condition", "and", "do", "done_callback" ]

[ "def", "_format", "(", "noms", ")", ":", "if", "isinstance", "(", "noms", ",", "(", "list", ",", "tuple", ",", "pd", ".", "Series", ")", ")", ":", "noms", "=", "','", ".", "join", "(", "noms", ")", "noms", "=", "noms", ".", "replace", "(", "\",\"", ",", "\"','\"", ")", "return", "noms" ]

[ "Formate", "une", "donnée", "d", "entrée", "pour", "être", "exploitable", "dans", "les", "fonctions", "liste_", "*", "et", "get_", "*", "." ]

[ "def", "process", "(", "self", ",", "nemo", ")", ":", "self", ".", "__nemo__", "=", "nemo", "for", "annotation", "in", "self", ".", "__annotations__", ":", "annotation", ".", "target", ".", "expanded", "=", "frozenset", "(", "self", ".", "__getinnerreffs__", "(", "objectId", "=", "annotation", ".", "target", ".", "objectId", ",", "subreference", "=", "annotation", ".", "target", ".", "subreference", ")", ")" ]

[ "Register", "nemo", "and", "parses", "annotations" ]

[ "def", "get_descendants", "(", "self", ",", "collections", "=", "True", ",", "resources", "=", "True", ",", "depth_first", "=", "False", ",", "depth", "=", "\"infinity\"", ",", "add_self", "=", "False", ",", ")", ":", "assert", "depth", "in", "(", "\"0\"", ",", "\"1\"", ",", "\"infinity\"", ")", "res", "=", "[", "]", "if", "add_self", "and", "not", "depth_first", ":", "res", ".", "append", "(", "self", ")", "if", "depth", "!=", "\"0\"", "and", "self", ".", "is_collection", ":", "for", "child", "in", "self", ".", "get_member_list", "(", ")", ":", "if", "not", "child", ":", "self", ".", "get_member_list", "(", ")", "want", "=", "(", "collections", "and", "child", ".", "is_collection", ")", "or", "(", "resources", "and", "not", "child", ".", "is_collection", ")", "if", "want", "and", "not", "depth_first", ":", "res", ".", "append", "(", "child", ")", "if", "child", ".", "is_collection", "and", "depth", "==", "\"infinity\"", ":", "res", ".", "extend", "(", "child", ".", "get_descendants", "(", "collections", ",", "resources", ",", "depth_first", ",", "depth", ",", "add_self", "=", "False", ")", ")", "if", "want", "and", "depth_first", ":", "res", ".", "append", "(", "child", ")", "if", "add_self", "and", "depth_first", ":", "res", ".", "append", "(", "self", ")", "return", "res" ]

[ "Return", "a", "list", "_DAVResource", "objects", "of", "a", "collection", "(", "children", "grand", "-", "children", "...", ")", "." ]

[ "def", "create", "(", "self", ",", "index", ",", "doc_type", ",", "body", ",", "id", "=", "None", ",", "*", "*", "query_params", ")", ":", "query_params", "[", "'op_type'", "]", "=", "'create'", "result", "=", "yield", "self", ".", "index", "(", "index", ",", "doc_type", ",", "body", ",", "id", "=", "id", ",", "params", "=", "query_params", ")", "returnValue", "(", "result", ")" ]

[ "Adds", "a", "typed", "JSON", "document", "in", "a", "specific", "index", "making", "it", "searchable", ".", "Behind", "the", "scenes", "this", "method", "calls", "index", "(", "...", "op_type", "=", "create", ")", "<http", ":", "//", "www", ".", "elastic", ".", "co", "/", "guide", "/", "en", "/", "elasticsearch", "/", "reference", "/", "current", "/", "docs", "-", "index_", ".", "html", ">", "_", ":", "param", "index", ":", "The", "name", "of", "the", "index", ":", "param", "doc_type", ":", "The", "type", "of", "the", "document", ":", "param", "body", ":", "The", "document", ":", "param", "id", ":", "Document", "ID", ":", "arg", "consistency", ":", "Explicit", "write", "consistency", "setting", "for", "the", "operation", "valid", "choices", "are", ":", "one", "quorum", "all", ":", "arg", "op_type", ":", "Explicit", "operation", "type", "default", "index", "valid", "choices", "are", ":", "index", "create", ":", "arg", "parent", ":", "ID", "of", "the", "parent", "document", ":", "arg", "refresh", ":", "Refresh", "the", "index", "after", "performing", "the", "operation", ":", "arg", "routing", ":", "Specific", "routing", "value", ":", "arg", "timeout", ":", "Explicit", "operation", "timeout", ":", "arg", "timestamp", ":", "Explicit", "timestamp", "for", "the", "document", ":", "arg", "ttl", ":", "Expiration", "time", "for", "the", "document", ":", "arg", "version", ":", "Explicit", "version", "number", "for", "concurrency", "control", ":", "arg", "version_type", ":", "Specific", "version", "type", "valid", "choices", "are", ":", "internal", "external", "external_gte", "force" ]

[ "def", "_update_statechanges", "(", "storage", ":", "SQLiteStorage", ")", ":", "batch_size", "=", "50", "batch_query", "=", "storage", ".", "batch_query_state_changes", "(", "batch_size", "=", "batch_size", ",", "filters", "=", "[", "(", "'_type'", ",", "'raiden.transfer.state_change.ContractReceiveChannelNew'", ")", ",", "]", ",", ")", "for", "state_changes_batch", "in", "batch_query", ":", "updated_state_changes", "=", "list", "(", ")", "for", "state_change", "in", "state_changes_batch", ":", "data", "=", "json", ".", "loads", "(", "state_change", ".", "data", ")", "msg", "=", "'v20 ContractReceiveChannelNew channel state should not contain medation_fee'", "assert", "'mediation_fee'", "not", "in", "data", "[", "'channel_state'", "]", ",", "msg", "data", "[", "'channel_state'", "]", "[", "'mediation_fee'", "]", "=", "'0'", "updated_state_changes", ".", "append", "(", "(", "json", ".", "dumps", "(", "data", ")", ",", "state_change", ".", "state_change_identifier", ",", ")", ")", "storage", ".", "update_state_changes", "(", "updated_state_changes", ")", "batch_query", "=", "storage", ".", "batch_query_state_changes", "(", "batch_size", "=", "batch_size", ",", "filters", "=", "[", "(", "'_type'", ",", "'raiden.transfer.mediated_transfer.state_change.ActionInitInitiator'", ")", ",", "]", ",", ")", "for", "state_changes_batch", "in", "batch_query", ":", "updated_state_changes", "=", "list", "(", ")", "for", "state_change", "in", "state_changes_batch", ":", "data", "=", "json", ".", "loads", "(", "state_change", ".", "data", ")", "msg", "=", "'v20 ActionInitInitiator transfer should not contain allocated_fee'", "assert", "'allocated_fee'", "not", "in", "data", "[", "'transfer'", "]", ",", "msg", "data", "[", "'transfer'", "]", "[", "'allocated_fee'", "]", "=", "'0'", "updated_state_changes", ".", "append", "(", "(", "json", ".", "dumps", "(", "data", ")", ",", "state_change", ".", "state_change_identifier", ",", ")", ")", "storage", ".", "update_state_changes", "(", "updated_state_changes", ")" ]

[ "Update", "each", "ContractReceiveChannelNew", "s", "channel_state", "member", "by", "setting", "the", "mediation_fee", "that", "was", "added", "to", "the", "NettingChannelState" ]

[ "def", "sg_leaky_relu", "(", "x", ",", "opt", ")", ":", "return", "tf", ".", "where", "(", "tf", ".", "greater", "(", "x", ",", "0", ")", ",", "x", ",", "0.01", "*", "x", ",", "name", "=", "opt", ".", "name", ")" ]

[ "r", "See", "[", "Xu", "et", "al", ".", "2015", "]", "(", "https", ":", "//", "arxiv", ".", "org", "/", "pdf", "/", "1505", ".", "00853v2", ".", "pdf", ")" ]

[ "def", "follow_fd", "(", "fd", ")", ":", "dump", "=", "Dump", "(", ")", "for", "line", "in", "fd", ":", "if", "not", "line", ".", "strip", "(", ")", ":", "continue", "with", "flushing", "(", "sys", ".", "stdout", ",", "sys", ".", "stderr", ")", ":", "status", "=", "load", "(", "line", ")", "if", "status", ":", "dump", "(", "status", ")" ]

[ "Dump", "each", "line", "of", "input", "to", "stdio", "." ]

[ "def", "p_preprocessor_line_line", "(", "p", ")", ":", "p", ".", "lexer", ".", "lineno", "=", "int", "(", "p", "[", "2", "]", ")", "+", "p", ".", "lexer", ".", "lineno", "-", "p", ".", "lineno", "(", "2", ")" ]

[ "preproc_line", ":", "_LINE", "INTEGER" ]

[ "def", "postprocess_subject", "(", "self", ",", "entry", ")", ":", "if", "type", "(", "entry", ".", "subject", ")", "not", "in", "[", "str", ",", "unicode", "]", ":", "subject", "=", "u' '", ".", "join", "(", "[", "unicode", "(", "k", ")", "for", "k", "in", "entry", ".", "subject", "]", ")", "else", ":", "subject", "=", "entry", ".", "subject", "entry", ".", "subject", "=", "[", "k", ".", "strip", "(", ")", ".", "upper", "(", ")", "for", "k", "in", "subject", ".", "split", "(", "';'", ")", "]" ]

[ "Parse", "subject", "keywords", "." ]

[ "def", "treat", "(", "request_body", ")", ":", "# Python 3+ support", "if", "isinstance", "(", "request_body", ",", "six", ".", "binary_type", ")", ":", "request_body", "=", "request_body", ".", "decode", "(", "'utf-8'", ")", "try", ":", "data", "=", "json", ".", "loads", "(", "request_body", ")", "except", "ValueError", ":", "raise", "exceptions", ".", "UnknownAPIResource", "(", "'Request body is malformed JSON.'", ")", "unsafe_api_resource", "=", "APIResource", ".", "factory", "(", "data", ")", "try", ":", "consistent_api_resource", "=", "unsafe_api_resource", ".", "get_consistent_resource", "(", ")", "except", "AttributeError", ":", "raise", "exceptions", ".", "UnknownAPIResource", "(", "'The API resource provided is invalid.'", ")", "return", "consistent_api_resource" ]

[ "Treat", "a", "notification", "and", "guarantee", "its", "authenticity", "." ]

[ "def", "stop", "(", "self", ")", ":", "err", "=", "_pa", ".", "Pa_StopStream", "(", "self", ".", "_stream", ")", "if", "err", "==", "_pa", ".", "paStreamIsStopped", ":", "return", "self", ".", "_handle_error", "(", "err", ")" ]

[ "Terminate", "audio", "processing", "." ]

[ "def", "_get_answer", "(", "self", ",", "query", ",", "*", "*", "kwargs", ")", ":", "# send request to getty", "request", "=", "self", ".", "base_url", "+", "\"sparql.json\"", "try", ":", "res", "=", "self", ".", "session", ".", "get", "(", "request", ",", "params", "=", "{", "\"query\"", ":", "query", "}", ")", "except", "ConnectionError", "as", "e", ":", "raise", "ProviderUnavailableException", "(", "\"Request could not be executed - Request: %s - Params: %s\"", "%", "(", "request", ",", "query", ")", ")", "if", "res", ".", "status_code", "==", "404", ":", "raise", "ProviderUnavailableException", "(", "\"Service not found (status_code 404) - Request: %s - Params: %s\"", "%", "(", "request", ",", "query", ")", ")", "if", "not", "res", ".", "encoding", ":", "res", ".", "encoding", "=", "'utf-8'", "r", "=", "res", ".", "json", "(", ")", "d", "=", "{", "}", "for", "result", "in", "r", "[", "\"results\"", "]", "[", "\"bindings\"", "]", ":", "uri", "=", "result", "[", "\"Subject\"", "]", "[", "\"value\"", "]", "if", "\"Term\"", "in", "result", ":", "label", "=", "result", "[", "\"Term\"", "]", "[", "\"value\"", "]", "else", ":", "label", "=", "\"<not available>\"", "item", "=", "{", "'id'", ":", "result", "[", "\"Id\"", "]", "[", "\"value\"", "]", ",", "'uri'", ":", "uri", ",", "'type'", ":", "result", "[", "\"Type\"", "]", "[", "\"value\"", "]", ".", "rsplit", "(", "'#'", ",", "1", ")", "[", "1", "]", ",", "'label'", ":", "label", ",", "'lang'", ":", "result", "[", "\"Lang\"", "]", "[", "\"value\"", "]", "}", "if", "uri", "not", "in", "d", ":", "d", "[", "uri", "]", "=", "item", "if", "tags", ".", "tag", "(", "d", "[", "uri", "]", "[", "'lang'", "]", ")", ".", "format", "==", "tags", ".", "tag", "(", "self", ".", "_get_language", "(", "*", "*", "kwargs", ")", ")", ".", "format", ":", "pass", "elif", "tags", ".", "tag", "(", "item", "[", "'lang'", "]", ")", ".", "format", "==", "tags", ".", "tag", "(", "self", ".", "_get_language", "(", "*", "*", "kwargs", ")", ")", ".", "format", ":", "d", "[", "uri", "]", "=", "item", "elif", "tags", ".", "tag", "(", "item", "[", "'lang'", "]", ")", ".", "language", "and", "(", "tags", ".", "tag", "(", "item", "[", "'lang'", "]", ")", ".", "language", ".", "format", "==", "tags", ".", "tag", "(", "self", ".", "_get_language", "(", ")", ")", ".", "language", ".", "format", ")", ":", "d", "[", "uri", "]", "=", "item", "elif", "tags", ".", "tag", "(", "item", "[", "'lang'", "]", ")", ".", "format", "==", "tags", ".", "tag", "(", "'en'", ")", ".", "format", ":", "d", "[", "uri", "]", "=", "item", "return", "list", "(", "d", ".", "values", "(", ")", ")" ]

[ "Returns", "the", "results", "of", "the", "Sparql", "query", "to", "a", ":", "class", ":", "lst", "of", "concepts", "and", "collections", ".", "The", "return", ":", "class", ":", "lst", "can", "be", "empty", "." ]

[ "def", "source_changed", "(", "self", ",", "event", ")", ":", "# bail out early if the chain is empty", "transforms", "=", "self", ".", "_chain", ".", "transforms", "[", ":", "]", "if", "len", "(", "transforms", ")", "==", "0", ":", "self", ".", "transforms", "=", "[", "]", "return", "# If the change signal comes from a transform that already appears in", "# our simplified transform list, then there is no need to re-simplify.", "if", "event", "is", "not", "None", ":", "for", "source", "in", "event", ".", "sources", "[", ":", ":", "-", "1", "]", ":", "if", "source", "in", "self", ".", "transforms", ":", "self", ".", "update", "(", "event", ")", "return", "# First flatten the chain by expanding all nested chains", "new_chain", "=", "[", "]", "while", "len", "(", "transforms", ")", ">", "0", ":", "tr", "=", "transforms", ".", "pop", "(", "0", ")", "if", "isinstance", "(", "tr", ",", "ChainTransform", ")", "and", "not", "tr", ".", "dynamic", ":", "transforms", "=", "tr", ".", "transforms", "[", ":", "]", "+", "transforms", "else", ":", "new_chain", ".", "append", "(", "tr", ")", "# Now combine together all compatible adjacent transforms", "cont", "=", "True", "tr", "=", "new_chain", "while", "cont", ":", "new_tr", "=", "[", "tr", "[", "0", "]", "]", "cont", "=", "False", "for", "t2", "in", "tr", "[", "1", ":", "]", ":", "t1", "=", "new_tr", "[", "-", "1", "]", "pr", "=", "t1", "*", "t2", "if", "(", "not", "t1", ".", "dynamic", "and", "not", "t2", ".", "dynamic", "and", "not", "isinstance", "(", "pr", ",", "ChainTransform", ")", ")", ":", "cont", "=", "True", "new_tr", ".", "pop", "(", ")", "new_tr", ".", "append", "(", "pr", ")", "else", ":", "new_tr", ".", "append", "(", "t2", ")", "tr", "=", "new_tr", "self", ".", "transforms", "=", "tr" ]

[ "Generate", "a", "simplified", "chain", "by", "joining", "adjacent", "transforms", "." ]

[ "def", "_start_node", "(", "node", ")", ":", "log", ".", "debug", "(", "\"_start_node: working on node `%s`\"", ",", "node", ".", "name", ")", "# FIXME: the following check is not optimal yet. When a node is still", "# in a starting state, it will start another node here, since the", "# `is_alive` method will only check for running nodes (see issue #13)", "if", "node", ".", "is_alive", "(", ")", ":", "log", ".", "info", "(", "\"Not starting node `%s` which is \"", "\"already up&running.\"", ",", "node", ".", "name", ")", "return", "True", "else", ":", "try", ":", "node", ".", "start", "(", ")", "log", ".", "info", "(", "\"Node `%s` has been started.\"", ",", "node", ".", "name", ")", "return", "True", "except", "Exception", "as", "err", ":", "log", ".", "exception", "(", "\"Could not start node `%s`: %s -- %s\"", ",", "node", ".", "name", ",", "err", ",", "err", ".", "__class__", ")", "return", "False" ]

[ "Start", "the", "given", "node", "VM", "." ]

[ "def", "_remove_action_from_type", "(", "valid_actions", ":", "Dict", "[", "str", ",", "List", "[", "str", "]", "]", ",", "type_", ":", "str", ",", "filter_function", ":", "Callable", "[", "[", "str", "]", ",", "bool", "]", ")", "->", "None", ":", "action_list", "=", "valid_actions", "[", "type_", "]", "matching_action_index", "=", "[", "i", "for", "i", ",", "action", "in", "enumerate", "(", "action_list", ")", "if", "filter_function", "(", "action", ")", "]", "assert", "len", "(", "matching_action_index", ")", "==", "1", ",", "\"Filter function didn't find one action\"", "action_list", ".", "pop", "(", "matching_action_index", "[", "0", "]", ")" ]

[ "Finds", "the", "production", "rule", "matching", "the", "filter", "function", "in", "the", "given", "type", "s", "valid", "action", "list", "and", "removes", "it", ".", "If", "there", "is", "more", "than", "one", "matching", "function", "we", "crash", "." ]

[ "def", "_parse_tree", "(", "self", ",", "node", ")", ":", "if", "'date'", "in", "node", ".", "attrib", ":", "dt", "=", "dateutil", ".", "parser", ".", "parse", "(", "node", ".", "attrib", "[", "'date'", "]", ")", "self", ".", "date", "=", "int", "(", "dt", ".", "strftime", "(", "\"%s\"", ")", ")", "if", "'id'", "in", "node", ".", "attrib", ":", "self", ".", "id", "=", "node", ".", "attrib", "[", "'id'", "]", "if", "'karma'", "in", "node", ".", "attrib", ":", "self", ".", "karma", "=", "int", "(", "node", ".", "attrib", "[", "'karma'", "]", ")", "if", "'score'", "in", "node", ".", "attrib", ":", "self", ".", "score", "=", "int", "(", "node", ".", "attrib", "[", "'score'", "]", ")", "if", "'rating'", "in", "node", ".", "attrib", ":", "self", ".", "rating", "=", "int", "(", "node", ".", "attrib", "[", "'rating'", "]", ")", "for", "c3", "in", "node", ":", "if", "c3", ".", "tag", "==", "'lang'", ":", "self", ".", "locale", "=", "c3", ".", "text", "if", "c3", ".", "tag", "==", "'version'", ":", "self", ".", "version", "=", "c3", ".", "text", "if", "c3", ".", "tag", "==", "'reviewer_id'", ":", "self", ".", "reviewer_id", "=", "c3", ".", "text", "if", "c3", ".", "tag", "==", "'reviewer_name'", ":", "self", ".", "reviewer_name", "=", "c3", ".", "text", "if", "c3", ".", "tag", "==", "'summary'", ":", "self", ".", "summary", "=", "c3", ".", "text", "if", "c3", ".", "tag", "==", "'description'", ":", "self", ".", "description", "=", "_parse_desc", "(", "c3", ")", "if", "c3", ".", "tag", "==", "'metadata'", ":", "for", "c4", "in", "c3", ":", "if", "c4", ".", "tag", "==", "'value'", ":", "if", "'key'", "in", "c4", ".", "attrib", ":", "self", ".", "metadata", "[", "c4", ".", "attrib", "[", "'key'", "]", "]", "=", "c4", ".", "text" ]

[ "Parse", "a", "<review", ">", "object" ]

[ "def", "get_partial_DOS", "(", "self", ")", ":", "warnings", ".", "warn", "(", "\"Phonopy.get_partial_DOS is deprecated. \"", "\"Use Phonopy.get_projected_dos_dict.\"", ",", "DeprecationWarning", ")", "pdos", "=", "self", ".", "get_projected_dos_dict", "(", ")", "return", "pdos", "[", "'frequency_points'", "]", ",", "pdos", "[", "'projected_dos'", "]" ]

[ "Return", "frequency", "points", "and", "partial", "DOS", "as", "a", "tuple", "." ]

[ "def", "do_status", "(", "self", ",", "arg", ")", ":", "info", "=", "self", ".", "arm", ".", "get_info", "(", ")", "max_len", "=", "len", "(", "max", "(", "info", ".", "keys", "(", ")", ",", "key", "=", "len", ")", ")", "print", "(", "self", ".", "style", ".", "theme", "(", "'\\nArm Status'", ")", ")", "for", "key", ",", "value", "in", "info", ".", "items", "(", ")", ":", "print", "(", "self", ".", "style", ".", "help", "(", "key", ".", "ljust", "(", "max_len", "+", "2", ")", ",", "str", "(", "value", ")", ")", ")", "print", "(", ")" ]

[ "Print", "information", "about", "the", "arm", "." ]

[ "def", "add_user_jobs", "(", "session", ",", "job_ids", ")", ":", "jobs_data", "=", "{", "'jobs[]'", ":", "job_ids", "}", "response", "=", "make_post_request", "(", "session", ",", "'self/jobs'", ",", "json_data", "=", "jobs_data", ")", "json_data", "=", "response", ".", "json", "(", ")", "if", "response", ".", "status_code", "==", "200", ":", "return", "json_data", "[", "'status'", "]", "else", ":", "raise", "UserJobsNotAddedException", "(", "message", "=", "json_data", "[", "'message'", "]", ",", "error_code", "=", "json_data", "[", "'error_code'", "]", ",", "request_id", "=", "json_data", "[", "'request_id'", "]", ")" ]

[ "Add", "a", "list", "of", "jobs", "to", "the", "currently", "authenticated", "user" ]

[ "def", "get_lldp_neighbors_request", "(", "last_ifindex", ",", "rbridge_id", ")", ":", "request_lldp", "=", "ET", ".", "Element", "(", "'get-lldp-neighbor-detail'", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-lldp-ext\"", ")", "if", "rbridge_id", "is", "not", "None", ":", "rbridge_el", "=", "ET", ".", "SubElement", "(", "request_lldp", ",", "\"rbridge-id\"", ")", "rbridge_el", ".", "text", "=", "rbridge_id", "elif", "last_ifindex", "!=", "''", ":", "last_received_int", "=", "ET", ".", "SubElement", "(", "request_lldp", ",", "\"last-rcvd-ifindex\"", ")", "last_received_int", ".", "text", "=", "last_ifindex", "return", "request_lldp" ]

[ "Creates", "a", "new", "Netconf", "request", "based", "on", "the", "last", "received", "or", "if", "rbridge_id", "is", "specifed", "ifindex", "when", "the", "hasMore", "flag", "is", "true" ]

[ "def", "_set_fields", "(", "self", ",", "fields", ")", ":", "for", "f", "in", "fields", ":", "if", "hasattr", "(", "self", ",", "f", ")", ":", "setattr", "(", "self", ",", "f", ",", "fields", "[", "f", "]", ")", "else", ":", "raise", "TypeError", "(", "\"'{arg}' is an invalid argument for {instance_type}\"", ".", "format", "(", "arg", "=", "f", ",", "instance_type", "=", "self", ".", "__class__", ".", "__name__", ")", ")" ]

[ "Helper", "method", "for", ":", "meth", ":", "upsert", "in", "the", "various", "subclasses" ]

[ "def", "_writeFASTA", "(", "self", ",", "i", ",", "image", ")", ":", "if", "isinstance", "(", "self", ".", "_titlesAlignments", ".", "readsAlignments", ".", "reads", ",", "FastqReads", ")", ":", "format_", "=", "'fastq'", "else", ":", "format_", "=", "'fasta'", "filename", "=", "'%s/%d.%s'", "%", "(", "self", ".", "_outputDir", ",", "i", ",", "format_", ")", "titleAlignments", "=", "self", ".", "_titlesAlignments", "[", "image", "[", "'title'", "]", "]", "with", "open", "(", "filename", ",", "'w'", ")", "as", "fp", ":", "for", "titleAlignment", "in", "titleAlignments", ":", "fp", ".", "write", "(", "titleAlignment", ".", "read", ".", "toString", "(", "format_", ")", ")", "return", "format_" ]

[ "Write", "a", "FASTA", "file", "containing", "the", "set", "of", "reads", "that", "hit", "a", "sequence", "." ]

[ "def", "configure", "(", "self", ",", "mount_point", ",", "mfa_type", "=", "'duo'", ",", "force", "=", "False", ")", ":", "if", "mfa_type", "!=", "'duo'", "and", "not", "force", ":", "# The situation described via this exception is not likely to change in the future.", "# However we provided that flexibility here just in case.", "error_msg", "=", "'Unsupported mfa_type argument provided \"{arg}\", supported types: \"{mfa_types}\"'", "raise", "exceptions", ".", "ParamValidationError", "(", "error_msg", ".", "format", "(", "mfa_types", "=", "','", ".", "join", "(", "SUPPORTED_MFA_TYPES", ")", ",", "arg", "=", "mfa_type", ",", ")", ")", "params", "=", "{", "'type'", ":", "mfa_type", ",", "}", "api_path", "=", "'/v1/auth/{mount_point}/mfa_config'", ".", "format", "(", "mount_point", "=", "mount_point", ")", "return", "self", ".", "_adapter", ".", "post", "(", "url", "=", "api_path", ",", "json", "=", "params", ",", ")" ]

[ "Configure", "MFA", "for", "a", "supported", "method", "." ]

[ "def", "_set_get_show_cfm", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "get_show_cfm", ".", "get_show_cfm", ",", "is_leaf", "=", "True", ",", "yang_name", "=", "\"get-show-cfm\"", ",", "rest_name", "=", "\"get-show-cfm\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "False", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'hidden'", ":", "u'rpccmd'", ",", "u'actionpoint'", ":", "u'dot1agSummaryShowCfm'", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-dot1ag'", ",", "defining_module", "=", "'brocade-dot1ag'", ",", "yang_type", "=", "'rpc'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"get_show_cfm must be of a type compatible with rpc\"\"\"", ",", "'defined-type'", ":", "\"rpc\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=get_show_cfm.get_show_cfm, is_leaf=True, yang_name=\"get-show-cfm\", rest_name=\"get-show-cfm\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'tailf-common': {u'hidden': u'rpccmd', u'actionpoint': u'dot1agSummaryShowCfm'}}, namespace='urn:brocade.com:mgmt:brocade-dot1ag', defining_module='brocade-dot1ag', yang_type='rpc', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__get_show_cfm", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "Setter", "method", "for", "get_show_cfm", "mapped", "from", "YANG", "variable", "/", "brocade_dot1ag_rpc", "/", "get_show_cfm", "(", "rpc", ")", "If", "this", "variable", "is", "read", "-", "only", "(", "config", ":", "false", ")", "in", "the", "source", "YANG", "file", "then", "_set_get_show_cfm", "is", "considered", "as", "a", "private", "method", ".", "Backends", "looking", "to", "populate", "this", "variable", "should", "do", "so", "via", "calling", "thisObj", ".", "_set_get_show_cfm", "()", "directly", "." ]

[ "def", "fit_transform", "(", "self", ",", "X", ")", ":", "X", "=", "as_features", "(", "X", ",", "stack", "=", "True", ")", "self", ".", "kmeans_fit_", "=", "copy", "(", "self", ".", "kmeans", ")", "assignments", "=", "self", ".", "kmeans_fit_", ".", "fit_predict", "(", "X", ".", "stacked_features", ")", "return", "self", ".", "_group_assignments", "(", "X", ",", "assignments", ")" ]

[ "Compute", "clustering", "and", "transform", "a", "list", "of", "bag", "features", "into", "its", "bag", "-", "of", "-", "words", "representation", ".", "Like", "calling", "fit", "(", "X", ")", "and", "then", "transform", "(", "X", ")", "but", "more", "efficient", "." ]

[ "def", "plot_every_step", "(", "sdat", ",", "lovs", ")", ":", "sovs", "=", "misc", ".", "set_of_vars", "(", "lovs", ")", "for", "step", "in", "sdat", ".", "walk", ".", "filter", "(", "rprof", "=", "True", ")", ":", "rprofs", "=", "{", "}", "rads", "=", "{", "}", "metas", "=", "{", "}", "for", "rvar", "in", "sovs", ":", "rprof", ",", "rad", ",", "meta", "=", "get_rprof", "(", "step", ",", "rvar", ")", "rprofs", "[", "rvar", "]", "=", "rprof", "metas", "[", "rvar", "]", "=", "meta", "if", "rad", "is", "not", "None", ":", "rads", "[", "rvar", "]", "=", "rad", "rprofs", "[", "'bounds'", "]", "=", "misc", ".", "get_rbounds", "(", "step", ")", "rcmb", ",", "rsurf", "=", "misc", ".", "get_rbounds", "(", "step", ")", "rprofs", "[", "'bounds'", "]", "=", "(", "step", ".", "sdat", ".", "scale", "(", "rcmb", ",", "'m'", ")", "[", "0", "]", ",", "step", ".", "sdat", ".", "scale", "(", "rsurf", ",", "'m'", ")", "[", "0", "]", ")", "rprofs", "[", "'r'", "]", "=", "get_rprof", "(", "step", ",", "'r'", ")", "[", "0", "]", "+", "rprofs", "[", "'bounds'", "]", "[", "0", "]", "stepstr", "=", "str", "(", "step", ".", "istep", ")", "_plot_rprof_list", "(", "sdat", ",", "lovs", ",", "rprofs", ",", "metas", ",", "stepstr", ",", "rads", ")" ]

[ "Plot", "profiles", "at", "each", "time", "step", "." ]

[ "def", "create_eager_metrics", "(", "metric_names", ",", "weights_fn", "=", "common_layers", ".", "weights_all", ")", ":", "metric_fns", "=", "dict", "(", "[", "(", "name", ",", "METRICS_FNS", "[", "name", "]", ")", "for", "name", "in", "metric_names", "]", ")", "return", "create_eager_metrics_internal", "(", "metric_fns", ",", "weights_fn", ")" ]

[ "Create", "metrics", "accumulators", "and", "averager", "for", "Eager", "mode", "." ]

[ "def", "sharing_agreements", "(", "self", ")", ":", "if", "self", ".", "api", "and", "self", ".", "sharing_agreement_ids", ":", "return", "self", ".", "api", ".", "_get_sharing_agreements", "(", "self", ".", "sharing_agreement_ids", ")" ]

[ "|", "Comment", ":", "The", "ids", "of", "the", "sharing", "agreements", "used", "for", "this", "ticket" ]

[ "def", "read", "(", "self", ")", ":", "if", "not", "self", ".", "ready_to_read", "(", ")", ":", "return", "None", "data", "=", "self", ".", "_read", "(", ")", "if", "data", "is", "None", ":", "return", "None", "return", "self", ".", "_parse_message", "(", "data", ")" ]

[ "If", "there", "is", "data", "available", "to", "be", "read", "from", "the", "transport", "reads", "the", "data", "and", "tries", "to", "parse", "it", "as", "a", "protobuf", "message", ".", "If", "the", "parsing", "succeeds", "return", "a", "protobuf", "object", ".", "Otherwise", "returns", "None", "." ]

[ "def", "get_ngrams", "(", "self", ",", "minimum", ",", "maximum", ",", "skip_sizes", "=", "None", ")", ":", "skip_sizes", "=", "skip_sizes", "or", "[", "]", "tokens", "=", "self", ".", "get_tokens", "(", ")", "for", "size", "in", "range", "(", "minimum", ",", "maximum", "+", "1", ")", ":", "if", "size", "not", "in", "skip_sizes", ":", "ngrams", "=", "collections", ".", "Counter", "(", "self", ".", "_ngrams", "(", "tokens", ",", "size", ")", ")", "yield", "(", "size", ",", "ngrams", ")" ]

[ "Returns", "a", "generator", "supplying", "the", "n", "-", "grams", "(", "minimum", "<", "=", "n", "<", "=", "maximum", ")", "for", "this", "text", "." ]

[ "def", "appendtext", "(", "self", ",", "window_name", ",", "object_name", ",", "data", ")", ":", "object_handle", "=", "self", ".", "_get_object_handle", "(", "window_name", ",", "object_name", ")", "if", "not", "object_handle", ".", "AXEnabled", ":", "raise", "LdtpServerException", "(", "u\"Object %s state disabled\"", "%", "object_name", ")", "object_handle", ".", "AXValue", "+=", "data", "return", "1" ]

[ "Append", "string", "sequence", ".", "@param", "window_name", ":", "Window", "name", "to", "type", "in", "either", "full", "name", "LDTP", "s", "name", "convention", "or", "a", "Unix", "glob", ".", "@type", "window_name", ":", "string", "@param", "object_name", ":", "Object", "name", "to", "type", "in", "either", "full", "name", "LDTP", "s", "name", "convention", "or", "a", "Unix", "glob", ".", "@type", "object_name", ":", "string", "@param", "data", ":", "data", "to", "type", ".", "@type", "data", ":", "string" ]

[ "def", "version", "(", ")", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ")", ",", "'pep8radius'", ",", "'main.py'", ")", ")", "as", "input_file", ":", "for", "line", "in", "input_file", ":", "if", "line", ".", "startswith", "(", "'__version__'", ")", ":", "return", "parse", "(", "line", ")", ".", "body", "[", "0", "]", ".", "value", ".", "s" ]

[ "Return", "version", "string", "." ]

[ "def", "run", "(", "self", ",", "args", ")", ":", "long_format", "=", "args", ".", "long_format", "# project_name and auth_role args are mutually exclusive", "if", "args", ".", "project_name", "or", "args", ".", "project_id", ":", "project", "=", "self", ".", "fetch_project", "(", "args", ",", "must_exist", "=", "True", ",", "include_children", "=", "True", ")", "self", ".", "print_project_details", "(", "project", ",", "long_format", ")", "else", ":", "self", ".", "print_project_list_details", "(", "args", ".", "auth_role", ",", "long_format", ")" ]

[ "Lists", "project", "names", ".", ":", "param", "args", "Namespace", "arguments", "parsed", "from", "the", "command", "line" ]

[ "def", "save_settings", "(", "self", ",", "filename", ")", ":", "data", "=", "dict", "(", ")", "data", "[", "'valueRanges'", "]", "=", "self", ".", "_value_ranges", "data", "[", "'best_values'", "]", "=", "[", "str", "(", "value", ")", "for", "value", "in", "self", ".", "_best_values", "]", "data", "[", "'minimize'", "]", "=", "self", ".", "_minimize", "data", "[", "'num_employers'", "]", "=", "self", ".", "_num_employers", "data", "[", "'best_score'", "]", "=", "str", "(", "self", ".", "_best_score", ")", "data", "[", "'limit'", "]", "=", "self", ".", "_limit", "data", "[", "'best_error'", "]", "=", "self", ".", "_best_error", "with", "open", "(", "filename", ",", "'w'", ")", "as", "outfile", ":", "json", ".", "dump", "(", "data", ",", "outfile", ",", "indent", "=", "4", ",", "sort_keys", "=", "True", ")" ]

[ "Save", "settings", "to", "a", "JSON", "file" ]

[ "def", "get_straight_line_transfer_distances", "(", "self", ",", "stop_I", "=", "None", ")", ":", "if", "stop_I", "is", "not", "None", ":", "query", "=", "u\"\"\" SELECT from_stop_I, to_stop_I, d\n FROM stop_distances\n WHERE\n from_stop_I=?\n \"\"\"", "params", "=", "(", "u\"{stop_I}\"", ".", "format", "(", "stop_I", "=", "stop_I", ")", ",", ")", "else", ":", "query", "=", "\"\"\" SELECT from_stop_I, to_stop_I, d\n FROM stop_distances\n \"\"\"", "params", "=", "None", "stop_data_df", "=", "pd", ".", "read_sql_query", "(", "query", ",", "self", ".", "conn", ",", "params", "=", "params", ")", "return", "stop_data_df" ]

[ "Get", "(", "straight", "line", ")", "distances", "to", "stations", "that", "can", "be", "transferred", "to", "." ]

[ "def", "print_application_traceback", "(", "self", ",", "space", ",", "file", "=", "None", ")", ":", "if", "file", "is", "None", ":", "file", "=", "sys", ".", "stderr", "self", ".", "print_app_tb_only", "(", "file", ")", "print", ">>", "file", ",", "self", ".", "errorstr", "(", "space", ")" ]

[ "NOT_RPYTHON", ":", "Dump", "a", "standard", "application", "-", "level", "traceback", "." ]

[ "def", "timeseries_reactive", "(", "self", ")", ":", "if", "self", ".", "_timeseries_reactive", "is", "None", ":", "if", "self", ".", "grid", ".", "network", ".", "timeseries", ".", "generation_reactive_power", "is", "not", "None", ":", "try", ":", "timeseries", "=", "self", ".", "grid", ".", "network", ".", "timeseries", ".", "generation_reactive_power", "[", "self", ".", "type", "]", ".", "to_frame", "(", "'q'", ")", "except", "(", "KeyError", ",", "TypeError", ")", ":", "try", ":", "timeseries", "=", "self", ".", "grid", ".", "network", ".", "timeseries", ".", "generation_reactive_power", "[", "'other'", "]", ".", "to_frame", "(", "'q'", ")", "except", ":", "logger", ".", "warning", "(", "\"No reactive power time series for type {} given. \"", "\"Reactive power time series will be calculated from \"", "\"assumptions in config files and active power \"", "\"timeseries.\"", ".", "format", "(", "self", ".", "type", ")", ")", "return", "None", "self", ".", "power_factor", "=", "'not_applicable'", "self", ".", "reactive_power_mode", "=", "'not_applicable'", "return", "timeseries", "*", "self", ".", "nominal_capacity", "else", ":", "return", "None", "else", ":", "return", "self", ".", "_timeseries_reactive", ".", "loc", "[", "self", ".", "grid", ".", "network", ".", "timeseries", ".", "timeindex", ",", ":", "]" ]

[ "Reactive", "power", "time", "series", "in", "kvar", "." ]

[ "def", "describe_route_table", "(", "route_table_id", "=", "None", ",", "route_table_name", "=", "None", ",", "tags", "=", "None", ",", "region", "=", "None", ",", "key", "=", "None", ",", "keyid", "=", "None", ",", "profile", "=", "None", ")", ":", "salt", ".", "utils", ".", "versions", ".", "warn_until", "(", "'Neon'", ",", "'The \\'describe_route_table\\' method has been deprecated and '", "'replaced by \\'describe_route_tables\\'.'", ")", "if", "not", "any", "(", "(", "route_table_id", ",", "route_table_name", ",", "tags", ")", ")", ":", "raise", "SaltInvocationError", "(", "'At least one of the following must be specified: '", "'route table id, route table name, or tags.'", ")", "try", ":", "conn", "=", "_get_conn", "(", "region", "=", "region", ",", "key", "=", "key", ",", "keyid", "=", "keyid", ",", "profile", "=", "profile", ")", "filter_parameters", "=", "{", "'filters'", ":", "{", "}", "}", "if", "route_table_id", ":", "filter_parameters", "[", "'route_table_ids'", "]", "=", "route_table_id", "if", "route_table_name", ":", "filter_parameters", "[", "'filters'", "]", "[", "'tag:Name'", "]", "=", "route_table_name", "if", "tags", ":", "for", "tag_name", ",", "tag_value", "in", "six", ".", "iteritems", "(", "tags", ")", ":", "filter_parameters", "[", "'filters'", "]", "[", "'tag:{0}'", ".", "format", "(", "tag_name", ")", "]", "=", "tag_value", "route_tables", "=", "conn", ".", "get_all_route_tables", "(", "*", "*", "filter_parameters", ")", "if", "not", "route_tables", ":", "return", "{", "}", "route_table", "=", "{", "}", "keys", "=", "[", "'id'", ",", "'vpc_id'", ",", "'tags'", ",", "'routes'", ",", "'associations'", "]", "route_keys", "=", "[", "'destination_cidr_block'", ",", "'gateway_id'", ",", "'instance_id'", ",", "'interface_id'", ",", "'vpc_peering_connection_id'", "]", "assoc_keys", "=", "[", "'id'", ",", "'main'", ",", "'route_table_id'", ",", "'subnet_id'", "]", "for", "item", "in", "route_tables", ":", "for", "key", "in", "keys", ":", "if", "hasattr", "(", "item", ",", "key", ")", ":", "route_table", "[", "key", "]", "=", "getattr", "(", "item", ",", "key", ")", "if", "key", "==", "'routes'", ":", "route_table", "[", "key", "]", "=", "_key_iter", "(", "key", ",", "route_keys", ",", "item", ")", "if", "key", "==", "'associations'", ":", "route_table", "[", "key", "]", "=", "_key_iter", "(", "key", ",", "assoc_keys", ",", "item", ")", "return", "route_table", "except", "BotoServerError", "as", "e", ":", "return", "{", "'error'", ":", "__utils__", "[", "'boto.get_error'", "]", "(", "e", ")", "}" ]

[ "Given", "route", "table", "properties", "return", "route", "table", "details", "if", "matching", "table", "(", "s", ")", "exist", "." ]

[ "def", "_tryMatch", "(", "self", ",", "textToMatchObject", ")", ":", "for", "rule", "in", "self", ".", "context", ".", "rules", ":", "ruleTryMatchResult", "=", "rule", ".", "tryMatch", "(", "textToMatchObject", ")", "if", "ruleTryMatchResult", "is", "not", "None", ":", "_logger", ".", "debug", "(", "'\\tmatched rule %s at %d in included context %s/%s'", ",", "rule", ".", "shortId", "(", ")", ",", "textToMatchObject", ".", "currentColumnIndex", ",", "self", ".", "context", ".", "parser", ".", "syntax", ".", "name", ",", "self", ".", "context", ".", "name", ")", "return", "ruleTryMatchResult", "else", ":", "return", "None" ]

[ "Try", "to", "find", "themselves", "in", "the", "text", ".", "Returns", "(", "count", "matchedRule", ")", "or", "(", "None", "None", ")", "if", "doesn", "t", "match" ]

[ "def", "merge_variables", "(", "variables", ",", "*", "*", "kwargs", ")", ":", "var_dict", "=", "OrderedDict", "(", ")", "for", "v", "in", "variables", ":", "if", "v", ".", "name", "not", "in", "var_dict", ":", "var_dict", "[", "v", ".", "name", "]", "=", "[", "]", "var_dict", "[", "v", ".", "name", "]", ".", "append", "(", "v", ")", "return", "[", "merge_variables", "(", "vars_", ",", "*", "*", "kwargs", ")", "for", "vars_", "in", "list", "(", "var_dict", ".", "values", "(", ")", ")", "]" ]

[ "Concatenates", "Variables", "along", "row", "axis", "." ]

[ "def", "binarycontent_sections", "(", "chunk", ")", ":", "# using string split because it is significantly faster than regex.", "# use common text of start and end tags to split the text", "# (i.e. without < or </ tag beginning)", "binary_content_tag", "=", "BINARY_CONTENT_START", "[", "1", ":", "]", "if", "binary_content_tag", "not", "in", "chunk", ":", "# if no tags are present, don't do any extra work", "yield", "chunk", "else", ":", "# split on common portion of foxml:binaryContent", "sections", "=", "chunk", ".", "split", "(", "binary_content_tag", ")", "for", "sec", "in", "sections", ":", "extra", "=", "b''", "# check the end of the section to determine start/end tag", "if", "sec", ".", "endswith", "(", "b'</'", ")", ":", "extra", "=", "sec", "[", "-", "2", ":", "]", "yield", "sec", "[", ":", "-", "2", "]", "elif", "sec", ".", "endswith", "(", "b'<'", ")", ":", "extra", "=", "sec", "[", "-", "1", ":", "]", "yield", "sec", "[", ":", "-", "1", "]", "else", ":", "yield", "sec", "if", "extra", ":", "# yield the actual binary content tag", "# (delimiter removed by split, but needed for processing)", "yield", "b''", ".", "join", "(", "[", "extra", ",", "binary_content_tag", "]", ")" ]

[ "Split", "a", "chunk", "of", "data", "into", "sections", "by", "start", "and", "end", "binary", "content", "tags", "." ]

[ "def", "maxRange", "(", "self", ")", ":", "try", ":", "x", ",", "freqs", "=", "self", ".", "datafile", ".", "get_calibration", "(", "str", "(", "self", ".", "ui", ".", "calChoiceCmbbx", ".", "currentText", "(", ")", ")", ",", "self", ".", "calf", ")", "self", ".", "ui", ".", "frangeLowSpnbx", ".", "setValue", "(", "freqs", "[", "0", "]", ")", "self", ".", "ui", ".", "frangeHighSpnbx", ".", "setValue", "(", "freqs", "[", "-", "1", "]", ")", "print", "'set freq range'", ",", "freqs", "[", "0", "]", ",", "freqs", "[", "-", "1", "]", ",", "freqs", "[", "0", "]", ",", "freqs", "[", "-", "1", "]", "except", "IOError", ":", "QtGui", ".", "QMessageBox", ".", "warning", "(", "self", ",", "\"File Read Error\"", ",", "\"Unable to read calibration file\"", ")", "except", "KeyError", ":", "QtGui", ".", "QMessageBox", ".", "warning", "(", "self", ",", "\"File Data Error\"", ",", "\"Unable to find data in file\"", ")" ]

[ "Sets", "the", "maximum", "range", "for", "the", "currently", "selection", "calibration", "determined", "from", "its", "range", "of", "values", "store", "on", "file" ]

[ "def", "get_groups", "(", "self", ",", "gs", "=", "None", ",", "processed", "=", "[", "]", ",", "initial", "=", "True", ")", ":", "# Check if language is set", "if", "not", "self", ".", "__language", ":", "raise", "IOError", "(", "\"ERROR: No language suplied!\"", ")", "# Initialize the list", "if", "initial", ":", "processed", "=", "[", "]", "# Where to look for fields", "if", "'list_fields'", "in", "dir", "(", "self", ")", ":", "list_fields", "=", "self", ".", "list_fields", "check_system", "=", "\"html_name\"", "else", ":", "list_fields", "=", "self", "check_system", "=", "\"name\"", "# Default attributes for fields", "attributes", "=", "[", "(", "'columns'", ",", "6", ")", ",", "(", "'color'", ",", "None", ")", ",", "(", "'bgcolor'", ",", "None", ")", ",", "(", "'textalign'", ",", "None", ")", ",", "(", "'inline'", ",", "False", ")", ",", "# input in line with label", "(", "'label'", ",", "True", ")", ",", "(", "'extra'", ",", "None", ")", ",", "(", "'extra_div'", ",", "None", ")", ",", "(", "'foreign_info'", ",", "{", "}", ")", ",", "]", "labels", "=", "[", "x", "[", "0", "]", "for", "x", "in", "attributes", "]", "# Get groups if none was given", "if", "gs", "is", "None", ":", "gs", "=", "self", ".", "__groups__", "(", ")", "# Prepare the answer", "groups", "=", "[", "]", "# Prepare focus control", "focus_first", "=", "None", "focus_must", "=", "None", "# html helper for groups and fields", "html_helper", "=", "self", ".", "html_helper", "(", ")", "# Start processing", "for", "g", "in", "gs", ":", "token", "=", "{", "}", "token", "[", "'name'", "]", "=", "g", "[", "0", "]", "if", "token", "[", "'name'", "]", "in", "html_helper", ":", "if", "'pre'", "in", "html_helper", "[", "token", "[", "'name'", "]", "]", ":", "token", "[", "\"html_helper_pre\"", "]", "=", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'pre'", "]", "if", "'post'", "in", "html_helper", "[", "token", "[", "'name'", "]", "]", ":", "token", "[", "\"html_helper_post\"", "]", "=", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'post'", "]", "styles", "=", "g", "[", "1", "]", "if", "type", "(", "styles", ")", "is", "tuple", ":", "if", "len", "(", "styles", ")", ">=", "1", ":", "token", "[", "'columns'", "]", "=", "g", "[", "1", "]", "[", "0", "]", "if", "len", "(", "styles", ")", ">=", "2", ":", "token", "[", "'color'", "]", "=", "g", "[", "1", "]", "[", "1", "]", "if", "len", "(", "styles", ")", ">=", "3", ":", "token", "[", "'bgcolor'", "]", "=", "g", "[", "1", "]", "[", "2", "]", "if", "len", "(", "styles", ")", ">=", "4", ":", "token", "[", "'textalign'", "]", "=", "g", "[", "1", "]", "[", "3", "]", "if", "len", "(", "styles", ")", ">=", "5", ":", "token", "[", "'inline'", "]", "=", "g", "[", "1", "]", "[", "4", "]", "if", "len", "(", "styles", ")", ">=", "7", ":", "token", "[", "'extra'", "]", "=", "g", "[", "1", "]", "[", "5", "]", "if", "len", "(", "styles", ")", ">=", "8", ":", "token", "[", "'extra_div'", "]", "=", "g", "[", "1", "]", "[", "6", "]", "else", ":", "token", "[", "'columns'", "]", "=", "g", "[", "1", "]", "fs", "=", "g", "[", "2", ":", "]", "fields", "=", "[", "]", "for", "f", "in", "fs", ":", "# Field", "atr", "=", "{", "}", "# Decide weather this is a Group or not", "if", "type", "(", "f", ")", "==", "tuple", ":", "# Recursive", "fields", "+=", "self", ".", "get_groups", "(", "[", "list", "(", "f", ")", "]", ",", "processed", ",", "False", ")", "else", ":", "try", ":", "list_type", "=", "[", "str", ",", "unicode", ",", "]", "except", "NameError", ":", "list_type", "=", "[", "str", ",", "]", "# Check if it is a list", "if", "type", "(", "f", ")", "==", "list", ":", "# This is a field with attributes, get the name", "field", "=", "f", "[", "0", "]", "if", "html_helper", "and", "token", "[", "'name'", "]", "in", "html_helper", "and", "'items'", "in", "html_helper", "[", "token", "[", "'name'", "]", "]", "and", "field", "in", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'items'", "]", ":", "if", "'pre'", "in", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'items'", "]", "[", "field", "]", ":", "atr", "[", "\"html_helper_pre\"", "]", "=", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'items'", "]", "[", "field", "]", "[", "'pre'", "]", "if", "'post'", "in", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'items'", "]", "[", "field", "]", ":", "atr", "[", "\"html_helper_post\"", "]", "=", "html_helper", "[", "token", "[", "'name'", "]", "]", "[", "'items'", "]", "[", "field", "]", "[", "'post'", "]", "# Process each attribute (if any)", "dictionary", "=", "False", "for", "idx", ",", "element", "in", "enumerate", "(", "f", "[", "1", ":", "]", ")", ":", "if", "type", "(", "element", ")", "==", "dict", ":", "dictionary", "=", "True", "for", "key", "in", "element", ".", "keys", "(", ")", ":", "if", "key", "in", "labels", ":", "atr", "[", "key", "]", "=", "element", "[", "key", "]", "else", ":", "raise", "IOError", "(", "\"Unknown attribute '{0}' as field '{1}' in list of fields\"", ".", "format", "(", "key", ",", "field", ")", ")", "else", ":", "if", "not", "dictionary", ":", "if", "element", "is", "not", "None", ":", "atr", "[", "attributes", "[", "idx", "]", "[", "0", "]", "]", "=", "element", "else", ":", "raise", "IOError", "(", "\"We already processed a dicionary element in this list of fields, you can not add anoother type of elements to it, you must keep going with dictionaries\"", ")", "elif", "type", "(", "f", ")", "in", "list_type", ":", "field", "=", "f", "else", ":", "raise", "IOError", "(", "\"Uknown element type '{0}' inside group '{1}'\"", ".", "format", "(", "type", "(", "f", ")", ",", "token", "[", "'name'", "]", ")", ")", "# Get the Django Field object", "found", "=", "None", "for", "infield", "in", "list_fields", ":", "if", "infield", ".", "__dict__", "[", "check_system", "]", "==", "field", ":", "found", "=", "infield", "break", "if", "found", ":", "# Get attributes (required and original attributes)", "wrequired", "=", "found", ".", "field", ".", "widget", ".", "is_required", "wattrs", "=", "found", ".", "field", ".", "widget", ".", "attrs", "# Fill base attributes", "atr", "[", "'name'", "]", "=", "found", ".", "html_name", "atr", "[", "'input'", "]", "=", "found", "atr", "[", "'focus'", "]", "=", "False", "# Set focus", "if", "focus_must", "is", "None", ":", "if", "focus_first", "is", "None", ":", "focus_first", "=", "atr", "if", "wrequired", ":", "focus_must", "=", "atr", "# Autocomplete", "if", "'autofill'", "in", "dir", "(", "self", ".", "Meta", ")", ":", "autofill", "=", "self", ".", "Meta", ".", "autofill", ".", "get", "(", "found", ".", "html_name", ",", "None", ")", "atr", "[", "'autofill'", "]", "=", "autofill", "if", "autofill", ":", "# Check format of the request", "autokind", "=", "autofill", "[", "0", "]", "if", "type", "(", "autokind", ")", "==", "str", ":", "# Using new format", "if", "autokind", "==", "'select'", ":", "# If autofill is True for this field set the DynamicSelect widget", "found", ".", "field", ".", "widget", "=", "DynamicSelect", "(", "wattrs", ")", "elif", "autokind", "==", "'multiselect'", ":", "# If autofill is True for this field set the DynamicSelect widget", "found", ".", "field", ".", "widget", "=", "MultiDynamicSelect", "(", "wattrs", ")", "elif", "autokind", "==", "'input'", ":", "# If autofill is True for this field set the DynamicSelect widget", "found", ".", "field", ".", "widget", "=", "DynamicInput", "(", "wattrs", ")", "else", ":", "raise", "IOError", "(", "\"Autofill filled using new format but autokind is '{}' and I only know 'input' or 'select'\"", ".", "format", "(", "autokind", ")", ")", "# Configure the field", "found", ".", "field", ".", "widget", ".", "is_required", "=", "wrequired", "found", ".", "field", ".", "widget", ".", "form_name", "=", "self", ".", "form_name", "found", ".", "field", ".", "widget", ".", "field_name", "=", "infield", ".", "html_name", "found", ".", "field", ".", "widget", ".", "autofill_deepness", "=", "autofill", "[", "1", "]", "found", ".", "field", ".", "widget", ".", "autofill_url", "=", "autofill", "[", "2", "]", "found", ".", "field", ".", "widget", ".", "autofill", "=", "autofill", "[", "3", ":", "]", "else", ":", "# Get old information [COMPATIBILITY WITH OLD VERSION]", "# If autofill is True for this field set the DynamicSelect widget", "found", ".", "field", ".", "widget", "=", "DynamicSelect", "(", "wattrs", ")", "found", ".", "field", ".", "widget", ".", "is_required", "=", "wrequired", "found", ".", "field", ".", "widget", ".", "form_name", "=", "self", ".", "form_name", "found", ".", "field", ".", "widget", ".", "field_name", "=", "infield", ".", "html_name", "found", ".", "field", ".", "widget", ".", "autofill_deepness", "=", "autofill", "[", "0", "]", "found", ".", "field", ".", "widget", ".", "autofill_url", "=", "autofill", "[", "1", "]", "found", ".", "field", ".", "widget", ".", "autofill", "=", "autofill", "[", "2", ":", "]", "else", ":", "# Set we don't have autofill for this field", "atr", "[", "'autofill'", "]", "=", "None", "# Check if we have to replace the widget with a newer one", "if", "isinstance", "(", "found", ".", "field", ".", "widget", ",", "Select", ")", "and", "not", "isinstance", "(", "found", ".", "field", ".", "widget", ",", "DynamicSelect", ")", ":", "if", "not", "isinstance", "(", "found", ".", "field", ".", "widget", ",", "MultiStaticSelect", ")", ":", "found", ".", "field", ".", "widget", "=", "StaticSelect", "(", "wattrs", ")", "found", ".", "field", ".", "widget", ".", "choices", "=", "found", ".", "field", ".", "choices", "found", ".", "field", ".", "widget", ".", "is_required", "=", "wrequired", "found", ".", "field", ".", "widget", ".", "form_name", "=", "self", ".", "form_name", "found", ".", "field", ".", "widget", ".", "field_name", "=", "infield", ".", "html_name", "# Fill all attributes", "for", "(", "attribute", ",", "default", ")", "in", "attributes", ":", "if", "attribute", "not", "in", "atr", ".", "keys", "(", ")", ":", "atr", "[", "attribute", "]", "=", "default", "# Fill label", "if", "atr", "[", "'label'", "]", "is", "True", ":", "atr", "[", "'label'", "]", "=", "found", ".", "label", "# Set language", "flang", "=", "getattr", "(", "found", ".", "field", ",", "\"set_language\"", ",", "None", ")", "if", "flang", ":", "flang", "(", "self", ".", "__language", ")", "flang", "=", "getattr", "(", "found", ".", "field", ".", "widget", ",", "\"set_language\"", ",", "None", ")", "if", "flang", ":", "flang", "(", "self", ".", "__language", ")", "# Attach the element", "fields", ".", "append", "(", "atr", ")", "# Remember we have processed it", "processed", ".", "append", "(", "found", ".", "__dict__", "[", "check_system", "]", ")", "else", ":", "raise", "IOError", "(", "\"Unknown field '{0}' specified in group '{1}'\"", ".", "format", "(", "f", ",", "token", "[", "'name'", "]", ")", ")", "token", "[", "'fields'", "]", "=", "fields", "groups", ".", "append", "(", "token", ")", "# Add the rest of attributes we didn't use yet", "if", "initial", ":", "fields", "=", "[", "]", "for", "infield", "in", "list_fields", ":", "if", "infield", ".", "__dict__", "[", "check_system", "]", "not", "in", "processed", ":", "# Get attributes (required and original attributes)", "wattrs", "=", "infield", ".", "field", ".", "widget", ".", "attrs", "wrequired", "=", "infield", ".", "field", ".", "widget", ".", "is_required", "# Prepare attr", "atr", "=", "{", "}", "# Fill base attributes", "atr", "[", "'name'", "]", "=", "infield", ".", "html_name", "atr", "[", "'input'", "]", "=", "infield", "atr", "[", "'focus'", "]", "=", "False", "# Set focus", "if", "focus_must", "is", "None", ":", "if", "focus_first", "is", "None", ":", "focus_first", "=", "atr", "if", "wrequired", ":", "focus_must", "=", "atr", "# Autocomplete", "if", "'autofill'", "in", "dir", "(", "self", ".", "Meta", ")", ":", "autofill", "=", "self", ".", "Meta", ".", "autofill", ".", "get", "(", "infield", ".", "html_name", ",", "None", ")", "atr", "[", "'autofill'", "]", "=", "autofill", "if", "autofill", ":", "# Check format of the request", "autokind", "=", "autofill", "[", "0", "]", "if", "type", "(", "autokind", ")", "==", "str", ":", "# Get old information", "# Using new format", "if", "autokind", "==", "'select'", ":", "# If autofill is True for this field set the DynamicSelect widget", "infield", ".", "field", ".", "widget", "=", "DynamicSelect", "(", "wattrs", ")", "elif", "autokind", "==", "'multiselect'", ":", "# If autofill is True for this field set the DynamicSelect widget", "infield", ".", "field", ".", "widget", "=", "MultiDynamicSelect", "(", "wattrs", ")", "elif", "autokind", "==", "'input'", ":", "# If autofill is True for this field set the DynamicSelect widget", "infield", ".", "field", ".", "widget", "=", "DynamicInput", "(", "wattrs", ")", "else", ":", "raise", "IOError", "(", "\"Autofill filled using new format but autokind is '{}' and I only know 'input' or 'select'\"", ".", "format", "(", "autokind", ")", ")", "# Configure the field", "infield", ".", "field", ".", "widget", ".", "is_required", "=", "wrequired", "infield", ".", "field", ".", "widget", ".", "form_name", "=", "self", ".", "form_name", "infield", ".", "field", ".", "widget", ".", "field_name", "=", "infield", ".", "html_name", "infield", ".", "field", ".", "widget", ".", "autofill_deepness", "=", "autofill", "[", "1", "]", "infield", ".", "field", ".", "widget", ".", "autofill_url", "=", "autofill", "[", "2", "]", "infield", ".", "field", ".", "widget", ".", "autofill", "=", "autofill", "[", "3", ":", "]", "else", ":", "# Get old information [COMPATIBILITY WITH OLD VERSION]", "# If autofill is True for this field set the DynamicSelect widget", "infield", ".", "field", ".", "widget", "=", "DynamicSelect", "(", "wattrs", ")", "infield", ".", "field", ".", "widget", ".", "is_required", "=", "wrequired", "infield", ".", "field", ".", "widget", ".", "form_name", "=", "self", ".", "form_name", "infield", ".", "field", ".", "widget", ".", "field_name", "=", "infield", ".", "html_name", "infield", ".", "field", ".", "widget", ".", "autofill_deepness", "=", "autofill", "[", "0", "]", "infield", ".", "field", ".", "widget", ".", "autofill_url", "=", "autofill", "[", "1", "]", "infield", ".", "field", ".", "widget", ".", "autofill", "=", "autofill", "[", "2", ":", "]", "else", ":", "# Set we don't have autofill for this field", "atr", "[", "'autofill'", "]", "=", "None", "# Check if we have to replace the widget with a newer one", "if", "isinstance", "(", "infield", ".", "field", ".", "widget", ",", "Select", ")", "and", "not", "isinstance", "(", "infield", ".", "field", ".", "widget", ",", "DynamicSelect", ")", ":", "if", "isinstance", "(", "infield", ".", "field", ",", "NullBooleanField", ")", ":", "infield", ".", "field", ".", "widget", "=", "CheckboxInput", "(", "wattrs", ")", "elif", "not", "isinstance", "(", "infield", ".", "field", ".", "widget", ",", "MultiStaticSelect", ")", ":", "infield", ".", "field", ".", "widget", "=", "StaticSelect", "(", "wattrs", ")", "if", "hasattr", "(", "infield", ".", "field", ".", "widget", ",", "'choices'", ")", "and", "hasattr", "(", "infield", ".", "field", ",", "'choices'", ")", ":", "infield", ".", "field", ".", "widget", ".", "choices", "=", "infield", ".", "field", ".", "choices", "infield", ".", "field", ".", "widget", ".", "is_required", "=", "wrequired", "infield", ".", "field", ".", "widget", ".", "form_name", "=", "self", ".", "form_name", "infield", ".", "field", ".", "widget", ".", "field_name", "=", "infield", ".", "html_name", "# Fill all attributes", "for", "(", "attribute", ",", "default", ")", "in", "attributes", ":", "if", "attribute", "not", "in", "atr", ".", "keys", "(", ")", ":", "atr", "[", "attribute", "]", "=", "default", "# Fill label", "if", "atr", "[", "'label'", "]", "is", "True", ":", "atr", "[", "'label'", "]", "=", "infield", ".", "label", "# Set language", "flang", "=", "getattr", "(", "infield", ".", "field", ",", "\"set_language\"", ",", "None", ")", "if", "flang", ":", "flang", "(", "self", ".", "__language", ")", "flang", "=", "getattr", "(", "infield", ".", "field", ".", "widget", ",", "\"set_language\"", ",", "None", ")", "if", "flang", ":", "flang", "(", "self", ".", "__language", ")", "# Attach the attribute", "fields", ".", "append", "(", "atr", ")", "# Save the new elements", "if", "fields", ":", "groups", ".", "append", "(", "{", "'name'", ":", "None", ",", "'columns'", ":", "12", ",", "'fields'", ":", "fields", "}", ")", "# Set focus", "if", "focus_must", ":", "focus_must", "[", "'focus'", "]", "=", "True", "elif", "focus_first", "is", "not", "None", ":", "focus_first", "[", "'focus'", "]", "=", "True", "# Return the resulting groups", "return", "groups" ]

[ "<", "---------------------------------------", "12", "columns", "------------------------------------", ">", "<", "---", "6", "columns", "---", ">", "<", "---", "6", "columns", "---", ">", "------------------------------------------", "------------------------------------------", "|", "Info", "|", "|", "Personal", "|", "|", "==========================================", "|", "|", "==========================================", "|", "|", "-----------------", "------------------", "|", "|", "|", "|", "|", "Passport", "|", "|", "Name", "|", "|", "|", "Phone", "Zipcode", "|", "|", "|", "=================", "|", "|", "[", ".....", "]", "[", ".....", "]", "|", "|", "|", "[", "...........................", "]", "[", ".......", "]", "|", "|", "|", "CID", "Country", "|", "|", "<", "-", "6", "-", ">", "<", "-", "6", "-", ">", "|", "|", "|", "<", "---", "8", "columns", "---", ">", "<", "-", "4", "col", "-", ">", "|", "|", "|", "[", ".....", "]", "[", ".....", "]", "|", "|", "|", "|", "|", "|", "|", "|", "<", "-", "6", "-", ">", "<", "-", "6", "-", ">", "|", "-----------------", "|", "|", "Address", "|", "|", "-----------------", "|", "|", "[", ".....................................", "]", "|", "------------------------------------------", "|", "<", "---", "12", "columns", "---", ">", "|", "|", "[", "..", "]", "number", "|", "|", "<", "---", "12", "columns", "---", ">", "|", "|", "|", "------------------------------------------", "group", "=", "[", "(", "_", "(", "Info", ")", "(", "6", "#8a6d3b", "#fcf8e3", "center", ")", "(", "_", "(", "Identification", ")", "6", "[", "cid", "6", "]", "[", "country", "6", "]", ")", "(", "None", "6", "[", "name", "None", "6", "]", "[", "surname", "None", "6", "False", "]", ")", ")", "(", "_", "(", "Personal", ")", "6", "[", "phone", "None", "8", "]", "[", "zipcode", "None", "4", "]", "[", "address", "None", "12", "]", "[", "number", "None", "12", "True", "]", ")", "]" ]

[ "def", "get_docstring_and_rest", "(", "filename", ")", ":", "node", ",", "content", "=", "parse_source_file", "(", "filename", ")", "if", "node", "is", "None", ":", "return", "SYNTAX_ERROR_DOCSTRING", ",", "content", ",", "1", "if", "not", "isinstance", "(", "node", ",", "ast", ".", "Module", ")", ":", "raise", "TypeError", "(", "\"This function only supports modules. \"", "\"You provided {0}\"", ".", "format", "(", "node", ".", "__class__", ".", "__name__", ")", ")", "if", "not", "(", "node", ".", "body", "and", "isinstance", "(", "node", ".", "body", "[", "0", "]", ",", "ast", ".", "Expr", ")", "and", "isinstance", "(", "node", ".", "body", "[", "0", "]", ".", "value", ",", "ast", ".", "Str", ")", ")", ":", "raise", "ValueError", "(", "(", "'Could not find docstring in file \"{0}\". '", "'A docstring is required by sphinx-gallery '", "'unless the file is ignored by \"ignore_pattern\"'", ")", ".", "format", "(", "filename", ")", ")", "if", "LooseVersion", "(", "sys", ".", "version", ")", ">=", "LooseVersion", "(", "'3.7'", ")", ":", "docstring", "=", "ast", ".", "get_docstring", "(", "node", ")", "assert", "docstring", "is", "not", "None", "# should be guaranteed above", "# This is just for backward compat", "if", "len", "(", "node", ".", "body", "[", "0", "]", ".", "value", ".", "s", ")", "and", "node", ".", "body", "[", "0", "]", ".", "value", ".", "s", "[", "0", "]", "==", "'\\n'", ":", "# just for strict backward compat here", "docstring", "=", "'\\n'", "+", "docstring", "ts", "=", "tokenize", ".", "tokenize", "(", "BytesIO", "(", "content", ".", "encode", "(", ")", ")", ".", "readline", ")", "# find the first string according to the tokenizer and get its end row", "for", "tk", "in", "ts", ":", "if", "tk", ".", "exact_type", "==", "3", ":", "lineno", ",", "_", "=", "tk", ".", "end", "break", "else", ":", "lineno", "=", "0", "else", ":", "# this block can be removed when python 3.6 support is dropped", "docstring_node", "=", "node", ".", "body", "[", "0", "]", "docstring", "=", "docstring_node", ".", "value", ".", "s", "# python2.7: Code was read in bytes needs decoding to utf-8", "# unless future unicode_literals is imported in source which", "# make ast output unicode strings", "if", "hasattr", "(", "docstring", ",", "'decode'", ")", "and", "not", "isinstance", "(", "docstring", ",", "unicode", ")", ":", "docstring", "=", "docstring", ".", "decode", "(", "'utf-8'", ")", "lineno", "=", "docstring_node", ".", "lineno", "# The last line of the string.", "# This get the content of the file after the docstring last line", "# Note: 'maxsplit' argument is not a keyword argument in python2", "rest", "=", "'\\n'", ".", "join", "(", "content", ".", "split", "(", "'\\n'", ")", "[", "lineno", ":", "]", ")", "lineno", "+=", "1", "return", "docstring", ",", "rest", ",", "lineno" ]

[ "Separate", "filename", "content", "between", "docstring", "and", "the", "rest" ]

[ "def", "songs_add", "(", "self", ",", "songs", ")", ":", "mutations", "=", "[", "mc_calls", ".", "TrackBatch", ".", "add", "(", "song", ")", "for", "song", "in", "songs", "]", "response", "=", "self", ".", "_call", "(", "mc_calls", ".", "TrackBatch", ",", "mutations", ")", "success_ids", "=", "[", "res", "[", "'id'", "]", "for", "res", "in", "response", ".", "body", "[", "'mutate_response'", "]", "if", "res", "[", "'response_code'", "]", "==", "'OK'", "]", "return", "success_ids" ]

[ "Add", "store", "songs", "to", "your", "library", "." ]

[ "def", "get_ssh_subsystem_names", "(", "self", ")", ":", "preferred_ssh_subsystem", "=", "self", ".", "device_params", ".", "get", "(", "\"ssh_subsystem_name\"", ")", "name_list", "=", "[", "\"netconf\"", ",", "\"xmlagent\"", "]", "if", "preferred_ssh_subsystem", ":", "return", "[", "preferred_ssh_subsystem", "]", "+", "[", "n", "for", "n", "in", "name_list", "if", "n", "!=", "preferred_ssh_subsystem", "]", "else", ":", "return", "name_list" ]

[ "Return", "a", "list", "of", "possible", "SSH", "subsystem", "names", "." ]

[ "def", "main", "(", "port", "=", "4118", ",", "parentpid", "=", "None", ")", ":", "if", "\"LDTP_DEBUG\"", "in", "os", ".", "environ", ":", "_ldtp_debug", "=", "True", "else", ":", "_ldtp_debug", "=", "False", "_ldtp_debug_file", "=", "os", ".", "environ", ".", "get", "(", "'LDTP_DEBUG_FILE'", ",", "None", ")", "if", "_ldtp_debug", ":", "print", "(", "\"Parent PID: {}\"", ".", "format", "(", "int", "(", "parentpid", ")", ")", ")", "if", "_ldtp_debug_file", ":", "with", "open", "(", "unicode", "(", "_ldtp_debug_file", ")", ",", "\"a\"", ")", "as", "fp", ":", "fp", ".", "write", "(", "\"Parent PID: {}\"", ".", "format", "(", "int", "(", "parentpid", ")", ")", ")", "server", "=", "LDTPServer", "(", "(", "''", ",", "port", ")", ",", "allow_none", "=", "True", ",", "logRequests", "=", "_ldtp_debug", ",", "requestHandler", "=", "RequestHandler", ")", "server", ".", "register_introspection_functions", "(", ")", "server", ".", "register_multicall_functions", "(", ")", "ldtp_inst", "=", "core", ".", "Core", "(", ")", "server", ".", "register_instance", "(", "ldtp_inst", ")", "if", "parentpid", ":", "thread", ".", "start_new_thread", "(", "notifyclient", ",", "(", "parentpid", ",", ")", ")", "try", ":", "server", ".", "serve_forever", "(", ")", "except", "KeyboardInterrupt", ":", "pass", "except", ":", "if", "_ldtp_debug", ":", "print", "(", "traceback", ".", "format_exc", "(", ")", ")", "if", "_ldtp_debug_file", ":", "with", "open", "(", "_ldtp_debug_file", ",", "\"a\"", ")", "as", "fp", ":", "fp", ".", "write", "(", "traceback", ".", "format_exc", "(", ")", ")" ]

[ "Main", "entry", "point", ".", "Parse", "command", "line", "options", "and", "start", "up", "a", "server", "." ]

[ "def", "add_gene_panel", "(", "self", ",", "panel_obj", ")", ":", "panel_name", "=", "panel_obj", "[", "'panel_name'", "]", "panel_version", "=", "panel_obj", "[", "'version'", "]", "display_name", "=", "panel_obj", ".", "get", "(", "'display_name'", ",", "panel_name", ")", "if", "self", ".", "gene_panel", "(", "panel_name", ",", "panel_version", ")", ":", "raise", "IntegrityError", "(", "\"Panel {0} with version {1} already\"", "\" exist in database\"", ".", "format", "(", "panel_name", ",", "panel_version", ")", ")", "LOG", ".", "info", "(", "\"loading panel {0}, version {1} to database\"", ".", "format", "(", "display_name", ",", "panel_version", ")", ")", "result", "=", "self", ".", "panel_collection", ".", "insert_one", "(", "panel_obj", ")", "LOG", ".", "debug", "(", "\"Panel saved\"", ")", "return", "result", ".", "inserted_id" ]

[ "Add", "a", "gene", "panel", "to", "the", "database" ]

[ "def", "model_temporal_evolotion", "(", "self", ",", "time_index", ",", "cycle_files", ")", ":", "for", "file", "in", "cycle_files", ":", "# generate log here about files being updated", "self", ".", "update_inputfile", "(", "file", "[", "0", "]", ",", "file", "[", "1", "]", ")" ]

[ "-", "The", "function", "prepares", "the", "model", "for", "this", "time", "cycle", "-", "Any", "time", "-", "dependant", "forcing", "should", "be", "handled", "here", ".", "This", "includes", "temporal", "stresses", "boundary", "conditions", "and", "initial", "conditions", ".", "-", "Two", "options", "are", "available", "(", "1", ")", "template", "files", "to", "update", "input", "parameters", "(", "2", ")", "use", "results", "from", "previous", "cycle", "to", "update", "input", "files", "using", "instruction", "files", ".", "(", "3", ")", "the", "user", "must", "prepare", "a", "pair", "of", "files", ":", ".", "tpl", "(", "or", ".", "ins", ")", "and", "corresponding", "file", "to", "change", ":", "param", "time_index", ":", ":", "return", ":" ]

[ "def", "get_domain_connect_template_sync_url", "(", "self", ",", "domain", ",", "provider_id", ",", "service_id", ",", "redirect_uri", "=", "None", ",", "params", "=", "None", ",", "state", "=", "None", ",", "group_ids", "=", "None", ")", ":", "# TODO: support for signatures", "# TODO: support for provider_name (for shared templates)", "if", "params", "is", "None", ":", "params", "=", "{", "}", "config", "=", "self", ".", "get_domain_config", "(", "domain", ")", "self", ".", "check_template_supported", "(", "config", ",", "provider_id", ",", "service_id", ")", "if", "config", ".", "urlSyncUX", "is", "None", ":", "raise", "InvalidDomainConnectSettingsException", "(", "\"No sync URL in config\"", ")", "sync_url_format", "=", "'{}/v2/domainTemplates/providers/{}/services/{}/'", "'apply?domain={}&host={}&{}'", "if", "redirect_uri", "is", "not", "None", ":", "params", "[", "\"redirect_uri\"", "]", "=", "redirect_uri", "if", "state", "is", "not", "None", ":", "params", "[", "\"state\"", "]", "=", "state", "if", "group_ids", "is", "not", "None", ":", "params", "[", "\"groupId\"", "]", "=", "\",\"", ".", "join", "(", "group_ids", ")", "return", "sync_url_format", ".", "format", "(", "config", ".", "urlSyncUX", ",", "provider_id", ",", "service_id", ",", "config", ".", "domain_root", ",", "config", ".", "host", ",", "urllib", ".", "parse", ".", "urlencode", "(", "sorted", "(", "params", ".", "items", "(", ")", ",", "key", "=", "lambda", "val", ":", "val", "[", "0", "]", ")", ")", ")" ]

[ "Makes", "full", "Domain", "Connect", "discovery", "of", "a", "domain", "and", "returns", "full", "url", "to", "request", "sync", "consent", "." ]

[ "def", "getGroupIDs", "(", "self", ",", "groupNames", ",", "communityInfo", "=", "None", ")", ":", "group_ids", "=", "[", "]", "if", "communityInfo", "is", "None", ":", "communityInfo", "=", "self", ".", "communitySelf", "if", "isinstance", "(", "groupNames", ",", "list", ")", ":", "groupNames", "=", "map", "(", "str", ".", "upper", ",", "groupNames", ")", "else", ":", "groupNames", "=", "groupNames", ".", "upper", "(", ")", "if", "'groups'", "in", "communityInfo", ":", "for", "gp", "in", "communityInfo", "[", "'groups'", "]", ":", "if", "str", "(", "gp", "[", "'title'", "]", ")", ".", "upper", "(", ")", "in", "groupNames", ":", "group_ids", ".", "append", "(", "gp", "[", "'id'", "]", ")", "del", "communityInfo", "return", "group_ids" ]

[ "This", "function", "retrieves", "the", "group", "IDs" ]

[ "def", "add_dependency", "(", "self", ",", "depend", ")", ":", "try", ":", "self", ".", "_add_child", "(", "self", ".", "depends", ",", "self", ".", "depends_set", ",", "depend", ")", "except", "TypeError", "as", "e", ":", "e", "=", "e", ".", "args", "[", "0", "]", "if", "SCons", ".", "Util", ".", "is_List", "(", "e", ")", ":", "s", "=", "list", "(", "map", "(", "str", ",", "e", ")", ")", "else", ":", "s", "=", "str", "(", "e", ")", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "\"attempted to add a non-Node dependency to %s:\\n\\t%s is a %s, not a Node\"", "%", "(", "str", "(", "self", ")", ",", "s", ",", "type", "(", "e", ")", ")", ")" ]

[ "Adds", "dependencies", "." ]

[ "def", "debug_ratelimit", "(", "g", ")", ":", "assert", "isinstance", "(", "g", ",", "github", ".", "MainClass", ".", "Github", ")", ",", "type", "(", "g", ")", "debug", "(", "\"github ratelimit: {rl}\"", ".", "format", "(", "rl", "=", "g", ".", "rate_limiting", ")", ")" ]

[ "Log", "debug", "of", "github", "ratelimit", "information", "from", "last", "API", "call" ]

[ "def", "get_configuration", "(", "dev", ")", ":", "bmRequestType", "=", "util", ".", "build_request_type", "(", "util", ".", "CTRL_IN", ",", "util", ".", "CTRL_TYPE_STANDARD", ",", "util", ".", "CTRL_RECIPIENT_DEVICE", ")", "return", "dev", ".", "ctrl_transfer", "(", "bmRequestType", ",", "bRequest", "=", "0x08", ",", "data_or_wLength", "=", "1", ")", "[", "0", "]" ]

[ "r", "Get", "the", "current", "active", "configuration", "of", "the", "device", "." ]

[ "def", "import_prefs", "(", ")", ":", "# settings.py locals if autodiscover_siteprefs() is in urls.py", "settings_locals", "=", "get_frame_locals", "(", "3", ")", "if", "'self'", "not", "in", "settings_locals", ":", "# If not SiteprefsConfig.ready()", "# Try to import project-wide prefs.", "project_package", "=", "settings_locals", "[", "'__package__'", "]", "# Expected project layout introduced in Django 1.4", "if", "not", "project_package", ":", "# Fallback to old layout.", "project_package", "=", "os", ".", "path", ".", "split", "(", "os", ".", "path", ".", "dirname", "(", "settings_locals", "[", "'__file__'", "]", ")", ")", "[", "-", "1", "]", "import_module", "(", "project_package", ",", "PREFS_MODULE_NAME", ")", "import_project_modules", "(", "PREFS_MODULE_NAME", ")" ]

[ "Imports", "preferences", "modules", "from", "packages", "(", "apps", ")", "and", "project", "root", "." ]

[ "def", "_create_linked_clone", "(", "self", ")", ":", "gns3_snapshot_exists", "=", "False", "vm_info", "=", "yield", "from", "self", ".", "_get_vm_info", "(", ")", "for", "entry", ",", "value", "in", "vm_info", ".", "items", "(", ")", ":", "if", "entry", ".", "startswith", "(", "\"SnapshotName\"", ")", "and", "value", "==", "\"GNS3 Linked Base for clones\"", ":", "gns3_snapshot_exists", "=", "True", "if", "not", "gns3_snapshot_exists", ":", "result", "=", "yield", "from", "self", ".", "manager", ".", "execute", "(", "\"snapshot\"", ",", "[", "self", ".", "_vmname", ",", "\"take\"", ",", "\"GNS3 Linked Base for clones\"", "]", ")", "log", ".", "debug", "(", "\"GNS3 snapshot created: {}\"", ".", "format", "(", "result", ")", ")", "args", "=", "[", "self", ".", "_vmname", ",", "\"--snapshot\"", ",", "\"GNS3 Linked Base for clones\"", ",", "\"--options\"", ",", "\"link\"", ",", "\"--name\"", ",", "self", ".", "name", ",", "\"--basefolder\"", ",", "self", ".", "working_dir", ",", "\"--register\"", "]", "result", "=", "yield", "from", "self", ".", "manager", ".", "execute", "(", "\"clonevm\"", ",", "args", ")", "log", ".", "debug", "(", "\"VirtualBox VM: {} cloned\"", ".", "format", "(", "result", ")", ")", "self", ".", "_vmname", "=", "self", ".", "_name", "yield", "from", "self", ".", "manager", ".", "execute", "(", "\"setextradata\"", ",", "[", "self", ".", "_vmname", ",", "\"GNS3/Clone\"", ",", "\"yes\"", "]", ")", "# We create a reset snapshot in order to simplify life of user who want to rollback their VM", "# Warning: Do not document this it's seem buggy we keep it because Raizo students use it.", "try", ":", "args", "=", "[", "self", ".", "_vmname", ",", "\"take\"", ",", "\"reset\"", "]", "result", "=", "yield", "from", "self", ".", "manager", ".", "execute", "(", "\"snapshot\"", ",", "args", ")", "log", ".", "debug", "(", "\"Snapshot 'reset' created: {}\"", ".", "format", "(", "result", ")", ")", "# It seem sometimes this failed due to internal race condition of Vbox", "# we have no real explanation of this.", "except", "VirtualBoxError", ":", "log", ".", "warn", "(", "\"Snapshot 'reset' not created\"", ")", "os", ".", "makedirs", "(", "os", ".", "path", ".", "join", "(", "self", ".", "working_dir", ",", "self", ".", "_vmname", ")", ",", "exist_ok", "=", "True", ")" ]

[ "Creates", "a", "new", "linked", "clone", "." ]

[ "def", "merge_lists", "(", "dest", ",", "source", ",", "extend_lists", "=", "False", ")", ":", "if", "not", "source", ":", "return", "if", "not", "extend_lists", ":", "# Make them the same size", "left", "=", "dest", "right", "=", "source", "[", ":", "]", "if", "len", "(", "dest", ")", ">", "len", "(", "source", ")", ":", "right", ".", "extend", "(", "[", "None", "]", "*", "(", "len", "(", "dest", ")", "-", "len", "(", "source", ")", ")", ")", "elif", "len", "(", "dest", ")", "<", "len", "(", "source", ")", ":", "left", ".", "extend", "(", "[", "None", "]", "*", "(", "len", "(", "source", ")", "-", "len", "(", "dest", ")", ")", ")", "# Merge lists", "for", "index", ",", "value", "in", "enumerate", "(", "left", ")", ":", "if", "value", "is", "None", "and", "right", "[", "index", "]", "is", "not", "None", ":", "dest", "[", "index", "]", "=", "right", "[", "index", "]", "elif", "isinstance", "(", "value", ",", "dict", ")", "and", "isinstance", "(", "right", "[", "index", "]", ",", "dict", ")", ":", "merge_dictionary", "(", "dest", "[", "index", "]", ",", "source", "[", "index", "]", ",", "extend_lists", "=", "extend_lists", ")", "elif", "isinstance", "(", "value", ",", "list", ")", ":", "merge_lists", "(", "value", ",", "right", "[", "index", "]", ")", "elif", "right", "[", "index", "]", "is", "not", "None", ":", "dest", "[", "index", "]", "=", "right", "[", "index", "]", "else", ":", "dest", ".", "extend", "(", "[", "src", "for", "src", "in", "source", "if", "src", "not", "in", "dest", "]", ")", "return", "dest" ]

[ "Recursively", "merge", "two", "lists", "." ]

[ "def", "modifyReject", "(", "LowLayerCompatibility_presence", "=", "0", ",", "HighLayerCompatibility_presence", "=", "0", ")", ":", "a", "=", "TpPd", "(", "pd", "=", "0x3", ")", "b", "=", "MessageType", "(", "mesType", "=", "0x13", ")", "# 00010011", "c", "=", "BearerCapability", "(", ")", "d", "=", "Cause", "(", ")", "packet", "=", "a", "/", "b", "/", "c", "/", "d", "if", "LowLayerCompatibility_presence", "is", "1", ":", "e", "=", "LowLayerCompatibilityHdr", "(", "ieiLLC", "=", "0x7C", ",", "eightBitLLC", "=", "0x0", ")", "packet", "=", "packet", "/", "e", "if", "HighLayerCompatibility_presence", "is", "1", ":", "f", "=", "HighLayerCompatibilityHdr", "(", "ieiHLC", "=", "0x7D", ",", "eightBitHLC", "=", "0x0", ")", "packet", "=", "packet", "/", "f", "return", "packet" ]

[ "MODIFY", "REJECT", "Section", "9", ".", "3", ".", "15" ]

[ "def", "parse", "(", "cls", ",", "requester", ",", "entry", ")", ":", "if", "not", "type", "(", "entry", ")", "is", "dict", ":", "return", "entry", "for", "key_to_parse", ",", "cls_to_parse", "in", "six", ".", "iteritems", "(", "cls", ".", "parser", ")", ":", "if", "key_to_parse", "in", "entry", ":", "entry", "[", "key_to_parse", "]", "=", "cls_to_parse", ".", "parse", "(", "requester", ",", "entry", "[", "key_to_parse", "]", ")", "return", "cls", "(", "requester", ",", "*", "*", "entry", ")" ]

[ "Turns", "a", "JSON", "object", "into", "a", "model", "instance", "." ]

[ "def", "prepare", "(", "self", ",", "engine", "=", "None", ",", "mode", "=", "None", ",", "model", "=", "None", ",", "index", "=", "None", ",", "key", "=", "None", ",", "filter", "=", "None", ",", "projection", "=", "None", ",", "consistent", "=", "None", ",", "forward", "=", "None", ",", "parallel", "=", "None", ")", ":", "self", ".", "prepare_iterator_cls", "(", "engine", ",", "mode", ")", "self", ".", "prepare_model", "(", "model", ",", "index", ",", "consistent", ")", "self", ".", "prepare_key", "(", "key", ")", "self", ".", "prepare_projection", "(", "projection", ")", "self", ".", "prepare_filter", "(", "filter", ")", "self", ".", "prepare_constraints", "(", "forward", ",", "parallel", ")", "self", ".", "prepare_request", "(", ")" ]

[ "Validates", "the", "search", "parameters", "and", "builds", "the", "base", "request", "dict", "for", "each", "Query", "/", "Scan", "call", "." ]

[ "def", "list_sessions", "(", "self", ",", "updated_since", "=", "None", ",", "max_results", "=", "100", ",", "skip", "=", "0", ")", ":", "if", "int", "(", "max_results", ")", "<", "1", ":", "raise", "ValueError", "(", "\"max_results must be 1 or greater.\"", ")", "self", ".", "_can_run", "(", ")", "message", "=", "{", "'last-updated-time'", ":", "updated_since", "or", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "0", ")", ",", "'skip'", ":", "skip", ",", "'top'", ":", "max_results", ",", "}", "return", "self", ".", "_mgmt_request_response", "(", "REQUEST_RESPONSE_GET_MESSAGE_SESSIONS_OPERATION", ",", "message", ",", "mgmt_handlers", ".", "list_sessions_op", ")" ]

[ "List", "session", "IDs", "." ]

[ "def", "rl_get_point", "(", ")", "->", "int", ":", "# pragma: no cover", "if", "rl_type", "==", "RlType", ".", "GNU", ":", "return", "ctypes", ".", "c_int", ".", "in_dll", "(", "readline_lib", ",", "\"rl_point\"", ")", ".", "value", "elif", "rl_type", "==", "RlType", ".", "PYREADLINE", ":", "return", "readline", ".", "rl", ".", "mode", ".", "l_buffer", ".", "point", "else", ":", "return", "0" ]

[ "Returns", "the", "offset", "of", "the", "current", "cursor", "position", "in", "rl_line_buffer" ]

[ "def", "__serializedDot", "(", "self", ")", ":", "temp", "=", "\"\"", "for", "x", ",", "y", ",", "z", "in", "self", ".", "rdflib_graph", ".", "triples", "(", "(", "None", ",", "None", ",", "None", ")", ")", ":", "temp", "+=", "\"\"\"\"%s\" -> \"%s\" [label=\"%s\"];\\n\"\"\"", "%", "(", "self", ".", "namespace_manager", ".", "normalizeUri", "(", "x", ")", ",", "self", ".", "namespace_manager", ".", "normalizeUri", "(", "z", ")", ",", "self", ".", "namespace_manager", ".", "normalizeUri", "(", "y", ")", ")", "temp", "=", "\"digraph graphname {\\n%s}\"", "%", "temp", "return", "temp" ]

[ "DOT", "format", ":", "digraph", "graphname", "{", "a", "-", ">", "b", "[", "label", "=", "instanceOf", "]", ";", "b", "-", ">", "d", "[", "label", "=", "isA", "]", ";", "}" ]

[ "def", "sign", "(", "self", ",", "pkey", ",", "digest", ")", ":", "if", "not", "isinstance", "(", "pkey", ",", "PKey", ")", ":", "raise", "TypeError", "(", "\"pkey must be a PKey instance\"", ")", "if", "pkey", ".", "_only_public", ":", "raise", "ValueError", "(", "\"Key only has public part\"", ")", "if", "not", "pkey", ".", "_initialized", ":", "raise", "ValueError", "(", "\"Key is uninitialized\"", ")", "evp_md", "=", "_lib", ".", "EVP_get_digestbyname", "(", "_byte_string", "(", "digest", ")", ")", "if", "evp_md", "==", "_ffi", ".", "NULL", ":", "raise", "ValueError", "(", "\"No such digest method\"", ")", "sign_result", "=", "_lib", ".", "X509_sign", "(", "self", ".", "_x509", ",", "pkey", ".", "_pkey", ",", "evp_md", ")", "_openssl_assert", "(", "sign_result", ">", "0", ")" ]

[ "Sign", "the", "certificate", "with", "this", "key", "and", "digest", "type", "." ]

[ "def", "get_exception", "(", ")", ":", "trace", "=", "\"\"", "exception", "=", "\"\"", "exc_list", "=", "traceback", ".", "format_exception_only", "(", "sys", ".", "exc_info", "(", ")", "[", "0", "]", ",", "sys", ".", "exc_info", "(", ")", "[", "1", "]", ")", "for", "entry", "in", "exc_list", ":", "exception", "+=", "entry", "tb_list", "=", "traceback", ".", "format_tb", "(", "sys", ".", "exc_info", "(", ")", "[", "2", "]", ")", "for", "entry", "in", "tb_list", ":", "trace", "+=", "entry", "return", "\"%s\\n%s\"", "%", "(", "exception", ",", "trace", ")" ]

[ "Return", "full", "formatted", "traceback", "as", "a", "string", "." ]

[ "def", "_get_fields", "(", "self", ",", "attr", ")", ":", "ret", "=", "set", "(", ")", "if", "\"OR\"", "in", "self", ".", "pieces", ":", "return", "ret", "for", "i", "in", "range", "(", "0", ",", "len", "(", "self", ".", "pieces", ")", ",", "2", ")", ":", "const", "=", "self", ".", "pieces", "[", "i", "]", "field", "=", "getattr", "(", "const", ",", "attr", ")", "if", "field", "is", "not", "None", ":", "ret", ".", "add", "(", "field", ")", "return", "ret" ]

[ "Get", "the", "hash", "/", "range", "fields", "of", "all", "joined", "constraints" ]

[ "def", "mkdir", "(", "dir", ",", "enter", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "dir", ")", ":", "os", ".", "makedirs", "(", "dir", ")" ]

[ "Create", "directory", "with", "template", "for", "topic", "of", "the", "current", "environment" ]

[ "def", "hnn_state", "(", "self", ",", "inputs", ",", "t", ",", "argv", ")", ":", "index", "=", "argv", "v", "=", "inputs", "[", "0", "]", "# membrane potential (v).\r", "m", "=", "inputs", "[", "1", "]", "# activation conductance of the sodium channel (m).\r", "h", "=", "inputs", "[", "2", "]", "# inactivaton conductance of the sodium channel (h).\r", "n", "=", "inputs", "[", "3", "]", "# activation conductance of the potassium channel (n).\r", "# Calculate ion current\r", "# gNa * m[i]^3 * h * (v[i] - vNa) + gK * n[i]^4 * (v[i] - vK) + gL (v[i] - vL)\r", "active_sodium_part", "=", "self", ".", "_params", ".", "gNa", "*", "(", "m", "**", "3", ")", "*", "h", "*", "(", "v", "-", "self", ".", "_params", ".", "vNa", ")", "inactive_sodium_part", "=", "self", ".", "_params", ".", "gK", "*", "(", "n", "**", "4", ")", "*", "(", "v", "-", "self", ".", "_params", ".", "vK", ")", "active_potassium_part", "=", "self", ".", "_params", ".", "gL", "*", "(", "v", "-", "self", ".", "_params", ".", "vL", ")", "Iion", "=", "active_sodium_part", "+", "inactive_sodium_part", "+", "active_potassium_part", "Iext", "=", "0.0", "Isyn", "=", "0.0", "if", "(", "index", "<", "self", ".", "_num_osc", ")", ":", "# PN - peripheral neuron - calculation of external current and synaptic current.\r", "Iext", "=", "self", ".", "_stimulus", "[", "index", "]", "*", "self", ".", "_noise", "[", "index", "]", "# probably noise can be pre-defined for reducting compexity\r", "memory_impact1", "=", "0.0", "for", "i", "in", "range", "(", "0", ",", "len", "(", "self", ".", "_central_element", "[", "0", "]", ".", "pulse_generation_time", ")", ")", ":", "memory_impact1", "+=", "self", ".", "__alfa_function", "(", "t", "-", "self", ".", "_central_element", "[", "0", "]", ".", "pulse_generation_time", "[", "i", "]", ",", "self", ".", "_params", ".", "alfa_inhibitory", ",", "self", ".", "_params", ".", "betta_inhibitory", ")", "memory_impact2", "=", "0.0", "for", "i", "in", "range", "(", "0", ",", "len", "(", "self", ".", "_central_element", "[", "1", "]", ".", "pulse_generation_time", ")", ")", ":", "memory_impact2", "+=", "self", ".", "__alfa_function", "(", "t", "-", "self", ".", "_central_element", "[", "1", "]", ".", "pulse_generation_time", "[", "i", "]", ",", "self", ".", "_params", ".", "alfa_inhibitory", ",", "self", ".", "_params", ".", "betta_inhibitory", ")", "Isyn", "=", "self", ".", "_params", ".", "w2", "*", "(", "v", "-", "self", ".", "_params", ".", "Vsyninh", ")", "*", "memory_impact1", "+", "self", ".", "_link_weight3", "[", "index", "]", "*", "(", "v", "-", "self", ".", "_params", ".", "Vsyninh", ")", "*", "memory_impact2", "else", ":", "# CN - central element.\r", "central_index", "=", "index", "-", "self", ".", "_num_osc", "if", "(", "central_index", "==", "0", ")", ":", "Iext", "=", "self", ".", "_params", ".", "Icn1", "# CN1\r", "memory_impact", "=", "0.0", "for", "index_oscillator", "in", "range", "(", "0", ",", "self", ".", "_num_osc", ")", ":", "for", "index_generation", "in", "range", "(", "0", ",", "len", "(", "self", ".", "_pulse_generation_time", "[", "index_oscillator", "]", ")", ")", ":", "memory_impact", "+=", "self", ".", "__alfa_function", "(", "t", "-", "self", ".", "_pulse_generation_time", "[", "index_oscillator", "]", "[", "index_generation", "]", ",", "self", ".", "_params", ".", "alfa_excitatory", ",", "self", ".", "_params", ".", "betta_excitatory", ")", "Isyn", "=", "self", ".", "_params", ".", "w1", "*", "(", "v", "-", "self", ".", "_params", ".", "Vsynexc", ")", "*", "memory_impact", "elif", "(", "central_index", "==", "1", ")", ":", "Iext", "=", "self", ".", "_params", ".", "Icn2", "# CN2\r", "Isyn", "=", "0.0", "else", ":", "assert", "0", "# Membrane potential\r", "dv", "=", "-", "Iion", "+", "Iext", "-", "Isyn", "# Calculate variables\r", "potential", "=", "v", "-", "self", ".", "_params", ".", "vRest", "am", "=", "(", "2.5", "-", "0.1", "*", "potential", ")", "/", "(", "math", ".", "exp", "(", "2.5", "-", "0.1", "*", "potential", ")", "-", "1.0", ")", "ah", "=", "0.07", "*", "math", ".", "exp", "(", "-", "potential", "/", "20.0", ")", "an", "=", "(", "0.1", "-", "0.01", "*", "potential", ")", "/", "(", "math", ".", "exp", "(", "1.0", "-", "0.1", "*", "potential", ")", "-", "1.0", ")", "bm", "=", "4.0", "*", "math", ".", "exp", "(", "-", "potential", "/", "18.0", ")", "bh", "=", "1.0", "/", "(", "math", ".", "exp", "(", "3.0", "-", "0.1", "*", "potential", ")", "+", "1.0", ")", "bn", "=", "0.125", "*", "math", ".", "exp", "(", "-", "potential", "/", "80.0", ")", "dm", "=", "am", "*", "(", "1.0", "-", "m", ")", "-", "bm", "*", "m", "dh", "=", "ah", "*", "(", "1.0", "-", "h", ")", "-", "bh", "*", "h", "dn", "=", "an", "*", "(", "1.0", "-", "n", ")", "-", "bn", "*", "n", "return", "[", "dv", ",", "dm", ",", "dh", ",", "dn", "]" ]

[ "!" ]

[ "def", "__download_file", "(", "self", ",", "url", ",", "path_file", ",", "timeout", ")", ":", "status_code", "=", "0", "init_time", "=", "time", ".", "time", "(", ")", "self", ".", "driver_wrapper", ".", "logger", ".", "info", "(", "'Downloading file from Selenoid node: %s'", "%", "url", ")", "# retries policy", "while", "status_code", "!=", "STATUS_OK", "and", "time", ".", "time", "(", ")", "-", "init_time", "<", "float", "(", "timeout", ")", ":", "body", "=", "requests", ".", "get", "(", "url", ")", "status_code", "=", "body", ".", "status_code", "if", "status_code", "!=", "STATUS_OK", ":", "time", ".", "sleep", "(", "1", ")", "took", "=", "time", ".", "time", "(", ")", "-", "init_time", "# time used to download the file", "# create the folders and store the file downloaded", "if", "status_code", "==", "STATUS_OK", ":", "path", ",", "name", "=", "os", ".", "path", ".", "split", "(", "path_file", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "os", ".", "makedirs", "(", "path", ")", "try", ":", "fp", "=", "open", "(", "path_file", ",", "'wb'", ")", "fp", ".", "write", "(", "body", ".", "content", ")", "fp", ".", "close", "(", ")", "self", ".", "driver_wrapper", ".", "logger", ".", "info", "(", "'File has been downloaded successfully to \"%s\" and took %d '", "'seconds'", "%", "(", "path_file", ",", "took", ")", ")", "return", "True", "except", "IOError", "as", "e", ":", "self", ".", "driver_wrapper", ".", "logger", ".", "warn", "(", "'Error writing downloaded file in \"%s\":\\n %s'", "%", "(", "path_file", ",", "e", ")", ")", "else", ":", "self", ".", "driver_wrapper", ".", "logger", ".", "warn", "(", "'File \"%s\" does not exist in the server after %s seconds'", "%", "(", "url", ",", "timeout", ")", ")", "return", "False" ]

[ "download", "a", "file", "from", "the", "server", "using", "a", "request", "with", "retries", "policy", ":", "param", "url", ":", "server", "url", "to", "request", ":", "param", "path_file", ":", "path", "and", "file", "where", "to", "download", ":", "param", "timeout", ":", "threshold", "until", "the", "video", "file", "is", "downloaded", ":", "return", "boolean" ]

[ "def", "findModuleOfName", "(", "self", ",", "dotted_name", ",", "level", ",", "filename", ",", "extrapath", "=", "None", ")", ":", "if", "dotted_name", ".", "endswith", "(", "'.*'", ")", ":", "return", "dotted_name", "[", ":", "-", "2", "]", "name", "=", "dotted_name", "# extrapath is None only in a couple of test cases; in real life it's", "# always present", "if", "level", "and", "level", ">", "1", "and", "extrapath", ":", "# strip trailing path bits for each extra level to account for", "# relative imports", "# from . import X has level == 1 and nothing is stripped (the level > 1 check accounts for this case)", "# from .. import X has level == 2 and one trailing path component must go", "# from ... import X has level == 3 and two trailing path components must go", "extrapath", "=", "extrapath", ".", "split", "(", "os", ".", "path", ".", "sep", ")", "level", "-=", "1", "extrapath", "=", "extrapath", "[", "0", ":", "-", "level", "]", "extrapath", "=", "os", ".", "path", ".", "sep", ".", "join", "(", "extrapath", ")", "while", "name", ":", "candidate", "=", "self", ".", "isModule", "(", "name", ",", "extrapath", ")", "if", "candidate", ":", "return", "candidate", "candidate", "=", "self", ".", "isPackage", "(", "name", ",", "extrapath", ")", "if", "candidate", ":", "return", "candidate", "name", "=", "name", "[", ":", "name", ".", "rfind", "(", "'.'", ")", "]", "self", ".", "warn", "(", "dotted_name", ",", "'%s: could not find %s'", ",", "filename", ",", "dotted_name", ")", "return", "dotted_name" ]

[ "Given", "a", "fully", "qualified", "name", "find", "what", "module", "contains", "it", "." ]

[ "def", "fit", "(", "self", ",", "X", ",", "C", ")", ":", "X", ",", "C", "=", "_check_fit_input", "(", "X", ",", "C", ")", "C", "=", "np", ".", "asfortranarray", "(", "C", ")", "self", ".", "nclasses", "=", "C", ".", "shape", "[", "1", "]", "self", ".", "classifiers", "=", "[", "deepcopy", "(", "self", ".", "base_classifier", ")", "for", "i", "in", "range", "(", "self", ".", "nclasses", ")", "]", "if", "not", "self", ".", "weight_simple_diff", ":", "C", "=", "WeightedAllPairs", ".", "_calculate_v", "(", "self", ",", "C", ")", "Parallel", "(", "n_jobs", "=", "self", ".", "njobs", ",", "verbose", "=", "0", ",", "require", "=", "\"sharedmem\"", ")", "(", "delayed", "(", "self", ".", "_fit", ")", "(", "c", ",", "X", ",", "C", ")", "for", "c", "in", "range", "(", "self", ".", "nclasses", ")", ")", "return", "self" ]

[ "Fit", "one", "weighted", "classifier", "per", "class", "Parameters", "----------", "X", ":", "array", "(", "n_samples", "n_features", ")", "The", "data", "on", "which", "to", "fit", "a", "cost", "-", "sensitive", "classifier", ".", "C", ":", "array", "(", "n_samples", "n_classes", ")", "The", "cost", "of", "predicting", "each", "label", "for", "each", "observation", "(", "more", "means", "worse", ")", "." ]

[ "def", "_create_union_types_specification", "(", "schema_graph", ",", "graphql_types", ",", "hidden_classes", ",", "base_name", ")", ":", "# When edges point to vertices of type base_name, and base_name is both non-abstract and", "# has subclasses, we need to represent the edge endpoint type with a union type based on", "# base_name and its subclasses. This function calculates what types that union should include.", "def", "types_spec", "(", ")", ":", "\"\"\"Return a list of GraphQL types that this class' corresponding union type includes.\"\"\"", "return", "[", "graphql_types", "[", "x", "]", "for", "x", "in", "sorted", "(", "list", "(", "schema_graph", ".", "get_subclass_set", "(", "base_name", ")", ")", ")", "if", "x", "not", "in", "hidden_classes", "]", "return", "types_spec" ]

[ "Return", "a", "function", "that", "gives", "the", "types", "in", "the", "union", "type", "rooted", "at", "base_name", "." ]

[ "def", "command", "(", "self", ",", "name", "=", "None", ")", ":", "def", "decorator", "(", "f", ")", ":", "self", ".", "add_command", "(", "f", ",", "name", ")", "return", "f", "return", "decorator" ]

[ "A", "decorator", "to", "add", "subcommands", "." ]

[ "def", "deref_const", "(", "self", ",", "index", ")", ":", "if", "not", "index", ":", "raise", "IndexError", "(", "\"Requested const 0\"", ")", "t", ",", "v", "=", "self", ".", "consts", "[", "index", "]", "if", "t", "in", "(", "CONST_Utf8", ",", "CONST_Integer", ",", "CONST_Float", ",", "CONST_Long", ",", "CONST_Double", ")", ":", "return", "v", "elif", "t", "in", "(", "CONST_Class", ",", "CONST_String", ",", "CONST_MethodType", ")", ":", "return", "self", ".", "deref_const", "(", "v", ")", "elif", "t", "in", "(", "CONST_Fieldref", ",", "CONST_Methodref", ",", "CONST_InterfaceMethodref", ",", "CONST_NameAndType", ",", "CONST_ModuleId", ")", ":", "return", "tuple", "(", "self", ".", "deref_const", "(", "i", ")", "for", "i", "in", "v", ")", "else", ":", "raise", "Unimplemented", "(", "\"Unknown constant pool type %r\"", "%", "t", ")" ]

[ "returns", "the", "dereferenced", "value", "from", "the", "const", "pool", ".", "For", "simple", "types", "this", "will", "be", "a", "single", "value", "indicating", "the", "constant", ".", "For", "more", "complex", "types", "such", "as", "fieldref", "methodref", "etc", "this", "will", "return", "a", "tuple", "." ]

[ "def", "is_callable_type", "(", "tp", ")", ":", "if", "NEW_TYPING", ":", "return", "(", "tp", "is", "Callable", "or", "isinstance", "(", "tp", ",", "_GenericAlias", ")", "and", "tp", ".", "__origin__", "is", "collections", ".", "abc", ".", "Callable", "or", "isinstance", "(", "tp", ",", "type", ")", "and", "issubclass", "(", "tp", ",", "Generic", ")", "and", "issubclass", "(", "tp", ",", "collections", ".", "abc", ".", "Callable", ")", ")", "return", "type", "(", "tp", ")", "is", "CallableMeta" ]

[ "Test", "if", "the", "type", "is", "a", "generic", "callable", "type", "including", "subclasses", "excluding", "non", "-", "generic", "types", "and", "callables", ".", "Examples", "::" ]

[ "def", "_from_dict", "(", "cls", ",", "_dict", ")", ":", "args", "=", "{", "}", "if", "'key'", "in", "_dict", ":", "args", "[", "'key'", "]", "=", "Key", ".", "_from_dict", "(", "_dict", ".", "get", "(", "'key'", ")", ")", "if", "'value'", "in", "_dict", ":", "args", "[", "'value'", "]", "=", "Value", ".", "_from_dict", "(", "_dict", ".", "get", "(", "'value'", ")", ")", "return", "cls", "(", "*", "*", "args", ")" ]

[ "Initialize", "a", "KeyValuePair", "object", "from", "a", "json", "dictionary", "." ]

[ "def", "set_stack", "(", "self", ",", "stack_dump", ",", "stack_top", ")", ":", "data", "=", "self", ".", "_read_data", "(", "stack_dump", ")", "self", ".", "real_stack_top", "=", "stack_top", "addr", "=", "stack_top", "-", "len", "(", "data", ")", "# Address of the bottom of the stack", "l", ".", "info", "(", "\"Setting stack from 0x%x up to %#x\"", ",", "addr", ",", "stack_top", ")", "#FIXME: we should probably make we don't overwrite other stuff loaded there", "self", ".", "_write", "(", "addr", ",", "data", ")" ]

[ "Stack", "dump", "is", "a", "dump", "of", "the", "stack", "from", "gdb", "i", ".", "e", ".", "the", "result", "of", "the", "following", "gdb", "command", ":" ]

[ "def", "add_member_email", "(", "self", ",", "email", ",", "permissions", "=", "None", ")", ":", "data", "=", "{", "'email'", ":", "email", "}", "if", "isinstance", "(", "permissions", ",", "dict", ")", ":", "data", ".", "update", "(", "{", "'permissions'", ":", "permissions", "}", ")", "extra", "=", "{", "'resource'", ":", "self", ".", "__class__", ".", "__name__", ",", "'query'", ":", "{", "'id'", ":", "self", ".", "id", ",", "'data'", ":", "data", ",", "}", "}", "logger", ".", "info", "(", "'Adding member using email'", ",", "extra", "=", "extra", ")", "response", "=", "self", ".", "_api", ".", "post", "(", "url", "=", "self", ".", "_URL", "[", "'members_query'", "]", ".", "format", "(", "id", "=", "self", ".", "id", ")", ",", "data", "=", "data", ")", "member_data", "=", "response", ".", "json", "(", ")", "return", "Member", "(", "api", "=", "self", ".", "_api", ",", "*", "*", "member_data", ")" ]

[ "Add", "a", "member", "to", "the", "project", "using", "member", "email", ".", ":", "param", "email", ":", "Member", "email", ".", ":", "param", "permissions", ":", "Permissions", "dictionary", ".", ":", "return", ":", "Member", "object", "." ]

[ "def", "apply", "(", "self", ",", "resource", ")", ":", "if", "not", "isinstance", "(", "resource", ",", "Image", ".", "Image", ")", ":", "raise", "ValueError", "(", "'Unknown resource format'", ")", "resource_format", "=", "resource", ".", "format", "resource", "=", "resource", ".", "rotate", "(", "self", ".", "angle", ",", "expand", "=", "True", ")", "resource", ".", "format", "=", "resource_format", "return", "resource" ]

[ "Apply", "filter", "to", "resource", ":", "param", "resource", ":", "Image", ":", "return", ":", "Image" ]

[ "def", "get_list", "(", "list_type", "=", "None", ",", "search_term", "=", "None", ",", "page", "=", "None", ",", "page_size", "=", "None", ",", "sort_by", "=", "None", ")", ":", "opts", "=", "salt", ".", "utils", ".", "namecheap", ".", "get_opts", "(", "'namecheap.domains.getList'", ")", "if", "list_type", "is", "not", "None", ":", "if", "list_type", "not", "in", "[", "'ALL'", ",", "'EXPIRING'", ",", "'EXPIRED'", "]", ":", "log", ".", "error", "(", "'Invalid option for list_type'", ")", "raise", "Exception", "(", "'Invalid option for list_type'", ")", "opts", "[", "'ListType'", "]", "=", "list_type", "if", "search_term", "is", "not", "None", ":", "if", "len", "(", "search_term", ")", ">", "70", ":", "log", ".", "warning", "(", "'search_term trimmed to first 70 characters'", ")", "search_term", "=", "search_term", "[", "0", ":", "70", "]", "opts", "[", "'SearchTerm'", "]", "=", "search_term", "if", "page", "is", "not", "None", ":", "opts", "[", "'Page'", "]", "=", "page", "if", "page_size", "is", "not", "None", ":", "if", "page_size", ">", "100", "or", "page_size", "<", "10", ":", "log", ".", "error", "(", "'Invalid option for page'", ")", "raise", "Exception", "(", "'Invalid option for page'", ")", "opts", "[", "'PageSize'", "]", "=", "page_size", "if", "sort_by", "is", "not", "None", ":", "if", "sort_by", "not", "in", "[", "'NAME'", ",", "'NAME_DESC'", ",", "'EXPIREDATE'", ",", "'EXPIREDATE_DESC'", ",", "'CREATEDATE'", ",", "'CREATEDATE_DESC'", "]", ":", "log", ".", "error", "(", "'Invalid option for sort_by'", ")", "raise", "Exception", "(", "'Invalid option for sort_by'", ")", "opts", "[", "'SortBy'", "]", "=", "sort_by", "response_xml", "=", "salt", ".", "utils", ".", "namecheap", ".", "get_request", "(", "opts", ")", "if", "response_xml", "is", "None", ":", "return", "[", "]", "domainresult", "=", "response_xml", ".", "getElementsByTagName", "(", "\"DomainGetListResult\"", ")", "[", "0", "]", "domains", "=", "[", "]", "for", "d", "in", "domainresult", ".", "getElementsByTagName", "(", "\"Domain\"", ")", ":", "domains", ".", "append", "(", "salt", ".", "utils", ".", "namecheap", ".", "atts_to_dict", "(", "d", ")", ")", "return", "domains" ]

[ "Returns", "a", "list", "of", "domains", "for", "the", "particular", "user", "as", "a", "list", "of", "objects", "offset", "by", "page", "length", "of", "page_size" ]

[ "def", "deleted", "(", "message", ")", ":", "def", "deleted", "(", "value", ",", "_context", ",", "*", "*", "_params", ")", ":", "return", "Deleted", "(", "value", ",", "message", ")", "return", "deleted" ]

[ "Create", "a", "Deleted", "response", "builder", "with", "specified", "message", "." ]

[ "def", "is_tensor_on_canonical_device", "(", "self", ",", "tensor_name", ")", ":", "device", "=", "self", ".", "get_tensor_device", "(", "tensor_name", ")", "return", "not", "device", "or", "device", "==", "self", ".", "canonical_device" ]

[ "Whether", "the", "tensor", "is", "on", "the", "first", "(", "canonical", ")", "device", "." ]

[ "def", "multiple_pups", "(", "request", ")", ":", "if", "request", ".", "method", "==", "\"POST\"", ":", "form", "=", "MultipleAnimalForm", "(", "request", ".", "POST", ")", "if", "form", ".", "is_valid", "(", ")", ":", "count", "=", "form", ".", "cleaned_data", "[", "'count'", "]", "for", "i", "in", "range", "(", "count", ")", ":", "animal", "=", "Animal", "(", "Strain", "=", "form", ".", "cleaned_data", "[", "'Strain'", "]", ",", "Background", "=", "form", ".", "cleaned_data", "[", "'Background'", "]", ",", "Breeding", "=", "form", ".", "cleaned_data", "[", "'Breeding'", "]", ",", "Cage", "=", "form", ".", "cleaned_data", "[", "'Cage'", "]", ",", "Rack", "=", "form", ".", "cleaned_data", "[", "'Rack'", "]", ",", "Rack_Position", "=", "form", ".", "cleaned_data", "[", "'Rack_Position'", "]", ",", "Genotype", "=", "form", ".", "cleaned_data", "[", "'Genotype'", "]", ",", "Gender", "=", "form", ".", "cleaned_data", "[", "'Gender'", "]", ",", "Born", "=", "form", ".", "cleaned_data", "[", "'Born'", "]", ",", "Weaned", "=", "form", ".", "cleaned_data", "[", "'Weaned'", "]", ",", "Backcross", "=", "form", ".", "cleaned_data", "[", "'Backcross'", "]", ",", "Generation", "=", "form", ".", "cleaned_data", "[", "'Generation'", "]", ",", "Father", "=", "form", ".", "cleaned_data", "[", "'Father'", "]", ",", "Mother", "=", "form", ".", "cleaned_data", "[", "'Mother'", "]", ",", "Markings", "=", "form", ".", "cleaned_data", "[", "'Markings'", "]", ",", "Notes", "=", "form", ".", "cleaned_data", "[", "'Notes'", "]", ")", "animal", ".", "save", "(", ")", "return", "HttpResponseRedirect", "(", "reverse", "(", "'strain-list'", ")", ")", "else", ":", "form", "=", "MultipleAnimalForm", "(", ")", "return", "render", "(", "request", ",", "\"animal_multiple_form.html\"", ",", "{", "\"form\"", ":", "form", ",", "}", ")" ]

[ "This", "view", "is", "used", "to", "enter", "multiple", "animals", "at", "the", "same", "time", ".", "It", "will", "generate", "a", "form", "containing", "animal", "information", "and", "a", "number", "of", "mice", ".", "It", "is", "intended", "to", "create", "several", "identical", "animals", "with", "the", "same", "attributes", "." ]

[ "def", "find_by_hash", "(", "self", ",", "hash", "=", "None", ",", "book", "=", "-", "1", ")", ":", "if", "hash", ":", "self", ".", "fyi", "(", "\"nota.find_by_hash() with abbreviated hash %s; book=%s\"", "%", "(", "hash", ",", "book", ")", ")", "try", ":", "if", "book", "<", "0", ":", "rows", "=", "self", ".", "cur", ".", "execute", "(", "\"SELECT noteId, hash FROM note WHERE book > 0;\"", ")", ".", "fetchall", "(", ")", "else", ":", "rows", "=", "self", ".", "cur", ".", "execute", "(", "\"SELECT noteId, hash FROM note WHERE book=?;\"", ",", "[", "book", "]", ")", ".", "fetchall", "(", ")", "except", ":", "self", ".", "error", "(", "\"nota.find_by_hash() cannot look up note list\"", ")", "# Possibly save time by finding IDs first.", "noteIds", "=", "[", "]", "if", "hash", ":", "l", "=", "len", "(", "hash", ")", "for", "r", "in", "rows", ":", "if", "hash", "==", "r", "[", "1", "]", "[", "0", ":", "l", "]", ":", "noteIds", ".", "append", "(", "(", "r", "[", "0", "]", ",", ")", ")", "else", ":", "for", "r", "in", "rows", ":", "noteIds", ".", "append", "(", "(", "r", "[", "0", "]", ",", ")", ")", "self", ".", "fyi", "(", "\"noteIds: %s\"", "%", "noteIds", ")", "rval", "=", "[", "]", "for", "n", "in", "noteIds", ":", "try", ":", "note", "=", "self", ".", "cur", ".", "execute", "(", "\"SELECT noteId, authorId, date, title, content, due, privacy, modified, hash, book FROM note WHERE noteId=?;\"", ",", "n", ")", ".", "fetchone", "(", ")", "except", ":", "self", ".", "warning", "(", "\"Problem extracting note %s from database\"", "%", "n", ")", "next", "if", "note", ":", "date", "=", "note", "[", "2", "]", "due", "=", "note", "[", "5", "]", "privacy", "=", "note", "[", "6", "]", "keywordIds", "=", "[", "]", "keywordIds", ".", "extend", "(", "self", ".", "con", ".", "execute", "(", "\"SELECT keywordid FROM notekeyword WHERE notekeyword.noteid=?;\"", ",", "n", ")", ")", "keywords", "=", "[", "]", "for", "k", "in", "keywordIds", ":", "keywords", ".", "append", "(", "self", ".", "cur", ".", "execute", "(", "\"SELECT keyword FROM keyword WHERE keywordId=?;\"", ",", "k", ")", ".", "fetchone", "(", ")", "[", "0", "]", ")", "rval", ".", "append", "(", "{", "\"noteId\"", ":", "note", "[", "0", "]", ",", "\"title\"", ":", "note", "[", "3", "]", ",", "\"keywords\"", ":", "keywords", ",", "\"content\"", ":", "note", "[", "4", "]", ",", "\"due\"", ":", "note", "[", "5", "]", ",", "\"privacy\"", ":", "note", "[", "6", "]", ",", "\"date\"", ":", "note", "[", "2", "]", ",", "\"modified\"", ":", "note", "[", "7", "]", ",", "\"hash\"", ":", "note", "[", "8", "]", ",", "\"book\"", ":", "note", "[", "9", "]", "}", ")", "return", "rval" ]

[ "Search", "notes", "for", "a", "given", "(", "possibly", "abbreviated", ")", "hash" ]

[ "def", "_handle_message_for_stream", "(", "self", ",", "stream_transport", ",", "message", ",", "timeout", ")", ":", "if", "message", ".", "command", "not", "in", "(", "'OKAY'", ",", "'CLSE'", ",", "'WRTE'", ")", ":", "raise", "usb_exceptions", ".", "AdbProtocolError", "(", "'%s received unexpected message: %s'", ",", "self", ",", "message", ")", "if", "message", ".", "arg1", "==", "stream_transport", ".", "local_id", ":", "# Ack writes immediately.", "if", "message", ".", "command", "==", "'WRTE'", ":", "# Make sure we don't get a WRTE before an OKAY/CLSE message.", "if", "not", "stream_transport", ".", "remote_id", ":", "raise", "usb_exceptions", ".", "AdbProtocolError", "(", "'%s received WRTE before OKAY/CLSE: %s'", ",", "stream_transport", ",", "message", ")", "self", ".", "transport", ".", "write_message", "(", "adb_message", ".", "AdbMessage", "(", "'OKAY'", ",", "stream_transport", ".", "local_id", ",", "stream_transport", ".", "remote_id", ")", ",", "timeout", ")", "elif", "message", ".", "command", "==", "'CLSE'", ":", "self", ".", "close_stream_transport", "(", "stream_transport", ",", "timeout", ")", "return", "message", "else", ":", "# Message was not for this stream, add it to the right stream's queue.", "with", "self", ".", "_stream_transport_map_lock", ":", "dest_transport", "=", "self", ".", "_stream_transport_map", ".", "get", "(", "message", ".", "arg1", ")", "if", "dest_transport", ":", "if", "message", ".", "command", "==", "'CLSE'", ":", "self", ".", "close_stream_transport", "(", "dest_transport", ",", "timeout", ")", "dest_transport", ".", "enqueue_message", "(", "message", ",", "timeout", ")", "else", ":", "_LOG", ".", "warning", "(", "'Received message for unknown local-id: %s'", ",", "message", ")" ]

[ "Handle", "an", "incoming", "message", "check", "if", "it", "s", "for", "the", "given", "stream", "." ]

[ "def", "inherit_kwargs", "(", "inherit_func", ")", ":", "import", "utool", "as", "ut", "keys", ",", "is_arbitrary", "=", "ut", ".", "get_kwargs", "(", "inherit_func", ")", "if", "is_arbitrary", ":", "keys", "+=", "[", "'**kwargs'", "]", "kwargs_append", "=", "'\\n'", ".", "join", "(", "keys", ")", "#from six.moves import builtins", "#builtins.print(kwargs_block)", "def", "_wrp", "(", "func", ")", ":", "if", "func", ".", "__doc__", "is", "None", ":", "func", ".", "__doc__", "=", "''", "# TODO append to kwargs block if it exists", "kwargs_block", "=", "'Kwargs:\\n'", "+", "ut", ".", "indent", "(", "kwargs_append", ")", "func", ".", "__doc__", "+=", "kwargs_block", "return", "func", "return", "_wrp" ]

[ "TODO", "move", "to", "util_decor", "inherit_func", "=", "inspect_pdfs", "func", "=", "encoder", ".", "visualize", ".", "im_func" ]

[ "def", "execute_hook", "(", "self", ",", "event_name", ")", ":", "hook", "=", "self", ".", "settings", ".", "hooks", ".", "get_string", "(", "'{!s}'", ".", "format", "(", "event_name", ")", ")", "if", "hook", "is", "not", "None", "and", "hook", "!=", "\"\"", ":", "hook", "=", "hook", ".", "split", "(", ")", "try", ":", "subprocess", ".", "Popen", "(", "hook", ")", "except", "OSError", "as", "oserr", ":", "if", "oserr", ".", "errno", "==", "8", ":", "log", ".", "error", "(", "\"Hook execution failed! Check shebang at first line of %s!\"", ",", "hook", ")", "log", ".", "debug", "(", "traceback", ".", "format_exc", "(", ")", ")", "else", ":", "log", ".", "error", "(", "str", "(", "oserr", ")", ")", "except", "Exception", "as", "e", ":", "log", ".", "error", "(", "\"hook execution failed! %s\"", ",", "e", ")", "log", ".", "debug", "(", "traceback", ".", "format_exc", "(", ")", ")", "else", ":", "log", ".", "debug", "(", "\"hook on event %s has been executed\"", ",", "event_name", ")" ]

[ "Execute", "shell", "commands", "related", "to", "current", "event_name" ]

[ "def", "time", "(", "self", ",", "time", ")", ":", "self", ".", "_set_query", "(", "self", ".", "time_query", ",", "time", "=", "self", ".", "_format_time", "(", "time", ")", ")", "return", "self" ]

[ "Add", "a", "request", "for", "a", "specific", "time", "to", "the", "query", "." ]

[ "def", "pass_context", "(", "f", ")", ":", "def", "new_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "f", "(", "get_current_context", "(", ")", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "update_wrapper", "(", "new_func", ",", "f", ")" ]

[ "Marks", "a", "callback", "as", "wanting", "to", "receive", "the", "current", "context", "object", "as", "first", "argument", "." ]

[ "def", "_compile_device_specific_prims", "(", "self", ",", "debug", "=", "False", ",", "stages", "=", "None", ",", "stagenames", "=", "None", ")", ":", "############### GROUPING BY EXEC BOUNDARIES!################", "fences", "=", "[", "]", "fence", "=", "[", "self", "[", "0", "]", "]", "for", "p", "in", "self", "[", "1", ":", "]", ":", "if", "type", "(", "fence", "[", "0", "]", ")", ".", "_layer", "==", "type", "(", "p", ")", ".", "_layer", "and", "isinstance", "(", "fence", "[", "0", "]", ",", "DeviceTarget", ")", "==", "isinstance", "(", "p", ",", "DeviceTarget", ")", ":", "fence", ".", "append", "(", "p", ")", "else", ":", "fences", ".", "append", "(", "fence", ")", "fence", "=", "[", "p", "]", "fences", ".", "append", "(", "fence", ")", "if", "debug", ":", "#pragma: no cover", "formatted_fences", "=", "[", "]", "for", "fence", "in", "fences", ":", "formatted_fence", "=", "[", "p", ".", "snapshot", "(", ")", "for", "p", "in", "fence", "]", "formatted_fences", ".", "append", "(", "formatted_fence", ")", "formatted_fences", ".", "append", "(", "[", "]", ")", "stages", ".", "append", "(", "formatted_fences", "[", ":", "-", "1", "]", ")", "#Ignore trailing []", "stagenames", ".", "append", "(", "\"Fencing off execution boundaries\"", ")", "############## SPLIT GROUPS BY DEVICE TARGET! ##############", "split_fences", "=", "[", "]", "for", "fence", "in", "fences", ":", "tmp_chains", "=", "{", "}", "for", "p", "in", "fence", ":", "k", "=", "p", ".", "_device_index", "if", "isinstance", "(", "p", ",", "DeviceTarget", ")", "else", "\"chain\"", "subchain", "=", "tmp_chains", ".", "setdefault", "(", "k", ",", "[", "]", ")", ".", "append", "(", "p", ")", "split_fences", ".", "append", "(", "list", "(", "tmp_chains", ".", "values", "(", ")", ")", ")", "if", "debug", ":", "#pragma: no cover", "formatted_split_fences", "=", "[", "]", "for", "fence", "in", "split_fences", ":", "for", "group", "in", "fence", ":", "formatted_split_fences", ".", "append", "(", "[", "p", ".", "snapshot", "(", ")", "for", "p", "in", "group", "]", ")", "formatted_split_fences", ".", "append", "(", "[", "]", ")", "stages", ".", "append", "(", "formatted_split_fences", "[", ":", "-", "1", "]", ")", "stagenames", ".", "append", "(", "\"Grouping prims of each boundary by \"", "\"target device\"", ")", "############## ALIGN SEQUENCES AND PAD FRAMES ##############", "#FIRST DEV REQUIRED LINE", "grouped_fences", "=", "[", "FrameSequence", "(", "self", ".", "_chain", ",", "*", "fence", ")", ".", "finalize", "(", ")", "for", "f_i", ",", "fence", "in", "enumerate", "(", "split_fences", ")", "]", "if", "debug", ":", "#pragma: no cover", "formatted_grouped_fences", "=", "[", "]", "for", "fence", "in", "grouped_fences", ":", "formatted_grouped_fences", "+=", "fence", ".", "snapshot", "(", ")", "+", "[", "[", "]", "]", "stages", ".", "append", "(", "formatted_grouped_fences", "[", ":", "-", "1", "]", ")", "stagenames", ".", "append", "(", "\"Aligning and combining each group dev \"", "\"prim stream\"", ")", "################## RECOMBINE FRAME GROUPS ##################", "ingested_chain", "=", "grouped_fences", "[", "0", "]", "for", "fence", "in", "grouped_fences", "[", "1", ":", "]", ":", "ingested_chain", "+=", "fence", "if", "debug", ":", "#pragma: no cover", "stages", ".", "append", "(", "ingested_chain", ".", "snapshot", "(", ")", ")", "stagenames", ".", "append", "(", "\"Recombining sanitized exec boundaries\"", ")", "###################### POST INGESTION ######################", "################ Flatten out LV3 Primitives ################", "while", "(", "any", "(", "(", "f", ".", "_layer", "==", "3", "for", "f", "in", "ingested_chain", ")", ")", ")", ":", "################# COMBINE COMPATIBLE PRIMS #################", "ingested_chain", "=", "_merge_prims", "(", "ingested_chain", ")", "if", "debug", ":", "#pragma: no cover", "stages", ".", "append", "(", "ingested_chain", ".", "snapshot", "(", ")", ")", "stagenames", ".", "append", "(", "\"Combining compatible lv3 prims.\"", ")", "################ TRANSLATION TO LOWER LAYER ################", "sm", "=", "JTAGStateMachine", "(", "self", ".", "_chain", ".", "_sm", ".", "state", ")", "expanded_prims", "=", "FrameSequence", "(", "self", ".", "_chain", ")", "for", "f", "in", "ingested_chain", ":", "if", "f", ".", "_layer", "==", "3", ":", "expanded_prims", "+=", "f", ".", "expand_macro", "(", "sm", ")", "else", ":", "expanded_prims", ".", "append", "(", "f", ")", "expanded_prims", ".", "finalize", "(", ")", "ingested_chain", "=", "expanded_prims", "if", "self", ".", "_fsm", "is", "None", ":", "self", ".", "_fsm", "=", "sm", "assert", "self", ".", "_fsm", "==", "sm", ",", "\"Target %s != Actual %s\"", "%", "(", "self", ".", "_fsm", ".", "state", ",", "sm", ".", "state", ")", "if", "debug", ":", "#pragma: no cover", "stages", ".", "append", "(", "ingested_chain", ".", "snapshot", "(", ")", ")", "stagenames", ".", "append", "(", "\"Expanding lv3 prims\"", ")", "############## Flatten out Dev LV2 Primitives ##############", "while", "(", "any", "(", "(", "isinstance", "(", "f", ".", "_valid_prim", ",", "DeviceTarget", ")", "for", "f", "in", "ingested_chain", ")", ")", ")", ":", "################# COMBINE COMPATIBLE PRIMS #################", "ingested_chain", "=", "_merge_prims", "(", "ingested_chain", ")", "if", "debug", ":", "#pragma: no cover", "stages", ".", "append", "(", "ingested_chain", ".", "snapshot", "(", ")", ")", "stagenames", ".", "append", "(", "\"Merging Device Specific Prims\"", ")", "################ TRANSLATION TO LOWER LAYER ################", "sm", "=", "JTAGStateMachine", "(", "self", ".", "_chain", ".", "_sm", ".", "state", ")", "expanded_prims", "=", "FrameSequence", "(", "self", ".", "_chain", ")", "for", "f", "in", "ingested_chain", ":", "if", "issubclass", "(", "f", ".", "_prim_type", ",", "DeviceTarget", ")", ":", "expanded_prims", "+=", "f", ".", "expand_macro", "(", "sm", ")", "else", ":", "f", "[", "0", "]", ".", "apply_tap_effect", "(", "sm", ")", "expanded_prims", ".", "append", "(", "f", ")", "expanded_prims", ".", "finalize", "(", ")", "ingested_chain", "=", "expanded_prims", "if", "self", ".", "_fsm", "is", "None", ":", "self", ".", "_fsm", "=", "sm", "assert", "self", ".", "_fsm", "==", "sm", ",", "\"Target %s != Actual %s\"", "%", "(", "self", ".", "_fsm", ".", "state", ",", "sm", ".", "state", ")", "if", "debug", ":", "#pragma: no cover", "stages", ".", "append", "(", "ingested_chain", ".", "snapshot", "(", ")", ")", "stagenames", ".", "append", "(", "\"Expanding Device Specific Prims\"", ")", "############ Convert FrameSequence to flat array ###########", "flattened_prims", "=", "[", "f", ".", "_valid_prim", "for", "f", "in", "ingested_chain", "]", "if", "debug", ":", "#pragma: no cover", "stages", ".", "append", "(", "[", "[", "p", ".", "snapshot", "(", ")", "for", "p", "in", "flattened_prims", "]", "]", ")", "stagenames", ".", "append", "(", "\"Converting format to single stream.\"", ")", "return", "flattened_prims" ]

[ "Using", "the", "data", "stored", "in", "the", "CommandQueue", "Extract", "and", "align", "compatible", "sequences", "of", "Primitives", "and", "compile", "/", "optimize", "the", "Primitives", "down", "into", "a", "stream", "of", "Level", "2", "device", "agnostic", "primitives", "." ]

[ "def", "currentEvent", "(", "self", ")", ":", "currentEvent", "=", "self", ".", "recentEvents", ".", "filter", "(", "endTime__gte", "=", "timezone", ".", "now", "(", ")", ")", ".", "order_by", "(", "'startTime'", ")", ".", "first", "(", ")", "if", "not", "currentEvent", ":", "currentEvent", "=", "self", ".", "recentEvents", ".", "filter", "(", "endTime__lte", "=", "timezone", ".", "now", "(", ")", ")", ".", "order_by", "(", "'-endTime'", ")", ".", "first", "(", ")", "return", "currentEvent" ]

[ "Return", "the", "first", "event", "that", "hasn", "t", "ended", "yet", "or", "if", "there", "are", "no", "future", "events", "the", "last", "one", "to", "end", "." ]

[ "def", "array_to_csv", "(", "array_like", ")", ":", "# type: (np.array or Iterable or int or float) -> str", "stream", "=", "StringIO", "(", ")", "np", ".", "savetxt", "(", "stream", ",", "array_like", ",", "delimiter", "=", "','", ",", "fmt", "=", "'%s'", ")", "return", "stream", ".", "getvalue", "(", ")" ]

[ "Convert", "an", "array", "like", "object", "to", "CSV", "." ]

[ "def", "p_property_assignment", "(", "self", ",", "p", ")", ":", "if", "len", "(", "p", ")", "==", "4", ":", "p", "[", "0", "]", "=", "self", ".", "asttypes", ".", "Assign", "(", "left", "=", "p", "[", "1", "]", ",", "op", "=", "p", "[", "2", "]", ",", "right", "=", "p", "[", "3", "]", ")", "p", "[", "0", "]", ".", "setpos", "(", "p", ",", "2", ")", "elif", "len", "(", "p", ")", "==", "8", ":", "p", "[", "0", "]", "=", "self", ".", "asttypes", ".", "GetPropAssign", "(", "prop_name", "=", "p", "[", "2", "]", ",", "elements", "=", "p", "[", "6", "]", ")", "p", "[", "0", "]", ".", "setpos", "(", "p", ")", "else", ":", "p", "[", "0", "]", "=", "self", ".", "asttypes", ".", "SetPropAssign", "(", "prop_name", "=", "p", "[", "2", "]", ",", "parameter", "=", "p", "[", "4", "]", ",", "elements", "=", "p", "[", "7", "]", ")", "p", "[", "0", "]", ".", "setpos", "(", "p", ")" ]

[ "property_assignment", "\\", ":", "property_name", "COLON", "assignment_expr", "|", "GETPROP", "property_name", "LPAREN", "RPAREN", "LBRACE", "function_body", "RBRACE", "|", "SETPROP", "property_name", "LPAREN", "property_set_parameter_list", "RPAREN", "\\", "LBRACE", "function_body", "RBRACE" ]

[ "def", "read_null_terminated_string", "(", "f", ")", ":", "x", "=", "bytearray", "(", ")", "while", "True", ":", "z", "=", "f", ".", "read", "(", "1", ")", "if", "ord", "(", "z", ")", "==", "0", ":", "return", "x", "else", ":", "x", ".", "append", "(", "ord", "(", "z", ")", ")" ]

[ "Read", "a", "null", "terminated", "string", "from", "a", "file", "-", "like", "object", "." ]

[ "def", "read_header", "(", "filename", ",", "return_idxs", "=", "False", ")", ":", "with", "open", "(", "filename", ",", "'rb'", ")", "as", "fh", ":", "header_dict", "=", "{", "}", "header_idxs", "=", "{", "}", "# Check this is a blimpy file", "keyword", ",", "value", ",", "idx", "=", "read_next_header_keyword", "(", "fh", ")", "try", ":", "assert", "keyword", "==", "b'HEADER_START'", "except", "AssertionError", ":", "raise", "RuntimeError", "(", "\"Not a valid blimpy file.\"", ")", "while", "True", ":", "keyword", ",", "value", ",", "idx", "=", "read_next_header_keyword", "(", "fh", ")", "if", "keyword", "==", "b'HEADER_END'", ":", "break", "else", ":", "header_dict", "[", "keyword", "]", "=", "value", "header_idxs", "[", "keyword", "]", "=", "idx", "if", "return_idxs", ":", "return", "header_idxs", "else", ":", "return", "header_dict" ]

[ "Read", "blimpy", "header", "and", "return", "a", "Python", "dictionary", "of", "key", ":", "value", "pairs" ]

[ "def", "plot_movie_with_attractive_mpl", "(", "worlds", ",", "marker_size", "=", "6", ",", "figsize", "=", "6", ",", "grid", "=", "True", ",", "wireframe", "=", "False", ",", "species_list", "=", "None", ",", "max_count", "=", "None", ",", "angle", "=", "None", ",", "noaxis", "=", "False", ",", "interval", "=", "0.16", ",", "repeat_delay", "=", "3000", ",", "stride", "=", "1", ",", "rotate", "=", "None", ",", "legend", "=", "True", ",", "whratio", "=", "1.33", ",", "scale", "=", "1", ",", "output", "=", "None", ",", "crf", "=", "10", ",", "bitrate", "=", "'1M'", ",", "*", "*", "kwargs", ")", ":", "import", "matplotlib", ".", "pyplot", "as", "plt", "import", "matplotlib", ".", "animation", "as", "animation", "from", "ecell4_base", ".", "core", "import", "Species", ",", "FixedIntervalHDF5Observer", "from", ".", "simulation", "import", "load_world", "import", "os", ".", "path", "# print(\"Start generating species_list ...\")", "if", "isinstance", "(", "worlds", ",", "FixedIntervalHDF5Observer", ")", ":", "obs", "=", "worlds", "worlds", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "obs", ".", "num_steps", "(", ")", ",", "stride", ")", ":", "filename", "=", "obs", ".", "filename", "(", "i", ")", "if", "os", ".", "path", ".", "isfile", "(", "filename", ")", ":", "worlds", ".", "append", "(", "load_world", "(", "filename", ")", ")", "elif", "len", "(", "worlds", ")", ">", "0", ":", "worlds", ".", "append", "(", "worlds", "[", "-", "1", "]", ")", "else", ":", "worlds", "=", "worlds", "[", ":", ":", "stride", "]", "if", "species_list", "is", "None", ":", "species_list", "=", "[", "]", "for", "world", "in", "worlds", ":", "species_list", ".", "extend", "(", "[", "p", ".", "species", "(", ")", ".", "serial", "(", ")", "for", "pid", ",", "p", "in", "world", ".", "list_particles", "(", ")", "]", ")", "species_list", "=", "sorted", "(", "set", "(", "species_list", ")", ",", "key", "=", "species_list", ".", "index", ")", "# XXX: pick unique ones", "# print(\"Start preparing mplot3d ...\")", "fig", ",", "ax", "=", "__prepare_mplot3d_with_attractive_mpl", "(", "__get_range_of_world", "(", "worlds", "[", "0", "]", ",", "scale", ")", ",", "figsize", ",", "grid", ",", "wireframe", ",", "angle", ",", "noaxis", ",", "whratio", ")", "from", "mpl_toolkits", ".", "mplot3d", ".", "art3d", "import", "juggle_axes", "def", "_update_plot", "(", "i", ",", "scatters", ",", "worlds", ",", "species_list", ")", ":", "world", "=", "worlds", "[", "i", "]", "for", "i", ",", "name", "in", "enumerate", "(", "species_list", ")", ":", "xs", ",", "ys", ",", "zs", "=", "[", "]", ",", "[", "]", ",", "[", "]", "particles", "=", "world", ".", "list_particles_exact", "(", "Species", "(", "name", ")", ")", "if", "max_count", "is", "not", "None", "and", "len", "(", "particles", ")", ">", "max_count", ":", "particles", "=", "random", ".", "sample", "(", "particles", ",", "max_count", ")", "for", "pid", ",", "p", "in", "particles", ":", "pos", "=", "p", ".", "position", "(", ")", "*", "scale", "xs", ".", "append", "(", "pos", "[", "0", "]", ")", "ys", ".", "append", "(", "pos", "[", "1", "]", ")", "zs", ".", "append", "(", "pos", "[", "2", "]", ")", "scatters", "[", "i", "]", ".", "_offsets3d", "=", "juggle_axes", "(", "xs", ",", "ys", ",", "zs", ",", "'z'", ")", "if", "rotate", "is", "not", "None", ":", "ax", ".", "elev", "+=", "rotate", "[", "0", "]", "ax", ".", "azim", "+=", "rotate", "[", "1", "]", "fig", ".", "canvas", ".", "draw", "(", ")", "# print(\"Start making animation ...\")", "color_scale", "=", "attractive_mpl_color_scale", "(", "{", "}", ")", "scatters", "=", "[", "]", "for", "i", ",", "name", "in", "enumerate", "(", "species_list", ")", ":", "opts", "=", "dict", "(", "marker", "=", "'o'", ",", "s", "=", "(", "2", "**", "marker_size", ")", ",", "edgecolors", "=", "'white'", ",", "alpha", "=", "0.7", ")", "opts", ".", "update", "(", "kwargs", ")", "scatters", ".", "append", "(", "ax", ".", "scatter", "(", "[", "]", ",", "[", "]", ",", "[", "]", ",", "facecolor", "=", "color_scale", ".", "get_color", "(", "name", ")", ",", "label", "=", "name", ",", "*", "*", "opts", ")", ")", "# if legend:", "# ax.legend(loc='best', shadow=True)", "if", "legend", "is", "not", "None", "and", "legend", "is", "not", "False", ":", "legend_opts", "=", "{", "'loc'", ":", "'center left'", ",", "'bbox_to_anchor'", ":", "(", "1.0", ",", "0.5", ")", ",", "'shadow'", ":", "False", ",", "'frameon'", ":", "False", ",", "'fontsize'", ":", "'x-large'", ",", "'scatterpoints'", ":", "1", "}", "if", "isinstance", "(", "legend", ",", "dict", ")", ":", "legend_opts", ".", "update", "(", "legend", ")", "ax", ".", "legend", "(", "*", "*", "legend_opts", ")", "ani", "=", "animation", ".", "FuncAnimation", "(", "fig", ",", "_update_plot", ",", "fargs", "=", "(", "scatters", ",", "worlds", ",", "species_list", ")", ",", "frames", "=", "len", "(", "worlds", ")", ",", "interval", "=", "interval", ",", "blit", "=", "False", ")", "plt", ".", "close", "(", "ani", ".", "_fig", ")", "# print(\"Start generating a movie ...\")", "display_anim", "(", "ani", ",", "output", ",", "fps", "=", "1.0", "/", "interval", ",", "crf", "=", "crf", ",", "bitrate", "=", "bitrate", ")" ]

[ "Generate", "a", "move", "from", "the", "received", "list", "of", "instances", "of", "World", "and", "show", "it", "on", "IPython", "notebook", ".", "This", "function", "may", "require", "ffmpeg", "." ]