Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "get_responses", "(", "self", ")", ":", "response_list", "=", "[", "]", "for", "question_map", "in", "self", ".", "_my_map", "[", "'questions'", "]", ":", "response_list", ".", "append", "(", "self", ".", "_get_response_from_question_map", "(", "question_map", ")", ")", "return", "ResponseList", "(", "response_list", ")" ]

[ "Gets", "list", "of", "the", "latest", "responses" ]

[ "def", "_transform_array", "(", "self", ",", "X", ")", ":", "X_meanfree", "=", "X", "-", "self", ".", "mean", "Y", "=", "np", ".", "dot", "(", "X_meanfree", ",", "self", ".", "eigenvectors", "[", ":", ",", "0", ":", "self", ".", "dimension", "(", ")", "]", ")", "return", "Y", ".", "astype", "(", "self", ".", "output_type", "(", ")", ")" ]

[ "r", "Projects", "the", "data", "onto", "the", "dominant", "independent", "components", "." ]

[ "def", "walk_orm_tree", "(", "obj", ",", "debug", ":", "bool", "=", "False", ",", "seen", ":", "Set", "=", "None", ",", "skip_relationships_always", ":", "List", "[", "str", "]", "=", "None", ",", "skip_relationships_by_tablename", ":", "Dict", "[", "str", ",", "List", "[", "str", "]", "]", "=", "None", ",", "skip_all_relationships_for_tablenames", ":", "List", "[", "str", "]", "=", "None", ",", "skip_all_objects_for_tablenames", ":", "List", "[", "str", "]", "=", "None", ")", "->", "Generator", "[", "object", ",", "None", ",", "None", "]", ":", "# http://docs.sqlalchemy.org/en/latest/faq/sessions.html#faq-walk-objects", "skip_relationships_always", "=", "skip_relationships_always", "or", "[", "]", "# type: List[str] # noqa", "skip_relationships_by_tablename", "=", "skip_relationships_by_tablename", "or", "{", "}", "# type: Dict[str, List[str]] # noqa", "skip_all_relationships_for_tablenames", "=", "skip_all_relationships_for_tablenames", "or", "[", "]", "# type: List[str] # noqa", "skip_all_objects_for_tablenames", "=", "skip_all_objects_for_tablenames", "or", "[", "]", "# type: List[str] # noqa", "stack", "=", "[", "obj", "]", "if", "seen", "is", "None", ":", "seen", "=", "set", "(", ")", "while", "stack", ":", "obj", "=", "stack", ".", "pop", "(", "0", ")", "if", "obj", "in", "seen", ":", "continue", "tablename", "=", "obj", ".", "__tablename__", "if", "tablename", "in", "skip_all_objects_for_tablenames", ":", "continue", "seen", ".", "add", "(", "obj", ")", "if", "debug", ":", "log", ".", "debug", "(", "\"walk: yielding {!r}\"", ",", "obj", ")", "yield", "obj", "insp", "=", "inspect", "(", "obj", ")", "# type: InstanceState", "for", "relationship", "in", "insp", ".", "mapper", ".", "relationships", ":", "# type: RelationshipProperty # noqa", "attrname", "=", "relationship", ".", "key", "# Skip?", "if", "attrname", "in", "skip_relationships_always", ":", "continue", "if", "tablename", "in", "skip_all_relationships_for_tablenames", ":", "continue", "if", "(", "tablename", "in", "skip_relationships_by_tablename", "and", "attrname", "in", "skip_relationships_by_tablename", "[", "tablename", "]", ")", ":", "continue", "# Process relationship", "if", "debug", ":", "log", ".", "debug", "(", "\"walk: following relationship {}\"", ",", "relationship", ")", "related", "=", "getattr", "(", "obj", ",", "attrname", ")", "if", "debug", "and", "related", ":", "log", ".", "debug", "(", "\"walk: queueing {!r}\"", ",", "related", ")", "if", "relationship", ".", "uselist", ":", "stack", ".", "extend", "(", "related", ")", "elif", "related", "is", "not", "None", ":", "stack", ".", "append", "(", "related", ")" ]

[ "Starting", "with", "a", "SQLAlchemy", "ORM", "object", "this", "function", "walks", "a", "relationship", "tree", "yielding", "each", "of", "the", "objects", "once", "." ]

[ "def", "populate_cmdsets", "(", "job", ",", "cmdsets", ",", "depth", ")", ":", "if", "len", "(", "cmdsets", ")", "<", "depth", ":", "cmdsets", ".", "append", "(", "set", "(", ")", ")", "cmdsets", "[", "depth", "-", "1", "]", ".", "add", "(", "job", ".", "command", ")", "if", "len", "(", "job", ".", "dependencies", ")", "==", "0", ":", "return", "cmdsets", "for", "j", "in", "job", ".", "dependencies", ":", "cmdsets", "=", "populate_cmdsets", "(", "j", ",", "cmdsets", ",", "depth", "+", "1", ")", "return", "cmdsets" ]

[ "Creates", "a", "list", "of", "sets", "containing", "jobs", "at", "different", "depths", "of", "the", "dependency", "tree", "." ]

[ "def", "lane_info", "(", "self", ")", ":", "resource_list", "=", "self", ".", "traffic_incident", "(", ")", "lane_info", "=", "namedtuple", "(", "'lane_info'", ",", "'lane_info'", ")", "if", "len", "(", "resource_list", ")", "==", "1", "and", "resource_list", "[", "0", "]", "is", "None", ":", "return", "None", "else", ":", "try", ":", "return", "[", "lane_info", "(", "resource", "[", "'lane'", "]", ")", "for", "resource", "in", "resource_list", "]", "except", "(", "KeyError", ",", "TypeError", ")", ":", "try", ":", "return", "[", "lane_info", "(", "resource", "[", "'LaneInfo'", "]", ")", "for", "resource", "in", "resource_list", "]", "except", "KeyError", ":", "return", "None" ]

[ "Retrieves", "the", "lane", "info", "of", "the", "incident", "/", "incidents", "from", "the", "output", "response" ]

[ "def", "get_setter", "(", "cls", ",", "prop_name", ",", "# @NoSelf", "user_setter", "=", "None", ",", "setter_takes_name", "=", "False", ",", "user_getter", "=", "None", ",", "getter_takes_name", "=", "False", ")", ":", "has_prop_variable", "=", "cls", ".", "has_prop_attribute", "(", "prop_name", ")", "# WARNING! These are deprecated", "has_specific_setter", "=", "hasattr", "(", "cls", ",", "SET_PROP_NAME", "%", "{", "'prop_name'", ":", "prop_name", "}", ")", "has_general_setter", "=", "hasattr", "(", "cls", ",", "SET_GENERIC_NAME", ")", "if", "not", "(", "has_prop_variable", "or", "has_specific_setter", "or", "has_general_setter", "or", "user_setter", ")", ":", "return", "None", "if", "has_prop_variable", ":", "if", "has_specific_setter", "or", "user_setter", ":", "logger", ".", "warning", "(", "\"In class %s.%s ignoring custom logical \"", "\"setter for property '%s' as a \"", "\"corresponding attribute exists\"", "%", "(", "cls", ".", "__module__", ",", "cls", ".", "__name__", ",", "prop_name", ")", ")", "user_setter", "=", "user_getter", "=", "None", "setter_takes_name", "=", "getter_takes_name", "=", "False", "else", ":", "if", "user_setter", ":", "pass", "else", ":", "if", "has_specific_setter", ":", "def", "__setter", "(", "self", ",", "val", ")", ":", "_setter", "=", "getattr", "(", "self", ",", "SET_PROP_NAME", "%", "{", "'prop_name'", ":", "prop_name", "}", ")", "_setter", "(", "val", ")", "return", "user_setter", "=", "__setter", "#user_setter = getattr(cls, SET_PROP_NAME % \\", "# {'prop_name' : prop_name})", "setter_takes_name", "=", "False", "else", ":", "assert", "has_general_setter", "def", "__setter", "(", "self", ",", "name", ",", "val", ")", ":", "_setter", "=", "getattr", "(", "self", ",", "SET_GENERIC_NAME", ")", "_setter", "(", "name", ",", "val", ")", "return", "user_setter", "=", "__setter", "#user_setter = getattr(cls, SET_GENERIC_NAME)", "setter_takes_name", "=", "True", "# the final setter is a combination of a basic setter, and", "# the getter (see how inner_{getter,setter} are used in", "# _setter below)", "_inner_setter", "=", "PropertyMeta", ".", "get_setter", "(", "cls", ",", "prop_name", ",", "user_setter", ",", "setter_takes_name", ",", "user_getter", ",", "getter_takes_name", ")", "_inner_getter", "=", "type", "(", "cls", ")", ".", "get_getter", "(", "cls", ",", "prop_name", ",", "user_getter", ",", "getter_takes_name", ")", "def", "_setter", "(", "self", ",", "val", ")", ":", "curr_frame", "=", "len", "(", "self", ".", "_notify_stack", ")", "if", "prop_name", "not", "in", "self", ".", "_notify_stack", ":", "self", ".", "_notify_stack", ".", "append", "(", "prop_name", ")", "old", "=", "_inner_getter", "(", "self", ")", "new", "=", "type", "(", "self", ")", ".", "create_value", "(", "prop_name", ",", "val", ",", "self", ")", "# to track dependencies", "olds", "=", "self", ".", "__before_property_value_change__", "(", "prop_name", ")", "if", "self", ".", "_has_observer", "(", ")", "else", "(", ")", "self", ".", "_notify_stack", ".", "extend", "(", "map", "(", "operator", ".", "itemgetter", "(", "1", ")", ",", "olds", ")", ")", "# this is the unique place where the value is set:", "_inner_setter", "(", "self", ",", "new", ")", "if", "type", "(", "self", ")", ".", "check_value_change", "(", "old", ",", "new", ")", ":", "self", ".", "_reset_property_notification", "(", "prop_name", ",", "old", ")", "self", ".", "notify_property_value_change", "(", "prop_name", ",", "old", ",", "val", ")", "# to notify dependencies", "self", ".", "__after_property_value_change__", "(", "prop_name", ",", "olds", ")", "del", "self", ".", "_notify_stack", "[", "curr_frame", ":", "]", "return", "_setter" ]

[ "The", "setter", "follows", "the", "rules", "of", "the", "getter", ".", "First", "search", "for", "property", "variable", "then", "logical", "custom", "setter", ".", "If", "no", "setter", "is", "found", "None", "is", "returned", "(", "i", ".", "e", ".", "the", "property", "is", "read", "-", "only", ".", ")" ]

[ "def", "check_valid", "(", "money", ")", ":", "if", "not", "isinstance", "(", "money", ",", "sc_messages", ".", "Money", ")", ":", "raise", "ValueError", "(", "u'Inputs should be of type %s'", "%", "(", "sc_messages", ".", "Money", ",", ")", ")", "currency", "=", "money", ".", "currencyCode", "if", "not", "currency", "or", "len", "(", "currency", ")", "!=", "3", ":", "raise", "ValueError", "(", "_MSG_3_LETTERS_LONG", ")", "units", "=", "money", ".", "units", "nanos", "=", "money", ".", "nanos", "if", "(", "(", "units", ">", "0", ")", "and", "(", "nanos", "<", "0", ")", ")", "or", "(", "(", "units", "<", "0", ")", "and", "(", "nanos", ">", "0", ")", ")", ":", "raise", "ValueError", "(", "_MSG_UNITS_NANOS_MISMATCH", ")", "if", "abs", "(", "nanos", ")", ">", "MAX_NANOS", ":", "raise", "ValueError", "(", "_MSG_NANOS_OOB", ")" ]

[ "Determine", "if", "an", "instance", "of", "Money", "is", "valid", "." ]

[ "def", "_proxy", "(", "self", ")", ":", "if", "self", ".", "_context", "is", "None", ":", "self", ".", "_context", "=", "DocumentPermissionContext", "(", "self", ".", "_version", ",", "service_sid", "=", "self", ".", "_solution", "[", "'service_sid'", "]", ",", "document_sid", "=", "self", ".", "_solution", "[", "'document_sid'", "]", ",", "identity", "=", "self", ".", "_solution", "[", "'identity'", "]", ",", ")", "return", "self", ".", "_context" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "def", "forward_messages", "(", "self", ",", "chat_id", ":", "Union", "[", "int", ",", "str", "]", ",", "from_chat_id", ":", "Union", "[", "int", ",", "str", "]", ",", "message_ids", ":", "Iterable", "[", "int", "]", ",", "disable_notification", ":", "bool", "=", "None", ",", "as_copy", ":", "bool", "=", "False", ",", "remove_caption", ":", "bool", "=", "False", ")", "->", "\"pyrogram.Messages\"", ":", "is_iterable", "=", "not", "isinstance", "(", "message_ids", ",", "int", ")", "message_ids", "=", "list", "(", "message_ids", ")", "if", "is_iterable", "else", "[", "message_ids", "]", "if", "as_copy", ":", "forwarded_messages", "=", "[", "]", "for", "chunk", "in", "[", "message_ids", "[", "i", ":", "i", "+", "200", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "message_ids", ")", ",", "200", ")", "]", ":", "messages", "=", "self", ".", "get_messages", "(", "chat_id", "=", "from_chat_id", ",", "message_ids", "=", "chunk", ")", "# type: pyrogram.Messages", "for", "message", "in", "messages", ".", "messages", ":", "forwarded_messages", ".", "append", "(", "message", ".", "forward", "(", "chat_id", ",", "disable_notification", "=", "disable_notification", ",", "as_copy", "=", "True", ",", "remove_caption", "=", "remove_caption", ")", ")", "return", "pyrogram", ".", "Messages", "(", "client", "=", "self", ",", "total_count", "=", "len", "(", "forwarded_messages", ")", ",", "messages", "=", "forwarded_messages", ")", "if", "is_iterable", "else", "forwarded_messages", "[", "0", "]", "else", ":", "r", "=", "self", ".", "send", "(", "functions", ".", "messages", ".", "ForwardMessages", "(", "to_peer", "=", "self", ".", "resolve_peer", "(", "chat_id", ")", ",", "from_peer", "=", "self", ".", "resolve_peer", "(", "from_chat_id", ")", ",", "id", "=", "message_ids", ",", "silent", "=", "disable_notification", "or", "None", ",", "random_id", "=", "[", "self", ".", "rnd_id", "(", ")", "for", "_", "in", "message_ids", "]", ")", ")", "forwarded_messages", "=", "[", "]", "users", "=", "{", "i", ".", "id", ":", "i", "for", "i", "in", "r", ".", "users", "}", "chats", "=", "{", "i", ".", "id", ":", "i", "for", "i", "in", "r", ".", "chats", "}", "for", "i", "in", "r", ".", "updates", ":", "if", "isinstance", "(", "i", ",", "(", "types", ".", "UpdateNewMessage", ",", "types", ".", "UpdateNewChannelMessage", ")", ")", ":", "forwarded_messages", ".", "append", "(", "pyrogram", ".", "Message", ".", "_parse", "(", "self", ",", "i", ".", "message", ",", "users", ",", "chats", ")", ")", "return", "pyrogram", ".", "Messages", "(", "client", "=", "self", ",", "total_count", "=", "len", "(", "forwarded_messages", ")", ",", "messages", "=", "forwarded_messages", ")", "if", "is_iterable", "else", "forwarded_messages", "[", "0", "]" ]

[ "Use", "this", "method", "to", "forward", "messages", "of", "any", "kind", "." ]

[ "def", "isdir", "(", "self", ",", "path", ")", ":", "result", "=", "True", "try", ":", "self", ".", "sftp_client", ".", "lstat", "(", "path", ")", "except", "FileNotFoundError", ":", "result", "=", "False", "return", "result" ]

[ "Return", "true", "if", "the", "path", "refers", "to", "an", "existing", "directory", "." ]

