Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "count_by_state_unsynced", "(", "self", ",", "arg", ")", ":", "if", "self", ".", "kill_timeout", "is", "not", "None", ":", "self", ".", "delete_running", "(", "self", ".", "kill_timeout", ")", "return", "super", "(", "CMongoTrials", ",", "self", ")", ".", "count_by_state_unsynced", "(", "arg", ")" ]

[ "Extends", "the", "original", "object", "in", "order", "to", "inject", "checking", "for", "stalled", "jobs", "and", "killing", "them", "if", "they", "are", "running", "for", "too", "long" ]

[ "def", "material_formula", "(", "self", ")", ":", "try", ":", "form", "=", "self", ".", "header", ".", "formula", "except", "IndexError", ":", "form", "=", "'No formula provided'", "return", "\"\"", ".", "join", "(", "map", "(", "str", ",", "form", ")", ")" ]

[ "Returns", "chemical", "formula", "of", "material", "from", "feff", ".", "inp", "file" ]

[ "def", "energy_prof", "(", "step", ")", ":", "diff", ",", "rad", "=", "diffs_prof", "(", "step", ")", "adv", ",", "_", "=", "advts_prof", "(", "step", ")", "return", "(", "diff", "+", "np", ".", "append", "(", "adv", ",", "0", ")", ")", ",", "rad" ]

[ "Energy", "flux", "." ]

[ "def", "new_message", "(", "cls", ",", "from_user", ",", "to_users", ",", "subject", ",", "content", ")", ":", "thread", "=", "Thread", ".", "objects", ".", "create", "(", "subject", "=", "subject", ")", "for", "user", "in", "to_users", ":", "thread", ".", "userthread_set", ".", "create", "(", "user", "=", "user", ",", "deleted", "=", "False", ",", "unread", "=", "True", ")", "thread", ".", "userthread_set", ".", "create", "(", "user", "=", "from_user", ",", "deleted", "=", "True", ",", "unread", "=", "False", ")", "msg", "=", "cls", ".", "objects", ".", "create", "(", "thread", "=", "thread", ",", "sender", "=", "from_user", ",", "content", "=", "content", ")", "message_sent", ".", "send", "(", "sender", "=", "cls", ",", "message", "=", "msg", ",", "thread", "=", "thread", ",", "reply", "=", "False", ")", "return", "msg" ]

[ "Create", "a", "new", "Message", "and", "Thread", "." ]

[ "def", "is_email", "(", ")", ":", "email", "=", "(", "ur'(?!^\\.)'", "# No dot at start", "ur'(?!.*\\.@)'", "# No dot before at sign", "ur'(?!.*@\\.)'", "# No dot after at sign", "ur'(?!.*\\.$)'", "# No dot at the end", "ur'(?!.*\\.\\.)'", "# No double dots anywhere", "ur'^\\S+'", "# Starts with one or more non-whitespace characters", "ur'@'", "# Contains an at sign", "ur'\\S+$'", "# Ends with one or more non-whitespace characters", ")", "regex", "=", "re", ".", "compile", "(", "email", ",", "re", ".", "IGNORECASE", "|", "re", ".", "UNICODE", ")", "def", "validate", "(", "value", ")", ":", "if", "not", "regex", ".", "match", "(", "value", ")", ":", "return", "e", "(", "\"{} is not a valid email address\"", ",", "value", ")", "return", "validate" ]

[ "Validates", "that", "a", "fields", "value", "is", "a", "valid", "email", "address", "." ]

[ "def", "draw", "(", "molecule", ",", "TraversalType", "=", "SmilesTraversal", ")", ":", "result", "=", "[", "]", "atoms", "=", "allAtoms", "=", "molecule", ".", "atoms", "visitedAtoms", "=", "{", "}", "#", "# Traverse all components of the graph to form", "# the output string", "while", "atoms", ":", "atom", "=", "_get_lowest_symorder", "(", "atoms", ")", "visitedAtoms", "[", "atom", "]", "=", "1", "visitedBonds", "=", "{", "}", "nextTraverse", "=", "TraversalType", "(", ")", "atomsUsed", ",", "bondsUsed", "=", "[", "]", ",", "[", "]", "_traverse", "(", "atom", ",", "nextTraverse", ",", "None", ",", "visitedAtoms", ",", "visitedBonds", ",", "atomsUsed", ",", "bondsUsed", ",", "TraversalType", ")", "atoms", "=", "[", "]", "for", "atom", "in", "allAtoms", ":", "if", "not", "visitedAtoms", ".", "has_key", "(", "atom", ")", ":", "atoms", ".", "append", "(", "atom", ")", "assert", "nextTraverse", ".", "atoms", "==", "atomsUsed", "assert", "nextTraverse", ".", "bonds", "==", "bondsUsed", ",", "\"%s %s\"", "%", "(", "nextTraverse", ".", "bonds", ",", "bondsUsed", ")", "result", ".", "append", "(", "(", "str", "(", "nextTraverse", ")", ",", "atomsUsed", ",", "bondsUsed", ")", ")", "result", ".", "sort", "(", ")", "fragments", "=", "[", "]", "for", "r", "in", "result", ":", "fragments", ".", "append", "(", "r", "[", "0", "]", ")", "return", "\".\"", ".", "join", "(", "fragments", ")", ",", "result" ]

[ "(", "molecule", ")", "-", ">", "canonical", "representation", "of", "a", "molecule", "Well", "it", "s", "only", "canonical", "if", "the", "atom", "symorders", "are", "canonical", "otherwise", "it", "s", "arbitrary", "." ]

[ "def", "serialize_checks", "(", "check_set", ")", ":", "check_set_list", "=", "[", "]", "for", "check", "in", "check_set", ".", "all", "(", ")", "[", ":", "25", "]", ":", "check_set_list", ".", "append", "(", "{", "'datetime'", ":", "check", ".", "checked_datetime", ".", "isoformat", "(", ")", ",", "'value'", ":", "check", ".", "response_time", ",", "'success'", ":", "1", "if", "check", ".", "success", "else", "0", "}", ")", "return", "check_set_list" ]

[ "Serialize", "a", "check_set", "for", "raphael" ]

[ "def", "get_policy_events_id_range", "(", "self", ",", "id", ",", "from_sec", ",", "to_sec", ",", "sampling", "=", "None", ",", "aggregations", "=", "None", ",", "scope_filter", "=", "None", ",", "event_filter", "=", "None", ")", ":", "options", "=", "{", "\"id\"", ":", "id", ",", "\"from\"", ":", "int", "(", "from_sec", ")", "*", "1000000", ",", "\"to\"", ":", "int", "(", "to_sec", ")", "*", "1000000", ",", "\"offset\"", ":", "0", ",", "\"limit\"", ":", "1000", ",", "\"sampling\"", ":", "sampling", ",", "\"aggregations\"", ":", "aggregations", ",", "\"scopeFilter\"", ":", "scope_filter", ",", "\"eventFilter\"", ":", "event_filter", "}", "ctx", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "options", ".", "items", "(", ")", "if", "v", "is", "not", "None", "}", "return", "self", ".", "_get_policy_events_int", "(", "ctx", ")" ]

[ "**", "Description", "**", "Fetch", "all", "policy", "events", "with", "id", "that", "occurred", "in", "the", "time", "range", "[", "from_sec", ":", "to_sec", "]", ".", "This", "method", "is", "used", "in", "conjunction", "with", ":", "func", ":", "~sdcclient", ".", "SdSecureClient", ".", "get_more_policy_events", "to", "provide", "paginated", "access", "to", "policy", "events", "." ]

[ "def", "stdio", "(", "filters", "=", "None", ",", "search_dirs", "=", "None", ",", "data_dir", "=", "True", ",", "sys_path", "=", "True", ",", "panfl_", "=", "False", ",", "input_stream", "=", "None", ",", "output_stream", "=", "None", ")", ":", "doc", "=", "load", "(", "input_stream", ")", "# meta = doc.metadata # Local variable 'meta' value is not used", "verbose", "=", "doc", ".", "get_metadata", "(", "'panflute-verbose'", ",", "False", ")", "if", "search_dirs", "is", "None", ":", "# metadata 'panflute-path' can be a list, a string, or missing", "# `search_dirs` should be a list of str", "search_dirs", "=", "doc", ".", "get_metadata", "(", "'panflute-path'", ",", "[", "]", ")", "if", "type", "(", "search_dirs", ")", "!=", "list", ":", "search_dirs", "=", "[", "search_dirs", "]", "if", "'--data-dir'", "in", "search_dirs", ":", "data_dir", "=", "True", "if", "'--no-sys-path'", "in", "search_dirs", ":", "sys_path", "=", "False", "search_dirs", "=", "[", "dir_", "for", "dir_", "in", "search_dirs", "if", "dir_", "not", "in", "(", "'--data-dir'", ",", "'--no-sys-path'", ")", "]", "if", "verbose", ":", "debug", "(", "'panflute: data_dir={} sys_path={}'", ".", "format", "(", "data_dir", ",", "sys_path", ")", ")", "search_dirs", "=", "[", "p", ".", "normpath", "(", "p", ".", "expanduser", "(", "p", ".", "expandvars", "(", "dir_", ")", ")", ")", "for", "dir_", "in", "search_dirs", "]", "if", "not", "panfl_", ":", "# default panflute behaviour:", "search_dirs", ".", "append", "(", "'.'", ")", "if", "data_dir", ":", "search_dirs", ".", "append", "(", "get_filter_dir", "(", ")", ")", "if", "sys_path", ":", "search_dirs", "+=", "sys", ".", "path", "else", ":", "# panfl/pandoctools behaviour:", "if", "data_dir", ":", "search_dirs", ".", "append", "(", "get_filter_dir", "(", ")", ")", "if", "sys_path", ":", "search_dirs", "+=", "reduced_sys_path", "# Display message (tests that everything is working ok)", "msg", "=", "doc", ".", "get_metadata", "(", "'panflute-echo'", ",", "False", ")", "if", "msg", ":", "debug", "(", "msg", ")", "if", "filters", "is", "None", ":", "# metadata 'panflute-filters' can be a list, a string, or missing", "# `filters` should be a list of str", "filters", "=", "doc", ".", "get_metadata", "(", "'panflute-filters'", ",", "[", "]", ")", "if", "type", "(", "filters", ")", "!=", "list", ":", "filters", "=", "[", "filters", "]", "if", "filters", ":", "if", "verbose", ":", "msg", "=", "\"panflute: will run the following filters:\"", "debug", "(", "msg", ",", "' '", ".", "join", "(", "filters", ")", ")", "doc", "=", "autorun_filters", "(", "filters", ",", "doc", ",", "search_dirs", ",", "verbose", ")", "elif", "verbose", ":", "debug", "(", "\"panflute: no filters were provided\"", ")", "dump", "(", "doc", ",", "output_stream", ")" ]

[ "Reads", "JSON", "from", "stdin", "and", "second", "CLI", "argument", ":", "sys", ".", "argv", "[", "1", "]", ".", "Dumps", "JSON", "doc", "to", "the", "stdout", "." ]

[ "def", "safe_unicode", "(", "self", ",", "buf", ")", ":", "tmp", "=", "\"\"", "buf", "=", "\"\"", ".", "join", "(", "b", "for", "b", "in", "buf", ")", "for", "character", "in", "buf", ":", "tmp", "+=", "character", "return", "tmp" ]

[ "Safely", "return", "an", "unicode", "encoded", "string" ]

[ "def", "rename", "(", "self", ",", "name", ")", ":", "self", ".", "ec2", ".", "create_tags", "(", "Resources", "=", "[", "self", ".", "instance_id", "]", ",", "Tags", "=", "[", "{", "'Key'", ":", "'Name'", ",", "'Value'", ":", "name", "}", "]", ")", "self", ".", "refresh_info", "(", ")" ]

[ "Set", "the", "name", "of", "the", "machine", "." ]

[ "def", "print_there", "(", "x", ",", "y", ",", "text", ")", ":", "sys", ".", "stdout", ".", "write", "(", "\"\\x1b7\\x1b[%d;%df%s\\x1b8\"", "%", "(", "x", ",", "y", ",", "text", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")" ]

[ "allows", "display", "of", "a", "game", "of", "life", "on", "a", "console", "via", "resetting", "cursor", "position", "to", "a", "set", "point", "-", "looks", "ok", "for", "testing", "but", "not", "production", "quality", "." ]

[ "async", "def", "left", "(", "self", ")", ":", "await", "self", ".", "_send_commands", "(", "self", ".", "_move", "(", "'Down'", ",", "0", ",", "75", ",", "100", ")", ",", "self", ".", "_move", "(", "'Move'", ",", "1", ",", "70", ",", "100", ")", ",", "self", ".", "_move", "(", "'Move'", ",", "3", ",", "65", ",", "100", ")", ",", "self", ".", "_move", "(", "'Move'", ",", "4", ",", "60", ",", "100", ")", ",", "self", ".", "_move", "(", "'Move'", ",", "5", ",", "55", ",", "100", ")", ",", "self", ".", "_move", "(", "'Move'", ",", "6", ",", "50", ",", "100", ")", ",", "self", ".", "_move", "(", "'Up'", ",", "7", ",", "50", ",", "100", ")", ")" ]

[ "Press", "key", "left", "." ]

[ "def", "line_protocol", "(", "name", ",", "tags", ":", "dict", "=", "None", ",", "fields", ":", "dict", "=", "None", ",", "timestamp", ":", "float", "=", "None", ")", "->", "str", ":", "output_str", "=", "name", "if", "tags", ":", "output_str", "+=", "','", "output_str", "+=", "','", ".", "join", "(", "'%s=%s'", "%", "(", "key", ",", "value", ")", "for", "key", ",", "value", "in", "sorted", "(", "tags", ".", "items", "(", ")", ")", ")", "output_str", "+=", "' '", "output_str", "+=", "','", ".", "join", "(", "(", "'%s=%r'", "%", "(", "key", ",", "value", ")", ")", ".", "replace", "(", "\"'\"", ",", "'\"'", ")", "for", "key", ",", "value", "in", "sorted", "(", "fields", ".", "items", "(", ")", ")", ")", "if", "timestamp", "is", "not", "None", ":", "# line protocol requires nanosecond precision, python uses seconds", "output_str", "+=", "' %d'", "%", "(", "timestamp", "*", "1E9", ")", "return", "output_str", "+", "'\\n'" ]

[ "Format", "a", "report", "as", "per", "InfluxDB", "line", "protocol" ]

[ "def", "add_genstrings_comments_to_file", "(", "localization_file", ",", "genstrings_err", ")", ":", "errors_to_log", "=", "[", "line", "for", "line", "in", "genstrings_err", ".", "splitlines", "(", ")", "if", "\"used with multiple comments\"", "not", "in", "line", "]", "if", "len", "(", "errors_to_log", ")", ">", "0", ":", "logging", ".", "warning", "(", "\"genstrings warnings:\\n%s\"", ",", "\"\\n\"", ".", "join", "(", "errors_to_log", ")", ")", "loc_file", "=", "open_strings_file", "(", "localization_file", ",", "\"a\"", ")", "regex_matches", "=", "re", ".", "findall", "(", "r'Warning: Key \"(.*?)\" used with multiple comments (\"[^\"]*\" (& \"[^\"]*\")+)'", ",", "genstrings_err", ")", "logging", ".", "info", "(", "\"Adding multiple comments from genstrings output\"", ")", "for", "regex_match", "in", "regex_matches", ":", "if", "len", "(", "regex_match", ")", "==", "3", ":", "key", "=", "regex_match", "[", "0", "]", "comments", "=", "[", "comment", ".", "strip", "(", ")", "[", "1", ":", "-", "1", "]", "for", "comment", "in", "regex_match", "[", "1", "]", ".", "split", "(", "\"&\"", ")", "]", "logging", ".", "info", "(", "\"Found key with %d comments: %s\"", ",", "len", "(", "comments", ")", ",", "key", ")", "loc_key", "=", "LocalizationEntry", "(", "comments", ",", "key", ",", "key", ")", "loc_file", ".", "write", "(", "unicode", "(", "loc_key", ")", ")", "loc_file", ".", "write", "(", "u\"\\n\"", ")", "loc_file", ".", "close", "(", ")" ]

[ "Adds", "the", "comments", "produced", "by", "the", "genstrings", "script", "for", "duplicate", "keys", "." ]

[ "def", "security_layer", "(", "tls_provider", ",", "sasl_providers", ")", ":", "sasl_providers", "=", "tuple", "(", "sasl_providers", ")", "if", "not", "sasl_providers", ":", "raise", "ValueError", "(", "\"At least one SASL provider must be given.\"", ")", "for", "sasl_provider", "in", "sasl_providers", ":", "sasl_provider", ".", "execute", "# check that sasl_provider has execute method", "result", "=", "SecurityLayer", "(", "tls_provider", ".", "ssl_context_factory", ",", "tls_provider", ".", "certificate_verifier_factory", ",", "tls_provider", ".", "tls_required", ",", "sasl_providers", ")", "return", "result" ]