[ "def", "oauth2_auth_url", "(", "redirect_uri", "=", "None", ",", "client_id", "=", "None", ",", "base_url", "=", "OH_BASE_URL", ")", ":", "if", "not", "client_id", ":", "client_id", "=", "os", ".", "getenv", "(", "'OHAPI_CLIENT_ID'", ")", "if", "not", "client_id", ":", "raise", "SettingsError", "(", "\"Client ID not provided! Provide client_id as a parameter, \"", "\"or set OHAPI_CLIENT_ID in your environment.\"", ")", "params", "=", "OrderedDict", "(", "[", "(", "'client_id'", ",", "client_id", ")", ",", "(", "'response_type'", ",", "'code'", ")", ",", "]", ")", "if", "redirect_uri", ":", "params", "[", "'redirect_uri'", "]", "=", "redirect_uri", "auth_url", "=", "urlparse", ".", "urljoin", "(", "base_url", ",", "'/direct-sharing/projects/oauth2/authorize/?{}'", ".", "format", "(", "urlparse", ".", "urlencode", "(", "params", ")", ")", ")", "return", "auth_url" ]

[ "Returns", "an", "OAuth2", "authorization", "URL", "for", "a", "project", "given", "Client", "ID", ".", "This", "function", "constructs", "an", "authorization", "URL", "for", "a", "user", "to", "follow", ".", "The", "user", "will", "be", "redirected", "to", "Authorize", "Open", "Humans", "data", "for", "our", "external", "application", ".", "An", "OAuth2", "project", "on", "Open", "Humans", "is", "required", "for", "this", "to", "properly", "work", ".", "To", "learn", "more", "about", "Open", "Humans", "OAuth2", "projects", "go", "to", ":", "https", ":", "//", "www", ".", "openhumans", ".", "org", "/", "direct", "-", "sharing", "/", "oauth2", "-", "features", "/" ]

[ "def", "route_table_get", "(", "name", ",", "resource_group", ",", "*", "*", "kwargs", ")", ":", "expand", "=", "kwargs", ".", "get", "(", "'expand'", ")", "netconn", "=", "__utils__", "[", "'azurearm.get_client'", "]", "(", "'network'", ",", "*", "*", "kwargs", ")", "try", ":", "table", "=", "netconn", ".", "route_tables", ".", "get", "(", "route_table_name", "=", "name", ",", "resource_group_name", "=", "resource_group", ",", "expand", "=", "expand", ")", "result", "=", "table", ".", "as_dict", "(", ")", "except", "CloudError", "as", "exc", ":", "__utils__", "[", "'azurearm.log_cloud_error'", "]", "(", "'network'", ",", "str", "(", "exc", ")", ",", "*", "*", "kwargs", ")", "result", "=", "{", "'error'", ":", "str", "(", "exc", ")", "}", "return", "result" ]

[ "..", "versionadded", "::", "2019", ".", "2", ".", "0" ]

[ "def", "_files_preserve", "(", "self", ")", ":", "result", "=", "set", "(", ")", "files", "=", "[", "]", "if", "not", "self", ".", "files_preserve", "else", "self", ".", "files_preserve", "files", ".", "extend", "(", "[", "self", ".", "stdin", ",", "self", ".", "stdout", ",", "self", ".", "stderr", "]", ")", "for", "item", "in", "files", ":", "if", "hasattr", "(", "item", ",", "'fileno'", ")", ":", "result", ".", "add", "(", "item", ".", "fileno", "(", ")", ")", "if", "isinstance", "(", "item", ",", "int", ")", ":", "result", ".", "add", "(", "item", ")", "return", "result" ]

[ "create", "a", "set", "of", "protected", "files" ]

[ "def", "_select_file", "(", "user_id", ",", "api_path", ",", "fields", ",", "limit", ")", ":", "query", "=", "select", "(", "fields", ")", ".", "where", "(", "_file_where", "(", "user_id", ",", "api_path", ")", ",", ")", ".", "order_by", "(", "_file_creation_order", "(", ")", ",", ")", "if", "limit", "is", "not", "None", ":", "query", "=", "query", ".", "limit", "(", "limit", ")", "return", "query" ]

[ "Return", "a", "SELECT", "statement", "that", "returns", "the", "latest", "N", "versions", "of", "a", "file", "." ]

[ "def", "update_agent_requirements", "(", "req_file", ",", "check", ",", "newline", ")", ":", "package_name", "=", "get_package_name", "(", "check", ")", "lines", "=", "read_file_lines", "(", "req_file", ")", "for", "i", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "current_package_name", "=", "line", ".", "split", "(", "'=='", ")", "[", "0", "]", "if", "current_package_name", "==", "package_name", ":", "lines", "[", "i", "]", "=", "'{}\\n'", ".", "format", "(", "newline", ")", "break", "write_file_lines", "(", "req_file", ",", "sorted", "(", "lines", ")", ")" ]

[ "Replace", "the", "requirements", "line", "for", "the", "given", "check" ]

[ "def", "next_addr", "(", "addr", ",", "i", ")", ":", "str_addr", "=", "pad_zeroes", "(", "str", "(", "int_addr", "(", "addr", ")", "+", "i", ")", ",", "len", "(", "addr", "[", "1", ":", "]", ")", ")", "return", "addr", "[", "0", "]", "+", "str_addr" ]

[ "Gets", "address", "after", "the", "current", "+", "i" ]

[ "def", "replace_seqres", "(", "self", ",", "pdb", ",", "update_atoms", "=", "True", ")", ":", "newpdb", "=", "PDB", "(", ")", "inserted_seqres", "=", "False", "entries_before_seqres", "=", "set", "(", "[", "\"HEADER\"", ",", "\"OBSLTE\"", ",", "\"TITLE\"", ",", "\"CAVEAT\"", ",", "\"COMPND\"", ",", "\"SOURCE\"", ",", "\"KEYWDS\"", ",", "\"EXPDTA\"", ",", "\"AUTHOR\"", ",", "\"REVDAT\"", ",", "\"SPRSDE\"", ",", "\"JRNL\"", ",", "\"REMARK\"", ",", "\"DBREF\"", ",", "\"SEQADV\"", "]", ")", "mutated_resids", "=", "{", "}", "if", "update_atoms", ":", "old_seqs", "=", "ChainSequences", "(", ")", "chainresnums", "=", "old_seqs", ".", "parse_atoms", "(", "pdb", ")", "assert", "self", ".", "keys", "(", ")", "==", "old_seqs", ".", "keys", "(", ")", "for", "chain", "in", "self", ".", "keys", "(", ")", ":", "assert", "len", "(", "self", "[", "chain", "]", ")", "==", "len", "(", "old_seqs", "[", "chain", "]", ")", "for", "i", "in", "xrange", "(", "len", "(", "self", "[", "chain", "]", ")", ")", ":", "if", "self", "[", "chain", "]", "[", "i", "]", "!=", "old_seqs", "[", "chain", "]", "[", "i", "]", ":", "resid", "=", "chain", "+", "chainresnums", "[", "chain", "]", "[", "i", "]", "mutated_resids", "[", "resid", "]", "=", "self", "[", "chain", "]", "[", "i", "]", "for", "line", "in", "pdb", ".", "lines", ":", "entry", "=", "line", "[", "0", ":", "6", "]", "if", "(", "not", "inserted_seqres", ")", "and", "entry", "not", "in", "entries_before_seqres", ":", "inserted_seqres", "=", "True", "newpdb", ".", "lines", "+=", "self", ".", "seqres_lines", "(", ")", "if", "update_atoms", "and", "entry", "==", "\"ATOM \"", ":", "resid", "=", "line", "[", "21", ":", "27", "]", "atom", "=", "line", "[", "12", ":", "16", "]", ".", "strip", "(", ")", "if", "not", "mutated_resids", ".", "has_key", "(", "resid", ")", ":", "newpdb", ".", "lines", "+=", "[", "line", "]", "else", ":", "newpdb", ".", "lines", "+=", "[", "line", "[", ":", "17", "]", "+", "mutated_resids", "[", "resid", "]", "+", "line", "[", "20", ":", "]", "]", "elif", "entry", "!=", "\"SEQRES\"", ":", "newpdb", ".", "lines", "+=", "[", "line", "]", "if", "update_atoms", ":", "newpdb", ".", "remove_nonbackbone_atoms", "(", "mutated_resids", ".", "keys", "(", ")", ")", "return", "newpdb" ]

[ "Replace", "SEQRES", "lines", "with", "a", "new", "sequence", "optionally", "removing", "mutated", "sidechains" ]

[ "def", "list_downloadable_sources", "(", "target_dir", ")", ":", "return", "[", "os", ".", "path", ".", "join", "(", "target_dir", ",", "fname", ")", "for", "fname", "in", "os", ".", "listdir", "(", "target_dir", ")", "if", "fname", ".", "endswith", "(", "'.py'", ")", "]" ]

[ "Returns", "a", "list", "of", "python", "source", "files", "is", "target_dir" ]

[ "def", "ConsultarDomicilios", "(", "self", ",", "nro_doc", ",", "tipo_doc", "=", "80", ",", "cat_iva", "=", "None", ")", ":", "self", ".", "cursor", ".", "execute", "(", "\"SELECT direccion FROM domicilio WHERE \"", "\" tipo_doc=? AND nro_doc=? ORDER BY id \"", ",", "[", "tipo_doc", ",", "nro_doc", "]", ")", "filas", "=", "self", ".", "cursor", ".", "fetchall", "(", ")", "self", ".", "domicilios", "=", "[", "fila", "[", "'direccion'", "]", "for", "fila", "in", "filas", "]", "return", "len", "(", "filas", ")" ]

[ "Busca", "los", "domicilios", "devuelve", "la", "cantidad", "y", "establece", "la", "lista" ]

[ "def", "systemCall", "(", "cmd", ",", "sh", "=", "True", ",", "log", "=", "None", ")", ":", "if", "log", "is", "None", ":", "log", "=", "logging", "log", ".", "debug", "(", "'System call [sh:%s]: %s'", "%", "(", "sh", ",", "cmd", ")", ")", "out", "=", "[", "]", "proc", "=", "None", "poller", "=", "None", "outBuf", "=", "[", "''", "]", "errBuf", "=", "[", "''", "]", "def", "pollOutput", "(", ")", ":", "'''\n Read, log and store output (if any) from processes pipes.\n '''", "removeChars", "=", "'\\r\\n'", "# collect fds with new output", "fds", "=", "[", "entry", "[", "0", "]", "for", "entry", "in", "poller", ".", "poll", "(", ")", "]", "if", "proc", ".", "stdout", ".", "fileno", "(", ")", "in", "fds", ":", "while", "True", ":", "try", ":", "tmp", "=", "proc", ".", "stdout", ".", "read", "(", "100", ")", "except", "IOError", ":", "break", "outBuf", "[", "0", "]", "+=", "tmp", "while", "'\\n'", "in", "outBuf", "[", "0", "]", ":", "line", ",", "_", ",", "outBuf", "[", "0", "]", "=", "outBuf", "[", "0", "]", ".", "partition", "(", "'\\n'", ")", "log", ".", "debug", "(", "line", ")", "out", ".", "append", "(", "line", "+", "'\\n'", ")", "if", "not", "tmp", ":", "break", "if", "proc", ".", "stderr", ".", "fileno", "(", ")", "in", "fds", ":", "while", "True", ":", "try", ":", "tmp", "=", "proc", ".", "stderr", ".", "read", "(", "100", ")", "except", "IOError", ":", "break", "errBuf", "[", "0", "]", "+=", "tmp", "while", "'\\n'", "in", "errBuf", "[", "0", "]", ":", "line", ",", "_", ",", "errBuf", "[", "0", "]", "=", "errBuf", "[", "0", "]", ".", "partition", "(", "'\\n'", ")", "log", ".", "warning", "(", "line", ")", "if", "not", "tmp", ":", "break", "while", "True", ":", "if", "proc", "is", "None", ":", "# create and start process", "proc", "=", "Popen", "(", "cmd", ",", "stdin", "=", "PIPE", ",", "stdout", "=", "PIPE", ",", "stderr", "=", "PIPE", ",", "shell", "=", "sh", ")", "# create poll select", "poller", "=", "select", ".", "poll", "(", ")", "flags", "=", "fcntl", ".", "fcntl", "(", "proc", ".", "stdout", ",", "fcntl", ".", "F_GETFL", ")", "fcntl", ".", "fcntl", "(", "proc", ".", "stdout", ",", "fcntl", ".", "F_SETFL", ",", "flags", "|", "os", ".", "O_NONBLOCK", ")", "flags", "=", "fcntl", ".", "fcntl", "(", "proc", ".", "stderr", ",", "fcntl", ".", "F_GETFL", ")", "fcntl", ".", "fcntl", "(", "proc", ".", "stderr", ",", "fcntl", ".", "F_SETFL", ",", "flags", "|", "os", ".", "O_NONBLOCK", ")", "# register pipes to polling", "poller", ".", "register", "(", "proc", ".", "stdout", ",", "select", ".", "POLLIN", ")", "poller", ".", "register", "(", "proc", ".", "stderr", ",", "select", ".", "POLLIN", ")", "pollOutput", "(", ")", "if", "proc", ".", "poll", "(", ")", "is", "not", "None", ":", "# proc finished", "break", "# poll once after the process ended to collect all the missing output", "pollOutput", "(", ")", "# check return code", "if", "proc", ".", "returncode", "!=", "0", ":", "raise", "RuntimeError", "(", "CalledProcessError", "(", "proc", ".", "returncode", ",", "cmd", ",", "''", ".", "join", "(", "out", ")", ")", ")", "return", "''", ".", "join", "(", "out", ")" ]

[ "Fancy", "magic", "version", "of", "os", ".", "system" ]

[ "def", "Matches", "(", "self", ",", "file_entry", ")", ":", "if", "not", "self", ".", "_names", "or", "not", "file_entry", ".", "IsFile", "(", ")", ":", "return", "False", "return", "file_entry", ".", "name", ".", "lower", "(", ")", "in", "self", ".", "_names" ]

[ "Compares", "the", "file", "entry", "against", "the", "filter", "." ]

[ "def", "msg_curse", "(", "self", ",", "args", "=", "None", ",", "max_width", "=", "None", ")", ":", "# Init the return message", "ret", "=", "[", "]", "# Only process if stats exist, not empty (issue #871) and plugin not disabled", "if", "not", "self", ".", "stats", "or", "(", "self", ".", "stats", "==", "[", "]", ")", "or", "self", ".", "is_disable", "(", ")", ":", "return", "ret", "# Check if all GPU have the same name", "same_name", "=", "all", "(", "s", "[", "'name'", "]", "==", "self", ".", "stats", "[", "0", "]", "[", "'name'", "]", "for", "s", "in", "self", ".", "stats", ")", "# gpu_stats contain the first GPU in the list", "gpu_stats", "=", "self", ".", "stats", "[", "0", "]", "# Header", "header", "=", "''", "if", "len", "(", "self", ".", "stats", ")", ">", "1", ":", "header", "+=", "'{} '", ".", "format", "(", "len", "(", "self", ".", "stats", ")", ")", "if", "same_name", ":", "header", "+=", "'{} {}'", ".", "format", "(", "'GPU'", ",", "gpu_stats", "[", "'name'", "]", ")", "else", ":", "header", "+=", "'{}'", ".", "format", "(", "'GPU'", ")", "msg", "=", "header", "[", ":", "17", "]", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ",", "\"TITLE\"", ")", ")", "# Build the string message", "if", "len", "(", "self", ".", "stats", ")", "==", "1", "or", "args", ".", "meangpu", ":", "# GPU stat summary or mono GPU", "# New line", "ret", ".", "append", "(", "self", ".", "curse_new_line", "(", ")", ")", "# GPU PROC", "try", ":", "mean_proc", "=", "sum", "(", "s", "[", "'proc'", "]", "for", "s", "in", "self", ".", "stats", "if", "s", "is", "not", "None", ")", "/", "len", "(", "self", ".", "stats", ")", "except", "TypeError", ":", "mean_proc_msg", "=", "'{:>4}'", ".", "format", "(", "'N/A'", ")", "else", ":", "mean_proc_msg", "=", "'{:>3.0f}%'", ".", "format", "(", "mean_proc", ")", "if", "len", "(", "self", ".", "stats", ")", ">", "1", ":", "msg", "=", "'{:13}'", ".", "format", "(", "'proc mean:'", ")", "else", ":", "msg", "=", "'{:13}'", ".", "format", "(", "'proc:'", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ")", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "mean_proc_msg", ",", "self", ".", "get_views", "(", "item", "=", "gpu_stats", "[", "self", ".", "get_key", "(", ")", "]", ",", "key", "=", "'proc'", ",", "option", "=", "'decoration'", ")", ")", ")", "# New line", "ret", ".", "append", "(", "self", ".", "curse_new_line", "(", ")", ")", "# GPU MEM", "try", ":", "mean_mem", "=", "sum", "(", "s", "[", "'mem'", "]", "for", "s", "in", "self", ".", "stats", "if", "s", "is", "not", "None", ")", "/", "len", "(", "self", ".", "stats", ")", "except", "TypeError", ":", "mean_mem_msg", "=", "'{:>4}'", ".", "format", "(", "'N/A'", ")", "else", ":", "mean_mem_msg", "=", "'{:>3.0f}%'", ".", "format", "(", "mean_mem", ")", "if", "len", "(", "self", ".", "stats", ")", ">", "1", ":", "msg", "=", "'{:13}'", ".", "format", "(", "'mem mean:'", ")", "else", ":", "msg", "=", "'{:13}'", ".", "format", "(", "'mem:'", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ")", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "mean_mem_msg", ",", "self", ".", "get_views", "(", "item", "=", "gpu_stats", "[", "self", ".", "get_key", "(", ")", "]", ",", "key", "=", "'mem'", ",", "option", "=", "'decoration'", ")", ")", ")", "else", ":", "# Multi GPU", "for", "gpu_stats", "in", "self", ".", "stats", ":", "# New line", "ret", ".", "append", "(", "self", ".", "curse_new_line", "(", ")", ")", "# GPU ID + PROC + MEM", "id_msg", "=", "'{}'", ".", "format", "(", "gpu_stats", "[", "'gpu_id'", "]", ")", "try", ":", "proc_msg", "=", "'{:>3.0f}%'", ".", "format", "(", "gpu_stats", "[", "'proc'", "]", ")", "except", "ValueError", ":", "proc_msg", "=", "'{:>4}'", ".", "format", "(", "'N/A'", ")", "try", ":", "mem_msg", "=", "'{:>3.0f}%'", ".", "format", "(", "gpu_stats", "[", "'mem'", "]", ")", "except", "ValueError", ":", "mem_msg", "=", "'{:>4}'", ".", "format", "(", "'N/A'", ")", "msg", "=", "'{}: {} mem: {}'", ".", "format", "(", "id_msg", ",", "proc_msg", ",", "mem_msg", ")", "ret", ".", "append", "(", "self", ".", "curse_add_line", "(", "msg", ")", ")", "return", "ret" ]

[ "Return", "the", "dict", "to", "display", "in", "the", "curse", "interface", "." ]

[ "def", "_ivy_jvm_options", "(", "self", ",", "repo", ")", ":", "# Get authentication for the publish repo if needed.", "if", "not", "repo", ".", "get", "(", "'auth'", ")", ":", "# No need to copy here, as this list isn't modified by the caller.", "return", "self", ".", "_jvm_options", "# Create a copy of the options, so that the modification is appropriately transient.", "jvm_options", "=", "copy", "(", "self", ".", "_jvm_options", ")", "user", "=", "repo", ".", "get", "(", "'username'", ")", "password", "=", "repo", ".", "get", "(", "'password'", ")", "if", "user", "and", "password", ":", "jvm_options", ".", "append", "(", "'-Dlogin={}'", ".", "format", "(", "user", ")", ")", "jvm_options", ".", "append", "(", "'-Dpassword={}'", ".", "format", "(", "password", ")", ")", "else", ":", "raise", "TaskError", "(", "'Unable to publish to {}. {}'", ".", "format", "(", "repo", ".", "get", "(", "'resolver'", ")", ",", "repo", ".", "get", "(", "'help'", ",", "''", ")", ")", ")", "return", "jvm_options" ]

[ "Get", "the", "JVM", "options", "for", "ivy", "authentication", "if", "needed", "." ]

[ "def", "get_tile_properties", "(", "self", ",", "x", ",", "y", ",", "layer", ")", ":", "try", ":", "assert", "(", "x", ">=", "0", "and", "y", ">=", "0", "and", "layer", ">=", "0", ")", "except", "AssertionError", ":", "raise", "ValueError", "try", ":", "gid", "=", "self", ".", "layers", "[", "int", "(", "layer", ")", "]", ".", "data", "[", "int", "(", "y", ")", "]", "[", "int", "(", "x", ")", "]", "except", "(", "IndexError", ",", "ValueError", ")", ":", "msg", "=", "\"Coords: ({0},{1}) in layer {2} is invalid.\"", "logger", ".", "debug", "(", "msg", ".", "format", "(", "x", ",", "y", ",", "layer", ")", ")", "raise", "Exception", "else", ":", "try", ":", "return", "self", ".", "tile_properties", "[", "gid", "]", "except", "(", "IndexError", ",", "ValueError", ")", ":", "msg", "=", "\"Coords: ({0},{1}) in layer {2} has invalid GID: {3}\"", "logger", ".", "debug", "(", "msg", ".", "format", "(", "x", ",", "y", ",", "layer", ",", "gid", ")", ")", "raise", "Exception", "except", "KeyError", ":", "return", "None" ]

[ "Return", "the", "tile", "image", "GID", "for", "this", "location" ]

[ "def", "parse_genelists", "(", "self", ")", ":", "if", "isinstance", "(", "self", ".", "gene_list", ",", "list", ")", ":", "genes", "=", "self", ".", "gene_list", "elif", "isinstance", "(", "self", ".", "gene_list", ",", "pd", ".", "DataFrame", ")", ":", "# input type is bed file", "if", "self", ".", "gene_list", ".", "shape", "[", "1", "]", ">=", "3", ":", "genes", "=", "self", ".", "gene_list", ".", "iloc", "[", ":", ",", ":", "3", "]", ".", "apply", "(", "lambda", "x", ":", "\"\\t\"", ".", "join", "(", "[", "str", "(", "i", ")", "for", "i", "in", "x", "]", ")", ",", "axis", "=", "1", ")", ".", "tolist", "(", ")", "# input type with weight values", "elif", "self", ".", "gene_list", ".", "shape", "[", "1", "]", "==", "2", ":", "genes", "=", "self", ".", "gene_list", ".", "apply", "(", "lambda", "x", ":", "\",\"", ".", "join", "(", "[", "str", "(", "i", ")", "for", "i", "in", "x", "]", ")", ",", "axis", "=", "1", ")", ".", "tolist", "(", ")", "else", ":", "genes", "=", "self", ".", "gene_list", ".", "squeeze", "(", ")", ".", "tolist", "(", ")", "elif", "isinstance", "(", "self", ".", "gene_list", ",", "pd", ".", "Series", ")", ":", "genes", "=", "self", ".", "gene_list", ".", "squeeze", "(", ")", ".", "tolist", "(", ")", "else", ":", "# get gene lists or bed file, or gene list with weighted values.", "genes", "=", "[", "]", "with", "open", "(", "self", ".", "gene_list", ")", "as", "f", ":", "for", "gene", "in", "f", ":", "genes", ".", "append", "(", "gene", ".", "strip", "(", ")", ")", "self", ".", "_isezid", "=", "all", "(", "map", "(", "self", ".", "_is_entrez_id", ",", "genes", ")", ")", "if", "self", ".", "_isezid", ":", "self", ".", "_gls", "=", "set", "(", "map", "(", "int", ",", "self", ".", "_gls", ")", ")", "else", ":", "self", ".", "_gls", "=", "genes", "return", "'\\n'", ".", "join", "(", "genes", ")" ]

[ "parse", "gene", "list" ]

[ "def", "protocol", "(", "alias_name", ",", "default", "=", "None", ",", "allow_none", "=", "False", ")", ":", "warnings", ".", "warn", "(", "'Will be removed in v1.0'", ",", "DeprecationWarning", ",", "stacklevel", "=", "2", ")", "try", ":", "return", "_split_docker_link", "(", "alias_name", ")", "[", "0", "]", "except", "KeyError", "as", "err", ":", "if", "default", "or", "allow_none", ":", "return", "default", "else", ":", "raise", "err" ]

[ "Get", "the", "protocol", "from", "the", "docker", "link", "alias", "or", "return", "the", "default", "." ]

[ "def", "replace_variables", "(", "self", ",", "text", ")", ":", "variables", "=", "{", "'python-executable'", ":", "str", "(", "self", ".", "_venv_path", "/", "'bin'", "/", "'python'", ")", "}", "return", "text", ".", "format", "(", "*", "*", "variables", ")" ]

[ "Replace", "variable", "placeholders", "in", "text", "with", "values", "from", "the", "virtual", "env", "." ]

[ "def", "get_setters_property", "(", "node", ")", ":", "property_", "=", "None", "property_name", "=", "get_setters_property_name", "(", "node", ")", "class_node", "=", "utils", ".", "node_frame_class", "(", "node", ")", "if", "property_name", "and", "class_node", ":", "class_attrs", "=", "class_node", ".", "getattr", "(", "node", ".", "name", ")", "for", "attr", "in", "class_attrs", ":", "if", "utils", ".", "decorated_with_property", "(", "attr", ")", ":", "property_", "=", "attr", "break", "return", "property_" ]

[ "Get", "the", "property", "node", "for", "the", "given", "setter", "node", "." ]

[ "def", "timedelta", "(", "self", ",", "start", ",", "end", ",", "start_key", "=", "min", ",", "end_key", "=", "max", ")", ":", "if", "not", "isinstance", "(", "start", ",", "datetime", ")", ":", "# handle single_result AsyncResults, where ar.stamp is single object,", "# not a list", "start", "=", "start_key", "(", "start", ")", "if", "not", "isinstance", "(", "end", ",", "datetime", ")", ":", "# handle single_result AsyncResults, where ar.stamp is single object,", "# not a list", "end", "=", "end_key", "(", "end", ")", "return", "_total_seconds", "(", "end", "-", "start", ")" ]

[ "compute", "the", "difference", "between", "two", "sets", "of", "timestamps", "The", "default", "behavior", "is", "to", "use", "the", "earliest", "of", "the", "first", "and", "the", "latest", "of", "the", "second", "list", "but", "this", "can", "be", "changed", "by", "passing", "a", "different", "Parameters", "----------", "start", ":", "one", "or", "more", "datetime", "objects", "(", "e", ".", "g", ".", "ar", ".", "submitted", ")", "end", ":", "one", "or", "more", "datetime", "objects", "(", "e", ".", "g", ".", "ar", ".", "received", ")", "start_key", ":", "callable", "Function", "to", "call", "on", "start", "to", "extract", "the", "relevant", "entry", "[", "defalt", ":", "min", "]", "end_key", ":", "callable", "Function", "to", "call", "on", "end", "to", "extract", "the", "relevant", "entry", "[", "default", ":", "max", "]", "Returns", "-------", "dt", ":", "float", "The", "time", "elapsed", "(", "in", "seconds", ")", "between", "the", "two", "selected", "timestamps", "." ]

[ "def", "user", "(", "self", ",", "extra_params", "=", "None", ")", ":", "if", "self", ".", "get", "(", "'assigned_to_id'", ",", "None", ")", ":", "users", "=", "self", ".", "space", ".", "users", "(", "id", "=", "self", "[", "'assigned_to_id'", "]", ",", "extra_params", "=", "extra_params", ")", "if", "users", ":", "return", "users", "[", "0", "]" ]

[ "The", "User", "currently", "assigned", "to", "the", "Ticket" ]

[ "def", "ParseOptions", "(", "self", ",", "options", ")", ":", "self", ".", "_ParseInformationalOptions", "(", "options", ")", "self", ".", "_verbose", "=", "getattr", "(", "options", ",", "'verbose'", ",", "False", ")", "self", ".", "_output_filename", "=", "getattr", "(", "options", ",", "'write'", ",", "None", ")", "argument_helper_names", "=", "[", "'process_resources'", ",", "'storage_file'", "]", "helpers_manager", ".", "ArgumentHelperManager", ".", "ParseOptions", "(", "options", ",", "self", ",", "names", "=", "argument_helper_names", ")", "# TODO: move check into _CheckStorageFile.", "if", "not", "self", ".", "_storage_file_path", ":", "raise", "errors", ".", "BadConfigOption", "(", "'Missing storage file option.'", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "self", ".", "_storage_file_path", ")", ":", "raise", "errors", ".", "BadConfigOption", "(", "'No such storage file: {0:s}.'", ".", "format", "(", "self", ".", "_storage_file_path", ")", ")", "compare_storage_file_path", "=", "self", ".", "ParseStringOption", "(", "options", ",", "'compare_storage_file'", ")", "if", "compare_storage_file_path", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "compare_storage_file_path", ")", ":", "raise", "errors", ".", "BadConfigOption", "(", "'No such storage file: {0:s}.'", ".", "format", "(", "compare_storage_file_path", ")", ")", "self", ".", "_compare_storage_file_path", "=", "compare_storage_file_path", "self", ".", "compare_storage_information", "=", "True", "self", ".", "_output_format", "=", "self", ".", "ParseStringOption", "(", "options", ",", "'output_format'", ")", "if", "self", ".", "_output_filename", ":", "if", "os", ".", "path", ".", "exists", "(", "self", ".", "_output_filename", ")", ":", "raise", "errors", ".", "BadConfigOption", "(", "'Output file already exists: {0:s}.'", ".", "format", "(", "self", ".", "_output_filename", ")", ")", "output_file_object", "=", "open", "(", "self", ".", "_output_filename", ",", "'wb'", ")", "self", ".", "_output_writer", "=", "tools", ".", "FileObjectOutputWriter", "(", "output_file_object", ")", "self", ".", "_EnforceProcessMemoryLimit", "(", "self", ".", "_process_memory_limit", ")" ]

[ "Parses", "the", "options", "." ]

[ "def", "JNG", "(", "cpu", ",", "target", ")", ":", "cpu", ".", "PC", "=", "Operators", ".", "ITEBV", "(", "cpu", ".", "address_bit_size", ",", "Operators", ".", "OR", "(", "cpu", ".", "ZF", ",", "cpu", ".", "SF", "!=", "cpu", ".", "OF", ")", ",", "target", ".", "read", "(", ")", ",", "cpu", ".", "PC", ")" ]

[ "Jumps", "short", "if", "not", "greater", "." ]

[ "def", "list_arc", "(", "archive", ",", "compression", ",", "cmd", ",", "verbosity", ",", "interactive", ")", ":", "cmdlist", "=", "[", "cmd", "]", "if", "verbosity", ">", "1", ":", "cmdlist", ".", "append", "(", "'v'", ")", "else", ":", "cmdlist", ".", "append", "(", "'l'", ")", "cmdlist", ".", "append", "(", "archive", ")", "return", "cmdlist" ]

[ "List", "a", "ARC", "archive", "." ]

[ "def", "__stop", "(", "self", ")", ":", "# pragma: no cover", "if", "not", "self", ".", "dispatcher_thread", ":", "return", "logger", ".", "info", "(", "'Stopping dispatcher'", ")", "self", ".", "running", "=", "False", "# graceful shutdown", "self", ".", "dispatcher_thread", ".", "join", "(", ")", "self", ".", "dispatcher_thread", "=", "None" ]

[ "Stops", "the", "background", "engine", "." ]