[ "..", "deprecated", "::", "0", ".", "6" ]

[ "def", "name", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'digest_name'", ")", ":", "self", ".", "digest_name", "=", "Oid", "(", "libcrypto", ".", "EVP_MD_type", "(", "self", ".", "digest", ")", ")", ".", "longname", "(", ")", "return", "self", ".", "digest_name" ]

[ "Returns", "name", "of", "the", "digest" ]

[ "def", "subpackets", "(", "*", "items", ")", ":", "prefixed", "=", "[", "subpacket_prefix_len", "(", "item", ")", "for", "item", "in", "items", "]", "return", "util", ".", "prefix_len", "(", "'>H'", ",", "b''", ".", "join", "(", "prefixed", ")", ")" ]

[ "Serialize", "several", "GPG", "subpackets", "." ]

[ "def", "create", "(", "server", ",", "name", ",", "project", ",", "apikey", ",", "output", ",", "threshold", ",", "verbose", ")", ":", "if", "verbose", ":", "log", "(", "\"Entity Matching Server: {}\"", ".", "format", "(", "server", ")", ")", "if", "threshold", "is", "None", ":", "raise", "ValueError", "(", "\"Please provide a threshold\"", ")", "# Create a new run", "try", ":", "response", "=", "run_create", "(", "server", ",", "project", ",", "apikey", ",", "threshold", ",", "name", ")", "except", "ServiceError", "as", "e", ":", "log", "(", "\"Unexpected response with status {}\"", ".", "format", "(", "e", ".", "status_code", ")", ")", "log", "(", "e", ".", "text", ")", "else", ":", "json", ".", "dump", "(", "response", ",", "output", ")" ]

[ "Create", "a", "new", "run", "on", "an", "entity", "matching", "server", "." ]

[ "def", "transform", "(", "self", ",", "y", ",", "exogenous", "=", "None", ",", "n_periods", "=", "0", ",", "*", "*", "_", ")", ":", "check_is_fitted", "(", "self", ",", "\"p_\"", ")", "_", ",", "exog", "=", "self", ".", "_check_y_exog", "(", "y", ",", "exogenous", ",", "null_allowed", "=", "True", ")", "if", "n_periods", "and", "exog", "is", "not", "None", ":", "if", "n_periods", "!=", "exog", ".", "shape", "[", "0", "]", ":", "raise", "ValueError", "(", "\"If n_periods and exog are specified, \"", "\"n_periods must match dims of exogenous\"", ")", "times", "=", "np", ".", "arange", "(", "self", ".", "n_", "+", "n_periods", ",", "dtype", "=", "np", ".", "float64", ")", "+", "1", "X_fourier", "=", "_fourier_terms", "(", "self", ".", "p_", ",", "times", ")", "# Maybe trim if we're in predict mode... in that case, we only keep the", "# last n_periods rows in the matrix we've created", "if", "n_periods", ":", "X_fourier", "=", "X_fourier", "[", "-", "n_periods", ":", ",", ":", "]", "if", "exog", "is", "None", ":", "exog", "=", "X_fourier", "else", ":", "exog", "=", "np", ".", "hstack", "(", "[", "exog", ",", "X_fourier", "]", ")", "return", "y", ",", "exog" ]

[ "Create", "Fourier", "term", "features" ]

[ "def", "AddKeywordsForName", "(", "self", ",", "name", ",", "keywords", ")", ":", "data_store", ".", "DB", ".", "IndexAddKeywordsForName", "(", "self", ".", "urn", ",", "name", ",", "keywords", ")" ]

[ "Associates", "keywords", "with", "name", "." ]

[ "def", "_middleware_call", "(", "self", ",", "middlewares", ":", "Iterator", "[", "MIDDLEWARE_TYPE", "]", ",", "ctx", ":", "Context", ",", "next_call", ":", "NEXT_CALL_TYPE", ",", ")", "->", "TypeGenerator", "[", "Any", ",", "None", ",", "None", "]", ":", "middleware", "=", "None", "try", ":", "middleware", "=", "next", "(", "middlewares", ")", "except", "StopIteration", ":", "return", "# next_call = self._next_middleware(middlewares, ctx)", "if", "asyncio", ".", "iscoroutinefunction", "(", "middleware", ")", ":", "temp", "=", "cast", "(", "Any", ",", "middleware", "(", "ctx", ",", "next_call", ")", ")", "body", "=", "yield", "from", "temp", "else", ":", "body", "=", "middleware", "(", "ctx", ",", "next_call", ")", "if", "body", "is", "not", "None", ":", "if", "isinstance", "(", "body", ",", "Generator", ")", ":", "gen_obj", "=", "body", "body", "=", "None", "# 处理同步方法使用 yield 来调用异步", "while", "True", ":", "try", ":", "gen", "=", "next", "(", "gen_obj", ")", "temp", "=", "yield", "from", "handle_async_gen", "(", "gen", ",", "gen_obj", ")", "except", "StopIteration", ":", "break", "if", "temp", "is", "not", "None", ":", "body", "=", "temp", "# elif asyncio.iscoroutine(body):", "# # 处理中间件返回了一个 coroutine 对象需要 await", "# try:", "# body = yield from body", "# except Exception:", "# pass", "if", "isinstance", "(", "body", ",", "tuple", ")", ":", "flag", "=", "True", "for", "item", "in", "body", ":", "if", "flag", ":", "ctx", ".", "response", ".", "body", "=", "item", "flag", "=", "False", "elif", "isinstance", "(", "item", ",", "int", ")", ":", "ctx", ".", "response", ".", "status", "=", "item", "elif", "isinstance", "(", "item", ",", "dict", ")", ":", "ctx", ".", "response", ".", "headers", ".", "update", "(", "item", ")", "# 中间件返回的结果如果不为空设置到 body", "elif", "body", "is", "not", "None", ":", "ctx", ".", "response", ".", "body", "=", "body" ]

[ "从迭代器中取出一个中间件，执行" ]

[ "def", "get_roles", "(", "client", ")", ":", "done", "=", "False", "marker", "=", "None", "roles", "=", "[", "]", "while", "not", "done", ":", "if", "marker", ":", "response", "=", "client", ".", "list_roles", "(", "Marker", "=", "marker", ")", "else", ":", "response", "=", "client", ".", "list_roles", "(", ")", "roles", "+=", "response", "[", "'Roles'", "]", "if", "response", "[", "'IsTruncated'", "]", ":", "marker", "=", "response", "[", "'Marker'", "]", "else", ":", "done", "=", "True", "return", "roles" ]

[ "Returns", "a", "list", "of", "all", "the", "roles", "for", "an", "account", ".", "Returns", "a", "list", "containing", "all", "the", "roles", "for", "the", "account", "." ]

[ "def", "add_size_info", "(", "self", ")", ":", "maxbytes", "=", "self", ".", "aggregate", ".", "config", "[", "\"maxfilesizedownload\"", "]", "if", "self", ".", "size", ">", "maxbytes", ":", "self", ".", "add_warning", "(", "_", "(", "\"Content size %(size)s is larger than %(maxbytes)s.\"", ")", "%", "dict", "(", "size", "=", "strformat", ".", "strsize", "(", "self", ".", "size", ")", ",", "maxbytes", "=", "strformat", ".", "strsize", "(", "maxbytes", ")", ")", ",", "tag", "=", "WARN_URL_CONTENT_SIZE_TOO_LARGE", ")" ]

[ "Set", "size", "of", "URL", "content", "(", "if", "any", ")", "..", "Should", "be", "overridden", "in", "subclasses", "." ]

[ "def", "_connect", "(", "self", ")", ":", "# ensure only one thread runs the authentication process, if needed", "with", "GoogleCloudProvider", ".", "__gce_lock", ":", "# check for existing connection", "if", "not", "self", ".", "_gce", ":", "version", "=", "pkg_resources", ".", "get_distribution", "(", "\"elasticluster\"", ")", ".", "version", "http", "=", "googleapiclient", ".", "http", ".", "set_user_agent", "(", "httplib2", ".", "Http", "(", ")", ",", "\"elasticluster/%s\"", "%", "version", ")", "credentials", "=", "self", ".", "_get_credentials", "(", ")", "self", ".", "_auth_http", "=", "credentials", ".", "authorize", "(", "http", ")", "self", ".", "_gce", "=", "build", "(", "GCE_API_NAME", ",", "GCE_API_VERSION", ",", "http", "=", "http", ")", "return", "self", ".", "_gce" ]

[ "Connects", "to", "the", "cloud", "web", "services", ".", "If", "this", "is", "the", "first", "authentication", "a", "web", "browser", "will", "be", "started", "to", "authenticate", "against", "google", "and", "provide", "access", "to", "elasticluster", "." ]

[ "def", "_state_error", "(", "self", ",", "reason", ")", ":", "log", ".", "err", "(", "reason", ")", "def", "matchException", "(", "failure", ")", ":", "for", "errorState", ",", "backOff", "in", "self", ".", "backOffs", ".", "iteritems", "(", ")", ":", "if", "'errorTypes'", "not", "in", "backOff", ":", "continue", "if", "failure", ".", "check", "(", "*", "backOff", "[", "'errorTypes'", "]", ")", ":", "return", "errorState", "return", "'other'", "errorState", "=", "matchException", "(", "reason", ")", "self", ".", "_reconnect", "(", "errorState", ")" ]

[ "The", "connection", "attempt", "resulted", "in", "an", "error", "." ]

[ "def", "collect_results", "(", "working_folder", ")", ":", "results", "=", "{", "}", "working_folder", "=", "Path", "(", "working_folder", ")", "output_folders", "=", "working_folder", "/", "'output_folders'", "for", "rec_name", "in", "os", ".", "listdir", "(", "output_folders", ")", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "output_folders", "/", "rec_name", ")", ":", "continue", "# print(rec_name)", "results", "[", "rec_name", "]", "=", "{", "}", "for", "sorter_name", "in", "os", ".", "listdir", "(", "output_folders", "/", "rec_name", ")", ":", "# print(' ', sorter_name)", "output_folder", "=", "output_folders", "/", "rec_name", "/", "sorter_name", "#~ print(output_folder)", "if", "not", "os", ".", "path", ".", "isdir", "(", "output_folder", ")", ":", "continue", "SorterClass", "=", "sorter_dict", "[", "sorter_name", "]", "results", "[", "rec_name", "]", "[", "sorter_name", "]", "=", "SorterClass", ".", "get_result_from_folder", "(", "output_folder", ")", "return", "results" ]

[ "Collect", "results", "in", "a", "working_folder", "." ]

[ "def", "main", "(", ")", ":", "argparser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "'Blockstack-file version {}'", ".", "format", "(", "__version__", ")", ")", "subparsers", "=", "argparser", ".", "add_subparsers", "(", "dest", "=", "'action'", ",", "help", "=", "'The file command to take [get/put/delete]'", ")", "parser", "=", "subparsers", ".", "add_parser", "(", "'init'", ",", "help", "=", "'Initialize this host to start sending and receiving files'", ")", "parser", ".", "add_argument", "(", "'--config'", ",", "action", "=", "'store'", ",", "help", "=", "'path to the config file to use (default is %s)'", "%", "CONFIG_PATH", ")", "parser", ".", "add_argument", "(", "'--blockchain_id'", ",", "action", "=", "'store'", ",", "help", "=", "'the recipient blockchain ID to use'", ")", ",", "parser", ".", "add_argument", "(", "'--hostname'", ",", "action", "=", "'store'", ",", "help", "=", "'the recipient hostname to use'", ")", "parser", "=", "subparsers", ".", "add_parser", "(", "'reset'", ",", "help", "=", "'Reset this host\\'s key'", ")", "parser", ".", "add_argument", "(", "'--config'", ",", "action", "=", "'store'", ",", "help", "=", "'path to the config file to use (default is %s)'", "%", "CONFIG_PATH", ")", "parser", ".", "add_argument", "(", "'--blockchain_id'", ",", "action", "=", "'store'", ",", "help", "=", "'the recipient blockchain ID to use'", ")", ",", "parser", ".", "add_argument", "(", "'--hostname'", ",", "action", "=", "'store'", ",", "help", "=", "'the recipient hostname to use'", ")", "parser", "=", "subparsers", ".", "add_parser", "(", "'get'", ",", "help", "=", "'Get a file'", ")", "parser", ".", "add_argument", "(", "'--config'", ",", "action", "=", "'store'", ",", "help", "=", "'path to the config file to use (default is %s)'", "%", "CONFIG_PATH", ")", "parser", ".", "add_argument", "(", "'--blockchain_id'", ",", "action", "=", "'store'", ",", "help", "=", "'the recipient blockchain ID to use'", ")", ",", "parser", ".", "add_argument", "(", "'--hostname'", ",", "action", "=", "'store'", ",", "help", "=", "'the recipient hostname to use'", ")", "parser", ".", "add_argument", "(", "'--passphrase'", ",", "action", "=", "'store'", ",", "help", "=", "'decryption passphrase'", ")", "parser", ".", "add_argument", "(", "'--wallet'", ",", "action", "=", "'store'", ",", "help", "=", "'path to your Blockstack wallet'", ")", "parser", ".", "add_argument", "(", "'sender_blockchain_id'", ",", "action", "=", "'store'", ",", "help", "=", "'the sender\\'s blockchain ID'", ")", "parser", ".", "add_argument", "(", "'data_name'", ",", "action", "=", "'store'", ",", "help", "=", "'Public name of the file to fetch'", ")", "parser", ".", "add_argument", "(", "'output_path'", ",", "action", "=", "'store'", ",", "nargs", "=", "'?'", ",", "help", "=", "'[optional] destination path to save the file; defaults to stdout'", ")", "parser", "=", "subparsers", ".", "add_parser", "(", "'put'", ",", "help", "=", "'Share a file'", ")", "parser", ".", "add_argument", "(", "'--config'", ",", "action", "=", "'store'", ",", "help", "=", "'path to the config file to use (default is %s)'", "%", "CONFIG_PATH", ")", "parser", ".", "add_argument", "(", "'--blockchain_id'", ",", "action", "=", "'store'", ",", "help", "=", "'the sender blockchain ID to use'", ")", ",", "parser", ".", "add_argument", "(", "'--hostname'", ",", "action", "=", "'store'", ",", "help", "=", "'the sender hostname to use'", ")", "parser", ".", "add_argument", "(", "'--passphrase'", ",", "action", "=", "'store'", ",", "help", "=", "'encryption passphrase'", ")", "parser", ".", "add_argument", "(", "'--wallet'", ",", "action", "=", "'store'", ",", "help", "=", "'path to your Blockstack wallet'", ")", "parser", ".", "add_argument", "(", "'input_path'", ",", "action", "=", "'store'", ",", "help", "=", "'Path to the file to share'", ")", "parser", ".", "add_argument", "(", "'data_name'", ",", "action", "=", "'store'", ",", "help", "=", "'Public name of the file to store'", ")", "# recipients come afterwards", "parser", "=", "subparsers", ".", "add_parser", "(", "'delete'", ",", "help", "=", "'Delete a shared file'", ")", "parser", ".", "add_argument", "(", "'--config'", ",", "action", "=", "'store'", ",", "help", "=", "'path to the config file to use (default is %s)'", "%", "CONFIG_PATH", ")", "parser", ".", "add_argument", "(", "'--blockchain_id'", ",", "action", "=", "'store'", ",", "help", "=", "'the sender blockchain ID to use'", ")", ",", "parser", ".", "add_argument", "(", "'--hostname'", ",", "action", "=", "'store'", ",", "help", "=", "'the sender hostname to use'", ")", "parser", ".", "add_argument", "(", "'--wallet'", ",", "action", "=", "'store'", ",", "help", "=", "'path to your Blockstack wallet'", ")", "parser", ".", "add_argument", "(", "'data_name'", ",", "action", "=", "'store'", ",", "help", "=", "'Public name of the file to delete'", ")", "args", ",", "unparsed", "=", "argparser", ".", "parse_known_args", "(", ")", "# load up config", "config_path", "=", "args", ".", "config", "if", "config_path", "is", "None", ":", "config_path", "=", "CONFIG_PATH", "conf", "=", "get_config", "(", "config_path", ")", "config_dir", "=", "os", ".", "path", ".", "dirname", "(", "config_path", ")", "blockchain_id", "=", "getattr", "(", "args", ",", "\"blockchain_id\"", ",", "None", ")", "hostname", "=", "getattr", "(", "args", ",", "\"hostname\"", ",", "None", ")", "passphrase", "=", "getattr", "(", "args", ",", "\"passphrase\"", ",", "None", ")", "data_name", "=", "getattr", "(", "args", ",", "\"data_name\"", ",", "None", ")", "wallet_path", "=", "getattr", "(", "args", ",", "\"wallet\"", ",", "None", ")", "if", "blockchain_id", "is", "None", ":", "blockchain_id", "=", "conf", "[", "'blockchain_id'", "]", "if", "hostname", "is", "None", ":", "hostname", "=", "conf", "[", "'hostname'", "]", "if", "wallet_path", "is", "None", ":", "wallet_path", "=", "conf", "[", "'wallet'", "]", "if", "wallet_path", "is", "None", "and", "config_dir", "is", "not", "None", ":", "wallet_path", "=", "os", ".", "path", ".", "join", "(", "config_dir", ",", "blockstack_client", ".", "config", ".", "WALLET_FILENAME", ")", "# load wallet ", "if", "wallet_path", "is", "not", "None", "and", "os", ".", "path", ".", "exists", "(", "wallet_path", ")", ":", "# load from disk", "log", ".", "debug", "(", "\"Load wallet from %s\"", "%", "wallet_path", ")", "wallet", "=", "blockstack_client", ".", "load_wallet", "(", "config_dir", "=", "config_dir", ",", "wallet_path", "=", "wallet_path", ",", "include_private", "=", "True", ")", "if", "'error'", "in", "wallet", ":", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "wallet", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "1", ")", "else", ":", "wallet", "=", "wallet", "[", "'wallet'", "]", "else", ":", "# load from RPC", "log", ".", "debug", "(", "\"Load wallet from RPC\"", ")", "wallet", "=", "blockstack_client", ".", "dump_wallet", "(", "config_path", "=", "config_path", ")", "if", "'error'", "in", "wallet", ":", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "wallet", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "1", ")", "log", ".", "debug", "(", "\"Process %s\"", "%", "args", ".", "action", ")", "if", "args", ".", "action", "in", "[", "'init'", ",", "'reset'", "]", ":", "# (re)key", "res", "=", "file_key_regenerate", "(", "blockchain_id", ",", "hostname", ",", "config_path", "=", "config_path", ",", "wallet_keys", "=", "wallet", ")", "if", "'error'", "in", "res", ":", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "res", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "1", ")", "if", "args", ".", "action", "==", "'get'", ":", "# get a file", "sender_blockchain_id", "=", "args", ".", "sender_blockchain_id", "output_path", "=", "args", ".", "output_path", "tmp", "=", "False", "if", "output_path", "is", "None", ":", "fd", ",", "path", "=", "tempfile", ".", "mkstemp", "(", "prefix", "=", "'blockstack-file-'", ",", "dir", "=", "config_dir", ")", "os", ".", "close", "(", "fd", ")", "output_path", "=", "path", "tmp", "=", "True", "res", "=", "file_get", "(", "blockchain_id", ",", "hostname", ",", "sender_blockchain_id", ",", "data_name", ",", "output_path", ",", "passphrase", "=", "passphrase", ",", "config_path", "=", "config_path", ",", "wallet_keys", "=", "wallet", ")", "if", "'error'", "in", "res", ":", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "res", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "1", ")", "if", "tmp", ":", "# print to stdout ", "with", "open", "(", "output_path", ",", "\"r\"", ")", "as", "f", ":", "while", "True", ":", "buf", "=", "f", ".", "read", "(", "65536", ")", "if", "len", "(", "buf", ")", "==", "0", ":", "break", "sys", ".", "stdout", ".", "write", "(", "buf", ")", "os", ".", "unlink", "(", "output_path", ")", "elif", "args", ".", "action", "==", "'put'", ":", "# put a file", "recipients", "=", "unparsed", "input_path", "=", "args", ".", "input_path", "res", "=", "file_put", "(", "blockchain_id", ",", "hostname", ",", "recipients", ",", "data_name", ",", "input_path", ",", "passphrase", "=", "passphrase", ",", "config_path", "=", "config_path", ",", "wallet_keys", "=", "wallet", ")", "if", "'error'", "in", "res", ":", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "res", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "1", ")", "elif", "args", ".", "action", "==", "'delete'", ":", "# delete a file", "res", "=", "file_delete", "(", "blockchain_id", ",", "data_name", ",", "config_path", "=", "config_path", ",", "wallet_keys", "=", "wallet", ")", "if", "'error'", "in", "res", ":", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "res", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "1", ")", "print", ">>", "sys", ".", "stderr", ",", "json", ".", "dumps", "(", "{", "'status'", ":", "True", "}", ",", "sort_keys", "=", "True", ",", "indent", "=", "4", ")", "sys", ".", "exit", "(", "0", ")" ]

[ "Entry", "point", "for", "the", "CLI", "interface" ]

[ "def", "_dict_to_tuple", "(", "d", ")", ":", "# TODO: Adding a ms field to struct_time tuples is problematic ", "# since they don't have this field. Should use datetime", "# which has a microseconds field, else no ms.. When mapping struct_time ", "# to gDateTime the last 3 fields are irrelevant, here using dummy values to make", "# everything happy.", "# ", "retval", "=", "_niltime", "[", ":", "]", "for", "k", ",", "i", "in", "(", "(", "'Y'", ",", "0", ")", ",", "(", "'M'", ",", "1", ")", ",", "(", "'D'", ",", "2", ")", ",", "(", "'h'", ",", "3", ")", ",", "(", "'m'", ",", "4", ")", ",", ")", ":", "v", "=", "d", ".", "get", "(", "k", ")", "if", "v", ":", "retval", "[", "i", "]", "=", "int", "(", "v", ")", "v", "=", "d", ".", "get", "(", "'s'", ")", "if", "v", ":", "msec", ",", "sec", "=", "_modf", "(", "float", "(", "v", ")", ")", "retval", "[", "6", "]", ",", "retval", "[", "5", "]", "=", "int", "(", "round", "(", "msec", "*", "1000", ")", ")", ",", "int", "(", "sec", ")", "v", "=", "d", ".", "get", "(", "'tz'", ")", "if", "v", "and", "v", "!=", "'Z'", ":", "h", ",", "m", "=", "map", "(", "int", ",", "v", ".", "split", "(", "':'", ")", ")", "# check for time zone offset, if within the same timezone, ", "# ignore offset specific calculations", "offset", "=", "_localtimezone", "(", ")", ".", "utcoffset", "(", "_datetime", ".", "now", "(", ")", ")", "local_offset_hour", "=", "offset", ".", "seconds", "/", "3600", "local_offset_min", "=", "(", "offset", ".", "seconds", "%", "3600", ")", "%", "60", "if", "local_offset_hour", ">", "12", ":", "local_offset_hour", "-=", "24", "if", "local_offset_hour", "!=", "h", "or", "local_offset_min", "!=", "m", ":", "if", "h", "<", "0", ":", "#TODO: why is this set to server", "#foff = _fixedoffset(-((abs(h)*60+m)),\"server\")", "foff", "=", "_fixedoffset", "(", "-", "(", "(", "abs", "(", "h", ")", "*", "60", "+", "m", ")", ")", ")", "else", ":", "#TODO: why is this set to server", "#foff = _fixedoffset((abs(h)*60+m),\"server\")", "foff", "=", "_fixedoffset", "(", "(", "abs", "(", "h", ")", "*", "60", "+", "m", ")", ")", "dt", "=", "_datetime", "(", "retval", "[", "0", "]", ",", "retval", "[", "1", "]", ",", "retval", "[", "2", "]", ",", "retval", "[", "3", "]", ",", "retval", "[", "4", "]", ",", "retval", "[", "5", "]", ",", "0", ",", "foff", ")", "# update dict with calculated timezone", "localdt", "=", "dt", ".", "astimezone", "(", "_localtimezone", "(", ")", ")", "retval", "[", "0", "]", "=", "localdt", ".", "year", "retval", "[", "1", "]", "=", "localdt", ".", "month", "retval", "[", "2", "]", "=", "localdt", ".", "day", "retval", "[", "3", "]", "=", "localdt", ".", "hour", "retval", "[", "4", "]", "=", "localdt", ".", "minute", "retval", "[", "5", "]", "=", "localdt", ".", "second", "if", "d", ".", "get", "(", "'neg'", ",", "0", ")", ":", "retval", "[", "0", ":", "5", "]", "=", "map", "(", "operator", ".", "__neg__", ",", "retval", "[", "0", ":", "5", "]", ")", "return", "tuple", "(", "retval", ")" ]

[ "Convert", "a", "dictionary", "to", "a", "time", "tuple", ".", "Depends", "on", "key", "values", "in", "the", "regexp", "pattern!" ]

[ "def", "next_order", "(", "self", ")", ":", "order_vals", "=", "[", "s", ".", "order", ".", "val", "for", "s", "in", "self", ".", "sers", "]", "if", "not", "order_vals", ":", "return", "0", "return", "max", "(", "order_vals", ")", "+", "1" ]

[ "Return", "the", "next", "available", "c", ":", "ser", "/", "c", ":", "order", "value", "within", "the", "scope", "of", "this", "chart", "the", "maximum", "order", "value", "found", "on", "existing", "series", "incremented", "by", "one", "." ]

[ "async", "def", "forward", "(", "self", ",", "n", ",", "*", ",", "timeout", "=", "None", ")", "->", "int", ":", "self", ".", "_check_ready", "(", ")", "if", "n", "<=", "0", ":", "raise", "exceptions", ".", "InterfaceError", "(", "'n must be greater than zero'", ")", "protocol", "=", "self", ".", "_connection", ".", "_protocol", "status", "=", "await", "protocol", ".", "query", "(", "'MOVE FORWARD {:d} {}'", ".", "format", "(", "n", ",", "self", ".", "_portal_name", ")", ",", "timeout", ")", "advanced", "=", "int", "(", "status", ".", "split", "(", ")", "[", "1", "]", ")", "if", "advanced", "<", "n", ":", "self", ".", "_exhausted", "=", "True", "return", "advanced" ]

[ "r", "Skip", "over", "the", "next", "*", "n", "*", "rows", "." ]

[ "def", "from_keras_log", "(", "csv_path", ",", "output_dir_path", ",", "*", "*", "kwargs", ")", ":", "# automatically get seperator by using Python's CSV parser", "data", "=", "pd", ".", "read_csv", "(", "csv_path", ",", "sep", "=", "None", ",", "engine", "=", "'python'", ")", "_from_keras_log_format", "(", "data", ",", "output_dir_path", "=", "output_dir_path", ",", "*", "*", "kwargs", ")" ]

[ "Plot", "accuracy", "and", "loss", "from", "a", "Keras", "CSV", "log", "." ]

[ "def", "to_yellow", "(", "self", ",", "on", ":", "bool", "=", "False", ")", ":", "self", ".", "_on", "=", "on", "if", "on", ":", "self", ".", "_load_new", "(", "led_yellow_on", ")", "if", "self", ".", "_toggle_on_click", ":", "self", ".", "_canvas", ".", "bind", "(", "'<Button-1>'", ",", "lambda", "x", ":", "self", ".", "to_yellow", "(", "False", ")", ")", "else", ":", "self", ".", "_load_new", "(", "led_yellow", ")", "if", "self", ".", "_toggle_on_click", ":", "self", ".", "_canvas", ".", "bind", "(", "'<Button-1>'", ",", "lambda", "x", ":", "self", ".", "to_yellow", "(", "True", ")", ")" ]

[ "Change", "the", "LED", "to", "yellow", "(", "on", "or", "off", ")", ":", "param", "on", ":", "True", "or", "False", ":", "return", ":", "None" ]

[ "def", "get_path_from_to", "(", "self", ",", "from_tid", ",", "to_tid", ")", ":", "shortest_subsumer", "=", "self", ".", "get_least_common_subsumer", "(", "from_tid", ",", "to_tid", ")", "#print 'From:',self.naf.get_term(from_tid).get_lemma()", "#print 'To:',self.naf.get_term(to_tid).get_lemma()", "termid_from", "=", "self", ".", "terminal_for_term", ".", "get", "(", "from_tid", ")", "termid_to", "=", "self", ".", "terminal_for_term", ".", "get", "(", "to_tid", ")", "path_from", "=", "self", ".", "paths_for_terminal", "[", "termid_from", "]", "[", "0", "]", "path_to", "=", "self", ".", "paths_for_terminal", "[", "termid_to", "]", "[", "0", "]", "if", "shortest_subsumer", "is", "None", ":", "return", "None", "complete_path", "=", "[", "]", "for", "node", "in", "path_from", ":", "complete_path", ".", "append", "(", "node", ")", "if", "node", "==", "shortest_subsumer", ":", "break", "begin", "=", "False", "for", "node", "in", "path_to", "[", "-", "1", ":", ":", "-", "1", "]", ":", "if", "begin", ":", "complete_path", ".", "append", "(", "node", ")", "if", "node", "==", "shortest_subsumer", ":", "begin", "=", "True", "labels", "=", "[", "self", ".", "label_for_nonter", "[", "nonter", "]", "for", "nonter", "in", "complete_path", "]", "return", "labels" ]

[ "This", "function", "returns", "the", "path", "(", "in", "terms", "of", "phrase", "types", ")", "from", "one", "term", "to", "another" ]

[ "def", "sequence_prep", "(", "self", ")", ":", "# Create a sorted list of all the FASTA files in the sequence path", "strains", "=", "sorted", "(", "glob", "(", "os", ".", "path", ".", "join", "(", "self", ".", "fastapath", ",", "'*.fa*'", ".", "format", "(", "self", ".", "fastapath", ")", ")", ")", ")", "for", "sample", "in", "strains", ":", "# Create the object", "metadata", "=", "MetadataObject", "(", ")", "# Set the sample name to be the file name of the sequence by removing the path and file extension", "sample_name", "=", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "sample", ")", ")", "[", "0", "]", "if", "sample_name", "in", "self", ".", "strainset", ":", "# Extract the OLNID from the dictionary using the SEQID", "samplename", "=", "self", ".", "straindict", "[", "sample_name", "]", "# samplename = sample_name", "# Set and create the output directory", "outputdir", "=", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "samplename", ")", "make_path", "(", "outputdir", ")", "# Set the name of the JSON file", "json_metadata", "=", "os", ".", "path", ".", "join", "(", "outputdir", ",", "'{name}.json'", ".", "format", "(", "name", "=", "samplename", ")", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "json_metadata", ")", ":", "# Create the name and output directory attributes", "metadata", ".", "name", "=", "samplename", "metadata", ".", "seqid", "=", "sample_name", "metadata", ".", "outputdir", "=", "outputdir", "metadata", ".", "jsonfile", "=", "json_metadata", "# Set the name of the FASTA file to use in the analyses", "metadata", ".", "bestassemblyfile", "=", "os", ".", "path", ".", "join", "(", "metadata", ".", "outputdir", ",", "'{name}.fasta'", ".", "format", "(", "name", "=", "metadata", ".", "name", ")", ")", "# Symlink the original file to the output directory", "relative_symlink", "(", "sample", ",", "outputdir", ",", "'{sn}.fasta'", ".", "format", "(", "sn", "=", "metadata", ".", "name", ")", ")", "# Associate the corresponding FASTQ files with the assembly", "metadata", ".", "fastqfiles", "=", "sorted", "(", "glob", "(", "os", ".", "path", ".", "join", "(", "self", ".", "fastqpath", ",", "'{name}*.gz'", ".", "format", "(", "name", "=", "metadata", ".", "name", ")", ")", ")", ")", "metadata", ".", "forward_fastq", ",", "metadata", ".", "reverse_fastq", "=", "metadata", ".", "fastqfiles", "# Write the object to file", "self", ".", "write_json", "(", "metadata", ")", "else", ":", "metadata", "=", "self", ".", "read_json", "(", "json_metadata", ")", "# Add the metadata object to the list of objects", "self", ".", "metadata", ".", "append", "(", "metadata", ")" ]

[ "Create", "metadata", "objects", "for", "all", "PacBio", "assembly", "FASTA", "files", "in", "the", "sequencepath", ".", "Create", "individual", "subdirectories", "for", "each", "sample", ".", "Relative", "symlink", "the", "original", "FASTA", "file", "to", "the", "appropriate", "subdirectory" ]

[ "def", "close", "(", "self", ")", ":", "if", "self", ".", "_closed", ":", "raise", "ProgrammingError", "(", "'the connection is already closed'", ")", "for", "cursor_ref", "in", "self", ".", "_cursors", ":", "cursor", "=", "cursor_ref", "(", ")", "if", "cursor", "is", "not", "None", "and", "not", "cursor", ".", "_closed", ":", "cursor", ".", "close", "(", ")", "self", ".", "_client", ".", "close_connection", "(", "self", ".", "_id", ")", "self", ".", "_client", ".", "close", "(", ")", "self", ".", "_closed", "=", "True" ]

[ "Closes", "the", "connection", ".", "No", "further", "operations", "are", "allowed", "either", "on", "the", "connection", "or", "any", "of", "its", "cursors", "once", "the", "connection", "is", "closed", "." ]