[ "def", "time_series", "(", "self", ",", "start_date", "=", "'-30d'", ",", "end_date", "=", "'now'", ",", "precision", "=", "None", ",", "distrib", "=", "None", ",", "tzinfo", "=", "None", ")", ":", "start_date", "=", "self", ".", "_parse_date_time", "(", "start_date", ",", "tzinfo", "=", "tzinfo", ")", "end_date", "=", "self", ".", "_parse_date_time", "(", "end_date", ",", "tzinfo", "=", "tzinfo", ")", "if", "end_date", "<", "start_date", ":", "raise", "ValueError", "(", "\"`end_date` must be greater than `start_date`.\"", ")", "if", "precision", "is", "None", ":", "precision", "=", "(", "end_date", "-", "start_date", ")", "/", "30", "precision", "=", "self", ".", "_parse_timedelta", "(", "precision", ")", "if", "distrib", "is", "None", ":", "def", "distrib", "(", "dt", ")", ":", "return", "self", ".", "generator", ".", "random", ".", "uniform", "(", "0", ",", "precision", ")", "# noqa", "if", "not", "callable", "(", "distrib", ")", ":", "raise", "ValueError", "(", "\"`distrib` must be a callable. Got {} instead.\"", ".", "format", "(", "distrib", ")", ")", "datapoint", "=", "start_date", "while", "datapoint", "<", "end_date", ":", "dt", "=", "timestamp_to_datetime", "(", "datapoint", ",", "tzinfo", ")", "datapoint", "+=", "precision", "yield", "(", "dt", ",", "distrib", "(", "dt", ")", ")" ]

[ "Returns", "a", "generator", "yielding", "tuples", "of", "(", "<datetime", ">", "<value", ">", ")", "." ]

[ "def", "Default", "(", "default", ")", ":", "@", "wraps", "(", "Default", ")", "def", "built", "(", "value", ")", ":", "if", "value", "==", "None", ":", "return", "default", "return", "value", "return", "built" ]

[ "Creates", "a", "validator", "callable", "that", "replaces", "None", "with", "the", "specified", "default", "value", "." ]

[ "def", "search", "(", "self", ",", "pattern", "=", "\"*\"", ",", "mode", "=", "\"both\"", ")", ":", "pattern", "=", "self", ".", "_glob_to_sql", "(", "pattern", ")", "COND", "=", "\"(keyword.name like ? OR keyword.doc like ?)\"", "args", "=", "[", "pattern", ",", "pattern", "]", "if", "mode", "==", "\"name\"", ":", "COND", "=", "\"(keyword.name like ?)\"", "args", "=", "[", "pattern", ",", "]", "sql", "=", "\"\"\"SELECT collection.collection_id, collection.name, keyword.name, keyword.doc\n FROM collection_table as collection\n JOIN keyword_table as keyword\n WHERE collection.collection_id == keyword.collection_id\n AND %s\n ORDER by collection.collection_id, collection.name, keyword.name\n \"\"\"", "%", "COND", "cursor", "=", "self", ".", "_execute", "(", "sql", ",", "args", ")", "result", "=", "[", "(", "row", "[", "0", "]", ",", "row", "[", "1", "]", ",", "row", "[", "2", "]", ",", "row", "[", "3", "]", ".", "strip", "(", ")", ".", "split", "(", "\"\\n\"", ")", "[", "0", "]", ")", "for", "row", "in", "cursor", ".", "fetchall", "(", ")", "]", "return", "list", "(", "set", "(", "result", ")", ")" ]

[ "Perform", "a", "pattern", "-", "based", "search", "on", "keyword", "names", "and", "documentation" ]

[ "def", "_verify", "(", "self", ",", "request", ",", "return_payload", "=", "False", ",", "verify", "=", "True", ",", "raise_missing", "=", "False", ",", "request_args", "=", "None", ",", "request_kwargs", "=", "None", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "\"permakey\"", "in", "request", ".", "headers", ":", "# Extract the permakey from the headers", "permakey", "=", "request", ".", "headers", ".", "get", "(", "\"permakey\"", ")", "# In production, probably should have some exception handling Here", "# in case the permakey is an empty string or some other bad value", "payload", "=", "self", ".", "_decode", "(", "permakey", ",", "verify", "=", "verify", ")", "# Sometimes, the application will call _verify(...return_payload=True)", "# So, let's make sure to handle this scenario.", "if", "return_payload", ":", "return", "payload", "# Retrieve the user from the database", "user_id", "=", "payload", ".", "get", "(", "\"user_id\"", ",", "None", ")", "user", "=", "userid_table", ".", "get", "(", "user_id", ")", "# If wer cannot find a user, then this method should return", "# is_valid == False", "# reason == some text for why", "# status == some status code, probably a 401", "if", "not", "user_id", "or", "not", "user", ":", "is_valid", "=", "False", "reason", "=", "\"No user found\"", "status", "=", "401", "else", ":", "# After finding a user, make sure the permakey matches,", "# or else return a bad status or some other error.", "# In production, both this scenario, and the above \"No user found\"", "# scenario should return an identical message and status code.", "# This is to prevent your application accidentally", "# leaking information about the existence or non-existence of users.", "is_valid", "=", "user", ".", "permakey", "==", "permakey", "reason", "=", "None", "if", "is_valid", "else", "\"Permakey mismatch\"", "status", "=", "200", "if", "is_valid", "else", "401", "return", "is_valid", ",", "status", ",", "reason", "else", ":", "return", "super", "(", ")", ".", "_verify", "(", "request", "=", "request", ",", "return_payload", "=", "return_payload", ",", "verify", "=", "verify", ",", "raise_missing", "=", "raise_missing", ",", "request_args", "=", "request_args", ",", "request_kwargs", "=", "request_kwargs", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "If", "there", "is", "a", "permakey", "then", "we", "will", "verify", "the", "token", "by", "checking", "the", "database", ".", "Otherwise", "just", "do", "the", "normal", "verification", "." ]

[ "def", "_repeat_iter", "(", "input_iter", ")", ":", "last_value", "=", "None", "for", "value", "in", "input_iter", ":", "last_value", "=", "value", "yield", "value", "if", "last_value", "is", "not", "None", ":", "while", "True", ":", "yield", "last_value" ]

[ "Iterate", "over", "the", "input", "iter", "values", ".", "Then", "repeat", "the", "last", "value", "indefinitely", ".", "This", "is", "useful", "to", "repeat", "seed", "values", "when", "an", "insufficient", "number", "of", "seeds", "are", "provided", "." ]

[ "def", "compare_operands", "(", "self", ",", "p_operand1", ",", "p_operand2", ")", ":", "if", "self", ".", "operator", "==", "'<'", ":", "return", "p_operand1", "<", "p_operand2", "elif", "self", ".", "operator", "==", "'<='", ":", "return", "p_operand1", "<=", "p_operand2", "elif", "self", ".", "operator", "==", "'='", ":", "return", "p_operand1", "==", "p_operand2", "elif", "self", ".", "operator", "==", "'>='", ":", "return", "p_operand1", ">=", "p_operand2", "elif", "self", ".", "operator", "==", "'>'", ":", "return", "p_operand1", ">", "p_operand2", "elif", "self", ".", "operator", "==", "'!'", ":", "return", "p_operand1", "!=", "p_operand2", "return", "False" ]

[ "Returns", "True", "if", "conditional", "constructed", "from", "both", "operands", "and", "self", ".", "operator", "is", "valid", ".", "Returns", "False", "otherwise", "." ]

[ "def", "binary2base64", "(", "binary_file", ":", "str", ")", "->", "str", ":", "# Use mode = \"rb\" to read binary file", "with", "open", "(", "binary_file", ",", "\"rb\"", ")", "as", "bin_file", ":", "encoded_string", "=", "base64", ".", "b64encode", "(", "bin_file", ".", "read", "(", ")", ")", "return", "encoded_string", ".", "decode", "(", ")" ]

[ "Convert", "a", "binary", "file", "(", "OGG", "executable", "etc", ".", ")", "to", "a", "printable", "string", "." ]

[ "def", "unpickle", "(", "self", ",", "parent", ")", ":", "self", ".", "parent", "=", "parent", "self", ".", "_unpickle_collection", "(", "self", ".", "members", ")", "self", ".", "_unpickle_collection", "(", "self", ".", "executables", ")", "self", ".", "_unpickle_collection", "(", "self", ".", "types", ")" ]

[ "Sets", "the", "parent", "pointer", "references", "for", "the", "module", "*", "and", "*", "all", "of", "its", "child", "classes", "that", "also", "have", "pointer", "references", "." ]

[ "def", "find", "(", "self", ",", "uid", ")", ":", "data", "=", "(", "db", ".", "select", "(", "self", ".", "table", ")", ".", "select", "(", "'username'", ",", "'email'", ",", "'real_name'", ",", "'password'", ",", "'bio'", ",", "'status'", ",", "'role'", ",", "'uid'", ")", ".", "condition", "(", "'uid'", ",", "uid", ")", ".", "execute", "(", ")", ")", "if", "data", ":", "logger", ".", "info", "(", "'data %s'", ",", "data", ")", "return", "self", ".", "load", "(", "data", "[", "0", "]", ",", "self", ".", "model", ")" ]

[ "Find", "and", "load", "the", "user", "from", "database", "by", "uid", "(", "user", "id", ")" ]

[ "def", "clear_cache_fields", "(", "self", ")", ":", "for", "field", "in", "self", ".", "_meta", ".", "scalarfields", ":", "if", "field", ".", "as_cache", ":", "setattr", "(", "self", ",", "field", ".", "name", ",", "None", ")" ]

[ "Set", "cache", "fields", "to", "None", ".", "Check", ":", "attr", ":", "Field", ".", "as_cache", "for", "information", "regarding", "fields", "which", "are", "considered", "cache", "." ]

[ "def", "generate", "(", "env", ")", ":", "import", "SCons", ".", "Defaults", "import", "SCons", ".", "Tool", "set_vars", "(", "env", ")", "static_obj", ",", "shared_obj", "=", "SCons", ".", "Tool", ".", "createObjBuilders", "(", "env", ")", "for", "suffix", "in", "CSuffixes", ":", "static_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "CAction", ")", "shared_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "ShCAction", ")", "for", "suffix", "in", "CXXSuffixes", ":", "static_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "CXXAction", ")", "shared_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "ShCXXAction", ")", "env", "[", "'CCCOMFLAGS'", "]", "=", "'$CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -nolink -o $TARGET $SOURCES'", "env", "[", "'CC'", "]", "=", "'mwcc'", "env", "[", "'CCCOM'", "]", "=", "'$CC $CFLAGS $CCFLAGS $CCCOMFLAGS'", "env", "[", "'CXX'", "]", "=", "'mwcc'", "env", "[", "'CXXCOM'", "]", "=", "'$CXX $CXXFLAGS $CCCOMFLAGS'", "env", "[", "'SHCC'", "]", "=", "'$CC'", "env", "[", "'SHCCFLAGS'", "]", "=", "'$CCFLAGS'", "env", "[", "'SHCFLAGS'", "]", "=", "'$CFLAGS'", "env", "[", "'SHCCCOM'", "]", "=", "'$SHCC $SHCFLAGS $SHCCFLAGS $CCCOMFLAGS'", "env", "[", "'SHCXX'", "]", "=", "'$CXX'", "env", "[", "'SHCXXFLAGS'", "]", "=", "'$CXXFLAGS'", "env", "[", "'SHCXXCOM'", "]", "=", "'$SHCXX $SHCXXFLAGS $CCCOMFLAGS'", "env", "[", "'CFILESUFFIX'", "]", "=", "'.c'", "env", "[", "'CXXFILESUFFIX'", "]", "=", "'.cpp'", "env", "[", "'CPPDEFPREFIX'", "]", "=", "'-D'", "env", "[", "'CPPDEFSUFFIX'", "]", "=", "''", "env", "[", "'INCPREFIX'", "]", "=", "'-I'", "env", "[", "'INCSUFFIX'", "]", "=", "''" ]

[ "Add", "Builders", "and", "construction", "variables", "for", "the", "mwcc", "to", "an", "Environment", "." ]

[ "def", "batch_iterable", "(", "l", ",", "n", ")", ":", "i", "=", "iter", "(", "l", ")", "piece", "=", "list", "(", "islice", "(", "i", ",", "n", ")", ")", "while", "piece", ":", "yield", "piece", "piece", "=", "list", "(", "islice", "(", "i", ",", "n", ")", ")" ]

[ "Chunks", "iterable", "into", "n", "sized", "batches", "Solution", "from", ":", "http", ":", "//", "stackoverflow", ".", "com", "/", "questions", "/", "1915170", "/", "split", "-", "a", "-", "generator", "-", "iterable", "-", "every", "-", "n", "-", "items", "-", "in", "-", "python", "-", "splitevery" ]

[ "def", "interpolate", "(", "self", ",", "factor", ",", "minInfo", ",", "maxInfo", ",", "round", "=", "True", ",", "suppressError", "=", "True", ")", ":", "factor", "=", "normalizers", ".", "normalizeInterpolationFactor", "(", "factor", ")", "if", "not", "isinstance", "(", "minInfo", ",", "BaseInfo", ")", ":", "raise", "TypeError", "(", "(", "\"Interpolation to an instance of %r can not be \"", "\"performed from an instance of %r.\"", ")", "%", "(", "self", ".", "__class__", ".", "__name__", ",", "minInfo", ".", "__class__", ".", "__name__", ")", ")", "if", "not", "isinstance", "(", "maxInfo", ",", "BaseInfo", ")", ":", "raise", "TypeError", "(", "(", "\"Interpolation to an instance of %r can not be \"", "\"performed from an instance of %r.\"", ")", "%", "(", "self", ".", "__class__", ".", "__name__", ",", "maxInfo", ".", "__class__", ".", "__name__", ")", ")", "round", "=", "normalizers", ".", "normalizeBoolean", "(", "round", ")", "suppressError", "=", "normalizers", ".", "normalizeBoolean", "(", "suppressError", ")", "self", ".", "_interpolate", "(", "factor", ",", "minInfo", ",", "maxInfo", ",", "round", "=", "round", ",", "suppressError", "=", "suppressError", ")" ]

[ "Interpolate", "all", "pairs", "between", "minInfo", "and", "maxInfo", ".", "The", "interpolation", "occurs", "on", "a", "0", "to", "1", ".", "0", "range", "where", "minInfo", "is", "located", "at", "0", "and", "maxInfo", "is", "located", "at", "1", ".", "0", "." ]

[ "def", "content", "(", "self", ")", ":", "# The code that follows is obviously pretty disgusting.", "# It seems like it might be impossible to completely replicate", "# the text of the original message if it has trailing whitespace", "message", "=", "self", ".", "_content_xpb", ".", "one_", "(", "self", ".", "_message_element", ")", "first_line", "=", "message", ".", "text", "if", "message", ".", "text", "[", ":", "2", "]", "==", "' '", ":", "first_line", "=", "message", ".", "text", "[", "2", ":", "]", "else", ":", "log", ".", "debug", "(", "\"message did not have expected leading whitespace\"", ")", "subsequent_lines", "=", "''", ".", "join", "(", "[", "html", ".", "tostring", "(", "child", ",", "encoding", "=", "'unicode'", ")", ".", "replace", "(", "'<br>'", ",", "'\\n'", ")", "for", "child", "in", "message", ".", "iterchildren", "(", ")", "]", ")", "message_text", "=", "first_line", "+", "subsequent_lines", "if", "len", "(", "message_text", ")", ">", "0", "and", "message_text", "[", "-", "1", "]", "==", "' '", ":", "message_text", "=", "message_text", "[", ":", "-", "1", "]", "else", ":", "log", ".", "debug", "(", "\"message did not have expected leading whitespace\"", ")", "return", "message_text" ]

[ ":", "returns", ":", "The", "text", "body", "of", "the", "message", "." ]

[ "def", "add_exec_to_user", "(", "self", ",", "name", ",", "env", ",", "command", ",", "args", ",", "*", "*", "attrs", ")", ":", "# Add exec option.", "exec_options", "=", "{", "'command'", ":", "command", ",", "'env'", ":", "env", ",", "'args'", ":", "args", ",", "}", "exec_options", ".", "update", "(", "attrs", ")", "# Add exec to user.", "self", ".", "add_to_user", "(", "name", "=", "name", ",", "exec", "=", "exec_options", ")" ]

[ "Add", "an", "exec", "option", "to", "your", "user", "." ]

[ "def", "update_metadata_from_rmd_options", "(", "name", ",", "value", ",", "metadata", ")", ":", "for", "jupyter_option", ",", "rmd_option", ",", "rev", "in", "_BOOLEAN_OPTIONS_DICTIONARY", ":", "if", "name", "==", "rmd_option", ":", "try", ":", "metadata", "[", "jupyter_option", "]", "=", "_py_logical_values", "(", "value", ")", "!=", "rev", "return", "True", "except", "RLogicalValueError", ":", "pass", "return", "False" ]