[ "def", "from_string", "(", "cls", ",", "source", ",", "distance_weights", "=", "None", ",", "merge_same_words", "=", "False", ",", "group_marker_opening", "=", "'<<'", ",", "group_marker_closing", "=", "'>>'", ")", ":", "if", "distance_weights", "is", "None", ":", "distance_weights", "=", "{", "1", ":", "1", "}", "# Convert distance_weights to a sorted list of tuples", "# To make output node list order more predictable", "sorted_weights_list", "=", "sorted", "(", "distance_weights", ".", "items", "(", ")", ",", "key", "=", "lambda", "i", ":", "i", "[", "0", "]", ")", "# regex that matches:", "# * Anything surrounded by", "# group_marker_opening and group_marker_closing,", "# * Groups of punctuation marks followed by whitespace", "# * Any continuous group of non-whitespace characters", "# followed by whitespace", "expression", "=", "r'{0}(.+){1}|([^\\w\\s]+)\\B|([\\S]+\\b)'", ".", "format", "(", "''", ".", "join", "(", "'\\\\'", "+", "c", "for", "c", "in", "group_marker_opening", ")", ",", "''", ".", "join", "(", "'\\\\'", "+", "c", "for", "c", "in", "group_marker_closing", ")", ")", "matches", "=", "re", ".", "findall", "(", "expression", ",", "source", ")", "# Un-tuple matches since we are only using groups to strip brackets", "# Is there a better way to do this?", "words", "=", "[", "next", "(", "t", "for", "t", "in", "match", "if", "t", ")", "for", "match", "in", "matches", "]", "if", "merge_same_words", ":", "# Ensure a 1:1 correspondence between words and nodes,", "# and that all links point to these nodes as well", "# Create nodes for every unique word", "temp_node_list", "=", "[", "]", "for", "word", "in", "words", ":", "if", "word", "not", "in", "(", "n", ".", "value", "for", "n", "in", "temp_node_list", ")", ":", "temp_node_list", ".", "append", "(", "Node", "(", "word", ")", ")", "# Loop through words, attaching links to nodes which correspond", "# to the current word. Ensure links also point to valid", "# corresponding nodes in the node list.", "for", "i", ",", "word", "in", "enumerate", "(", "words", ")", ":", "matching_node", "=", "next", "(", "(", "n", "for", "n", "in", "temp_node_list", "if", "n", ".", "value", "==", "word", ")", ")", "for", "key", ",", "weight", "in", "sorted_weights_list", ":", "# Wrap the index of edge items", "wrapped_index", "=", "(", "key", "+", "i", ")", "%", "len", "(", "words", ")", "target_word", "=", "words", "[", "wrapped_index", "]", "matching_target_node", "=", "next", "(", "(", "n", "for", "n", "in", "temp_node_list", "if", "n", ".", "value", "==", "target_word", ")", ")", "matching_node", ".", "add_link", "(", "matching_target_node", ",", "weight", ")", "else", ":", "# Create one node for every (not necessarily unique) word.", "temp_node_list", "=", "[", "Node", "(", "word", ")", "for", "word", "in", "words", "]", "for", "i", ",", "node", "in", "enumerate", "(", "temp_node_list", ")", ":", "for", "key", ",", "weight", "in", "sorted_weights_list", ":", "# Wrap the index of edge items", "wrapped_index", "=", "(", "key", "+", "i", ")", "%", "len", "(", "temp_node_list", ")", "node", ".", "add_link", "(", "temp_node_list", "[", "wrapped_index", "]", ",", "weight", ")", "graph", "=", "cls", "(", ")", "graph", ".", "add_nodes", "(", "temp_node_list", ")", "return", "graph" ]

[ "Read", "a", "string", "and", "derive", "of", "Graph", "from", "it", "." ]

[ "def", "keyword", "(", "self", ",", "*", "*", "kwargs", ")", ":", "path", "=", "self", ".", "_get_path", "(", "'keyword'", ")", "response", "=", "self", ".", "_GET", "(", "path", ",", "kwargs", ")", "self", ".", "_set_attrs_to_values", "(", "response", ")", "return", "response" ]

[ "Search", "for", "keywords", "by", "name", "." ]

[ "def", "put", "(", "self", ",", "file", ")", ":", "input_", "=", "{", "\"message\"", ":", "file", ".", "logs", ",", "\"author\"", ":", "file", ".", "author", ".", "dict", "(", ")", ",", "\"content\"", ":", "file", ".", "base64", ",", "\"branch\"", ":", "file", ".", "branch", "}", "uri", "=", "\"{api}/repos/{origin}/contents/{path}\"", ".", "format", "(", "api", "=", "self", ".", "github_api_url", ",", "origin", "=", "self", ".", "origin", ",", "path", "=", "file", ".", "path", ")", "data", "=", "self", ".", "request", "(", "\"PUT\"", ",", "uri", ",", "data", "=", "input_", ")", "if", "data", ".", "status_code", "==", "201", ":", "file", ".", "pushed", "=", "True", "return", "file", "else", ":", "decoded_data", "=", "json", ".", "loads", "(", "data", ".", "content", ".", "decode", "(", "\"utf-8\"", ")", ")", "return", "self", ".", "ProxyError", "(", "data", ".", "status_code", ",", "(", "decoded_data", ",", "\"message\"", ")", ",", "step", "=", "\"put\"", ",", "context", "=", "{", "\"uri\"", ":", "uri", ",", "\"params\"", ":", "input_", "}", ")" ]

[ "Create", "a", "new", "file", "on", "github" ]

[ "def", "get", "(", "self", ",", "route", ":", "str", "(", ")", ",", "callback", ":", "object", "(", ")", ")", ":", "self", ".", "__set_route", "(", "'get'", ",", "{", "route", ":", "callback", "}", ")", "return", "RouteMapping" ]

[ "Binds", "a", "GET", "route", "with", "the", "given", "callback", ":", "rtype", ":", "object" ]

[ "def", "all_mouse_sprites", "(", "self", ")", ":", "def", "all_recursive", "(", "sprites", ")", ":", "if", "not", "sprites", ":", "return", "for", "sprite", "in", "sprites", ":", "if", "sprite", ".", "visible", ":", "yield", "sprite", "for", "child", "in", "all_recursive", "(", "sprite", ".", "get_mouse_sprites", "(", ")", ")", ":", "yield", "child", "return", "all_recursive", "(", "self", ".", "get_mouse_sprites", "(", ")", ")" ]

[ "Returns", "flat", "list", "of", "the", "sprite", "tree", "for", "simplified", "iteration" ]

[ "def", "owl_to_model", "(", "fname", ")", ":", "io_class", "=", "autoclass", "(", "'org.biopax.paxtools.io.SimpleIOHandler'", ")", "io", "=", "io_class", "(", "autoclass", "(", "'org.biopax.paxtools.model.BioPAXLevel'", ")", ".", "L3", ")", "try", ":", "file_is", "=", "autoclass", "(", "'java.io.FileInputStream'", ")", "(", "fname", ")", "except", "JavaException", ":", "logger", ".", "error", "(", "'Could not open data file %s'", "%", "fname", ")", "return", "try", ":", "biopax_model", "=", "io", ".", "convertFromOWL", "(", "file_is", ")", "except", "JavaException", "as", "e", ":", "logger", ".", "error", "(", "'Could not convert data file %s to BioPax model'", "%", "fname", ")", "logger", ".", "error", "(", "e", ")", "return", "file_is", ".", "close", "(", ")", "return", "biopax_model" ]

[ "Return", "a", "BioPAX", "model", "object", "from", "an", "OWL", "file", "." ]

[ "def", "filter_gradient_threshold", "(", "self", ",", "analyte", ",", "win", ",", "threshold", ",", "recalc", "=", "True", ")", ":", "params", "=", "locals", "(", ")", "del", "(", "params", "[", "'self'", "]", ")", "# calculate absolute gradient", "if", "recalc", "or", "not", "self", ".", "grads_calced", ":", "self", ".", "grads", "=", "calc_grads", "(", "self", ".", "Time", ",", "self", ".", "focus", ",", "[", "analyte", "]", ",", "win", ")", "self", ".", "grads_calced", "=", "True", "below", ",", "above", "=", "filters", ".", "threshold", "(", "abs", "(", "self", ".", "grads", "[", "analyte", "]", ")", ",", "threshold", ")", "setn", "=", "self", ".", "filt", ".", "maxset", "+", "1", "self", ".", "filt", ".", "add", "(", "analyte", "+", "'_gthresh_below'", ",", "below", ",", "'Keep gradient below {:.3e} '", ".", "format", "(", "threshold", ")", "+", "analyte", ",", "params", ",", "setn", "=", "setn", ")", "self", ".", "filt", ".", "add", "(", "analyte", "+", "'_gthresh_above'", ",", "above", ",", "'Keep gradient above {:.3e} '", ".", "format", "(", "threshold", ")", "+", "analyte", ",", "params", ",", "setn", "=", "setn", ")" ]

[ "Apply", "gradient", "threshold", "filter", "." ]

[ "def", "redraw_now", "(", "self", ",", "whence", "=", "0", ")", ":", "try", ":", "time_start", "=", "time", ".", "time", "(", ")", "self", ".", "redraw_data", "(", "whence", "=", "whence", ")", "# finally update the window drawable from the offscreen surface", "self", ".", "update_image", "(", ")", "time_done", "=", "time", ".", "time", "(", ")", "time_delta", "=", "time_start", "-", "self", ".", "time_last_redraw", "time_elapsed", "=", "time_done", "-", "time_start", "self", ".", "time_last_redraw", "=", "time_done", "self", ".", "logger", ".", "debug", "(", "\"widget '%s' redraw (whence=%d) delta=%.4f elapsed=%.4f sec\"", "%", "(", "self", ".", "name", ",", "whence", ",", "time_delta", ",", "time_elapsed", ")", ")", "except", "Exception", "as", "e", ":", "self", ".", "logger", ".", "error", "(", "\"Error redrawing image: %s\"", "%", "(", "str", "(", "e", ")", ")", ")", "try", ":", "# log traceback, if possible", "(", "type", ",", "value", ",", "tb", ")", "=", "sys", ".", "exc_info", "(", ")", "tb_str", "=", "\"\"", ".", "join", "(", "traceback", ".", "format_tb", "(", "tb", ")", ")", "self", ".", "logger", ".", "error", "(", "\"Traceback:\\n%s\"", "%", "(", "tb_str", ")", ")", "except", "Exception", ":", "tb_str", "=", "\"Traceback information unavailable.\"", "self", ".", "logger", ".", "error", "(", "tb_str", ")" ]

[ "Redraw", "the", "displayed", "image", "." ]

[ "def", "compile_rename_column", "(", "self", ",", "blueprint", ",", "command", ",", "connection", ")", ":", "schema", "=", "connection", ".", "get_schema_manager", "(", ")", "table", "=", "self", ".", "get_table_prefix", "(", ")", "+", "blueprint", ".", "get_table", "(", ")", "column", "=", "connection", ".", "get_column", "(", "table", ",", "command", ".", "from_", ")", "table_diff", "=", "self", ".", "_get_renamed_diff", "(", "blueprint", ",", "command", ",", "column", ",", "schema", ")", "return", "schema", ".", "get_database_platform", "(", ")", ".", "get_alter_table_sql", "(", "table_diff", ")" ]

[ "Compile", "a", "rename", "column", "command", "." ]

[ "def", "matrix_representation", "(", "op", ")", ":", "if", "not", "op", ".", "is_linear", ":", "raise", "ValueError", "(", "'the operator is not linear'", ")", "if", "not", "(", "isinstance", "(", "op", ".", "domain", ",", "TensorSpace", ")", "or", "(", "isinstance", "(", "op", ".", "domain", ",", "ProductSpace", ")", "and", "op", ".", "domain", ".", "is_power_space", "and", "all", "(", "isinstance", "(", "spc", ",", "TensorSpace", ")", "for", "spc", "in", "op", ".", "domain", ")", ")", ")", ":", "raise", "TypeError", "(", "'operator domain {!r} is neither `TensorSpace` '", "'nor `ProductSpace` with only equal `TensorSpace` '", "'components'", ".", "format", "(", "op", ".", "domain", ")", ")", "if", "not", "(", "isinstance", "(", "op", ".", "range", ",", "TensorSpace", ")", "or", "(", "isinstance", "(", "op", ".", "range", ",", "ProductSpace", ")", "and", "op", ".", "range", ".", "is_power_space", "and", "all", "(", "isinstance", "(", "spc", ",", "TensorSpace", ")", "for", "spc", "in", "op", ".", "range", ")", ")", ")", ":", "raise", "TypeError", "(", "'operator range {!r} is neither `TensorSpace` '", "'nor `ProductSpace` with only equal `TensorSpace` '", "'components'", ".", "format", "(", "op", ".", "range", ")", ")", "# Generate the matrix", "dtype", "=", "np", ".", "promote_types", "(", "op", ".", "domain", ".", "dtype", ",", "op", ".", "range", ".", "dtype", ")", "matrix", "=", "np", ".", "zeros", "(", "op", ".", "range", ".", "shape", "+", "op", ".", "domain", ".", "shape", ",", "dtype", "=", "dtype", ")", "tmp_ran", "=", "op", ".", "range", ".", "element", "(", ")", "# Store for reuse in loop", "tmp_dom", "=", "op", ".", "domain", ".", "zero", "(", ")", "# Store for reuse in loop", "for", "j", "in", "nd_iterator", "(", "op", ".", "domain", ".", "shape", ")", ":", "tmp_dom", "[", "j", "]", "=", "1.0", "op", "(", "tmp_dom", ",", "out", "=", "tmp_ran", ")", "matrix", "[", "(", "Ellipsis", ",", ")", "+", "j", "]", "=", "tmp_ran", ".", "asarray", "(", ")", "tmp_dom", "[", "j", "]", "=", "0.0", "return", "matrix" ]

[ "Return", "a", "matrix", "representation", "of", "a", "linear", "operator", "." ]

[ "def", "qasm", "(", "self", ",", "prec", "=", "15", ")", ":", "return", "\",\"", ".", "join", "(", "[", "self", ".", "children", "[", "j", "]", ".", "qasm", "(", "prec", ")", "for", "j", "in", "range", "(", "self", ".", "size", "(", ")", ")", "]", ")" ]

[ "Return", "the", "corresponding", "OPENQASM", "string", "." ]

[ "def", "visualRectRC", "(", "self", ",", "row", ",", "column", ")", ":", "rect", "=", "self", ".", "_rects", "[", "row", "]", "[", "column", "]", "if", "rect", ".", "isValid", "(", ")", ":", "return", "QtCore", ".", "QRect", "(", "rect", ".", "x", "(", ")", "-", "self", ".", "horizontalScrollBar", "(", ")", ".", "value", "(", ")", ",", "rect", ".", "y", "(", ")", "-", "self", ".", "verticalScrollBar", "(", ")", ".", "value", "(", ")", ",", "rect", ".", "width", "(", ")", ",", "rect", ".", "height", "(", ")", ")", "else", ":", "return", "rect" ]

[ "The", "rectangle", "for", "the", "bounds", "of", "the", "item", "at", "*", "row", "*", "*", "column", "*" ]

[ "def", "post", "(", "self", ",", "url", ",", "data", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "request", "(", "'post'", ",", "url", ",", "data", "=", "data", ",", "*", "*", "kwargs", ")" ]

[ "Sends", "a", "POST", "request", ".", "Returns", ":", "class", ":", "Response", "object", "." ]

[ "def", "coerce_data_source", "(", "x", ")", ":", "if", "isinstance", "(", "x", ",", "AbstractDataSource", ")", ":", "return", "x", "elif", "isinstance", "(", "x", ",", "(", "list", ",", "tuple", ")", ")", ":", "# Sequence of array-likes", "items", "=", "[", "]", "for", "item", "in", "x", ":", "if", "_is_array_like", "(", "item", ")", ":", "items", ".", "append", "(", "item", ")", "else", ":", "raise", "TypeError", "(", "'Cannot convert x to a data source; x is a sequence and '", "'one of the elements is not an array-like object, rather '", "'a {}'", ".", "format", "(", "type", "(", "item", ")", ")", ")", "if", "len", "(", "items", ")", "==", "0", ":", "raise", "ValueError", "(", "'Cannot convert x to a data source; x is an '", "'empty sequence'", ")", "return", "ArrayDataSource", "(", "items", ")", "elif", "isinstance", "(", "x", ",", "collections", ".", "Iterator", ")", ":", "return", "IteratorDataSource", "(", "x", ")", "elif", "callable", "(", "x", ")", ":", "return", "CallableDataSource", "(", "x", ")", "else", ":", "raise", "TypeError", "(", "'Cannot convert x to a data source; can only handle '", "'iterators, callables, non-empty sequences of '", "'array-like objects; cannot '", "'handle {}'", ".", "format", "(", "type", "(", "x", ")", ")", ")" ]