[ "Update", "metadata", "using", "the", "_BOOLEAN_OPTIONS_DICTIONARY", "mapping", ":", "param", "name", ":", "option", "name", ":", "param", "value", ":", "option", "value", ":", "param", "metadata", ":", ":", "return", ":" ]

[ "def", "calculate_activity_rate", "(", "self", ",", "strain_data", ",", "cumulative", "=", "False", ",", "in_seconds", "=", "False", ")", ":", "self", ".", "strain", "=", "strain_data", "self", ".", "strain", ".", "target_magnitudes", "=", "self", ".", "target_magnitudes", "# Adjust strain rates from annual to seconds (SI)", "for", "key", "in", "STRAIN_VARIABLES", ":", "self", ".", "strain", ".", "data", "[", "key", "]", "=", "self", ".", "strain", ".", "data", "[", "key", "]", "/", "SECS_PER_YEAR", "if", "'region'", "not", "in", "self", ".", "strain", ".", "data", ":", "raise", "ValueError", "(", "'Cannot implment SHIFT methodology without '", "'definition of regionalisation'", ")", "else", ":", "self", ".", "_reclassify_Bird_regions_with_data", "(", ")", "# Initially all seismicity rates assigned to background rate", "self", ".", "strain", ".", "seismicity_rate", "=", "np", ".", "tile", "(", "self", ".", "base_rate", ",", "[", "self", ".", "strain", ".", "get_number_observations", "(", ")", ",", "1", "]", ")", "regionalisation_zones", "=", "(", "np", ".", "unique", "(", "self", ".", "strain", ".", "data", "[", "'region'", "]", ")", ")", ".", "tolist", "(", ")", "for", "region", "in", "regionalisation_zones", ":", "id0", "=", "self", ".", "strain", ".", "data", "[", "'region'", "]", "==", "region", "if", "b'IPL'", "in", "region", ":", "# For intra-plate seismicity everything is refered to", "# the background rate", "continue", "elif", "b'OSR_special_1'", "in", "region", ":", "# Special case 1 - normal and transform faulting", "calculated_rate", "=", "self", ".", "get_rate_osr_normal_transform", "(", "self", ".", "threshold_moment", ",", "id0", ")", "elif", "b'OSR_special_2'", "in", "region", ":", "# Special case 2 - convergent and transform faulting", "calculated_rate", "=", "self", ".", "get_rate_osr_convergent_transform", "(", "self", ".", "threshold_moment", ",", "id0", ")", "else", ":", "region", "=", "region", ".", "decode", "(", "'utf-8'", ")", "calculated_rate", "=", "self", ".", "regionalisation", "[", "region", "]", "[", "'adjustment_factor'", "]", "*", "self", ".", "continuum_seismicity", "(", "self", ".", "threshold_moment", ",", "self", ".", "strain", ".", "data", "[", "'e1h'", "]", "[", "id0", "]", ",", "self", ".", "strain", ".", "data", "[", "'e2h'", "]", "[", "id0", "]", ",", "self", ".", "strain", ".", "data", "[", "'err'", "]", "[", "id0", "]", ",", "self", ".", "regionalisation", "[", "region", "]", ")", "for", "jloc", ",", "iloc", "in", "enumerate", "(", "np", ".", "where", "(", "id0", ")", "[", "0", "]", ")", ":", "# Where the calculated rate exceeds the base rate then becomes", "# calculated rate. In this version the magnitudes are treated", "# independently (i.e. if Rate(M < 7) > Base Rate (M < 7) but", "# Rate (M > 7) < Base Rate (M > 7) then returned Rate (M < 7)", "# = Rate (M < 7) and returned Rate (M > 7) = Base Rate (M > 7)", "id1", "=", "calculated_rate", "[", "jloc", "]", ">", "self", ".", "base_rate", "self", ".", "strain", ".", "seismicity_rate", "[", "iloc", ",", "id1", "]", "=", "calculated_rate", "[", "jloc", ",", "id1", "]", "if", "not", "cumulative", "and", "self", ".", "number_magnitudes", ">", "1", ":", "# Seismicity rates are currently cumulative - need to turn them", "# into discrete", "for", "iloc", "in", "range", "(", "0", ",", "self", ".", "number_magnitudes", "-", "1", ")", ":", "self", ".", "strain", ".", "seismicity_rate", "[", ":", ",", "iloc", "]", "=", "self", ".", "strain", ".", "seismicity_rate", "[", ":", ",", "iloc", "]", "-", "self", ".", "strain", ".", "seismicity_rate", "[", ":", ",", "iloc", "+", "1", "]", "if", "not", "in_seconds", ":", "self", ".", "strain", ".", "seismicity_rate", "=", "self", ".", "strain", ".", "seismicity_rate", "*", "SECS_PER_YEAR", "for", "key", "in", "STRAIN_VARIABLES", ":", "self", ".", "strain", ".", "data", "[", "key", "]", "=", "self", ".", "strain", ".", "data", "[", "key", "]", "*", "SECS_PER_YEAR" ]

[ "Main", "function", "to", "calculate", "the", "activity", "rate", "(", "for", "each", "of", "the", "magnitudes", "in", "target_magnitudes", ")", "for", "all", "of", "the", "cells", "specified", "in", "the", "input", "strain", "model", "file" ]

[ "def", "post", "(", "url", ",", "data", "=", "None", ",", "return_json", "=", "True", ")", ":", "bot", ".", "debug", "(", "\"POST %s\"", "%", "url", ")", "return", "call", "(", "url", ",", "headers", "=", "headers", ",", "func", "=", "requests", ".", "post", ",", "data", "=", "data", ",", "return_json", "=", "return_json", ")" ]

[ "post", "will", "use", "requests", "to", "get", "a", "particular", "url" ]

[ "def", "upload_to_cloud", "(", "file_handles", ",", "staging_bucket", ",", "replica", ",", "from_cloud", "=", "False", ")", ":", "s3", "=", "boto3", ".", "resource", "(", "\"s3\"", ")", "file_uuids", "=", "[", "]", "key_names", "=", "[", "]", "abs_file_paths", "=", "[", "]", "if", "from_cloud", ":", "file_uuids", ",", "key_names", "=", "_copy_from_s3", "(", "file_handles", "[", "0", "]", ",", "s3", ")", "else", ":", "destination_bucket", "=", "s3", ".", "Bucket", "(", "staging_bucket", ")", "for", "raw_fh", "in", "file_handles", ":", "file_size", "=", "os", ".", "path", ".", "getsize", "(", "raw_fh", ".", "name", ")", "multipart_chunksize", "=", "s3_multipart", ".", "get_s3_multipart_chunk_size", "(", "file_size", ")", "tx_cfg", "=", "TransferConfig", "(", "multipart_threshold", "=", "s3_multipart", ".", "MULTIPART_THRESHOLD", ",", "multipart_chunksize", "=", "multipart_chunksize", ")", "with", "ChecksummingBufferedReader", "(", "raw_fh", ",", "multipart_chunksize", ")", "as", "fh", ":", "file_uuid", "=", "str", "(", "uuid", ".", "uuid4", "(", ")", ")", "key_name", "=", "\"{}/{}\"", ".", "format", "(", "file_uuid", ",", "os", ".", "path", ".", "basename", "(", "fh", ".", "raw", ".", "name", ")", ")", "destination_bucket", ".", "upload_fileobj", "(", "fh", ",", "key_name", ",", "Config", "=", "tx_cfg", ",", "ExtraArgs", "=", "{", "'ContentType'", ":", "_mime_type", "(", "fh", ".", "raw", ".", "name", ")", ",", "}", ")", "sums", "=", "fh", ".", "get_checksums", "(", ")", "metadata", "=", "{", "\"hca-dss-s3_etag\"", ":", "sums", "[", "\"s3_etag\"", "]", ",", "\"hca-dss-sha1\"", ":", "sums", "[", "\"sha1\"", "]", ",", "\"hca-dss-sha256\"", ":", "sums", "[", "\"sha256\"", "]", ",", "\"hca-dss-crc32c\"", ":", "sums", "[", "\"crc32c\"", "]", ",", "}", "s3", ".", "meta", ".", "client", ".", "put_object_tagging", "(", "Bucket", "=", "destination_bucket", ".", "name", ",", "Key", "=", "key_name", ",", "Tagging", "=", "dict", "(", "TagSet", "=", "encode_tags", "(", "metadata", ")", ")", ")", "file_uuids", ".", "append", "(", "file_uuid", ")", "key_names", ".", "append", "(", "key_name", ")", "abs_file_paths", ".", "append", "(", "fh", ".", "raw", ".", "name", ")", "return", "file_uuids", ",", "key_names", ",", "abs_file_paths" ]

[ "Upload", "files", "to", "cloud", "." ]

[ "def", "write_cols", "(", "self", ",", "sid", ",", "dts", ",", "cols", ",", "invalid_data_behavior", "=", "'warn'", ")", ":", "if", "not", "all", "(", "len", "(", "dts", ")", "==", "len", "(", "cols", "[", "name", "]", ")", "for", "name", "in", "self", ".", "COL_NAMES", ")", ":", "raise", "BcolzMinuteWriterColumnMismatch", "(", "\"Length of dts={0} should match cols: {1}\"", ".", "format", "(", "len", "(", "dts", ")", ",", "\" \"", ".", "join", "(", "\"{0}={1}\"", ".", "format", "(", "name", ",", "len", "(", "cols", "[", "name", "]", ")", ")", "for", "name", "in", "self", ".", "COL_NAMES", ")", ")", ")", "self", ".", "_write_cols", "(", "sid", ",", "dts", ",", "cols", ",", "invalid_data_behavior", ")" ]

[ "Write", "the", "OHLCV", "data", "for", "the", "given", "sid", ".", "If", "there", "is", "no", "bcolz", "ctable", "yet", "created", "for", "the", "sid", "create", "it", ".", "If", "the", "length", "of", "the", "bcolz", "ctable", "is", "not", "exactly", "to", "the", "date", "before", "the", "first", "day", "provided", "fill", "the", "ctable", "with", "0s", "up", "to", "that", "date", "." ]

[ "def", "_delete", "(", "self", ",", "*", "criterion", ")", ":", "with", "self", ".", "flushing", "(", ")", ":", "count", "=", "self", ".", "_query", "(", "*", "criterion", ")", ".", "delete", "(", ")", "if", "count", "==", "0", ":", "raise", "ModelNotFoundError", "return", "True" ]

[ "Delete", "a", "model", "by", "some", "criterion", "." ]

[ "def", "include", "(", "self", ",", "scheduled_operation", ":", "ScheduledOperation", ")", ":", "collisions", "=", "self", ".", "query", "(", "time", "=", "scheduled_operation", ".", "time", ",", "duration", "=", "scheduled_operation", ".", "duration", ",", "qubits", "=", "scheduled_operation", ".", "operation", ".", "qubits", ")", "if", "collisions", ":", "raise", "ValueError", "(", "'Operation {} has collisions: {}'", ".", "format", "(", "scheduled_operation", ".", "operation", ",", "collisions", ")", ")", "self", ".", "scheduled_operations", ".", "add", "(", "scheduled_operation", ")", "self", ".", "_max_duration", "=", "max", "(", "self", ".", "_max_duration", ",", "scheduled_operation", ".", "duration", ")" ]

[ "Adds", "a", "scheduled", "operation", "to", "the", "schedule", "." ]

[ "def", "deleteLogicalInterface", "(", "self", ",", "logicalInterfaceId", ")", ":", "req", "=", "ApiClient", ".", "oneLogicalInterfaceUrl", "%", "(", "self", ".", "host", ",", "\"/draft\"", ",", "logicalInterfaceId", ")", "resp", "=", "requests", ".", "delete", "(", "req", ",", "auth", "=", "self", ".", "credentials", ",", "verify", "=", "self", ".", "verify", ")", "if", "resp", ".", "status_code", "==", "204", ":", "self", ".", "logger", ".", "debug", "(", "\"logical interface deleted\"", ")", "else", ":", "raise", "ibmiotf", ".", "APIException", "(", "resp", ".", "status_code", ",", "\"HTTP error deleting a logical interface\"", ",", "resp", ")", "return", "resp" ]

[ "Deletes", "a", "logical", "interface", ".", "Parameters", ":", "logicalInterfaceId", "(", "string", ")", ".", "Throws", "APIException", "on", "failure", "." ]

[ "def", "git_clone_job_list", "(", "job_list", ")", ":", "queue", "=", "Queue", "(", ")", "for", "job", "in", "job_list", ":", "queue", ".", "put", "(", "job", ")", "if", "len", "(", "job_list", ")", "<", "20", ":", "thread_num", "=", "len", "(", "job_list", ")", "else", ":", "thread_num", "=", "20", "threads", "=", "[", "]", "for", "_", "in", "range", "(", "thread_num", ")", ":", "thread", "=", "Thread", "(", "target", "=", "git_clone_worker", ",", "args", "=", "(", "queue", ",", ")", ")", "thread", ".", "start", "(", ")", "threads", ".", "append", "(", "thread", ")", "queue", ".", "join", "(", ")", "for", "_", "in", "range", "(", "thread_num", ")", ":", "queue", ".", "put", "(", "None", ")", "for", "thread", "in", "threads", ":", "thread", ".", "join", "(", ")" ]

[ "Deal", "with", "all", "git", "clone", "jobs", "in", "$job_list", "." ]

[ "def", "safe_data", "(", "self", ")", ":", "if", "self", ".", "data", "is", "None", ":", "raise", "DeadEntityException", "(", "\"Entity {}:{} is dead - its attributes can no longer be \"", "\"accessed. Use the .previous() method on this object to get \"", "\"a copy of the object at its previous state.\"", ".", "format", "(", "self", ".", "entity_type", ",", "self", ".", "entity_id", ")", ")", "return", "self", ".", "data" ]

[ "The", "data", "dictionary", "for", "this", "entity", "." ]

[ "def", "layer", "(", "self", ",", "img", ",", "x", "=", "0", ",", "y", "=", "0", ",", "name", "=", "\"\"", ")", ":", "from", "types", "import", "StringType", "if", "isinstance", "(", "img", ",", "Image", ".", "Image", ")", ":", "img", "=", "img", ".", "convert", "(", "\"RGBA\"", ")", "self", ".", "layers", ".", "append", "(", "Layer", "(", "self", ",", "img", ",", "x", ",", "y", ",", "name", ")", ")", "return", "len", "(", "self", ".", "layers", ")", "-", "1", "if", "isinstance", "(", "img", ",", "Layer", ")", ":", "img", ".", "canvas", "=", "self", "self", ".", "layers", ".", "append", "(", "img", ")", "return", "len", "(", "self", ".", "layers", ")", "-", "1", "if", "type", "(", "img", ")", "==", "StringType", ":", "img", "=", "Image", ".", "open", "(", "img", ")", "img", "=", "img", ".", "convert", "(", "\"RGBA\"", ")", "self", ".", "layers", ".", "append", "(", "Layer", "(", "self", ",", "img", ",", "x", ",", "y", ",", "name", ")", ")", "return", "len", "(", "self", ".", "layers", ")", "-", "1" ]

[ "Creates", "a", "new", "layer", "from", "file", "Layer", "PIL", "Image", ".", "If", "img", "is", "an", "image", "file", "or", "PIL", "Image", "object", "Creates", "a", "new", "layer", "with", "the", "given", "image", "file", ".", "The", "image", "is", "positioned", "on", "the", "canvas", "at", "x", "y", ".", "If", "img", "is", "a", "Layer", "uses", "that", "layer", "s", "x", "and", "y", "position", "and", "name", "." ]

[ "def", "start", "(", "self", ")", "->", "None", ":", "self", ".", "_shutdown", "=", "False", "# Start listening (if server) / Open connection (if client)", "if", "isinstance", "(", "self", ".", "_protocol", ",", "Server", ")", ":", "self", ".", "create_task", "(", "self", ".", "_async_listen", ")", "elif", "isinstance", "(", "self", ".", "_protocol", ",", "Client", ")", ":", "self", ".", "create_task", "(", "self", ".", "_async_open", ")", "else", ":", "raise", "NotImplementedError" ]

[ "Start", "monitoring", "the", "base", "unit", "." ]

[ "def", "_auth", "(", "self", ")", ":", "codec", "=", "PbufCodec", "(", ")", "username", "=", "self", ".", "_client", ".", "_credentials", ".", "username", "password", "=", "self", ".", "_client", ".", "_credentials", ".", "password", "if", "not", "password", ":", "password", "=", "''", "msg", "=", "codec", ".", "encode_auth", "(", "username", ",", "password", ")", "resp_code", ",", "_", "=", "self", ".", "_non_connect_send_recv_msg", "(", "msg", ")", "if", "resp_code", "==", "riak", ".", "pb", ".", "messages", ".", "MSG_CODE_AUTH_RESP", ":", "return", "True", "else", ":", "return", "False" ]

[ "Perform", "an", "authorization", "request", "against", "Riak", "returns", "True", "upon", "success", "False", "otherwise", "Note", ":", "Riak", "will", "sleep", "for", "a", "short", "period", "of", "time", "upon", "a", "failed", "auth", "request", "/", "response", "to", "prevent", "denial", "of", "service", "attacks" ]

[ "def", "_set_tk_config", "(", "self", ",", "keys", ",", "value", ")", ":", "# if a single key is passed, convert to list", "if", "isinstance", "(", "keys", ",", "str", ")", ":", "keys", "=", "[", "keys", "]", "# loop through all the keys", "for", "key", "in", "keys", ":", "if", "key", "in", "self", ".", "tk", ".", "keys", "(", ")", ":", "if", "value", "is", "None", ":", "# reset to default", "self", ".", "tk", "[", "key", "]", "=", "self", ".", "_tk_defaults", "[", "key", "]", "else", ":", "self", ".", "tk", "[", "key", "]", "=", "value" ]

[ "Gets", "the", "config", "from", "the", "widget", "s", "tk", "object" ]

[ "def", "json_or_jsonp", "(", "func", ")", ":", "@", "wraps", "(", "func", ")", "def", "_", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "mimetype", "=", "'application/javascript'", "callback", "=", "request", ".", "args", ".", "get", "(", "'callback'", ",", "None", ")", "if", "callback", "is", "None", ":", "content", "=", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "content", "=", "\"%s(%s)\"", "%", "(", "callback", ",", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "return", "current_app", ".", "response_class", "(", "content", ",", "mimetype", "=", "mimetype", ")", "return", "_" ]

[ "Wrap", "response", "in", "JSON", "or", "JSONP", "style" ]

[ "def", "merge", "(", "s", ",", "t", ")", ":", "for", "k", ",", "v", "in", "t", ".", "items", "(", ")", ":", "if", "isinstance", "(", "v", ",", "dict", ")", ":", "if", "k", "not", "in", "s", ":", "s", "[", "k", "]", "=", "v", "continue", "s", "[", "k", "]", "=", "merge", "(", "s", "[", "k", "]", ",", "v", ")", "continue", "s", "[", "k", "]", "=", "v", "return", "s" ]

[ "Merge", "dictionary", "t", "into", "s", "." ]

[ "def", "f_load_skeleton", "(", "self", ")", ":", "self", ".", "f_load", "(", "self", ".", "v_name", ",", "as_new", "=", "False", ",", "load_parameters", "=", "pypetconstants", ".", "LOAD_SKELETON", ",", "load_derived_parameters", "=", "pypetconstants", ".", "LOAD_SKELETON", ",", "load_results", "=", "pypetconstants", ".", "LOAD_SKELETON", ",", "load_other_data", "=", "pypetconstants", ".", "LOAD_SKELETON", ",", "with_run_information", "=", "False", ")" ]

[ "Loads", "the", "full", "skeleton", "from", "the", "storage", "service", "." ]

[ "def", "parse_path", "(", "path", ")", ":", "bits", "=", "path", ".", "lstrip", "(", "'/'", ")", ".", "split", "(", "'/'", ")", "if", "not", "bits", ":", "raise", "exceptions", ".", "BadPathError", "(", "path", ")", "if", "bits", "[", "-", "1", "]", ":", "bits", "[", "-", "1", "]", ",", "port", "=", "get_port", "(", "bits", "[", "-", "1", "]", ")", "else", ":", "port", "=", "None", "if", "path", "[", "0", "]", "==", "'/'", ":", "bits", "=", "[", "'/'", "]", "+", "bits", "condensed_bits", "=", "[", "]", "for", "bit", "in", "bits", ":", "if", "bit", "==", "'.'", ":", "continue", "if", "bit", "==", "'..'", ":", "condensed_bits", "=", "condensed_bits", "[", ":", "-", "1", "]", "continue", "condensed_bits", ".", "append", "(", "bit", ")", "if", "not", "condensed_bits", ":", "condensed_bits", "=", "[", "'/'", "]", "return", "condensed_bits", ",", "port" ]

[ "Parses", "an", "address", "into", "directory", "and", "port", "parts", ".", "The", "last", "segment", "of", "the", "address", "will", "be", "checked", "to", "see", "if", "it", "matches", "a", "port", "specification", "(", "i", ".", "e", ".", "contains", "a", "colon", "followed", "by", "text", ")", ".", "This", "will", "be", "returned", "separately", "from", "the", "directory", "parts", ".", "If", "a", "leading", "/", "is", "given", "that", "will", "be", "returned", "as", "the", "first", "directory", "component", ".", "All", "other", "/", "characters", "are", "removed", ".", "All", "leading", "/", "characters", "are", "condensed", "into", "a", "single", "leading", "/", ".", "Any", "path", "components", "that", "are", ".", "will", "be", "removed", "as", "they", "just", "point", "to", "the", "previous", "path", "component", ".", "For", "example", "/", "localhost", "/", ".", "will", "become", "/", "localhost", ".", "Any", "path", "components", "that", "are", "..", "will", "be", "removed", "along", "with", "the", "previous", "path", "component", ".", "If", "this", "renders", "the", "path", "empty", "it", "will", "be", "replaced", "with", "/", ".", "Examples", ":", ">>>", "parse_path", "(", "localhost", ":", "30000", "/", "manager", "/", "comp0", ".", "rtc", ")", "(", "[", "localhost", ":", "30000", "manager", "comp0", ".", "rtc", "]", "None", ")", ">>>", "parse_path", "(", "localhost", "/", "manager", "/", "comp0", ".", "rtc", ":", "in", ")", "(", "[", "localhost", "manager", "comp0", ".", "rtc", "]", "in", ")", ">>>", "parse_path", "(", "/", "localhost", "/", "manager", "/", "comp0", ".", "rtc", ")", "(", "[", "/", "localhost", "manager", "comp0", ".", "rtc", "]", "None", ")", ">>>", "parse_path", "(", "/", "localhost", "/", "manager", "/", "comp0", ".", "rtc", ":", "in", ")", "(", "[", "/", "localhost", "manager", "comp0", ".", "rtc", "]", "in", ")", ">>>", "parse_path", "(", "manager", "/", "comp0", ".", "rtc", ")", "(", "[", "manager", "comp0", ".", "rtc", "]", "None", ")", ">>>", "parse_path", "(", "comp0", ".", "rtc", ")", "(", "[", "comp0", ".", "rtc", "]", "None", ")" ]

[ "def", "bind_kernel", "(", "*", "*", "kwargs", ")", ":", "from", "IPython", ".", "zmq", ".", "ipkernel", "import", "IPKernelApp", "from", "IPython", ".", "parallel", ".", "apps", ".", "ipengineapp", "import", "IPEngineApp", "# first check for IPKernelApp, in which case this should be a no-op", "# because there is already a bound kernel", "if", "IPKernelApp", ".", "initialized", "(", ")", "and", "isinstance", "(", "IPKernelApp", ".", "_instance", ",", "IPKernelApp", ")", ":", "return", "if", "IPEngineApp", ".", "initialized", "(", ")", ":", "try", ":", "app", "=", "IPEngineApp", ".", "instance", "(", ")", "except", "MultipleInstanceError", ":", "pass", "else", ":", "return", "app", ".", "bind_kernel", "(", "*", "*", "kwargs", ")", "raise", "RuntimeError", "(", "\"bind_kernel be called from an IPEngineApp instance\"", ")" ]

[ "Bind", "an", "Engine", "s", "Kernel", "to", "be", "used", "as", "a", "full", "IPython", "kernel", ".", "This", "allows", "a", "running", "Engine", "to", "be", "used", "simultaneously", "as", "a", "full", "IPython", "kernel", "with", "the", "QtConsole", "or", "other", "frontends", ".", "This", "function", "returns", "immediately", "." ]

[ "def", "run_analysis", "(", "self", ",", "argv", ")", ":", "args", "=", "self", ".", "_parser", ".", "parse_args", "(", "argv", ")", "if", "not", "HAVE_ST", ":", "raise", "RuntimeError", "(", "\"Trying to run fermipy analysis, but don't have ST\"", ")", "if", "is_not_null", "(", "args", ".", "roi_baseline", ")", ":", "gta", "=", "GTAnalysis", ".", "create", "(", "args", ".", "roi_baseline", ",", "args", ".", "config", ")", "else", ":", "gta", "=", "GTAnalysis", "(", "args", ".", "config", ",", "logging", "=", "{", "'verbosity'", ":", "3", "}", ",", "fileio", "=", "{", "'workdir_regex'", ":", "'\\.xml$|\\.npy$'", "}", ")", "gta", ".", "print_roi", "(", ")", "test_source", "=", "args", ".", "target", "gta", ".", "sed", "(", "test_source", ",", "outfile", "=", "'sed_%s.fits'", "%", "'FL8Y'", ",", "make_plots", "=", "True", ")", "gta", ".", "extension", "(", "test_source", ",", "make_plots", "=", "True", ")", "return", "gta" ]

[ "Run", "this", "analysis" ]

[ "def", "removeInput", "(", "self", ",", "key_id", ",", "input_type", "=", "'key'", ")", ":", "root", "=", "self", ".", "etree", "t_inputs", "=", "root", ".", "find", "(", "'inputs'", ")", "if", "not", "t_inputs", ":", "return", "False", "keys", "=", "t_inputs", ".", "findall", "(", "input_type", ")", "key", "=", "[", "key", "for", "key", "in", "keys", "if", "key", ".", "get", "(", "'id'", ")", "==", "key_id", "]", "try", ":", "t_inputs", ".", "remove", "(", "key", "[", "0", "]", ")", "return", "True", "except", "(", "Exception", ",", ")", "as", "e", ":", "print", "(", "e", ")", "return", "False" ]

[ "Remove", "key", "(", "key", "value", "map", ")", "from", "Input", "key_id", ":", "id", "of", "the", "input", "element", "i", ".", "e", "<key", "id", "=", "artist", "/", ">", "input_type", ":", "type", "of", "the", "input", ";", "key", "value", "or", "map" ]

[ "def", "deprecated", "(", "*", "optional_message", ")", ":", "def", "_deprecated", "(", "func", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "filename", ",", "lineno", "=", "get_culprit", "(", ")", "user_msg", "=", "'Call to deprecated function \"%s\". Called from %s line %i. %s'", "%", "(", "func", ".", "__name__", ",", "filename", ",", "lineno", ",", "msg", ")", "warnings", ".", "warn_explicit", "(", "user_msg", ",", "category", "=", "PyEMMA_DeprecationWarning", ",", "filename", "=", "filename", ",", "lineno", "=", "lineno", ")", "return", "func", "(", "*", "args", ",", "*", "*", "kw", ")", "# add deprecation notice to func docstring:", "if", "len", "(", "optional_message", ")", "==", "1", "and", "callable", "(", "optional_message", "[", "0", "]", ")", ":", "# this is the function itself, decorate!", "msg", "=", "\"\"", "return", "decorate", "(", "optional_message", "[", "0", "]", ",", "_deprecated", ")", "else", ":", "# actually got a message (or empty parenthesis)", "msg", "=", "optional_message", "[", "0", "]", "if", "len", "(", "optional_message", ")", ">", "0", "else", "\"\"", "return", "decorator", "(", "_deprecated", ")" ]

[ "This", "is", "a", "decorator", "which", "can", "be", "used", "to", "mark", "functions", "as", "deprecated", ".", "It", "will", "result", "in", "a", "warning", "being", "emitted", "when", "the", "function", "is", "used", "." ]

[ "def", "get_by_id", "(", "self", ",", "process_name", ",", "db_id", ")", ":", "collection_name", "=", "self", ".", "_get_job_collection_name", "(", "process_name", ")", "collection", "=", "self", ".", "ds", ".", "connection", "(", "collection_name", ")", "document", "=", "collection", ".", "find_one", "(", "{", "'_id'", ":", "ObjectId", "(", "db_id", ")", "}", ")", "if", "document", "is", "None", ":", "raise", "LookupError", "(", "'MongoDB has no job record in collection {0} for {1}'", ".", "format", "(", "collection", ",", "db_id", ")", ")", "return", "Job", ".", "from_json", "(", "document", ")" ]

[ "method", "finds", "a", "single", "job", "record", "and", "returns", "it", "to", "the", "caller" ]

[ "def", "select_action", "(", "self", ",", "state", ")", ":", "value", "=", "0", "if", "self", ".", "steps", "<", "self", ".", "min_steps", ":", "action", "=", "np", ".", "random", ".", "randint", "(", "self", ".", "actions", ")", "else", ":", "self", ".", "eps", "=", "max", "(", "self", ".", "eps_end", ",", "self", ".", "eps", "*", "self", ".", "eps_decay", ")", "if", "random", ".", "random", "(", ")", "<", "self", ".", "eps", ":", "action", "=", "np", ".", "random", ".", "randint", "(", "self", ".", "actions", ")", "else", ":", "self", ".", "local", ".", "eval", "(", ")", "with", "torch", ".", "no_grad", "(", ")", ":", "state", "=", "torch", ".", "tensor", "(", "state", ",", "device", "=", "self", ".", "device", ",", "dtype", "=", "torch", ".", "float", ")", ".", "unsqueeze", "(", "0", ")", "Q", "=", "self", ".", "local", "(", "state", ")", "value", ",", "action", "=", "torch", ".", "max", "(", "Q", ",", "1", ")", "return", "int", "(", "action", ")", ",", "float", "(", "value", ")" ]

[ "Select", "the", "best", "action", "for", "the", "given", "state", "using", "e", "-", "greedy", "exploration", "to", "minimize", "overfitting" ]