[ "Helper", "function", "to", "coerce", "an", "object", "into", "a", "data", "source", "selecting", "the", "appropriate", "data", "source", "class", "for", "the", "given", "object", ".", "If", "x", "is", "already", "a", "data", "source", "it", "is", "returned", "as", "is", "." ]

[ "def", "load_with_fn", "(", "load_fn", ",", "content_or_strm", ",", "container", ",", "allow_primitives", "=", "False", ",", "*", "*", "options", ")", ":", "ret", "=", "load_fn", "(", "content_or_strm", ",", "*", "*", "options", ")", "if", "anyconfig", ".", "utils", ".", "is_dict_like", "(", "ret", ")", ":", "return", "container", "(", ")", "if", "(", "ret", "is", "None", "or", "not", "ret", ")", "else", "container", "(", "ret", ")", "return", "ret", "if", "allow_primitives", "else", "container", "(", "ret", ")" ]

[ "Load", "data", "from", "given", "string", "or", "stream", "content_or_strm", "." ]

[ "def", "hook_wnd_proc", "(", "self", ")", ":", "self", ".", "__local_wnd_proc_wrapped", "=", "WndProcType", "(", "self", ".", "local_wnd_proc", ")", "self", ".", "__old_wnd_proc", "=", "SetWindowLong", "(", "self", ".", "__local_win_handle", ",", "GWL_WNDPROC", ",", "self", ".", "__local_wnd_proc_wrapped", ")" ]

[ "Attach", "to", "OS", "Window", "message", "handler" ]

[ "def", "_copy_with_changed_callback", "(", "self", ",", "new_callback", ")", ":", "return", "TimeoutCallback", "(", "self", ".", "_document", ",", "new_callback", ",", "self", ".", "_timeout", ",", "self", ".", "_id", ")" ]

[ "Dev", "API", "used", "to", "wrap", "the", "callback", "with", "decorators", "." ]

[ "def", "_Open", "(", "self", ",", "path_spec", "=", "None", ",", "mode", "=", "'rb'", ")", ":", "if", "not", "path_spec", ":", "raise", "ValueError", "(", "'Missing path specification.'", ")", "if", "not", "path_spec", ".", "HasParent", "(", ")", ":", "raise", "errors", ".", "PathSpecError", "(", "'Unsupported path specification without parent.'", ")", "self", ".", "_file_system", "=", "resolver", ".", "Resolver", ".", "OpenFileSystem", "(", "path_spec", ",", "resolver_context", "=", "self", ".", "_resolver_context", ")", "tsk_volume", "=", "self", ".", "_file_system", ".", "GetTSKVolume", "(", ")", "tsk_vs", ",", "_", "=", "tsk_partition", ".", "GetTSKVsPartByPathSpec", "(", "tsk_volume", ",", "path_spec", ")", "if", "tsk_vs", "is", "None", ":", "raise", "errors", ".", "PathSpecError", "(", "'Unable to retrieve TSK volume system part from path '", "'specification.'", ")", "range_offset", "=", "tsk_partition", ".", "TSKVsPartGetStartSector", "(", "tsk_vs", ")", "range_size", "=", "tsk_partition", ".", "TSKVsPartGetNumberOfSectors", "(", "tsk_vs", ")", "if", "range_offset", "is", "None", "or", "range_size", "is", "None", ":", "raise", "errors", ".", "PathSpecError", "(", "'Unable to retrieve TSK volume system part data range from path '", "'specification.'", ")", "bytes_per_sector", "=", "tsk_partition", ".", "TSKVolumeGetBytesPerSector", "(", "tsk_volume", ")", "range_offset", "*=", "bytes_per_sector", "range_size", "*=", "bytes_per_sector", "self", ".", "SetRange", "(", "range_offset", ",", "range_size", ")", "self", ".", "_file_object", "=", "resolver", ".", "Resolver", ".", "OpenFileObject", "(", "path_spec", ".", "parent", ",", "resolver_context", "=", "self", ".", "_resolver_context", ")", "self", ".", "_file_object_set_in_init", "=", "True", "# pylint: disable=protected-access", "super", "(", "TSKPartitionFile", ",", "self", ")", ".", "_Open", "(", "path_spec", "=", "path_spec", ",", "mode", "=", "mode", ")" ]

[ "Opens", "the", "file", "-", "like", "object", "defined", "by", "path", "specification", "." ]

[ "def", "Kim_Mudawar", "(", "m", ",", "x", ",", "rhol", ",", "rhog", ",", "mul", ",", "mug", ",", "sigma", ",", "D", ",", "L", "=", "1", ")", ":", "def", "friction_factor", "(", "Re", ")", ":", "if", "Re", "<", "2000", ":", "return", "64.", "/", "Re", "elif", "Re", "<", "20000", ":", "return", "0.316", "*", "Re", "**", "-", "0.25", "else", ":", "return", "0.184", "*", "Re", "**", "-", "0.2", "# Actual Liquid flow", "v_l", "=", "m", "*", "(", "1", "-", "x", ")", "/", "rhol", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "Re_l", "=", "Reynolds", "(", "V", "=", "v_l", ",", "rho", "=", "rhol", ",", "mu", "=", "mul", ",", "D", "=", "D", ")", "fd_l", "=", "friction_factor", "(", "Re", "=", "Re_l", ")", "dP_l", "=", "fd_l", "*", "L", "/", "D", "*", "(", "0.5", "*", "rhol", "*", "v_l", "**", "2", ")", "# Actual gas flow", "v_g", "=", "m", "*", "x", "/", "rhog", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "Re_g", "=", "Reynolds", "(", "V", "=", "v_g", ",", "rho", "=", "rhog", ",", "mu", "=", "mug", ",", "D", "=", "D", ")", "fd_g", "=", "friction_factor", "(", "Re", "=", "Re_g", ")", "dP_g", "=", "fd_g", "*", "L", "/", "D", "*", "(", "0.5", "*", "rhog", "*", "v_g", "**", "2", ")", "# Liquid-only flow", "v_lo", "=", "m", "/", "rhol", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "Re_lo", "=", "Reynolds", "(", "V", "=", "v_lo", ",", "rho", "=", "rhol", ",", "mu", "=", "mul", ",", "D", "=", "D", ")", "Su", "=", "Suratman", "(", "L", "=", "D", ",", "rho", "=", "rhog", ",", "mu", "=", "mug", ",", "sigma", "=", "sigma", ")", "X", "=", "(", "dP_l", "/", "dP_g", ")", "**", "0.5", "Re_c", "=", "2000", "# Transition Reynolds number", "if", "Re_l", "<", "Re_c", "and", "Re_g", "<", "Re_c", ":", "C", "=", "3.5E-5", "*", "Re_lo", "**", "0.44", "*", "Su", "**", "0.5", "*", "(", "rhol", "/", "rhog", ")", "**", "0.48", "elif", "Re_l", "<", "Re_c", "and", "Re_g", ">=", "Re_c", ":", "C", "=", "0.0015", "*", "Re_lo", "**", "0.59", "*", "Su", "**", "0.19", "*", "(", "rhol", "/", "rhog", ")", "**", "0.36", "elif", "Re_l", ">=", "Re_c", "and", "Re_g", "<", "Re_c", ":", "C", "=", "8.7E-4", "*", "Re_lo", "**", "0.17", "*", "Su", "**", "0.5", "*", "(", "rhol", "/", "rhog", ")", "**", "0.14", "else", ":", "# Turbulent case", "C", "=", "0.39", "*", "Re_lo", "**", "0.03", "*", "Su", "**", "0.10", "*", "(", "rhol", "/", "rhog", ")", "**", "0.35", "phi_l2", "=", "1", "+", "C", "/", "X", "+", "1.", "/", "X", "**", "2", "return", "dP_l", "*", "phi_l2" ]

[ "r", "Calculates", "two", "-", "phase", "pressure", "drop", "with", "the", "Kim", "and", "Mudawar", "(", "2012", ")", "correlation", "as", "in", "[", "1", "]", "_", "also", "presented", "in", "[", "2", "]", "_", "." ]

[ "def", "set_deltatime", "(", "self", ",", "delta_time", ")", ":", "if", "type", "(", "delta_time", ")", "==", "int", ":", "delta_time", "=", "self", ".", "int_to_varbyte", "(", "delta_time", ")", "self", ".", "delta_time", "=", "delta_time" ]

[ "Set", "the", "delta_time", "." ]

[ "def", "get_name", "(", "self", ",", "r", ")", ":", "namer", "=", "ResourceNameAdapters", "[", "self", ".", "manager", ".", "resource_type", ".", "service", "]", "return", "namer", "(", "r", ")" ]

[ "Given", "an", "arbitrary", "resource", "attempt", "to", "resolve", "back", "to", "a", "qualified", "name", "." ]

[ "def", "get_singular_and_plural_dtype", "(", "self", ",", "dtype", ")", ":", "dtype", "=", "dtype", ".", "strip", "(", ")", "if", "dtype", ".", "endswith", "(", "'s'", ")", ":", "return", "dtype", "[", ":", "-", "1", "]", ",", "dtype", "elif", "dtype", "==", "'criteria'", ":", "return", "'table_column'", ",", "'criteria'", "elif", "dtype", "==", "'contribution'", ":", "return", "'doi'", ",", "'contribution'" ]

[ "Parameters", "----------", "dtype", ":", "str", "MagIC", "table", "type", "(", "specimens", "samples", "contribution", "etc", ".", ")" ]

[ "def", "validate_instance", "(", "instance", ")", ":", "excludes", "=", "settings", ".", "AUTOMATED_LOGGING", "[", "'exclude'", "]", "[", "'model'", "]", "for", "excluded", "in", "excludes", ":", "if", "(", "excluded", "in", "[", "instance", ".", "_meta", ".", "app_label", ".", "lower", "(", ")", ",", "instance", ".", "__class__", ".", "__name__", ".", "lower", "(", ")", "]", "or", "instance", ".", "__module__", ".", "lower", "(", ")", ".", "startswith", "(", "excluded", ")", ")", ":", "return", "False", "return", "True" ]

[ "Validating", "if", "the", "instance", "should", "be", "logged", "or", "is", "excluded" ]

[ "def", "dispatchEvent", "(", "self", ",", "event", ",", "*", "args", ")", ":", "for", "callback", "in", "self", ".", "listeners", "[", "event", "]", ":", "yield", "callback", "(", "event", ",", "self", ",", "*", "args", ")" ]

[ "Fire", "all", "callbacks", "assigned", "to", "a", "particular", "event", ".", "To", "be", "called", "by", "derivative", "classes", ".", ":", "param", "*", "args", ":", "Additional", "arguments", "to", "be", "passed", "to", "the", "callback", "function", "." ]

[ "def", "layerset2list", "(", "discoursegraph", ")", ":", "for", "node_id", "in", "discoursegraph", ":", "discoursegraph", ".", "node", "[", "node_id", "]", "[", "'layers'", "]", "=", "list", "(", "discoursegraph", ".", "node", "[", "node_id", "]", "[", "'layers'", "]", ")", "for", "(", "from_id", ",", "to_id", ")", "in", "discoursegraph", ".", "edges_iter", "(", ")", ":", "# there might be multiple edges between 2 nodes", "edge_dict", "=", "discoursegraph", ".", "edge", "[", "from_id", "]", "[", "to_id", "]", "for", "edge_id", "in", "edge_dict", ":", "edge_dict", "[", "edge_id", "]", "[", "'layers'", "]", "=", "list", "(", "edge_dict", "[", "edge_id", "]", "[", "'layers'", "]", ")" ]

[ "typecasts", "all", "layers", "sets", "to", "lists", "to", "make", "the", "graph", "exportable", "(", "e", ".", "g", ".", "into", "the", "geoff", "format", ")", "." ]

[ "def", "decipher_atom_keys", "(", "self", ",", "forcefield", "=", "'DLF'", ",", "dict_key", "=", "'atom_ids'", ")", ":", "# In case there is no 'atom_ids' key we try 'elements'. This is for", "# XYZ and MOL files mostly. But, we keep the dict_key keyword for", "# someone who would want to decipher 'elements' even if 'atom_ids' key", "# is present in the system's dictionary.", "if", "'atom_ids'", "not", "in", "self", ".", "system", ".", "keys", "(", ")", ":", "dict_key", "=", "'elements'", "# I do it on temporary object so that it only finishes when successful", "temp", "=", "deepcopy", "(", "self", ".", "system", "[", "dict_key", "]", ")", "for", "element", "in", "range", "(", "len", "(", "temp", ")", ")", ":", "temp", "[", "element", "]", "=", "\"{0}\"", ".", "format", "(", "decipher_atom_key", "(", "temp", "[", "element", "]", ",", "forcefield", "=", "forcefield", ")", ")", "self", ".", "system", "[", "'elements'", "]", "=", "temp" ]

[ "Decipher", "force", "field", "atom", "ids", "." ]

[ "def", "download", "(", "self", ",", "file", ":", "Optional", "[", "IO", "[", "bytes", "]", "]", "=", "None", ",", "duration_timeout", ":", "Optional", "[", "float", "]", "=", "None", ")", ":", "yield", "from", "self", ".", "_current_session", ".", "download", "(", "file", ",", "duration_timeout", "=", "duration_timeout", ")" ]

[ "Download", "content", "." ]

[ "def", "txt_line_iterator", "(", "path", ")", ":", "with", "tf", ".", "gfile", ".", "Open", "(", "path", ")", "as", "f", ":", "for", "line", "in", "f", ":", "yield", "line", ".", "strip", "(", ")" ]

[ "Iterate", "through", "lines", "of", "file", "." ]

[ "def", "parse_chromium", "(", "url_data", ")", ":", "from", ".", ".", "bookmarks", ".", "chromium", "import", "parse_bookmark_data", "for", "url", ",", "name", "in", "parse_bookmark_data", "(", "url_data", ".", "get_content", "(", ")", ")", ":", "url_data", ".", "add_url", "(", "url", ",", "name", "=", "name", ")" ]

[ "Parse", "a", "Chromium", "or", "Google", "Chrome", "bookmark", "file", "." ]

[ "def", "observe", "(", "self", ",", "event", ",", "fn", ")", ":", "iscoroutine", "=", "asyncio", ".", "iscoroutinefunction", "(", "fn", ")", "if", "not", "iscoroutine", "and", "not", "isfunction", "(", "fn", ")", ":", "raise", "TypeError", "(", "'paco: fn param must be a callable '", "'object or coroutine function'", ")", "observers", "=", "self", ".", "_pool", ".", "get", "(", "event", ")", "if", "not", "observers", ":", "observers", "=", "self", ".", "_pool", "[", "event", "]", "=", "[", "]", "# Register the observer", "observers", ".", "append", "(", "fn", "if", "iscoroutine", "else", "coroutine_wrapper", "(", "fn", ")", ")" ]

[ "Arguments", ":", "event", "(", "str", ")", ":", "event", "to", "subscribe", ".", "fn", "(", "function|coroutinefunction", ")", ":", "function", "to", "trigger", "." ]

[ "def", "_postgresql", "(", "self", ",", "dbhost", ",", "dbport", ",", "dbname", ",", "dbuser", ",", "dbpass", ",", "dsn_style", "=", "None", ")", ":", "# noqa", "dsn", "=", "[", "]", "if", "dsn_style", "is", "None", "or", "dsn_style", "==", "'all'", "or", "dsn_style", "==", "'keyvalue'", ":", "dsnstr", "=", "\"host='{0}' dbname='{2}' user='{3}' password='{4}'\"", "if", "dbport", "is", "not", "None", ":", "dsnstr", "+=", "\" port='{1}'\"", "dsn", ".", "append", "(", "dsnstr", ".", "format", "(", "dbhost", ",", "dbport", ",", "dbname", ",", "dbuser", ",", "dbpass", ",", ")", ")", "if", "dsn_style", "==", "'all'", "or", "dsn_style", "==", "'kwargs'", ":", "dsnstr", "=", "\"host='{0}', database='{2}', user='{3}', password='{4}'\"", "if", "dbport", "is", "not", "None", ":", "dsnstr", "+=", "\", port='{1}'\"", "dsn", ".", "append", "(", "dsnstr", ".", "format", "(", "dbhost", ",", "dbport", ",", "dbname", ",", "dbuser", ",", "dbpass", ")", ")", "if", "dsn_style", "==", "'all'", "or", "dsn_style", "==", "'uri'", ":", "dsnstr", "=", "\"postgresql://{user}:{password}@{host}/{name}\"", "dsn", ".", "append", "(", "dsnstr", ".", "format", "(", "host", "=", "\"{host}:{port}\"", ".", "format", "(", "host", "=", "dbhost", ",", "port", "=", "dbport", ")", "if", "dbport", "else", "dbhost", ",", "# noqa", "name", "=", "dbname", ",", "user", "=", "dbuser", ",", "password", "=", "dbpass", ")", ")", "if", "dsn_style", "==", "'all'", "or", "dsn_style", "==", "'pgpass'", ":", "dsn", ".", "append", "(", "':'", ".", "join", "(", "map", "(", "str", ",", "filter", "(", "None", ",", "[", "dbhost", ",", "dbport", ",", "dbname", ",", "dbuser", ",", "dbpass", "]", ")", ")", ")", ")", "return", "dsn" ]