[ "async", "def", "connect", "(", "self", ",", "loop", ",", "port", ",", "baudrate", "=", "9600", ",", "bytesize", "=", "serial", ".", "EIGHTBITS", ",", "parity", "=", "serial", ".", "PARITY_NONE", ",", "stopbits", "=", "serial", ".", "STOPBITS_ONE", ",", "connection_timeout", "=", "10", ",", "inactivity_timeout", "=", "5", ")", ":", "if", "self", ".", "_connected", ":", "# We are actually reconnecting, cleanup first.", "_LOGGER", ".", "debug", "(", "\"Reconnecting to serial device on %s\"", ",", "port", ")", "if", "self", ".", "_gpio_task", ":", "self", ".", "_gpio_task", ".", "cancel", "(", ")", "self", ".", "_connected", "=", "False", "self", ".", "_transport", ".", "close", "(", ")", "await", "asyncio", ".", "sleep", "(", "3", ")", "self", ".", "loop", "=", "loop", "transport", "=", "None", "while", "transport", "is", "None", ":", "try", ":", "transport", ",", "protocol", "=", "(", "await", "serial_asyncio", ".", "create_serial_connection", "(", "loop", ",", "otgw", ".", "protocol", ",", "port", ",", "baudrate", ",", "bytesize", ",", "parity", ",", "stopbits", ",", "connection_timeout", ")", ")", "except", "serial", ".", "serialutil", ".", "SerialException", "as", "e", ":", "if", "not", "self", ".", "_conn_error", ":", "_LOGGER", ".", "error", "(", "\"Could not connect to serial device on %s. \"", "\"Will keep trying. Reported error was: %s\"", ",", "port", ",", "e", ")", "self", ".", "_conn_error", "=", "True", "transport", "=", "None", "await", "asyncio", ".", "sleep", "(", "5", ")", "self", ".", "_conn_error", "=", "False", "_LOGGER", ".", "debug", "(", "\"Connected to serial device on %s\"", ",", "port", ")", "self", ".", "_transport", "=", "transport", "self", ".", "_protocol", "=", "protocol", "self", ".", "loop", ".", "create_task", "(", "self", ".", "_protocol", ".", "set_update_cb", "(", "self", ".", "_send_report", ")", ")", "if", "0", "<", "inactivity_timeout", "<", "3", ":", "_LOGGER", ".", "error", "(", "\"Inactivity timeout too low. Should be at least 3 \"", "\"seconds, got %d\"", ",", "inactivity_timeout", ")", "if", "inactivity_timeout", ">=", "3", ":", "async", "def", "reconnect", "(", ")", ":", "\"\"\"Reconnect to the OpenTherm Gateway.\"\"\"", "_LOGGER", ".", "debug", "(", "\"Scheduling reconnect...\"", ")", "await", "self", ".", "connect", "(", "loop", ",", "port", ",", "baudrate", ",", "bytesize", ",", "parity", ",", "stopbits", ",", "connection_timeout", ",", "inactivity_timeout", ")", "self", ".", "loop", ".", "create_task", "(", "self", ".", "_protocol", ".", "setup_watchdog", "(", "reconnect", ",", "inactivity_timeout", ")", ")", "self", ".", "_gpio_task", "=", "None", "self", ".", "_connected", "=", "True", "await", "self", ".", "get_reports", "(", ")", "await", "self", ".", "get_status", "(", ")", "if", "(", "self", ".", "_protocol", ".", "status", ".", "get", "(", "OTGW_GPIO_A", ")", "or", "self", ".", "_protocol", ".", "status", ".", "get", "(", "OTGW_GPIO_B", ")", ")", ":", "await", "self", ".", "_poll_gpio", "(", "True", ")", "return", "dict", "(", "self", ".", "_protocol", ".", "status", ")" ]

[ "Connect", "to", "Opentherm", "Gateway", "at", "@port", ".", "Initialize", "the", "parameters", "obtained", "from", "the", "PS", "=", "and", "PR", "=", "commands", "and", "returns", "the", "status", "dict", "with", "the", "obtained", "values", ".", "If", "called", "while", "connected", "reconnect", "to", "the", "gateway", "." ]

[ "def", "collapse_initials", "(", "name", ")", ":", "if", "len", "(", "name", ".", "split", "(", "\".\"", ")", ")", ">", "1", ":", "name", "=", "re", ".", "sub", "(", "r'([A-Z]\\.)[\\s\\-]+(?=[A-Z]\\.)'", ",", "r'\\1'", ",", "name", ")", "return", "name" ]

[ "Remove", "the", "space", "between", "initials", "eg", "T", ".", "A", ".", "--", ">", "T", ".", "A", "." ]

[ "def", "has_predecessor", "(", "self", ",", "u", ",", "v", ",", "t", "=", "None", ")", ":", "return", "self", ".", "has_interaction", "(", "v", ",", "u", ",", "t", ")" ]

[ "Return", "True", "if", "node", "u", "has", "predecessor", "v", "at", "time", "t", "(", "optional", ")", "." ]

[ "def", "slice", "(", "self", ",", "serie_node", ",", "node", ",", "radius", ",", "small_radius", ",", "angle", ",", "start_angle", ",", "center", ",", "val", ",", "i", ",", "metadata", ")", ":", "if", "angle", "==", "2", "*", "pi", ":", "angle", "=", "nearly_2pi", "if", "angle", ">", "0", ":", "to", "=", "[", "coord_abs_project", "(", "center", ",", "radius", ",", "start_angle", ")", ",", "coord_abs_project", "(", "center", ",", "radius", ",", "start_angle", "+", "angle", ")", ",", "coord_abs_project", "(", "center", ",", "small_radius", ",", "start_angle", "+", "angle", ")", ",", "coord_abs_project", "(", "center", ",", "small_radius", ",", "start_angle", ")", "]", "rv", "=", "self", ".", "node", "(", "node", ",", "'path'", ",", "d", "=", "'M%s A%s 0 %d 1 %s L%s A%s 0 %d 0 %s z'", "%", "(", "to", "[", "0", "]", ",", "coord_dual", "(", "radius", ")", ",", "int", "(", "angle", ">", "pi", ")", ",", "to", "[", "1", "]", ",", "to", "[", "2", "]", ",", "coord_dual", "(", "small_radius", ")", ",", "int", "(", "angle", ">", "pi", ")", ",", "to", "[", "3", "]", ")", ",", "class_", "=", "'slice reactive tooltip-trigger'", ")", "else", ":", "rv", "=", "None", "x", ",", "y", "=", "coord_diff", "(", "center", ",", "coord_project", "(", "(", "radius", "+", "small_radius", ")", "/", "2", ",", "start_angle", "+", "angle", "/", "2", ")", ")", "self", ".", "graph", ".", "_tooltip_data", "(", "node", ",", "val", ",", "x", ",", "y", ",", "\"centered\"", ",", "self", ".", "graph", ".", "_x_labels", "and", "self", ".", "graph", ".", "_x_labels", "[", "i", "]", "[", "0", "]", ")", "if", "angle", ">=", "0.3", ":", "# 0.3 radians is about 17 degrees", "self", ".", "graph", ".", "_static_value", "(", "serie_node", ",", "val", ",", "x", ",", "y", ",", "metadata", ")", "return", "rv" ]

[ "Draw", "a", "pie", "slice" ]

[ "def", "run", "(", "self", ",", "command", ",", "arguments", "=", "(", ")", ",", "console_mode_stdin", "=", "True", ",", "skip_cmd_shell", "=", "False", ")", ":", "logging", ".", "info", "(", "'running command: '", "+", "command", ")", "resource", "=", "ResourceLocator", "(", "CommandShell", ".", "ShellResource", ")", "resource", ".", "add_selector", "(", "'ShellId'", ",", "self", ".", "__shell_id", ")", "resource", ".", "add_option", "(", "'WINRS_SKIP_CMD_SHELL'", ",", "[", "'FALSE'", ",", "'TRUE'", "]", "[", "bool", "(", "skip_cmd_shell", ")", "]", ",", "True", ")", "resource", ".", "add_option", "(", "'WINRS_CONSOLEMODE_STDIN'", ",", "[", "'FALSE'", ",", "'TRUE'", "]", "[", "bool", "(", "console_mode_stdin", ")", "]", ",", "True", ")", "command", "=", "OrderedDict", "(", "[", "(", "'rsp:Command'", ",", "command", ")", "]", ")", "command", "[", "'rsp:Arguments'", "]", "=", "list", "(", "arguments", ")", "response", "=", "self", ".", "session", ".", "command", "(", "resource", ",", "{", "'rsp:CommandLine'", ":", "command", "}", ")", "command_id", "=", "response", "[", "'rsp:CommandResponse'", "]", "[", "'rsp:CommandId'", "]", "logging", ".", "info", "(", "'receive command: '", "+", "command_id", ")", "return", "command_id" ]

[ "This", "function", "does", "something", ".", ":", "param", "command", ":", "The", "command", "to", "be", "executed", ":", "type", "name", ":", "str", ".", ":", "param", "arguments", ":", "A", "list", "of", "arguments", "to", "be", "passed", "to", "the", "command", ":", "type", "state", ":", "str", ".", ":", "returns", ":", "int", "--", "the", "return", "code", ".", ":", "raises", ":", "AttributeError", "KeyError" ]

[ "def", "edit", "(", "self", ",", "id_", ",", "text", ")", ":", "data", "=", "dict", "(", "thing_id", "=", "id_", ",", "text", "=", "text", ")", "j", "=", "self", ".", "post", "(", "'api'", ",", "'editusertext'", ",", "data", "=", "data", ")", "try", ":", "return", "self", ".", "_thingify", "(", "j", "[", "'json'", "]", "[", "'data'", "]", "[", "'things'", "]", "[", "0", "]", ")", "except", "Exception", ":", "raise", "UnexpectedResponse", "(", "j", ")" ]

[ "Login", "required", ".", "Sends", "POST", "to", "change", "selftext", "or", "comment", "text", "to", "text", ".", "Returns", ":", "class", ":", "things", ".", "Comment", "or", ":", "class", ":", "things", ".", "Link", "object", "depending", "on", "what", "s", "being", "edited", ".", "Raises", ":", "class", ":", "UnexpectedResponse", "if", "neither", "is", "returned", ".", "URL", ":", "http", ":", "//", "www", ".", "reddit", ".", "com", "/", "api", "/", "editusertext", "/", ":", "param", "id", "\\", "_", ":", "full", "id", "of", "link", "or", "comment", "to", "edit", ":", "param", "text", ":", "new", "self", "or", "comment", "text" ]

[ "def", "received", "(", "self", ",", "limit", "=", "None", ")", ":", "return", "list", "(", "itertools", ".", "islice", "(", "(", "itertools", ".", "filterfalse", "(", "lambda", "x", ":", "x", "[", "1", "]", ".", "sent", ",", "self", ".", "store", ")", ")", ",", "limit", ")", ")", "[", ":", ":", "-", "1", "]" ]

[ "Returns", "all", "the", "events", "that", "have", "been", "received", "(", "excluding", "sent", "events", ")", "until", "a", "limit", "if", "defined" ]

[ "def", "to_string", "(", "self", ")", ":", "from", "pandas", "import", "Series", "frame", "=", "self", ".", "frame", "if", "len", "(", "frame", ".", "columns", ")", "==", "0", "or", "len", "(", "frame", ".", "index", ")", "==", "0", ":", "info_line", "=", "(", "'Empty {name}\\nColumns: {col}\\nIndex: {idx}'", ".", "format", "(", "name", "=", "type", "(", "self", ".", "frame", ")", ".", "__name__", ",", "col", "=", "pprint_thing", "(", "frame", ".", "columns", ")", ",", "idx", "=", "pprint_thing", "(", "frame", ".", "index", ")", ")", ")", "text", "=", "info_line", "else", ":", "strcols", "=", "self", ".", "_to_str_columns", "(", ")", "if", "self", ".", "line_width", "is", "None", ":", "# no need to wrap around just print", "# the whole frame", "text", "=", "self", ".", "adj", ".", "adjoin", "(", "1", ",", "*", "strcols", ")", "elif", "(", "not", "isinstance", "(", "self", ".", "max_cols", ",", "int", ")", "or", "self", ".", "max_cols", ">", "0", ")", ":", "# need to wrap around", "text", "=", "self", ".", "_join_multiline", "(", "*", "strcols", ")", "else", ":", "# max_cols == 0. Try to fit frame to terminal", "text", "=", "self", ".", "adj", ".", "adjoin", "(", "1", ",", "*", "strcols", ")", ".", "split", "(", "'\\n'", ")", "max_len", "=", "Series", "(", "text", ")", ".", "str", ".", "len", "(", ")", ".", "max", "(", ")", "# plus truncate dot col", "dif", "=", "max_len", "-", "self", ".", "w", "# '+ 1' to avoid too wide repr (GH PR #17023)", "adj_dif", "=", "dif", "+", "1", "col_lens", "=", "Series", "(", "[", "Series", "(", "ele", ")", ".", "apply", "(", "len", ")", ".", "max", "(", ")", "for", "ele", "in", "strcols", "]", ")", "n_cols", "=", "len", "(", "col_lens", ")", "counter", "=", "0", "while", "adj_dif", ">", "0", "and", "n_cols", ">", "1", ":", "counter", "+=", "1", "mid", "=", "int", "(", "round", "(", "n_cols", "/", "2.", ")", ")", "mid_ix", "=", "col_lens", ".", "index", "[", "mid", "]", "col_len", "=", "col_lens", "[", "mid_ix", "]", "# adjoin adds one", "adj_dif", "-=", "(", "col_len", "+", "1", ")", "col_lens", "=", "col_lens", ".", "drop", "(", "mid_ix", ")", "n_cols", "=", "len", "(", "col_lens", ")", "# subtract index column", "max_cols_adj", "=", "n_cols", "-", "self", ".", "index", "# GH-21180. Ensure that we print at least two.", "max_cols_adj", "=", "max", "(", "max_cols_adj", ",", "2", ")", "self", ".", "max_cols_adj", "=", "max_cols_adj", "# Call again _chk_truncate to cut frame appropriately", "# and then generate string representation", "self", ".", "_chk_truncate", "(", ")", "strcols", "=", "self", ".", "_to_str_columns", "(", ")", "text", "=", "self", ".", "adj", ".", "adjoin", "(", "1", ",", "*", "strcols", ")", "self", ".", "buf", ".", "writelines", "(", "text", ")", "if", "self", ".", "should_show_dimensions", ":", "self", ".", "buf", ".", "write", "(", "\"\\n\\n[{nrows} rows x {ncols} columns]\"", ".", "format", "(", "nrows", "=", "len", "(", "frame", ")", ",", "ncols", "=", "len", "(", "frame", ".", "columns", ")", ")", ")" ]

[ "Render", "a", "DataFrame", "to", "a", "console", "-", "friendly", "tabular", "output", "." ]

[ "def", "_address_rxp", "(", "self", ",", "addr", ")", ":", "try", ":", "addr", "=", "to_checksum_address", "(", "addr", ")", "rxp", "=", "'(?:0x)?'", "+", "pex", "(", "address_checksum_and_decode", "(", "addr", ")", ")", "+", "f'(?:{addr.lower()[10:]})?'", "self", ".", "_extra_keys", "[", "pex", "(", "address_checksum_and_decode", "(", "addr", ")", ")", "]", "=", "addr", ".", "lower", "(", ")", "self", ".", "_extra_keys", "[", "addr", "[", "2", ":", "]", ".", "lower", "(", ")", "]", "=", "addr", ".", "lower", "(", ")", "except", "ValueError", ":", "rxp", "=", "addr", "return", "rxp" ]

[ "Create", "a", "regex", "string", "for", "addresses", "that", "matches", "several", "representations", ":", "-", "with", "(", "out", ")", "0x", "prefix", "-", "pex", "version", "This", "function", "takes", "care", "of", "maintaining", "additional", "lookup", "keys", "for", "substring", "matches", ".", "In", "case", "the", "given", "string", "is", "no", "address", "it", "returns", "the", "original", "string", "." ]

[ "def", "get_chat", "(", "self", ",", "chat_id", ")", ":", "assert_type_or_raise", "(", "chat_id", ",", "(", "int", ",", "unicode_type", ")", ",", "parameter_name", "=", "\"chat_id\"", ")", "result", "=", "self", ".", "do", "(", "\"getChat\"", ",", "chat_id", "=", "chat_id", ")", "if", "self", ".", "return_python_objects", ":", "logger", ".", "debug", "(", "\"Trying to parse {data}\"", ".", "format", "(", "data", "=", "repr", "(", "result", ")", ")", ")", "from", "pytgbot", ".", "api_types", ".", "receivable", ".", "peer", "import", "Chat", "try", ":", "return", "Chat", ".", "from_array", "(", "result", ")", "except", "TgApiParseException", ":", "logger", ".", "debug", "(", "\"Failed parsing as api_type Chat\"", ",", "exc_info", "=", "True", ")", "# end try", "# no valid parsing so far", "raise", "TgApiParseException", "(", "\"Could not parse result.\"", ")", "# See debug log for details!", "# end if return_python_objects", "return", "result" ]

[ "Use", "this", "method", "to", "get", "up", "to", "date", "information", "about", "the", "chat", "(", "current", "name", "of", "the", "user", "for", "one", "-", "on", "-", "one", "conversations", "current", "username", "of", "a", "user", "group", "or", "channel", "etc", ".", ")", ".", "Returns", "a", "Chat", "object", "on", "success", "." ]