[ "PostgreSQL", "psycopg2", "driver", "accepts", "two", "syntaxes" ]

[ "def", "closeEvent", "(", "self", ",", "event", ")", ":", "self", ".", "acqmodel", ".", "stop_listening", "(", ")", "# close listener threads", "self", ".", "saveInputs", "(", "self", ".", "inputsFilename", ")", "# save GUI size", "settings", "=", "QtCore", ".", "QSettings", "(", "\"audiolab\"", ")", "settings", ".", "setValue", "(", "\"geometry\"", ",", "self", ".", "saveGeometry", "(", ")", ")", "settings", ".", "setValue", "(", "\"windowState\"", ",", "self", ".", "saveState", "(", ")", ")", "logger", "=", "logging", ".", "getLogger", "(", "'main'", ")", "logger", ".", "info", "(", "'All user settings saved'", ")", "self", ".", "garbage_timer", ".", "stop", "(", ")", "gc", ".", "enable", "(", ")" ]

[ "Closes", "listening", "threads", "and", "saves", "GUI", "data", "for", "later", "use", "." ]

[ "def", "is_cyclic", "(", "graph", ")", ":", "path", "=", "set", "(", ")", "def", "visit", "(", "vertex", ")", ":", "path", ".", "add", "(", "vertex", ")", "for", "neighbour", "in", "graph", ".", "get", "(", "vertex", ",", "(", ")", ")", ":", "if", "neighbour", "in", "path", "or", "visit", "(", "neighbour", ")", ":", "return", "True", "path", ".", "remove", "(", "vertex", ")", "return", "False", "return", "any", "(", "visit", "(", "v", ")", "for", "v", "in", "graph", ")" ]

[ "Return", "True", "if", "the", "directed", "graph", "g", "has", "a", "cycle", ".", "The", "directed", "graph", "should", "be", "represented", "as", "a", "dictionary", "mapping", "of", "edges", "for", "each", "node", "." ]

[ "def", "_attach_files", "(", "filepaths", ",", "email_", ")", ":", "for", "filepath", "in", "filepaths", ":", "base", "=", "os", ".", "path", ".", "basename", "(", "filepath", ")", "with", "open", "(", "filepath", ",", "\"rb\"", ")", "as", "file", ":", "part", "=", "MIMEApplication", "(", "file", ".", "read", "(", ")", ",", "Name", "=", "base", ")", "part", "[", "\"Content-Disposition\"", "]", "=", "'attachment; filename=\"%s\"'", "%", "base", "email_", ".", "attach", "(", "part", ")" ]

[ "Take", "a", "list", "of", "filepaths", "and", "attach", "the", "files", "to", "a", "MIMEMultipart", "." ]

[ "def", "verify_chunks", "(", "self", ",", "chunks", ")", ":", "err", "=", "[", "]", "for", "chunk", "in", "chunks", ":", "err", ".", "extend", "(", "self", ".", "verify_data", "(", "chunk", ")", ")", "return", "err" ]

[ "Verify", "the", "chunks", "in", "a", "list", "of", "low", "data", "structures" ]

[ "def", "login", "(", "self", ",", "client_id", ",", "access_token", ",", "connection", ",", "scope", "=", "'openid'", ")", ":", "return", "self", ".", "post", "(", "'https://{}/oauth/access_token'", ".", "format", "(", "self", ".", "domain", ")", ",", "data", "=", "{", "'client_id'", ":", "client_id", ",", "'access_token'", ":", "access_token", ",", "'connection'", ":", "connection", ",", "'scope'", ":", "scope", ",", "}", ",", "headers", "=", "{", "'Content-Type'", ":", "'application/json'", "}", ")" ]

[ "Login", "using", "a", "social", "provider", "s", "access", "token" ]

[ "def", "normalize", "(", "expr", ")", ":", "children", "=", "[", "]", "for", "child", "in", "expr", ".", "children", ":", "branch", "=", "normalize", "(", "child", ")", "if", "branch", "is", "None", ":", "continue", "if", "type", "(", "branch", ")", "is", "type", "(", "expr", ")", ":", "children", ".", "extend", "(", "branch", ".", "children", ")", "else", ":", "children", ".", "append", "(", "branch", ")", "if", "len", "(", "children", ")", "==", "0", ":", "return", "None", "if", "len", "(", "children", ")", "==", "1", ":", "return", "children", "[", "0", "]", "return", "type", "(", "expr", ")", "(", "*", "children", ",", "start", "=", "children", "[", "0", "]", ".", "start", ",", "end", "=", "children", "[", "-", "1", "]", ".", "end", ")" ]

[ "Pass", "through", "n", "-", "ary", "expressions", "and", "eliminate", "empty", "branches", "." ]

[ "def", "canonical_url", "(", "configs", ",", "endpoint_type", "=", "PUBLIC", ")", ":", "scheme", "=", "_get_scheme", "(", "configs", ")", "address", "=", "resolve_address", "(", "endpoint_type", ")", "if", "is_ipv6", "(", "address", ")", ":", "address", "=", "\"[{}]\"", ".", "format", "(", "address", ")", "return", "'%s://%s'", "%", "(", "scheme", ",", "address", ")" ]

[ "Returns", "the", "correct", "HTTP", "URL", "to", "this", "host", "given", "the", "state", "of", "HTTPS", "configuration", "hacluster", "and", "charm", "configuration", "." ]

[ "def", "controlprompt_cmd", "(", "self", ",", "cmd", ")", ":", "data", "=", "tags", ".", "string_tag", "(", "'cmbe'", ",", "cmd", ")", "+", "tags", ".", "uint8_tag", "(", "'cmcc'", ",", "0", ")", "return", "self", ".", "daap", ".", "post", "(", "_CTRL_PROMPT_CMD", ",", "data", "=", "data", ")" ]

[ "Perform", "a", "controlpromptentry", "command", "." ]

[ "def", "get_os_path_to_library", "(", "self", ",", "library_path", ",", "library_name", ",", "allow_user_interaction", "=", "True", ")", ":", "original_path_and_name", "=", "os", ".", "path", ".", "join", "(", "library_path", ",", "library_name", ")", "library_path_root", "=", "library_path", ".", "split", "(", "os", ".", "sep", ")", "[", "0", "]", "if", "library_path", ".", "split", "(", "os", ".", "sep", ")", "and", "(", "library_path", ".", "startswith", "(", "os", ".", "sep", ")", "or", "library_path", ".", "endswith", "(", "os", ".", "sep", ")", "or", "os", ".", "sep", "+", "os", ".", "sep", "in", "library_path", ")", ":", "raise", "LibraryNotFoundException", "(", "\"A library_path is not considered to start or end with {2} or to have two \"", "\"path separators {2}{2} in a row like '{0}' with library name {1}\"", "\"\"", ".", "format", "(", "library_path", ",", "library_name", ",", "os", ".", "sep", ")", ")", "if", "not", "self", ".", "_library_root_paths", ":", "raise", "LibraryNotFoundException", "(", "\"There are no libraries registered\"", ")", "# skip already skipped states", "if", "original_path_and_name", "in", "self", ".", "_skipped_states", "or", "library_path_root", "in", "self", ".", "_skipped_library_roots", ":", "# if an already skipped state shall be loaded again, directly raise the exception to jump over this state", "raise", "LibraryNotFoundException", "(", "\"Library '{0}' not found in subfolder {1}\"", ".", "format", "(", "library_name", ",", "library_path", ")", ")", "# replace already replaced states", "if", "original_path_and_name", "in", "self", ".", "_replaced_libraries", ":", "new_library_os_path", "=", "self", ".", "_replaced_libraries", "[", "original_path_and_name", "]", "[", "0", "]", "new_library_path", "=", "self", ".", "_replaced_libraries", "[", "original_path_and_name", "]", "[", "1", "]", "# only show debug message if a state is automatically replaced by the appropriate library state", "# chosen by the user before", "if", "not", "self", ".", "_replaced_libraries", "[", "original_path_and_name", "]", "[", "2", "]", ":", "logger", ".", "debug", "(", "\"The library with library_path \\\"{0}\\\" and name \\\"{1}\\\" \"", "\"is automatically replaced by the library \"", "\"with file system library_os_path \\\"{2}\\\" and library_path \\\"{3}\\\"\"", "\"\"", ".", "format", "(", "library_path", ",", "library_name", ",", "new_library_os_path", ",", "new_library_path", ")", ")", "return", "new_library_os_path", ",", "new_library_path", ",", "library_name", "# a boolean to indicate if a state was regularly found or by the help of the user", "regularly_found", "=", "True", "library_os_path", "=", "self", ".", "_get_library_os_path_from_library_dict_tree", "(", "library_path", ",", "library_name", ")", "while", "library_os_path", "is", "None", ":", "# until the library is found or the user aborts", "regularly_found", "=", "False", "new_library_os_path", "=", "None", "if", "allow_user_interaction", ":", "notice", "=", "\"Cannot find library '{0}' in library_path '{1}' in any of the library root paths. \"", "\"Please check your library root paths configuration in config.yaml \"", "\"LIBRARY_PATHS and environment variable RAFCON_LIBRARY_PATH. \"", "\"If your library_path is correct and the library was moved, please \"", "\"select the new root/library_os_path folder of the library which should be situated within a \"", "\"loaded library_root_path. If not, please abort.\"", ".", "format", "(", "library_name", ",", "library_path", ")", "interface", ".", "show_notice_func", "(", "notice", ")", "new_library_os_path", "=", "interface", ".", "open_folder_func", "(", "\"Select root folder for library name '{0}'\"", "\"\"", ".", "format", "(", "original_path_and_name", ")", ")", "if", "new_library_os_path", "is", "None", ":", "# User clicked cancel => cancel library search", "# If the library root path is existent (e.g. \"generic\") and only the specific library state is not (", "# e.g. \"generic/wait\", then the state is added to the skipped states.", "# If the library root path is not existing, we ignore the whole library, preventing the user from", "# endless dialogs for each missing library state.", "if", "library_path_root", "not", "in", "self", ".", "libraries", ":", "self", ".", "_skipped_library_roots", ".", "append", "(", "library_path_root", ")", "else", ":", "self", ".", "_skipped_states", ".", "append", "(", "original_path_and_name", ")", "raise", "LibraryNotFoundException", "(", "\"Library '{0}' not found in sub-folder {1}\"", ".", "format", "(", "library_name", ",", "library_path", ")", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "new_library_os_path", ")", ":", "logger", ".", "error", "(", "'Specified library_os_path does not exist'", ")", "continue", "# check if valid library_path and library_name can be created", "library_path", ",", "library_name", "=", "self", ".", "get_library_path_and_name_for_os_path", "(", "new_library_os_path", ")", "if", "library_path", "is", "None", ":", "logger", ".", "error", "(", "\"Specified library_os_path not within loaded library_root_path list or your config.yaml \"", "\"file LIBRARY_PATHS or in the list of paths in environment variable RAFCON_LIBRARY_PATH\"", ")", "continue", "# Allow the user to change the directory", "# verification if library is also in library tree", "library_os_path", "=", "self", ".", "_get_library_os_path_from_library_dict_tree", "(", "library_path", ",", "library_name", ")", "if", "library_os_path", "is", "not", "None", ":", "assert", "library_os_path", "==", "new_library_os_path", "# save the replacement in order that for a future occurrence the correct library_os_path can be used,", "# without asking the user for the correct library_os_path", "self", ".", "_replaced_libraries", "[", "original_path_and_name", "]", "=", "(", "library_os_path", ",", "library_path", ",", "regularly_found", ")", "return", "library_os_path", ",", "library_path", ",", "library_name" ]

[ "Find", "library_os_path", "of", "library" ]

[ "def", "set_page_permissions", "(", "context", ",", "token", ")", ":", "page", "=", "context", "[", "token", ".", "split_contents", "(", ")", "[", "1", "]", "]", "model", "=", "page", ".", "get_content_model", "(", ")", "try", ":", "opts", "=", "model", ".", "_meta", "except", "AttributeError", ":", "if", "model", "is", "None", ":", "error", "=", "_", "(", "\"Could not load the model for the following page, \"", "\"was it removed?\"", ")", "obj", "=", "page", "else", ":", "# A missing inner Meta class usually means the Page model", "# hasn't been directly subclassed.", "error", "=", "_", "(", "\"An error occured with the following class. Does \"", "\"it subclass Page directly?\"", ")", "obj", "=", "model", ".", "__class__", ".", "__name__", "raise", "ImproperlyConfigured", "(", "error", "+", "\" '%s'\"", "%", "obj", ")", "perm_name", "=", "opts", ".", "app_label", "+", "\".%s_\"", "+", "opts", ".", "object_name", ".", "lower", "(", ")", "request", "=", "context", "[", "\"request\"", "]", "setattr", "(", "page", ",", "\"perms\"", ",", "{", "}", ")", "for", "perm_type", "in", "(", "\"add\"", ",", "\"change\"", ",", "\"delete\"", ")", ":", "perm", "=", "request", ".", "user", ".", "has_perm", "(", "perm_name", "%", "perm_type", ")", "perm", "=", "perm", "and", "getattr", "(", "model", ",", "\"can_%s\"", "%", "perm_type", ")", "(", "request", ")", "page", ".", "perms", "[", "perm_type", "]", "=", "perm", "return", "\"\"" ]

[ "Assigns", "a", "permissions", "dict", "to", "the", "given", "page", "instance", "combining", "Django", "s", "permission", "for", "the", "page", "s", "model", "and", "a", "permission", "check", "against", "the", "instance", "itself", "calling", "the", "page", "s", "can_add", "can_change", "and", "can_delete", "custom", "methods", "." ]

[ "def", "decode_response", "(", "status", ":", "int", ",", "headers", ":", "MutableMapping", ",", "body", ":", "bytes", ")", "->", "dict", ":", "data", "=", "decode_body", "(", "headers", ",", "body", ")", "raise_for_status", "(", "status", ",", "headers", ",", "data", ")", "raise_for_api_error", "(", "headers", ",", "data", ")", "return", "data" ]

[ "Decode", "incoming", "response" ]

[ "def", "run_setkey", "(", "input", ")", ":", "SETKEY_BINARY", "=", "'/usr/sbin/setkey'", "fd", ",", "filename", "=", "tempfile", ".", "mkstemp", "(", "'w'", ")", "f", "=", "os", ".", "fdopen", "(", "fd", ",", "'w'", ")", "f", ".", "write", "(", "input", ")", "f", ".", "close", "(", ")", "output", "=", "subprocess", ".", "check_output", "(", "[", "'sudo'", ",", "SETKEY_BINARY", ",", "'-f'", ",", "filename", "]", ")", "os", ".", "remove", "(", "filename", ")", "return", "output", ".", "decode", "(", "'utf-8'", ")" ]

[ "Runs", "a", "script", "through", "the", "setkey", "command", "that", "is", "a", "user", "space", "insterface", "for", "PFKEY", ".", ":", "param", "input", ":", "setkey", "configuration", "file", "contents", "." ]

[ "def", "append", "(", "self", ",", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "#if no set is associated with the layer yet, we learn it from span annotation elements that are added", "if", "self", ".", "set", "is", "False", "or", "self", ".", "set", "is", "None", ":", "if", "inspect", ".", "isclass", "(", "child", ")", ":", "if", "issubclass", "(", "child", ",", "AbstractSpanAnnotation", ")", ":", "if", "'set'", "in", "kwargs", ":", "self", ".", "set", "=", "kwargs", "[", "'set'", "]", "elif", "isinstance", "(", "child", ",", "AbstractSpanAnnotation", ")", ":", "if", "child", ".", "set", ":", "self", ".", "set", "=", "child", ".", "set", "elif", "isinstance", "(", "child", ",", "Correction", ")", ":", "#descend into corrections to find the proper set for this layer (derived from span annotation elements)", "for", "e", "in", "itertools", ".", "chain", "(", "child", ".", "new", "(", ")", ",", "child", ".", "original", "(", ")", ",", "child", ".", "suggestions", "(", ")", ")", ":", "if", "isinstance", "(", "e", ",", "AbstractSpanAnnotation", ")", "and", "e", ".", "set", ":", "self", ".", "set", "=", "e", ".", "set", "break", "return", "super", "(", "AbstractAnnotationLayer", ",", "self", ")", ".", "append", "(", "child", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "See", ":", "meth", ":", "AbstractElement", ".", "append" ]