[ "def", "boolean_arg", "(", "ctx", ",", "obj", ")", ":", "if", "hasattr", "(", "obj", ",", "'compute'", ")", ":", "obj", "=", "next", "(", "obj", ".", "compute", "(", "ctx", ")", ",", "False", ")", "return", "to_boolean", "(", "obj", ")" ]

[ "Handles", "LiteralObjects", "as", "well", "as", "computable", "arguments" ]

[ "def", "make_nfs_path", "(", "path", ")", ":", "if", "os", ".", "path", ".", "isabs", "(", "path", ")", ":", "fullpath", "=", "path", "else", ":", "fullpath", "=", "os", ".", "path", ".", "abspath", "(", "path", ")", "if", "len", "(", "fullpath", ")", "<", "6", ":", "return", "fullpath", "if", "fullpath", "[", "0", ":", "6", "]", "==", "'/gpfs/'", ":", "fullpath", "=", "fullpath", ".", "replace", "(", "'/gpfs/'", ",", "'/nfs/'", ")", "return", "fullpath" ]

[ "Make", "a", "nfs", "version", "of", "a", "file", "path", ".", "This", "just", "puts", "/", "nfs", "at", "the", "beginning", "instead", "of", "/", "gpfs" ]

[ "def", "get_all_ids", "(", "idVendor", "=", "GrizzlyUSB", ".", "ID_VENDOR", ",", "idProduct", "=", "GrizzlyUSB", ".", "ID_PRODUCT", ")", ":", "all_dev", "=", "GrizzlyUSB", ".", "get_all_usb_devices", "(", "idVendor", ",", "idProduct", ")", "if", "len", "(", "all_dev", ")", "<=", "0", ":", "raise", "usb", ".", "USBError", "(", "\"Could not find any GrizzlyBear device (idVendor=%d, idProduct=%d)\"", "%", "(", "idVendor", ",", "idProduct", ")", ")", "else", ":", "all_addresses", "=", "[", "]", "# bound devices is a list of devices that are already busy.", "bound_devices", "=", "[", "]", "for", "device", "in", "all_dev", ":", "internal_addr", "=", "GrizzlyUSB", ".", "get_device_address", "(", "device", ")", "if", "internal_addr", "==", "GrizzlyUSB", ".", "USB_DEVICE_ERROR", ":", "# device bound", "bound_devices", ".", "append", "(", "device", ")", "else", ":", "all_addresses", ".", "append", "(", "internal_addr", ")", "# we release all devices that we aren't using and aren't bound.", "for", "device", "in", "all_dev", ":", "if", "device", "not", "in", "bound_devices", ":", "usb", ".", "util", ".", "dispose_resources", "(", "device", ")", "return", "map", "(", "addr_to_id", ",", "all_addresses", ")" ]

[ "Scans", "for", "grizzlies", "that", "have", "not", "been", "bound", "or", "constructed", "and", "returns", "a", "list", "of", "their", "id", "s", "or", "motor", "number", "." ]

[ "def", "_set_esp", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "RestrictedClassType", "(", "base_type", "=", "unicode", ",", "restriction_type", "=", "\"dict_key\"", ",", "restriction_arg", "=", "{", "u'NULL'", ":", "{", "'value'", ":", "1", "}", "}", ",", ")", ",", "is_leaf", "=", "True", ",", "yang_name", "=", "\"esp\"", ",", "rest_name", "=", "\"esp\"", ",", "parent", "=", "self", ",", "choice", "=", "(", "u'ch-algorithm'", ",", "u'ca-esp-algorithm'", ")", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'Specify Encapsulating Security Payload (ESP)'", ",", "u'cli-incomplete-command'", ":", "None", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-ospfv3'", ",", "defining_module", "=", "'brocade-ospfv3'", ",", "yang_type", "=", "'algorithm-type-esp'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"esp must be of a type compatible with algorithm-type-esp\"\"\"", ",", "'defined-type'", ":", "\"brocade-ospfv3:algorithm-type-esp\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_type=\"dict_key\", restriction_arg={u'NULL': {'value': 1}},), is_leaf=True, yang_name=\"esp\", rest_name=\"esp\", parent=self, choice=(u'ch-algorithm', u'ca-esp-algorithm'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Specify Encapsulating Security Payload (ESP)', u'cli-incomplete-command': None}}, namespace='urn:brocade.com:mgmt:brocade-ospfv3', defining_module='brocade-ospfv3', yang_type='algorithm-type-esp', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__esp", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "Setter", "method", "for", "esp", "mapped", "from", "YANG", "variable", "/", "routing_system", "/", "interface", "/", "ve", "/", "ipv6", "/", "interface_ospfv3_conf", "/", "authentication", "/", "ipsec_auth_key_config", "/", "esp", "(", "algorithm", "-", "type", "-", "esp", ")", "If", "this", "variable", "is", "read", "-", "only", "(", "config", ":", "false", ")", "in", "the", "source", "YANG", "file", "then", "_set_esp", "is", "considered", "as", "a", "private", "method", ".", "Backends", "looking", "to", "populate", "this", "variable", "should", "do", "so", "via", "calling", "thisObj", ".", "_set_esp", "()", "directly", "." ]

[ "def", "show_run", "(", "*", "*", "kwargs", ")", ":", "command", "=", "'show running-config'", "info", "=", "''", "info", "=", "show", "(", "command", ",", "*", "*", "kwargs", ")", "if", "isinstance", "(", "info", ",", "list", ")", ":", "info", "=", "info", "[", "0", "]", "return", "info" ]

[ "Shortcut", "to", "run", "show", "running", "-", "config", "on", "the", "NX", "-", "OS", "device", "." ]

[ "def", "folder2ver", "(", "folder", ")", ":", "ver", "=", "folder", ".", "split", "(", "'EnergyPlus'", ")", "[", "-", "1", "]", "ver", "=", "ver", "[", "1", ":", "]", "splitapp", "=", "ver", ".", "split", "(", "'-'", ")", "ver", "=", "'.'", ".", "join", "(", "splitapp", ")", "return", "ver" ]

[ "get", "the", "version", "number", "from", "the", "E", "+", "install", "folder" ]

[ "def", "training_data", "(", "self", ")", ":", "data", "=", "pickle", ".", "load", "(", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "repopath", ",", "'training.pkl'", ")", ")", ")", "return", "data", ".", "keys", "(", ")", ",", "data", ".", "values", "(", ")" ]

[ "Returns", "data", "dictionary", "from", "training", ".", "pkl" ]

[ "def", "series_with_slh", "(", "self", ",", "other", ")", ":", "new_S", "=", "self", ".", "S", "*", "other", ".", "S", "new_L", "=", "self", ".", "S", "*", "other", ".", "L", "+", "self", ".", "L", "def", "ImAdjoint", "(", "m", ")", ":", "return", "(", "m", ".", "H", "-", "m", ")", "*", "(", "I", "/", "2", ")", "delta", "=", "ImAdjoint", "(", "self", ".", "L", ".", "adjoint", "(", ")", "*", "self", ".", "S", "*", "other", ".", "L", ")", "if", "isinstance", "(", "delta", ",", "Matrix", ")", ":", "new_H", "=", "self", ".", "H", "+", "other", ".", "H", "+", "delta", "[", "0", ",", "0", "]", "else", ":", "assert", "delta", "==", "0", "new_H", "=", "self", ".", "H", "+", "other", ".", "H", "return", "SLH", "(", "new_S", ",", "new_L", ",", "new_H", ")" ]

[ "Series", "product", "with", "another", ":", "class", ":", "SLH", "object" ]

[ "def", "obj_to_string", "(", "obj", ")", ":", "if", "not", "obj", ":", "return", "None", "elif", "isinstance", "(", "obj", ",", "bytes", ")", ":", "return", "obj", ".", "decode", "(", "'utf-8'", ")", "elif", "isinstance", "(", "obj", ",", "basestring", ")", ":", "return", "obj", "elif", "is_lazy_string", "(", "obj", ")", ":", "return", "obj", ".", "value", "elif", "hasattr", "(", "obj", ",", "'__html__'", ")", ":", "return", "obj", ".", "__html__", "(", ")", "else", ":", "return", "str", "(", "obj", ")" ]

[ "Render", "an", "object", "into", "a", "unicode", "string", "if", "possible" ]

[ "def", "_add_label_edges", "(", "self", ")", ":", "labels", "=", "self", ".", "ast", ".", "select", "(", "'atom_label'", ")", "if", "not", "labels", ":", "return", "# We need each individual label and atoms with multiple ring labels", "# would yield e.g. the string '12' so split those up.", "label_digits", "=", "defaultdict", "(", "list", ")", "for", "label", "in", "labels", ":", "digits", "=", "list", "(", "label", ".", "tail", "[", "0", "]", ")", "for", "digit", "in", "digits", ":", "label_digits", "[", "digit", "]", ".", "append", "(", "label", ".", "parent", "(", ")", ")", "for", "label", ",", "(", "atom1", ",", "atom2", ")", "in", "label_digits", ".", "items", "(", ")", ":", "atom1_idx", "=", "self", ".", "_atom_indices", "[", "id", "(", "atom1", ")", "]", "atom2_idx", "=", "self", ".", "_atom_indices", "[", "id", "(", "atom2", ")", "]", "self", ".", "add_edge", "(", "atom1_idx", ",", "atom2_idx", ")" ]

[ "Add", "edges", "between", "all", "atoms", "with", "the", "same", "atom_label", "in", "rings", "." ]

[ "def", "add_new_reset_method", "(", "cls", ")", ":", "orig_reset", "=", "cls", ".", "reset", "def", "new_reset", "(", "self", ",", "seed", "=", "None", ")", ":", "logger", ".", "debug", "(", "f\"Calling reset() on {self} (seed={seed})\"", ")", "orig_reset", "(", "self", ",", "seed", ")", "for", "c", "in", "self", ".", "_dependent_generators", ":", "c", ".", "reset_dependent_generator", "(", "seed", ")", "return", "self", "cls", ".", "reset", "=", "new_reset" ]

[ "Replace", "existing", "cls", ".", "reset", "()", "method", "with", "a", "new", "one", "which", "also", "calls", "reset", "()", "on", "any", "clones", "." ]

[ "def", "call_local_plugin_method", "(", "self", ",", "chname", ",", "plugin_name", ",", "method_name", ",", "args", ",", "kwargs", ")", ":", "channel", "=", "self", ".", "get_channel", "(", "chname", ")", "opmon", "=", "channel", ".", "opmon", "p_obj", "=", "opmon", ".", "get_plugin", "(", "plugin_name", ")", "method", "=", "getattr", "(", "p_obj", ",", "method_name", ")", "return", "self", ".", "gui_call", "(", "method", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parameters", "----------", "chname", ":", "str", "The", "name", "of", "the", "channel", "containing", "the", "plugin", "." ]

[ "def", "differentiate_shown_data", "(", "neighbors", "=", "1", ",", "fyname", "=", "1", ",", "*", "*", "kwargs", ")", ":", "if", "neighbors", ":", "def", "D", "(", "x", ",", "y", ")", ":", "return", "_fun", ".", "derivative_fit", "(", "x", ",", "y", ",", "neighbors", ")", "else", ":", "def", "D", "(", "x", ",", "y", ")", ":", "return", "_fun", ".", "derivative", "(", "x", ",", "y", ")", "if", "fyname", "==", "1", ":", "fyname", "=", "'$\\\\partial_{x(\\\\pm'", "+", "str", "(", "neighbors", ")", "+", "')}$'", "manipulate_shown_data", "(", "D", ",", "fxname", "=", "None", ",", "fyname", "=", "fyname", ",", "*", "*", "kwargs", ")" ]

[ "Differentiates", "the", "data", "visible", "on", "the", "specified", "axes", "using", "fun", ".", "derivative_fit", "()", "(", "if", "neighbors", ">", "0", ")", "and", "derivative", "()", "otherwise", ".", "Modifies", "the", "visible", "data", "using", "manipulate_shown_data", "(", "**", "kwargs", ")" ]

[ "def", "open_tablebase_native", "(", "directory", ":", "PathLike", ",", "*", ",", "libgtb", ":", "Any", "=", "None", ",", "LibraryLoader", ":", "Any", "=", "ctypes", ".", "cdll", ")", "->", "NativeTablebase", ":", "libgtb", "=", "libgtb", "or", "ctypes", ".", "util", ".", "find_library", "(", "\"gtb\"", ")", "or", "\"libgtb.so.1.0.1\"", "tables", "=", "NativeTablebase", "(", "LibraryLoader", ".", "LoadLibrary", "(", "libgtb", ")", ")", "tables", ".", "add_directory", "(", "directory", ")", "return", "tables" ]

[ "Opens", "a", "collection", "of", "tables", "for", "probing", "using", "libgtb", "." ]

[ "def", "df_pdb_blast", "(", "self", ")", ":", "blast_results_pre_df", "=", "[", "]", "for", "p", "in", "self", ".", "get_experimental_structures", "(", ")", ":", "for", "c", "in", "p", ".", "chains", ":", "if", "hasattr", "(", "c", ",", "'blast_results'", ")", ":", "# Summary dataframe", "infodict", "=", "p", ".", "get_dict_with_chain", "(", "chain", "=", "c", ".", "id", ")", "[", "'blast_results'", "]", "infodict", "[", "'pdb_id'", "]", "=", "p", ".", "id", "infodict", "[", "'pdb_chain_id'", "]", "=", "c", ".", "id", "blast_results_pre_df", ".", "append", "(", "infodict", ")", "cols", "=", "[", "'pdb_id'", ",", "'pdb_chain_id'", ",", "'hit_score'", ",", "'hit_evalue'", ",", "'hit_percent_similar'", ",", "'hit_percent_ident'", ",", "'hit_percent_gaps'", ",", "'hit_num_ident'", ",", "'hit_num_similar'", ",", "'hit_num_gaps'", "]", "df", "=", "pd", ".", "DataFrame", ".", "from_records", "(", "blast_results_pre_df", ",", "columns", "=", "cols", ")", ".", "set_index", "(", "'pdb_id'", ")", "return", "ssbio", ".", "utils", ".", "clean_df", "(", "df", ")" ]

[ "DataFrame", ":", "Get", "a", "dataframe", "of", "PDB", "BLAST", "results" ]

[ "def", "_get_merged_params_string", "(", "self", ")", ":", "params_temp", "=", "{", "}", "for", "p", "in", "self", ".", "processes", ":", "logger", ".", "debug", "(", "\"[{}] Adding parameters: {}\"", ".", "format", "(", "p", ".", "template", ",", "p", ".", "params", ")", ")", "for", "param", ",", "val", "in", "p", ".", "params", ".", "items", "(", ")", ":", "params_temp", "[", "param", "]", "=", "val", "[", "\"default\"", "]", "config_str", "=", "\"\\n\\t\"", "+", "\"\\n\\t\"", ".", "join", "(", "[", "\"{} = {}\"", ".", "format", "(", "param", ",", "val", ")", "for", "param", ",", "val", "in", "params_temp", ".", "items", "(", ")", "]", ")", "return", "config_str" ]

[ "Returns", "the", "merged", "nextflow", "params", "string", "from", "a", "dictionary", "object", "." ]

[ "def", "list_roles_for_user", "(", "self", ",", "user", ")", ":", "user_id", "=", "utils", ".", "get_id", "(", "user", ")", "uri", "=", "\"users/%s/roles\"", "%", "user_id", "resp", ",", "resp_body", "=", "self", ".", "method_get", "(", "uri", ")", "if", "resp", ".", "status_code", "in", "(", "401", ",", "403", ")", ":", "raise", "exc", ".", "AuthorizationFailure", "(", "\"You are not authorized to list \"", "\"user roles.\"", ")", "roles", "=", "resp_body", ".", "get", "(", "\"roles\"", ")", "return", "roles" ]

[ "ADMIN", "ONLY", ".", "Returns", "a", "list", "of", "roles", "for", "the", "specified", "user", ".", "Each", "role", "will", "be", "a", "3", "-", "tuple", "consisting", "of", "(", "role_id", "role_name", "role_description", ")", "." ]