[ "def", "draw", "(", "self", ",", "drawDC", "=", "None", ")", ":", "DEBUG_MSG", "(", "\"draw()\"", ",", "1", ",", "self", ")", "self", ".", "renderer", "=", "RendererWx", "(", "self", ".", "bitmap", ",", "self", ".", "figure", ".", "dpi", ")", "self", ".", "figure", ".", "draw", "(", "self", ".", "renderer", ")", "self", ".", "_isDrawn", "=", "True", "self", ".", "gui_repaint", "(", "drawDC", "=", "drawDC", ")" ]

[ "Render", "the", "figure", "using", "RendererWx", "instance", "renderer", "or", "using", "a", "previously", "defined", "renderer", "if", "none", "is", "specified", "." ]

[ "def", "find_contours", "(", "x", ",", "level", "=", "0.8", ",", "fully_connected", "=", "'low'", ",", "positive_orientation", "=", "'low'", ")", ":", "return", "skimage", ".", "measure", ".", "find_contours", "(", "x", ",", "level", ",", "fully_connected", "=", "fully_connected", ",", "positive_orientation", "=", "positive_orientation", ")" ]

[ "Find", "iso", "-", "valued", "contours", "in", "a", "2D", "array", "for", "a", "given", "level", "value", "returns", "list", "of", "(", "n", "2", ")", "-", "ndarrays", "see", "skimage", ".", "measure", ".", "find_contours", "<http", ":", "//", "scikit", "-", "image", ".", "org", "/", "docs", "/", "dev", "/", "api", "/", "skimage", ".", "measure", ".", "html#skimage", ".", "measure", ".", "find_contours", ">", "__", "." ]

[ "def", "parse_second_row", "(", "row", ",", "url", ")", ":", "tags", "=", "row", ".", "findall", "(", "'./td'", ")", "category", ",", "subcategory", ",", "quality", ",", "language", "=", "Parser", ".", "parse_torrent_properties", "(", "tags", "[", "0", "]", ")", "user_info", "=", "tags", "[", "1", "]", ".", "find", "(", "'./a'", ")", "user", "=", "user_info", ".", "text_content", "(", ")", "user_url", "=", "url", ".", "combine", "(", "user_info", ".", "get", "(", "'href'", ")", ")", "# Two urls - one is spam, second is torrent url.", "# Don't combine it with BASE_URL, since it's an absolute url.", "torrent_link", "=", "Parser", ".", "parse_torrent_link", "(", "tags", "[", "2", "]", ")", "size", "=", "tags", "[", "3", "]", ".", "text", "# as 10.5 GB", "comments", "=", "tags", "[", "4", "]", ".", "text", "times_completed", "=", "tags", "[", "5", "]", ".", "text", "seeders", "=", "tags", "[", "6", "]", ".", "text", "leechers", "=", "tags", "[", "7", "]", ".", "text", "return", "[", "category", ",", "subcategory", ",", "quality", ",", "language", ",", "user", ",", "user_url", ",", "torrent_link", ",", "size", ",", "comments", ",", "times_completed", ",", "seeders", ",", "leechers", "]" ]

[ "Static", "method", "that", "parses", "a", "given", "table", "row", "element", "by", "using", "helper", "methods", "Parser", ".", "parse_category_subcategory_and_or_quality", "Parser", ".", "parse_torrent_link", "and", "scrapping", "torrent", "s", "category", "subcategory", "quality", "language", "user", "user", "url", "torrent", "link", "size", "comments", "times", "completed", "seeders", "and", "leechers", ".", "Used", "specifically", "with", "a", "torrent", "s", "second", "table", "row", "." ]

[ "def", "most_common", "(", "self", ",", "n", "=", "None", ")", ":", "if", "n", "is", "None", ":", "return", "sorted", "(", "iteritems", "(", "self", ")", ",", "key", "=", "itemgetter", "(", "1", ")", ",", "reverse", "=", "True", ")", "return", "nlargest", "(", "n", ",", "iteritems", "(", "self", ")", ",", "key", "=", "itemgetter", "(", "1", ")", ")" ]

[ "List", "the", "n", "most", "common", "elements", "and", "their", "counts", "from", "the", "most", "common", "to", "the", "least", ".", "If", "n", "is", "None", "then", "list", "all", "element", "counts", "." ]

[ "def", "_pack_prms", "(", ")", ":", "config_dict", "=", "{", "\"Paths\"", ":", "prms", ".", "Paths", ".", "to_dict", "(", ")", ",", "\"FileNames\"", ":", "prms", ".", "FileNames", ".", "to_dict", "(", ")", ",", "\"Db\"", ":", "prms", ".", "Db", ".", "to_dict", "(", ")", ",", "\"DbCols\"", ":", "prms", ".", "DbCols", ".", "to_dict", "(", ")", ",", "\"DataSet\"", ":", "prms", ".", "DataSet", ".", "to_dict", "(", ")", ",", "\"Reader\"", ":", "prms", ".", "Reader", ".", "to_dict", "(", ")", ",", "\"Instruments\"", ":", "prms", ".", "Instruments", ".", "to_dict", "(", ")", ",", "# \"excel_db_cols\": prms.excel_db_cols.to_dict(),", "# \"excel_db_filename_cols\": prms.excel_db_filename_cols.to_dict(),", "\"Batch\"", ":", "prms", ".", "Batch", ".", "to_dict", "(", ")", ",", "}", "return", "config_dict" ]

[ "if", "you", "introduce", "new", "save", "-", "able", "parameter", "dictionaries", "then", "you", "have", "to", "include", "them", "here" ]

[ "def", "qs_add", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "query", "=", "self", ".", "query", ".", "copy", "(", ")", "if", "args", ":", "mdict", "=", "MultiDict", "(", "args", "[", "0", "]", ")", "for", "k", ",", "v", "in", "mdict", ".", "items", "(", ")", ":", "query", ".", "add", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "kwargs", ".", "items", "(", ")", ":", "query", ".", "add", "(", "k", ",", "v", ")", "return", "self", ".", "_copy", "(", "query", "=", "query", ")" ]

[ "Add", "value", "to", "QuerySet", "MultiDict" ]

[ "def", "root_namespace", "(", "self", ",", "value", ")", ":", "if", "value", "is", "not", "None", ":", "assert", "type", "(", "value", ")", "is", "unicode", ",", "\"'{0}' attribute: '{1}' type is not 'unicode'!\"", ".", "format", "(", "\"root_namespace\"", ",", "value", ")", "self", ".", "__root_namespace", "=", "value" ]

[ "Setter", "for", "**", "self", ".", "__root_namespace", "**", "attribute", "." ]

[ "def", "connect_nodes", "(", "nodes", ")", ":", "for", "n", ",", "next_node", "in", "zip", "(", "nodes", ",", "nodes", "[", "1", ":", "]", ")", ":", "if", "isinstance", "(", "n", ",", "ControlFlowNode", ")", ":", "_connect_control_flow_node", "(", "n", ",", "next_node", ")", "elif", "isinstance", "(", "next_node", ",", "ControlFlowNode", ")", ":", "n", ".", "connect", "(", "next_node", ".", "test", ")", "elif", "isinstance", "(", "next_node", ",", "RestoreNode", ")", ":", "continue", "elif", "CALL_IDENTIFIER", "in", "next_node", ".", "label", ":", "continue", "else", ":", "n", ".", "connect", "(", "next_node", ")" ]

[ "Connect", "the", "nodes", "in", "a", "list", "linearly", "." ]

[ "def", "expire", "(", "self", ",", "age", ")", ":", "now", "=", "time", ".", "time", "(", ")", "cache", "=", "self", ".", "_acquire_cache", "(", ")", "expired", "=", "[", "k", "for", "k", ",", "v", "in", "cache", ".", "items", "(", ")", "if", "(", "now", "-", "v", "[", "0", "]", ")", ">", "age", "]", "for", "k", "in", "expired", ":", "if", "k", "in", "cache", ":", "del", "cache", "[", "k", "]", "if", "k", "in", "self", ".", "store", ":", "del", "self", ".", "store", "[", "k", "]", "self", ".", "_write_cache", "(", "cache", ")" ]

[ "Expire", "any", "items", "in", "the", "cache", "older", "than", "age", "seconds" ]

[ "def", "load_file", "(", "self", ",", "filename", ")", ":", "self", ".", "tree_editor", ".", "load_file", "(", "filename", ")", "self", ".", "project_name", ".", "configure", "(", "text", "=", "filename", ")", "self", ".", "currentfile", "=", "filename", "self", ".", "is_changed", "=", "False" ]

[ "Load", "xml", "into", "treeview" ]

[ "def", "fingerprint_from_file", "(", "filename", ")", ":", "cmd", "=", "flatten", "(", "[", "gnupg_bin", "(", ")", ",", "gnupg_home", "(", ")", ",", "filename", "]", ")", "outp", "=", "stderr_output", "(", "cmd", ")", ".", "split", "(", "'\\n'", ")", "if", "not", "outp", "[", "0", "]", ".", "startswith", "(", "'pub'", ")", ":", "raise", "CryptoritoError", "(", "'probably an invalid gpg key'", ")", "return", "outp", "[", "1", "]", ".", "strip", "(", ")" ]

[ "Extract", "a", "fingerprint", "from", "a", "GPG", "public", "key", "file" ]

[ "def", "_next_in_mro", "(", "cls", ")", ":", "next_in_mro", "=", "object", "# Look for the last occurrence of Generic or Generic[...].", "for", "i", ",", "c", "in", "enumerate", "(", "cls", ".", "__mro__", "[", ":", "-", "1", "]", ")", ":", "if", "isinstance", "(", "c", ",", "GenericMeta", ")", "and", "_gorg", "(", "c", ")", "is", "Generic", ":", "next_in_mro", "=", "cls", ".", "__mro__", "[", "i", "+", "1", "]", "return", "next_in_mro" ]

[ "Helper", "for", "Generic", ".", "__new__", "." ]

[ "def", "return_hdr", "(", "self", ")", ":", "# fieldtrip does not have this information", "orig", "=", "dict", "(", ")", "subj_id", "=", "str", "(", ")", "start_time", "=", "datetime", ".", "fromordinal", "(", "1", ")", "# fake", "try", ":", "ft_data", "=", "loadmat", "(", "self", ".", "filename", ",", "struct_as_record", "=", "True", ",", "squeeze_me", "=", "True", ")", "if", "VAR", "not", "in", "ft_data", ":", "raise", "KeyError", "(", "'Save the FieldTrip variable as '", "'{}'", "''", "''", ".", "format", "(", "VAR", ")", ")", "ft_data", "=", "ft_data", "[", "VAR", "]", "s_freq", "=", "ft_data", "[", "'fsample'", "]", ".", "astype", "(", "'float64'", ")", ".", "item", "(", ")", "n_samples", "=", "ft_data", "[", "'trial'", "]", ".", "item", "(", ")", ".", "shape", "[", "1", "]", "chan_name", "=", "list", "(", "ft_data", "[", "'label'", "]", ".", "item", "(", ")", ")", "except", "NotImplementedError", ":", "with", "File", "(", "self", ".", "filename", ")", "as", "f", ":", "if", "VAR", "not", "in", "f", ".", "keys", "(", ")", ":", "raise", "KeyError", "(", "'Save the FieldTrip variable as '", "'{}'", "''", "''", ".", "format", "(", "VAR", ")", ")", "s_freq", "=", "int", "(", "f", "[", "VAR", "]", "[", "'fsample'", "]", ".", "value", ".", "squeeze", "(", ")", ")", "chan_name", "=", "read_hdf5_chan_name", "(", "f", ",", "f", "[", "VAR", "]", "[", "'label'", "]", ")", "n_samples", "=", "int", "(", "around", "(", "f", "[", "f", "[", "VAR", "]", "[", "'trial'", "]", "[", "0", "]", ".", "item", "(", ")", "]", ".", "shape", "[", "0", "]", ")", ")", "return", "subj_id", ",", "start_time", ",", "s_freq", ",", "chan_name", ",", "n_samples", ",", "orig" ]

[ "Return", "the", "header", "for", "further", "use", "." ]

[ "def", "cmp_code_objects", "(", "version", ",", "is_pypy", ",", "code_obj1", ",", "code_obj2", ",", "verify", ",", "name", "=", "''", ")", ":", "# print code_obj1, type(code_obj2)", "assert", "iscode", "(", "code_obj1", ")", ",", "\"cmp_code_object first object type is %s, not code\"", "%", "type", "(", "code_obj1", ")", "assert", "iscode", "(", "code_obj2", ")", ",", "\"cmp_code_object second object type is %s, not code\"", "%", "type", "(", "code_obj2", ")", "# print dir(code_obj1)", "if", "isinstance", "(", "code_obj1", ",", "object", ")", ":", "# new style classes (Python 2.2)", "# assume _both_ code objects to be new stle classes", "assert", "dir", "(", "code_obj1", ")", "==", "dir", "(", "code_obj2", ")", "else", ":", "# old style classes", "assert", "dir", "(", "code_obj1", ")", "==", "code_obj1", ".", "__members__", "assert", "dir", "(", "code_obj2", ")", "==", "code_obj2", ".", "__members__", "assert", "code_obj1", ".", "__members__", "==", "code_obj2", ".", "__members__", "if", "name", "==", "'__main__'", ":", "name", "=", "code_obj1", ".", "co_name", "else", ":", "name", "=", "'%s.%s'", "%", "(", "name", ",", "code_obj1", ".", "co_name", ")", "if", "name", "==", "'.?'", ":", "name", "=", "'__main__'", "if", "isinstance", "(", "code_obj1", ",", "object", ")", "and", "code_equal", "(", "code_obj1", ",", "code_obj2", ")", ":", "# use the new style code-classes' __cmp__ method, which", "# should be faster and more sophisticated", "# if this compare fails, we use the old routine to", "# find out, what exactly is nor equal", "# if this compare succeds, simply return", "# return", "pass", "if", "isinstance", "(", "code_obj1", ",", "object", ")", ":", "members", "=", "[", "x", "for", "x", "in", "dir", "(", "code_obj1", ")", "if", "x", ".", "startswith", "(", "'co_'", ")", "]", "else", ":", "members", "=", "dir", "(", "code_obj1", ")", "members", ".", "sort", "(", ")", "# ; members.reverse()", "tokens1", "=", "None", "for", "member", "in", "members", ":", "if", "member", "in", "__IGNORE_CODE_MEMBERS__", "or", "verify", "!=", "'verify'", ":", "pass", "elif", "member", "==", "'co_code'", ":", "if", "verify", "!=", "'strong'", ":", "continue", "scanner", "=", "get_scanner", "(", "version", ",", "is_pypy", ",", "show_asm", "=", "False", ")", "global", "JUMP_OPS", "JUMP_OPS", "=", "list", "(", "scan", ".", "JUMP_OPS", ")", "+", "[", "'JUMP_BACK'", "]", "# use changed Token class", "# We (re)set this here to save exception handling,", "# which would get confusing.", "scanner", ".", "setTokenClass", "(", "Token", ")", "try", ":", "# ingest both code-objects", "tokens1", ",", "customize", "=", "scanner", ".", "ingest", "(", "code_obj1", ")", "del", "customize", "# save memory", "tokens2", ",", "customize", "=", "scanner", ".", "ingest", "(", "code_obj2", ")", "del", "customize", "# save memory", "finally", ":", "scanner", ".", "resetTokenClass", "(", ")", "# restore Token class", "targets1", "=", "dis", ".", "findlabels", "(", "code_obj1", ".", "co_code", ")", "tokens1", "=", "[", "t", "for", "t", "in", "tokens1", "if", "t", ".", "kind", "!=", "'COME_FROM'", "]", "tokens2", "=", "[", "t", "for", "t", "in", "tokens2", "if", "t", ".", "kind", "!=", "'COME_FROM'", "]", "i1", "=", "0", "i2", "=", "0", "offset_map", "=", "{", "}", "check_jumps", "=", "{", "}", "while", "i1", "<", "len", "(", "tokens1", ")", ":", "if", "i2", ">=", "len", "(", "tokens2", ")", ":", "if", "len", "(", "tokens1", ")", "==", "len", "(", "tokens2", ")", "+", "2", "and", "tokens1", "[", "-", "1", "]", ".", "kind", "==", "'RETURN_VALUE'", "and", "tokens1", "[", "-", "2", "]", ".", "kind", "==", "'LOAD_CONST'", "and", "tokens1", "[", "-", "2", "]", ".", "pattr", "is", "None", "and", "tokens1", "[", "-", "3", "]", ".", "kind", "==", "'RETURN_VALUE'", ":", "break", "else", ":", "raise", "CmpErrorCodeLen", "(", "name", ",", "tokens1", ",", "tokens2", ")", "offset_map", "[", "tokens1", "[", "i1", "]", ".", "offset", "]", "=", "tokens2", "[", "i2", "]", ".", "offset", "for", "idx1", ",", "idx2", ",", "offset2", "in", "check_jumps", ".", "get", "(", "tokens1", "[", "i1", "]", ".", "offset", ",", "[", "]", ")", ":", "if", "offset2", "!=", "tokens2", "[", "i2", "]", ".", "offset", ":", "raise", "CmpErrorCode", "(", "name", ",", "tokens1", "[", "idx1", "]", ".", "offset", ",", "tokens1", "[", "idx1", "]", ",", "tokens2", "[", "idx2", "]", ",", "tokens1", ",", "tokens2", ")", "if", "tokens1", "[", "i1", "]", ".", "kind", "!=", "tokens2", "[", "i2", "]", ".", "kind", ":", "if", "tokens1", "[", "i1", "]", ".", "kind", "==", "'LOAD_CONST'", "==", "tokens2", "[", "i2", "]", ".", "kind", ":", "i", "=", "1", "while", "tokens1", "[", "i1", "+", "i", "]", ".", "kind", "==", "'LOAD_CONST'", ":", "i", "+=", "1", "if", "tokens1", "[", "i1", "+", "i", "]", ".", "kind", ".", "startswith", "(", "(", "'BUILD_TUPLE'", ",", "'BUILD_LIST'", ")", ")", "and", "i", "==", "int", "(", "tokens1", "[", "i1", "+", "i", "]", ".", "kind", ".", "split", "(", "'_'", ")", "[", "-", "1", "]", ")", ":", "t", "=", "tuple", "(", "[", "elem", ".", "pattr", "for", "elem", "in", "tokens1", "[", "i1", ":", "i1", "+", "i", "]", "]", ")", "if", "t", "!=", "tokens2", "[", "i2", "]", ".", "pattr", ":", "raise", "CmpErrorCode", "(", "name", ",", "tokens1", "[", "i1", "]", ".", "offset", ",", "tokens1", "[", "i1", "]", ",", "tokens2", "[", "i2", "]", ",", "tokens1", ",", "tokens2", ")", "i1", "+=", "i", "+", "1", "i2", "+=", "1", "continue", "elif", "i", "==", "2", "and", "tokens1", "[", "i1", "+", "i", "]", ".", "kind", "==", "'ROT_TWO'", "and", "tokens2", "[", "i2", "+", "1", "]", ".", "kind", "==", "'UNPACK_SEQUENCE_2'", ":", "i1", "+=", "3", "i2", "+=", "2", "continue", "elif", "i", "==", "2", "and", "tokens1", "[", "i1", "+", "i", "]", ".", "kind", "in", "BIN_OP_FUNCS", ":", "f", "=", "BIN_OP_FUNCS", "[", "tokens1", "[", "i1", "+", "i", "]", ".", "kind", "]", "if", "f", "(", "tokens1", "[", "i1", "]", ".", "pattr", ",", "tokens1", "[", "i1", "+", "1", "]", ".", "pattr", ")", "==", "tokens2", "[", "i2", "]", ".", "pattr", ":", "i1", "+=", "3", "i2", "+=", "1", "continue", "elif", "tokens1", "[", "i1", "]", ".", "kind", "==", "'UNARY_NOT'", ":", "if", "tokens2", "[", "i2", "]", ".", "kind", "==", "'POP_JUMP_IF_TRUE'", ":", "if", "tokens1", "[", "i1", "+", "1", "]", ".", "kind", "==", "'POP_JUMP_IF_FALSE'", ":", "i1", "+=", "2", "i2", "+=", "1", "continue", "elif", "tokens2", "[", "i2", "]", ".", "kind", "==", "'POP_JUMP_IF_FALSE'", ":", "if", "tokens1", "[", "i1", "+", "1", "]", ".", "kind", "==", "'POP_JUMP_IF_TRUE'", ":", "i1", "+=", "2", "i2", "+=", "1", "continue", "elif", "tokens1", "[", "i1", "]", ".", "kind", "in", "(", "'JUMP_FORWARD'", ",", "'JUMP_BACK'", ")", "and", "tokens1", "[", "i1", "-", "1", "]", ".", "kind", "==", "'RETURN_VALUE'", "and", "tokens2", "[", "i2", "-", "1", "]", ".", "kind", "in", "(", "'RETURN_VALUE'", ",", "'RETURN_END_IF'", ")", "and", "int", "(", "tokens1", "[", "i1", "]", ".", "offset", ")", "not", "in", "targets1", ":", "i1", "+=", "1", "continue", "elif", "tokens1", "[", "i1", "]", ".", "kind", "==", "'JUMP_BACK'", "and", "tokens2", "[", "i2", "]", ".", "kind", "==", "'CONTINUE'", ":", "# FIXME: should make sure that offset is inside loop, not outside of it", "i1", "+=", "2", "i2", "+=", "2", "continue", "elif", "tokens1", "[", "i1", "]", ".", "kind", "==", "'JUMP_FORWARD'", "and", "tokens2", "[", "i2", "]", ".", "kind", "==", "'JUMP_BACK'", "and", "tokens1", "[", "i1", "+", "1", "]", ".", "kind", "==", "'JUMP_BACK'", "and", "tokens2", "[", "i2", "+", "1", "]", ".", "kind", "==", "'JUMP_BACK'", "and", "int", "(", "tokens1", "[", "i1", "]", ".", "pattr", ")", "==", "int", "(", "tokens1", "[", "i1", "]", ".", "offset", ")", "+", "3", ":", "if", "int", "(", "tokens1", "[", "i1", "]", ".", "pattr", ")", "==", "int", "(", "tokens1", "[", "i1", "+", "1", "]", ".", "offset", ")", ":", "i1", "+=", "2", "i2", "+=", "2", "continue", "elif", "tokens1", "[", "i1", "]", ".", "kind", "==", "'LOAD_NAME'", "and", "tokens2", "[", "i2", "]", ".", "kind", "==", "'LOAD_CONST'", "and", "tokens1", "[", "i1", "]", ".", "pattr", "==", "'None'", "and", "tokens2", "[", "i2", "]", ".", "pattr", "is", "None", ":", "pass", "elif", "tokens1", "[", "i1", "]", ".", "kind", "==", "'LOAD_GLOBAL'", "and", "tokens2", "[", "i2", "]", ".", "kind", "==", "'LOAD_NAME'", "and", "tokens1", "[", "i1", "]", ".", "pattr", "==", "tokens2", "[", "i2", "]", ".", "pattr", ":", "pass", "elif", "tokens1", "[", "i1", "]", ".", "kind", "==", "'LOAD_ASSERT'", "and", "tokens2", "[", "i2", "]", ".", "kind", "==", "'LOAD_NAME'", "and", "tokens1", "[", "i1", "]", ".", "pattr", "==", "tokens2", "[", "i2", "]", ".", "pattr", ":", "pass", "elif", "(", "tokens1", "[", "i1", "]", ".", "kind", "==", "'RETURN_VALUE'", "and", "tokens2", "[", "i2", "]", ".", "kind", "==", "'RETURN_END_IF'", ")", ":", "pass", "elif", "(", "tokens1", "[", "i1", "]", ".", "kind", "==", "'BUILD_TUPLE_0'", "and", "tokens2", "[", "i2", "]", ".", "pattr", "==", "(", ")", ")", ":", "pass", "else", ":", "raise", "CmpErrorCode", "(", "name", ",", "tokens1", "[", "i1", "]", ".", "offset", ",", "tokens1", "[", "i1", "]", ",", "tokens2", "[", "i2", "]", ",", "tokens1", ",", "tokens2", ")", "elif", "tokens1", "[", "i1", "]", ".", "kind", "in", "JUMP_OPS", "and", "tokens1", "[", "i1", "]", ".", "pattr", "!=", "tokens2", "[", "i2", "]", ".", "pattr", ":", "if", "tokens1", "[", "i1", "]", ".", "kind", "==", "'JUMP_BACK'", ":", "dest1", "=", "int", "(", "tokens1", "[", "i1", "]", ".", "pattr", ")", "dest2", "=", "int", "(", "tokens2", "[", "i2", "]", ".", "pattr", ")", "if", "offset_map", "[", "dest1", "]", "!=", "dest2", ":", "raise", "CmpErrorCode", "(", "name", ",", "tokens1", "[", "i1", "]", ".", "offset", ",", "tokens1", "[", "i1", "]", ",", "tokens2", "[", "i2", "]", ",", "tokens1", ",", "tokens2", ")", "else", ":", "# import pdb; pdb.set_trace()", "try", ":", "dest1", "=", "int", "(", "tokens1", "[", "i1", "]", ".", "pattr", ")", "if", "dest1", "in", "check_jumps", ":", "check_jumps", "[", "dest1", "]", ".", "append", "(", "(", "i1", ",", "i2", ",", "dest2", ")", ")", "else", ":", "check_jumps", "[", "dest1", "]", "=", "[", "(", "i1", ",", "i2", ",", "dest2", ")", "]", "except", ":", "pass", "i1", "+=", "1", "i2", "+=", "1", "del", "tokens1", ",", "tokens2", "# save memory", "elif", "member", "==", "'co_consts'", ":", "# partial optimization can make the co_consts look different,", "# so we'll just compare the code consts", "codes1", "=", "(", "c", "for", "c", "in", "code_obj1", ".", "co_consts", "if", "hasattr", "(", "c", ",", "'co_consts'", ")", ")", "codes2", "=", "(", "c", "for", "c", "in", "code_obj2", ".", "co_consts", "if", "hasattr", "(", "c", ",", "'co_consts'", ")", ")", "for", "c1", ",", "c2", "in", "zip", "(", "codes1", ",", "codes2", ")", ":", "cmp_code_objects", "(", "version", ",", "is_pypy", ",", "c1", ",", "c2", ",", "verify", ",", "name", "=", "name", ")", "elif", "member", "==", "'co_flags'", ":", "flags1", "=", "code_obj1", ".", "co_flags", "flags2", "=", "code_obj2", ".", "co_flags", "if", "is_pypy", ":", "# For PYPY for now we don't care about PYPY_SOURCE_IS_UTF8:", "flags2", "&=", "~", "0x0100", "# PYPY_SOURCE_IS_UTF8", "# We also don't care about COROUTINE or GENERATOR for now", "flags1", "&=", "~", "0x000000a0", "flags2", "&=", "~", "0x000000a0", "if", "flags1", "!=", "flags2", ":", "raise", "CmpErrorMember", "(", "name", ",", "'co_flags'", ",", "pretty_flags", "(", "flags1", ")", ",", "pretty_flags", "(", "flags2", ")", ")", "else", ":", "# all other members must be equal", "if", "getattr", "(", "code_obj1", ",", "member", ")", "!=", "getattr", "(", "code_obj2", ",", "member", ")", ":", "raise", "CmpErrorMember", "(", "name", ",", "member", ",", "getattr", "(", "code_obj1", ",", "member", ")", ",", "getattr", "(", "code_obj2", ",", "member", ")", ")" ]

[ "Compare", "two", "code", "-", "objects", "." ]

[ "def", "num_orifices", "(", "FlowPlant", ",", "RatioVCOrifice", ",", "HeadLossOrifice", ",", "DiamOrifice", ")", ":", "#Inputs do not need to be checked here because they are checked by", "#functions this function calls.", "return", "np", ".", "ceil", "(", "area_orifice", "(", "HeadLossOrifice", ",", "RatioVCOrifice", ",", "FlowPlant", ")", ".", "magnitude", "/", "area_circle", "(", "DiamOrifice", ")", ".", "magnitude", ")" ]

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

[ "def", "to_internal_value", "(", "self", ",", "data", ")", ":", "if", "html", ".", "is_html_input", "(", "data", ")", ":", "data", "=", "html", ".", "parse_html_dict", "(", "data", ")", "if", "not", "isinstance", "(", "data", ",", "dict", ")", ":", "self", ".", "fail", "(", "'not_a_dict'", ",", "input_type", "=", "type", "(", "data", ")", ".", "__name__", ")", "return", "{", "six", ".", "text_type", "(", "key", ")", ":", "self", ".", "child", ".", "run_validation", "(", "value", ")", "for", "key", ",", "value", "in", "data", ".", "items", "(", ")", "}" ]

[ "Dicts", "of", "native", "values", "<", "-", "Dicts", "of", "primitive", "datatypes", "." ]

[ "def", "checkpoint_filepath", "(", "checkpoint", ",", "pm", ")", ":", "# Handle case in which checkpoint is given not just as a string, but", "# as a checkpoint-like filename. Don't worry about absolute path status", "# of a potential filename input, or whether it's in the pipeline's", "# output folder. That's handled upstream. While this isn't a protected", "# function, there's no real reason to call this from outside the package.", "if", "isinstance", "(", "checkpoint", ",", "str", ")", ":", "if", "os", ".", "path", ".", "isabs", "(", "checkpoint", ")", ":", "if", "is_in_file_tree", "(", "checkpoint", ",", "pm", ".", "outfolder", ")", ":", "return", "checkpoint", "else", ":", "raise", "ValueError", "(", "\"Absolute checkpoint path '{}' is not in pipeline output \"", "\"folder '{}'\"", ".", "format", "(", "checkpoint", ",", "pm", ".", "outfolder", ")", ")", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "checkpoint", ")", "if", "ext", "==", "CHECKPOINT_EXTENSION", ":", "return", "pipeline_filepath", "(", "pm", ",", "filename", "=", "checkpoint", ")", "# Allow Pipeline as pm type without importing Pipeline.", "try", ":", "pm", "=", "pm", ".", "manager", "except", "AttributeError", ":", "pass", "# We want the checkpoint filename itself to become a suffix, with a", "# delimiter intervening between the pipeline name and the checkpoint", "# name + extension. This is to handle the case in which a single, e.g.,", "# sample's output folder is the destination for output from multiple", "# pipelines, and we thus want to be able to distinguish between", "# checkpoint files from different pipelines for that sample that may", "# well define one or more stages with the same name (e.g., trim_reads,", "# align_reads, etc.)", "chkpt_name", "=", "checkpoint_filename", "(", "checkpoint", ",", "pipeline_name", "=", "pm", ".", "name", ")", "return", "pipeline_filepath", "(", "pm", ",", "filename", "=", "chkpt_name", ")" ]

[ "Create", "filepath", "for", "indicated", "checkpoint", "." ]

[ "def", "loop_stop", "(", "self", ",", "force", "=", "False", ")", ":", "if", "self", ".", "_thread", "is", "None", ":", "return", "MQTT_ERR_INVAL", "self", ".", "_thread_terminate", "=", "True", "self", ".", "_thread", ".", "join", "(", ")", "self", ".", "_thread", "=", "None" ]

[ "This", "is", "part", "of", "the", "threaded", "client", "interface", ".", "Call", "this", "once", "to", "stop", "the", "network", "thread", "previously", "created", "with", "loop_start", "()", ".", "This", "call", "will", "block", "until", "the", "network", "thread", "finishes", "." ]

[ "def", "to_multidimensional", "(", "tpm", ")", ":", "# Cast to np.array.", "tpm", "=", "np", ".", "array", "(", "tpm", ")", "# Get the number of nodes.", "N", "=", "tpm", ".", "shape", "[", "-", "1", "]", "# Reshape. We use Fortran ordering here so that the rows use the", "# little-endian convention (least-significant bits correspond to low-index", "# nodes). Note that this does not change the actual memory layout (C- or", "# Fortran-contiguous), so there is no performance loss.", "return", "tpm", ".", "reshape", "(", "[", "2", "]", "*", "N", "+", "[", "N", "]", ",", "order", "=", "\"F\"", ")", ".", "astype", "(", "float", ")" ]

[ "Reshape", "a", "state", "-", "by", "-", "node", "TPM", "to", "the", "multidimensional", "form", "." ]

[ "def", "clipping_params", "(", "ts", ",", "capacity", "=", "100", ")", ":", "ts_sorted", "=", "ts", ".", "order", "(", "ascending", "=", "False", ")", "i", ",", "t0", ",", "t1", ",", "integral", "=", "1", ",", "None", ",", "None", ",", "0", "while", "integral", "<=", "capacity", "and", "i", "+", "1", "<", "len", "(", "ts", ")", ":", "i", "+=", "1", "t0_within_capacity", "=", "t0", "t1_within_capacity", "=", "t1", "t0", "=", "min", "(", "ts_sorted", ".", "index", "[", ":", "i", "]", ")", "t1", "=", "max", "(", "ts_sorted", ".", "index", "[", ":", "i", "]", ")", "integral", "=", "integrated_change", "(", "ts", "[", "t0", ":", "t1", "]", ")", "print", "i", ",", "t0", ",", "ts", "[", "t0", "]", ",", "t1", ",", "ts", "[", "t1", "]", ",", "integral", "if", "t0_within_capacity", "and", "t1_within_capacity", ":", "return", "t0_within_capacity", ",", "t1_within_capacity" ]

[ "Start", "and", "end", "index", "that", "clips", "the", "price", "/", "value", "of", "a", "time", "series", "the", "most" ]