Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "point", "(", "self", ")", ":", "string", "=", "unhexlify", "(", "self", ".", "unCompressed", "(", ")", ")", "return", "ecdsa", ".", "VerifyingKey", ".", "from_string", "(", "string", "[", "1", ":", "]", ",", "curve", "=", "ecdsa", ".", "SECP256k1", ")", ".", "pubkey", ".", "point" ]

[ "Return", "the", "point", "for", "the", "public", "key" ]

[ "def", "check_oversized_pickle", "(", "pickled", ",", "name", ",", "obj_type", ",", "worker", ")", ":", "length", "=", "len", "(", "pickled", ")", "if", "length", "<=", "ray_constants", ".", "PICKLE_OBJECT_WARNING_SIZE", ":", "return", "warning_message", "=", "(", "\"Warning: The {} {} has size {} when pickled. \"", "\"It will be stored in Redis, which could cause memory issues. \"", "\"This may mean that its definition uses a large array or other object.\"", ")", ".", "format", "(", "obj_type", ",", "name", ",", "length", ")", "push_error_to_driver", "(", "worker", ",", "ray_constants", ".", "PICKLING_LARGE_OBJECT_PUSH_ERROR", ",", "warning_message", ",", "driver_id", "=", "worker", ".", "task_driver_id", ")" ]

[ "Send", "a", "warning", "message", "if", "the", "pickled", "object", "is", "too", "large", "." ]

[ "def", "find_previous", "(", "element", ",", "l", ")", ":", "length", "=", "len", "(", "l", ")", "for", "index", ",", "current", "in", "enumerate", "(", "l", ")", ":", "# current is the last element", "if", "length", "-", "1", "==", "index", ":", "return", "current", "# current is the first element", "if", "index", "==", "0", ":", "if", "element", "<", "current", ":", "return", "None", "if", "current", "<=", "element", "<", "l", "[", "index", "+", "1", "]", ":", "return", "current" ]

[ "find", "previous", "element", "in", "a", "sorted", "list" ]

[ "def", "PSRLDQ", "(", "cpu", ",", "dest", ",", "src", ")", ":", "# TODO(yan): Verify the correctness of truncating SRC like this ( tests", "# use '-1' as the value", "temp", "=", "Operators", ".", "EXTRACT", "(", "src", ".", "read", "(", ")", ",", "0", ",", "8", ")", "temp", "=", "Operators", ".", "ITEBV", "(", "src", ".", "size", ",", "temp", ">", "15", ",", "16", ",", "temp", ")", "dest", ".", "write", "(", "dest", ".", "read", "(", ")", ">>", "(", "temp", "*", "8", ")", ")" ]

[ "Packed", "shift", "right", "logical", "double", "quadword", "." ]

[ "def", "__initialize_node", "(", "self", ",", "attributes_flags", "=", "int", "(", "Qt", ".", "ItemIsSelectable", "|", "Qt", ".", "ItemIsEnabled", ")", ")", ":", "attributes", "=", "dir", "(", "self", ".", "__component", ")", "for", "attribute", "in", "attributes", ":", "if", "attribute", "==", "\"name\"", ":", "continue", "if", "not", "\"_Profile__{0}\"", ".", "format", "(", "attribute", ")", "in", "attributes", ":", "continue", "value", "=", "getattr", "(", "self", ".", "__component", ",", "attribute", ")", "value", "=", "\", \"", ".", "join", "(", "value", ")", "if", "type", "(", "value", ")", "in", "(", "tuple", ",", "list", ")", "else", "value", "roles", "=", "{", "Qt", ".", "DisplayRole", ":", "value", ",", "Qt", ".", "EditRole", ":", "value", "}", "self", "[", "attribute", "]", "=", "umbra", ".", "ui", ".", "nodes", ".", "GraphModelAttribute", "(", "attribute", ",", "value", ",", "roles", ",", "attributes_flags", ")", "self", ".", "update_tool_tip", "(", ")" ]

[ "Initializes", "the", "node", "." ]

[ "def", "get_elemental_abunds", "(", "self", ",", "cycle", ",", "index", "=", "None", ")", ":", "isoabunds", "=", "self", ".", "se", ".", "get", "(", "cycle", ",", "'iso_massf'", ")", "A", "=", "array", "(", "self", ".", "se", ".", "A", ")", "Z", "=", "array", "(", "self", ".", "se", ".", "Z", ")", "names", "=", "self", ".", "se", ".", "isos", "Zuq", "=", "list", "(", "set", "(", "Z", ")", ")", "# list of unique Zs", "Zuq", ".", "sort", "(", ")", "if", "index", "==", "None", ":", "index", "=", "[", "0", ",", "len", "(", "isoabunds", ")", "]", "if", "type", "(", "index", ")", "==", "list", ":", "elemabunds", "=", "[", "]", "for", "zone", "in", "range", "(", "index", "[", "0", "]", ",", "index", "[", "1", "]", ")", ":", "percent", "=", "int", "(", "(", "zone", "-", "index", "[", "0", "]", ")", "*", "100.", "/", "(", "index", "[", "1", "]", "-", "index", "[", "0", "]", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stdout", ".", "write", "(", "\"\\rgetting elemental abundances \"", "+", "\"...%d%%\"", "%", "percent", ")", "elemabunds", ".", "append", "(", "[", "sum", "(", "isoabunds", "[", "zone", "]", "[", "where", "(", "Z", "==", "iZ", ")", "]", ")", "for", "iZ", "in", "Zuq", "]", ")", "else", ":", "elemabunds", "=", "[", "sum", "(", "isoabunds", "[", "index", "]", "[", "where", "(", "Z", "==", "iZ", ")", "]", ")", "for", "iZ", "in", "Zuq", "]", "return", "elemabunds" ]

[ "returns", "the", "elemental", "abundances", "for", "one", "cycle", "either", "for", "the", "whole", "star", "or", "a", "specific", "zone", "depending", "upon", "the", "value", "of", "index", "." ]

[ "def", "_add_text_size_ngrams", "(", "self", ",", "text_id", ",", "size", ",", "ngrams", ")", ":", "unique_ngrams", "=", "len", "(", "ngrams", ")", "self", ".", "_logger", ".", "info", "(", "'Adding {} unique {}-grams'", ".", "format", "(", "unique_ngrams", ",", "size", ")", ")", "parameters", "=", "[", "[", "text_id", ",", "ngram", ",", "size", ",", "count", "]", "for", "ngram", ",", "count", "in", "ngrams", ".", "items", "(", ")", "]", "with", "self", ".", "_conn", ":", "self", ".", "_conn", ".", "execute", "(", "constants", ".", "INSERT_TEXT_HAS_NGRAM_SQL", ",", "[", "text_id", ",", "size", ",", "unique_ngrams", "]", ")", "self", ".", "_conn", ".", "executemany", "(", "constants", ".", "INSERT_NGRAM_SQL", ",", "parameters", ")" ]

[ "Adds", "ngrams", "that", "are", "of", "size", "size", "to", "the", "data", "store", "." ]

[ "def", "_report_subject", "(", "self", ",", "subject", ",", "*", "*", "kwargs", ")", ":", "description_list", "=", "[", "]", "# Remove sess from kwargs if provided, else set sess as all available", "sessions", "=", "kwargs", ".", "pop", "(", "'session'", ",", "self", ".", "layout", ".", "get_sessions", "(", "subject", "=", "subject", ",", "*", "*", "kwargs", ")", ")", "if", "not", "sessions", ":", "sessions", "=", "[", "None", "]", "elif", "not", "isinstance", "(", "sessions", ",", "list", ")", ":", "sessions", "=", "[", "sessions", "]", "for", "ses", "in", "sessions", ":", "niftis", "=", "self", ".", "layout", ".", "get", "(", "subject", "=", "subject", ",", "extensions", "=", "'nii.gz'", ",", "*", "*", "kwargs", ")", "if", "niftis", ":", "description_list", ".", "append", "(", "'For session {0}:'", ".", "format", "(", "ses", ")", ")", "description_list", "+=", "parsing", ".", "parse_niftis", "(", "self", ".", "layout", ",", "niftis", ",", "subject", ",", "self", ".", "config", ",", "session", "=", "ses", ")", "metadata", "=", "self", ".", "layout", ".", "get_metadata", "(", "niftis", "[", "0", "]", ".", "path", ")", "else", ":", "raise", "Exception", "(", "'No niftis for subject {0}'", ".", "format", "(", "subject", ")", ")", "# Assume all data were converted the same way and use the last nifti", "# file's json for conversion information.", "if", "'metadata'", "not", "in", "vars", "(", ")", ":", "raise", "Exception", "(", "'No valid jsons found. Cannot generate final '", "'paragraph.'", ")", "description", "=", "'\\n\\t'", ".", "join", "(", "description_list", ")", "description", "=", "description", ".", "replace", "(", "'\\tFor session'", ",", "'\\nFor session'", ")", "description", "+=", "'\\n\\n{0}'", ".", "format", "(", "parsing", ".", "final_paragraph", "(", "metadata", ")", ")", "return", "description" ]

[ "Write", "a", "report", "for", "a", "single", "subject", "." ]

[ "def", "_validate", "(", "instance", ")", ":", "try", ":", "_", "=", "instance", ".", "schema", ".", "validate", "(", "instance", ".", "to_dict", "(", ")", ")", "except", "ValidationError", "as", "ex", ":", "raise", "ModelValidationError", "(", "ex", ".", "messages", ",", "ex", ".", "field_names", ",", "ex", ".", "fields", ",", "ex", ".", "data", ",", "*", "*", "ex", ".", "kwargs", ")" ]

[ "Validate", "the", "internal", "representation", "of", "the", "instance", "." ]

[ "def", "column_width", "(", "tokens", ")", ":", "get_len", "=", "tools", ".", "display_len", "if", "PY3", "else", "len", "lens", "=", "sorted", "(", "map", "(", "get_len", ",", "tokens", "or", "[", "]", ")", ")", "or", "[", "0", "]", "width", "=", "lens", "[", "-", "1", "]", "# adjust for disproportionately long strings", "if", "width", ">=", "18", ":", "most", "=", "lens", "[", "int", "(", "len", "(", "lens", ")", "*", "0.9", ")", "]", "if", "most", "<", "width", "+", "6", ":", "return", "most", "return", "width" ]

[ "Return", "a", "suitable", "column", "width", "to", "display", "one", "or", "more", "strings", "." ]

[ "def", "reset", "(", "self", ")", ":", "# Populate loaded_values with values from --config-file, if it was given.", "self", ".", "_loaded_values", "=", "{", "}", "if", "self", ".", "_flags", ".", "config_file", "is", "not", "None", ":", "self", ".", "load_from_file", "(", "self", ".", "_flags", ".", "config_file", ",", "_allow_undeclared", "=", "True", ")" ]

[ "Reset", "the", "loaded", "state", "of", "the", "configuration", "to", "what", "it", "was", "at", "import", "." ]

[ "def", "add", "(", "self", ",", "nb", "=", "1", ",", "name", "=", "None", ")", ":", "for", "x", "in", "xrange", "(", "nb", ")", ":", "self", ".", "count_lock", ".", "acquire", "(", ")", "self", ".", "shared", "[", "'workers'", "]", "+=", "1", "xid", "=", "self", ".", "shared", "[", "'workers'", "]", "self", ".", "kill_event", ".", "clear", "(", ")", "self", ".", "count_lock", ".", "release", "(", ")", "w", "=", "WorkerProc", "(", "xid", ",", "self", ".", "queue", ",", "self", ".", "shared", ",", "self", ".", "tasks", ",", "self", ".", "life_time", ",", "self", ".", "count_lock", ",", "self", ".", "kill_event", ")", "w", ".", "name", "=", "self", ".", "get_name", "(", "xid", ",", "name", ")", "w", ".", "start", "(", ")" ]

[ "Create", "one", "or", "many", "workers", "." ]

[ "def", "parse_ctuple", "(", "s", ",", "length", "=", "2", ")", ":", "if", "parse_utuple", "(", "s", ",", "colrx_s", ",", "length", "=", "length", ")", "is", "None", ":", "raise", "ValueError", "(", "\"{} is not a valid color tuple.\"", ".", "format", "(", "s", ")", ")", "#quote strings", "s", "=", "quote_subs", "(", "s", ",", "colorfix", "=", "True", ")", "return", "evalt", "(", "s", ")" ]

[ "parse", "a", "string", "of", "acceptable", "colors", "into", "matplotlib", "that", "is", "either", "strings", "or", "three", "tuples", "of", "rgb", ".", "Don", "t", "quote", "strings", "." ]

[ "def", "getmembers_runtime", "(", "self", ")", ":", "names", "=", "set", "(", ")", "for", "scope", "in", "self", ".", "scopes", ":", "names", ".", "update", "(", "structured", ".", "getmembers_runtime", "(", "scope", ")", ")", "return", "names" ]

[ "Gets", "members", "(", "vars", ")", "from", "all", "scopes", "using", "ONLY", "runtime", "information", "." ]

[ "def", "validateYesNo", "(", "value", ",", "blank", "=", "False", ",", "strip", "=", "None", ",", "allowlistRegexes", "=", "None", ",", "blocklistRegexes", "=", "None", ",", "yesVal", "=", "'yes'", ",", "noVal", "=", "'no'", ",", "caseSensitive", "=", "False", ",", "excMsg", "=", "None", ")", ":", "# Validate parameters. TODO - can probably improve this to remove the duplication.", "_validateGenericParameters", "(", "blank", "=", "blank", ",", "strip", "=", "strip", ",", "allowlistRegexes", "=", "allowlistRegexes", ",", "blocklistRegexes", "=", "blocklistRegexes", ")", "returnNow", ",", "value", "=", "_prevalidationCheck", "(", "value", ",", "blank", ",", "strip", ",", "allowlistRegexes", ",", "blocklistRegexes", ",", "excMsg", ")", "if", "returnNow", ":", "return", "value", "yesVal", "=", "str", "(", "yesVal", ")", "noVal", "=", "str", "(", "noVal", ")", "if", "len", "(", "yesVal", ")", "==", "0", ":", "raise", "PySimpleValidateException", "(", "'yesVal argument must be a non-empty string.'", ")", "if", "len", "(", "noVal", ")", "==", "0", ":", "raise", "PySimpleValidateException", "(", "'noVal argument must be a non-empty string.'", ")", "if", "(", "yesVal", "==", "noVal", ")", "or", "(", "not", "caseSensitive", "and", "yesVal", ".", "upper", "(", ")", "==", "noVal", ".", "upper", "(", ")", ")", ":", "raise", "PySimpleValidateException", "(", "'yesVal and noVal arguments must be different.'", ")", "if", "(", "yesVal", "[", "0", "]", "==", "noVal", "[", "0", "]", ")", "or", "(", "not", "caseSensitive", "and", "yesVal", "[", "0", "]", ".", "upper", "(", ")", "==", "noVal", "[", "0", "]", ".", "upper", "(", ")", ")", ":", "raise", "PySimpleValidateException", "(", "'first character of yesVal and noVal arguments must be different'", ")", "returnNow", ",", "value", "=", "_prevalidationCheck", "(", "value", ",", "blank", ",", "strip", ",", "allowlistRegexes", ",", "blocklistRegexes", ",", "excMsg", ")", "if", "returnNow", ":", "return", "value", "if", "caseSensitive", ":", "if", "value", "in", "(", "yesVal", ",", "yesVal", "[", "0", "]", ")", ":", "return", "yesVal", "elif", "value", "in", "(", "noVal", ",", "noVal", "[", "0", "]", ")", ":", "return", "noVal", "else", ":", "if", "value", ".", "upper", "(", ")", "in", "(", "yesVal", ".", "upper", "(", ")", ",", "yesVal", "[", "0", "]", ".", "upper", "(", ")", ")", ":", "return", "yesVal", "elif", "value", ".", "upper", "(", ")", "in", "(", "noVal", ".", "upper", "(", ")", ",", "noVal", "[", "0", "]", ".", "upper", "(", ")", ")", ":", "return", "noVal", "_raiseValidationException", "(", "_", "(", "'%r is not a valid %s/%s response.'", ")", "%", "(", "_errstr", "(", "value", ")", ",", "yesVal", ",", "noVal", ")", ",", "excMsg", ")" ]

[ "Raises", "ValidationException", "if", "value", "is", "not", "a", "yes", "or", "no", "response", ".", "Returns", "the", "yesVal", "or", "noVal", "argument", "not", "value", "." ]

[ "def", "shape", "(", "self", ")", "->", "Tuple", "[", "int", ",", "...", "]", ":", "return", "tuple", "(", "int", "(", "sub", ")", "for", "sub", "in", "self", ".", "ratios", ".", "shape", ")" ]

[ "The", "shape", "of", "array", "|anntools", ".", "SeasonalANN", ".", "ratios|", "." ]

[ "def", "transform_search_hit", "(", "self", ",", "pid", ",", "record_hit", ",", "links_factory", "=", "None", ",", "*", "*", "kwargs", ")", ":", "result", "=", "super", "(", "JSONLDTransformerMixin", ",", "self", ")", ".", "transform_search_hit", "(", "pid", ",", "record_hit", ",", "links_factory", ",", "*", "*", "kwargs", ")", "return", "self", ".", "transform_jsonld", "(", "result", ")" ]

[ "Transform", "search", "result", "hit", "into", "an", "intermediate", "representation", "." ]

[ "def", "fetch_robots_txt", "(", "self", ",", "request", ":", "Request", ",", "file", "=", "None", ")", ":", "url_info", "=", "request", ".", "url_info", "url", "=", "URLInfo", ".", "parse", "(", "'{0}://{1}/robots.txt'", ".", "format", "(", "url_info", ".", "scheme", ",", "url_info", ".", "hostname_with_port", ")", ")", ".", "url", "if", "not", "file", ":", "file", "=", "wpull", ".", "body", ".", "new_temp_file", "(", "os", ".", "getcwd", "(", ")", ",", "hint", "=", "'robots'", ")", "with", "contextlib", ".", "closing", "(", "file", ")", ":", "request", "=", "Request", "(", "url", ")", "session", "=", "self", ".", "_web_client", ".", "session", "(", "request", ")", "while", "not", "session", ".", "done", "(", ")", ":", "wpull", ".", "util", ".", "truncate_file", "(", "file", ".", "name", ")", "try", ":", "response", "=", "yield", "from", "session", ".", "start", "(", ")", "yield", "from", "session", ".", "download", "(", "file", "=", "file", ")", "except", "ProtocolError", ":", "self", ".", "_accept_as_blank", "(", "url_info", ")", "return", "status_code", "=", "response", ".", "status_code", "if", "500", "<=", "status_code", "<=", "599", ":", "raise", "ServerError", "(", "'Server returned error for robots.txt.'", ")", "if", "status_code", "==", "200", ":", "self", ".", "_read_content", "(", "response", ",", "url_info", ")", "else", ":", "self", ".", "_accept_as_blank", "(", "url_info", ")" ]

[ "Fetch", "the", "robots", ".", "txt", "file", "for", "the", "request", "." ]

[ "def", "map_to_matype", "(", "self", ",", "matype", ")", ":", "# Check if it is an integer or a string", "try", ":", "value", "=", "int", "(", "matype", ")", "if", "abs", "(", "value", ")", ">", "len", "(", "AlphaVantage", ".", "_ALPHA_VANTAGE_MATH_MAP", ")", ":", "raise", "ValueError", "(", "\"The value {} is not supported\"", ".", "format", "(", "value", ")", ")", "except", "ValueError", ":", "value", "=", "AlphaVantage", ".", "_ALPHA_VANTAGE_MATH_MAP", ".", "index", "(", "matype", ")", "return", "value" ]

[ "Convert", "to", "the", "alpha", "vantage", "math", "type", "integer", ".", "It", "returns", "an", "integer", "correspondent", "to", "the", "type", "of", "math", "to", "apply", "to", "a", "function", ".", "It", "raises", "ValueError", "if", "an", "integer", "greater", "than", "the", "supported", "math", "types", "is", "given", "." ]

[ "def", "delete_firewall_rule", "(", "self", ",", "firewall_rule", ")", ":", "firewall_rule_id", "=", "self", ".", "_find_firewall_rule_id", "(", "firewall_rule", ")", "ret", "=", "self", ".", "network_conn", ".", "delete_firewall_rule", "(", "firewall_rule_id", ")", "return", "ret", "if", "ret", "else", "True" ]

[ "Deletes", "the", "specified", "firewall", "rule" ]

[ "def", "proximal_step", "(", "self", ",", "grad", "=", "None", ")", ":", "if", "grad", "is", "None", ":", "grad", "=", "self", ".", "eval_grad", "(", ")", "V", "=", "self", ".", "Y", "-", "(", "1.", "/", "self", ".", "L", ")", "*", "grad", "self", ".", "X", "=", "self", ".", "eval_proxop", "(", "V", ")", "return", "grad" ]

[ "Compute", "proximal", "update", "(", "gradient", "descent", "+", "regularization", ")", "." ]

[ "def", "should_skip_logging", "(", "func", ")", ":", "disabled", "=", "strtobool", "(", "request", ".", "headers", ".", "get", "(", "\"x-request-nolog\"", ",", "\"false\"", ")", ")", "return", "disabled", "or", "getattr", "(", "func", ",", "SKIP_LOGGING", ",", "False", ")" ]

[ "Should", "we", "skip", "logging", "for", "this", "handler?" ]

[ "def", "_heapify_max", "(", "x", ")", ":", "n", "=", "len", "(", "x", ")", "for", "i", "in", "reversed", "(", "range", "(", "n", "//", "2", ")", ")", ":", "_siftup_max", "(", "x", ",", "i", ")" ]

[ "Transform", "list", "into", "a", "maxheap", "in", "-", "place", "in", "O", "(", "len", "(", "x", "))", "time", "." ]

[ "def", "ref_file", "(", "ticker", ":", "str", ",", "fld", ":", "str", ",", "has_date", "=", "False", ",", "cache", "=", "False", ",", "ext", "=", "'parq'", ",", "*", "*", "kwargs", ")", "->", "str", ":", "data_path", "=", "os", ".", "environ", ".", "get", "(", "assist", ".", "BBG_ROOT", ",", "''", ")", ".", "replace", "(", "'\\\\'", ",", "'/'", ")", "if", "(", "not", "data_path", ")", "or", "(", "not", "cache", ")", ":", "return", "''", "proper_ticker", "=", "ticker", ".", "replace", "(", "'/'", ",", "'_'", ")", "cache_days", "=", "kwargs", ".", "pop", "(", "'cache_days'", ",", "10", ")", "root", "=", "f'{data_path}/{ticker.split()[-1]}/{proper_ticker}/{fld}'", "if", "len", "(", "kwargs", ")", ">", "0", ":", "info", "=", "utils", ".", "to_str", "(", "kwargs", ")", "[", "1", ":", "-", "1", "]", ".", "replace", "(", "'|'", ",", "'_'", ")", "else", ":", "info", "=", "'ovrd=None'", "# Check date info", "if", "has_date", ":", "cur_dt", "=", "utils", ".", "cur_time", "(", ")", "missing", "=", "f'{root}/asof={cur_dt}, {info}.{ext}'", "to_find", "=", "re", ".", "compile", "(", "rf'{root}/asof=(.*), {info}\\.pkl'", ")", "cur_files", "=", "list", "(", "filter", "(", "to_find", ".", "match", ",", "sorted", "(", "files", ".", "all_files", "(", "path_name", "=", "root", ",", "keyword", "=", "info", ",", "ext", "=", "ext", ")", ")", ")", ")", "if", "len", "(", "cur_files", ")", ">", "0", ":", "upd_dt", "=", "to_find", ".", "match", "(", "cur_files", "[", "-", "1", "]", ")", ".", "group", "(", "1", ")", "diff", "=", "pd", ".", "Timestamp", "(", "'today'", ")", "-", "pd", ".", "Timestamp", "(", "upd_dt", ")", "if", "diff", ">=", "pd", ".", "Timedelta", "(", "days", "=", "cache_days", ")", ":", "return", "missing", "return", "sorted", "(", "cur_files", ")", "[", "-", "1", "]", "else", ":", "return", "missing", "else", ":", "return", "f'{root}/{info}.{ext}'" ]

[ "Data", "file", "location", "for", "Bloomberg", "reference", "data" ]

[ "def", "getQuotes", "(", "symbols", ")", ":", "if", "type", "(", "symbols", ")", "==", "type", "(", "'str'", ")", ":", "symbols", "=", "[", "symbols", "]", "content", "=", "json", ".", "loads", "(", "request", "(", "symbols", ")", ")", "return", "replaceKeys", "(", "content", ")" ]

[ "get", "real", "-", "time", "quotes", "(", "index", "last", "trade", "price", "last", "trade", "time", "etc", ")", "for", "stocks", "using", "google", "api", ":", "http", ":", "//", "finance", ".", "google", ".", "com", "/", "finance", "/", "info?client", "=", "ig&q", "=", "symbols" ]

[ "def", "extract", "(", "data", ")", ":", "_", ",", "tmp_file_path", "=", "tempfile", ".", "mkstemp", "(", ")", "try", ":", "with", "open", "(", "tmp_file_path", ",", "'wb'", ")", "as", "tmp_file", ":", "tmp_file", ".", "write", "(", "data", ")", "if", "zipfile", ".", "is_zipfile", "(", "tmp_file_path", ")", ":", "return", "extract_zip", "(", "tmp_file_path", ")", "else", ":", "raise", "DataSdkError", "(", "'Unsupported file type'", ")", "finally", ":", "shutil", ".", "rmtree", "(", "tmp_file_path", ",", "ignore_errors", "=", "True", ")" ]

[ "Args", ":", "data", "(", "str", "|", "byte", ")", ":" ]

[ "def", "getFriendlyString", "(", "self", ")", ":", "if", "self", ".", "_friendlyString", "is", "not", "None", ":", "return", "self", ".", "_friendlyString", "resultComponents", "=", "[", "self", ".", "getIntMajor", "(", ")", ",", "self", ".", "getIntMinor", "(", ")", ",", "self", ".", "getIntBuild", "(", ")", ",", "self", ".", "getIntRevision", "(", ")", "]", "for", "i", "in", "range", "(", "len", "(", "resultComponents", ")", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "if", "resultComponents", "[", "i", "]", "==", "0", ":", "del", "resultComponents", "[", "i", "]", "else", ":", "break", "result", "=", "\".\"", ".", "join", "(", "map", "(", "str", ",", "resultComponents", ")", ")", "self", ".", "_friendlyString", "=", "result", "return", "result" ]

[ "Returns", "the", "version", "printed", "in", "a", "friendly", "way", "." ]

[ "def", "print_to_screen", "(", "self", ",", "metrics_dict", ")", ":", "score_strings", "=", "defaultdict", "(", "list", ")", "for", "split_metric", ",", "value", "in", "metrics_dict", ".", "items", "(", ")", ":", "split", ",", "metric", "=", "split_metric", ".", "split", "(", "\"/\"", ",", "1", ")", "if", "isinstance", "(", "value", ",", "float", ")", ":", "score_strings", "[", "split", "]", ".", "append", "(", "f\"{metric}={value:0.3f}\"", ")", "else", ":", "score_strings", "[", "split", "]", ".", "append", "(", "f\"{metric}={value}\"", ")", "header", "=", "f\"{self.unit_total} {self.log_unit[:3]}\"", "if", "self", ".", "log_unit", "!=", "\"epochs\"", ":", "epochs", "=", "self", ".", "example_total", "/", "self", ".", "epoch_size", "header", "+=", "f\" ({epochs:0.2f} epo)\"", "string", "=", "f\"[{header}]:\"", "if", "score_strings", "[", "\"train\"", "]", ":", "train_scores", "=", "f\"{', '.join(score_strings['train'])}\"", "string", "+=", "f\" TRAIN:[{train_scores}]\"", "if", "score_strings", "[", "\"valid\"", "]", ":", "valid_scores", "=", "f\"{', '.join(score_strings['valid'])}\"", "string", "+=", "f\" VALID:[{valid_scores}]\"", "print", "(", "string", ")" ]

[ "Print", "all", "metrics", "in", "metrics_dict", "to", "screen" ]

[ "def", "transcribe", "(", "self", ",", "restore_model_path", ":", "Optional", "[", "str", "]", "=", "None", ")", "->", "None", ":", "saver", "=", "tf", ".", "train", ".", "Saver", "(", ")", "with", "tf", ".", "Session", "(", "config", "=", "allow_growth_config", ")", "as", "sess", ":", "if", "restore_model_path", ":", "saver", ".", "restore", "(", "sess", ",", "restore_model_path", ")", "else", ":", "if", "self", ".", "saved_model_path", ":", "saver", ".", "restore", "(", "sess", ",", "self", ".", "saved_model_path", ")", "else", ":", "raise", "PersephoneException", "(", "\"No model to use for transcription.\"", ")", "batch_gen", "=", "self", ".", "corpus_reader", ".", "untranscribed_batch_gen", "(", ")", "hyp_batches", "=", "[", "]", "for", "batch_i", ",", "batch", "in", "enumerate", "(", "batch_gen", ")", ":", "batch_x", ",", "batch_x_lens", ",", "feat_fn_batch", "=", "batch", "feed_dict", "=", "{", "self", ".", "batch_x", ":", "batch_x", ",", "self", ".", "batch_x_lens", ":", "batch_x_lens", "}", "[", "dense_decoded", "]", "=", "sess", ".", "run", "(", "[", "self", ".", "dense_decoded", "]", ",", "feed_dict", "=", "feed_dict", ")", "hyps", "=", "self", ".", "corpus_reader", ".", "human_readable", "(", "dense_decoded", ")", "# Prepare dir for transcription", "hyps_dir", "=", "os", ".", "path", ".", "join", "(", "self", ".", "exp_dir", ",", "\"transcriptions\"", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "hyps_dir", ")", ":", "os", ".", "mkdir", "(", "hyps_dir", ")", "hyp_batches", ".", "append", "(", "(", "hyps", ",", "feat_fn_batch", ")", ")", "with", "open", "(", "os", ".", "path", ".", "join", "(", "hyps_dir", ",", "\"hyps.txt\"", ")", ",", "\"w\"", ",", "encoding", "=", "ENCODING", ")", "as", "hyps_f", ":", "for", "hyp_batch", ",", "fn_batch", "in", "hyp_batches", ":", "for", "hyp", ",", "fn", "in", "zip", "(", "hyp_batch", ",", "fn_batch", ")", ":", "print", "(", "fn", ",", "file", "=", "hyps_f", ")", "print", "(", "\" \"", ".", "join", "(", "hyp", ")", ",", "file", "=", "hyps_f", ")", "print", "(", "\"\"", ",", "file", "=", "hyps_f", ")" ]

[ "Transcribes", "an", "untranscribed", "dataset", ".", "Similar", "to", "eval", "()", "except", "no", "reference", "translation", "is", "assumed", "thus", "no", "LER", "is", "calculated", "." ]

[ "def", "_get_node_text", "(", "self", ",", "goid", ",", "goobj", ")", ":", "txt", "=", "[", "]", "# Header line: \"GO:0036464 L04 D06\"", "txt", ".", "append", "(", "self", ".", "pltvars", ".", "fmthdr", ".", "format", "(", "GO", "=", "goobj", ".", "id", ".", "replace", "(", "\"GO:\"", ",", "\"GO\"", ")", ",", "level", "=", "goobj", ".", "level", ",", "depth", "=", "goobj", ".", "depth", ")", ")", "# GO name line: \"cytoplamic ribonucleoprotein\"", "name", "=", "goobj", ".", "name", ".", "replace", "(", "\",\"", ",", "\"\\n\"", ")", "txt", ".", "append", "(", "name", ")", "# study info line: \"24 genes\"", "study_txt", "=", "self", ".", "_get_study_txt", "(", "goid", ")", "if", "study_txt", "is", "not", "None", ":", "txt", ".", "append", "(", "study_txt", ")", "# return text string", "return", "\"\\n\"", ".", "join", "(", "txt", ")" ]

[ "Return", "a", "string", "to", "be", "printed", "in", "a", "GO", "term", "box", "." ]

[ "def", "updateReferenceURL", "(", "self", ",", "pid", ",", "name", ",", "ref_url", ",", "path", "=", "\"\"", ")", ":", "return", "self", ".", "updateReferencedFile", "(", "pid", ",", "path", ",", "name", ",", "ref_url", ")" ]

[ "Update", "a", "Referenced", "Content", "File", "(", ".", "url", ")" ]

[ "def", "precision", "(", "result", ",", "reference", ")", ":", "result", "=", "numpy", ".", "atleast_1d", "(", "result", ".", "astype", "(", "numpy", ".", "bool", ")", ")", "reference", "=", "numpy", ".", "atleast_1d", "(", "reference", ".", "astype", "(", "numpy", ".", "bool", ")", ")", "tp", "=", "numpy", ".", "count_nonzero", "(", "result", "&", "reference", ")", "fp", "=", "numpy", ".", "count_nonzero", "(", "result", "&", "~", "reference", ")", "try", ":", "precision", "=", "tp", "/", "float", "(", "tp", "+", "fp", ")", "except", "ZeroDivisionError", ":", "precision", "=", "0.0", "return", "precision" ]

[ "Precison", ".", "Parameters", "----------", "result", ":", "array_like", "Input", "data", "containing", "objects", ".", "Can", "be", "any", "type", "but", "will", "be", "converted", "into", "binary", ":", "background", "where", "0", "object", "everywhere", "else", ".", "reference", ":", "array_like", "Input", "data", "containing", "objects", ".", "Can", "be", "any", "type", "but", "will", "be", "converted", "into", "binary", ":", "background", "where", "0", "object", "everywhere", "else", ".", "Returns", "-------", "precision", ":", "float", "The", "precision", "between", "two", "binary", "datasets", "here", "mostly", "binary", "objects", "in", "images", "which", "is", "defined", "as", "the", "fraction", "of", "retrieved", "instances", "that", "are", "relevant", ".", "The", "precision", "is", "not", "symmetric", ".", "See", "also", "--------", ":", "func", ":", "recall", "Notes", "-----", "Not", "symmetric", ".", "The", "inverse", "of", "the", "precision", "is", ":", "func", ":", "recall", ".", "High", "precision", "means", "that", "an", "algorithm", "returned", "substantially", "more", "relevant", "results", "than", "irrelevant", ".", "References", "----------", "..", "[", "1", "]", "http", ":", "//", "en", ".", "wikipedia", ".", "org", "/", "wiki", "/", "Precision_and_recall", "..", "[", "2", "]", "http", ":", "//", "en", ".", "wikipedia", ".", "org", "/", "wiki", "/", "Confusion_matrix#Table_of_confusion" ]

[ "def", "api_key_post", "(", "params", ",", "request_path", ",", "_async", "=", "False", ")", ":", "method", "=", "'POST'", "timestamp", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", ".", "strftime", "(", "'%Y-%m-%dT%H:%M:%S'", ")", "params_to_sign", "=", "{", "'AccessKeyId'", ":", "ACCESS_KEY", ",", "'SignatureMethod'", ":", "'HmacSHA256'", ",", "'SignatureVersion'", ":", "'2'", ",", "'Timestamp'", ":", "timestamp", "}", "host_url", "=", "TRADE_URL", "host_name", "=", "urllib", ".", "parse", ".", "urlparse", "(", "host_url", ")", ".", "hostname", "host_name", "=", "host_name", ".", "lower", "(", ")", "secret_sign", "=", "createSign", "(", "params_to_sign", ",", "method", ",", "host_name", ",", "request_path", ",", "SECRET_KEY", ")", "params_to_sign", "[", "'Signature'", "]", "=", "secret_sign", "if", "PRIVATE_KEY", ":", "params_to_sign", "[", "'PrivateSignature'", "]", "=", "createPrivateSign", "(", "secret_sign", ",", "PRIVATE_KEY", ")", "url", "=", "host_url", "+", "request_path", "+", "'?'", "+", "urllib", ".", "parse", ".", "urlencode", "(", "params_to_sign", ")", "return", "http_post_request", "(", "url", ",", "params", ",", "_async", "=", "_async", ")" ]

[ "from", "火币demo", "构造post请求并调用post方法", ":", "param", "params", ":", ":", "param", "request_path", ":", ":", "return", ":" ]

[ "def", "stop", "(", "self", ",", "*", "*", "kwargs", ")", ":", "for", "key", "in", "kwargs", ":", "setattr", "(", "self", ",", "key", ",", "kwargs", "[", "key", "]", ")", "self", ".", "command", "=", "self", ".", "COMMAND_STOP" ]

[ "Stop", "any", "of", "the", "run", "commands", "before", "they", "are", "complete", "using", "the", "action", "specified", "by", "stop_action", "." ]

[ "def", "pairwise_tukey", "(", "dv", "=", "None", ",", "between", "=", "None", ",", "data", "=", "None", ",", "alpha", "=", ".05", ",", "tail", "=", "'two-sided'", ",", "effsize", "=", "'hedges'", ")", ":", "from", "pingouin", ".", "external", ".", "qsturng", "import", "psturng", "# First compute the ANOVA", "aov", "=", "anova", "(", "dv", "=", "dv", ",", "data", "=", "data", ",", "between", "=", "between", ",", "detailed", "=", "True", ")", "df", "=", "aov", ".", "loc", "[", "1", ",", "'DF'", "]", "ng", "=", "aov", ".", "loc", "[", "0", ",", "'DF'", "]", "+", "1", "grp", "=", "data", ".", "groupby", "(", "between", ")", "[", "dv", "]", "n", "=", "grp", ".", "count", "(", ")", ".", "values", "gmeans", "=", "grp", ".", "mean", "(", ")", ".", "values", "gvar", "=", "aov", ".", "loc", "[", "1", ",", "'MS'", "]", "/", "n", "# Pairwise combinations", "g1", ",", "g2", "=", "np", ".", "array", "(", "list", "(", "combinations", "(", "np", ".", "arange", "(", "ng", ")", ",", "2", ")", ")", ")", ".", "T", "mn", "=", "gmeans", "[", "g1", "]", "-", "gmeans", "[", "g2", "]", "se", "=", "np", ".", "sqrt", "(", "gvar", "[", "g1", "]", "+", "gvar", "[", "g2", "]", ")", "tval", "=", "mn", "/", "se", "# Critical values and p-values", "# from pingouin.external.qsturng import qsturng", "# crit = qsturng(1 - alpha, ng, df) / np.sqrt(2)", "pval", "=", "psturng", "(", "np", ".", "sqrt", "(", "2", ")", "*", "np", ".", "abs", "(", "tval", ")", ",", "ng", ",", "df", ")", "pval", "*=", "0.5", "if", "tail", "==", "'one-sided'", "else", "1", "# Uncorrected p-values", "# from scipy.stats import t", "# punc = t.sf(np.abs(tval), n[g1].size + n[g2].size - 2) * 2", "# Effect size", "d", "=", "tval", "*", "np", ".", "sqrt", "(", "1", "/", "n", "[", "g1", "]", "+", "1", "/", "n", "[", "g2", "]", ")", "ef", "=", "convert_effsize", "(", "d", ",", "'cohen'", ",", "effsize", ",", "n", "[", "g1", "]", ",", "n", "[", "g2", "]", ")", "# Create dataframe", "# Careful: pd.unique does NOT sort whereas numpy does", "stats", "=", "pd", ".", "DataFrame", "(", "{", "'A'", ":", "np", ".", "unique", "(", "data", "[", "between", "]", ")", "[", "g1", "]", ",", "'B'", ":", "np", ".", "unique", "(", "data", "[", "between", "]", ")", "[", "g2", "]", ",", "'mean(A)'", ":", "gmeans", "[", "g1", "]", ",", "'mean(B)'", ":", "gmeans", "[", "g2", "]", ",", "'diff'", ":", "mn", ",", "'SE'", ":", "np", ".", "round", "(", "se", ",", "3", ")", ",", "'tail'", ":", "tail", ",", "'T'", ":", "np", ".", "round", "(", "tval", ",", "3", ")", ",", "# 'alpha': alpha,", "# 'crit': np.round(crit, 3),", "'p-tukey'", ":", "pval", ",", "'efsize'", ":", "np", ".", "round", "(", "ef", ",", "3", ")", ",", "'eftype'", ":", "effsize", ",", "}", ")", "return", "stats" ]

[ "Pairwise", "Tukey", "-", "HSD", "post", "-", "hoc", "test", "." ]

[ "def", "get_client_for_file", "(", "self", ",", "filename", ")", ":", "client", "=", "None", "for", "idx", ",", "cl", "in", "enumerate", "(", "self", ".", "get_clients", "(", ")", ")", ":", "if", "self", ".", "filenames", "[", "idx", "]", "==", "filename", ":", "self", ".", "tabwidget", ".", "setCurrentIndex", "(", "idx", ")", "client", "=", "cl", "break", "return", "client" ]

[ "Get", "client", "associated", "with", "a", "given", "file", "." ]

[ "def", "get_object_type_by_name", "(", "object_type_name", ")", ":", "if", "object_type_name", "==", "b\"commit\"", ":", "from", ".", "import", "commit", "return", "commit", ".", "Commit", "elif", "object_type_name", "==", "b\"tag\"", ":", "from", ".", "import", "tag", "return", "tag", ".", "TagObject", "elif", "object_type_name", "==", "b\"blob\"", ":", "from", ".", "import", "blob", "return", "blob", ".", "Blob", "elif", "object_type_name", "==", "b\"tree\"", ":", "from", ".", "import", "tree", "return", "tree", ".", "Tree", "else", ":", "raise", "ValueError", "(", "\"Cannot handle unknown object type: %s\"", "%", "object_type_name", ")" ]

[ ":", "return", ":", "type", "suitable", "to", "handle", "the", "given", "object", "type", "name", ".", "Use", "the", "type", "to", "create", "new", "instances", "." ]

[ "def", "prox_tv", "(", "x", ",", "gamma", ",", "G", ",", "A", "=", "None", ",", "At", "=", "None", ",", "nu", "=", "1", ",", "tol", "=", "10e-4", ",", "maxit", "=", "200", ",", "use_matrix", "=", "True", ")", ":", "if", "A", "is", "None", ":", "def", "A", "(", "x", ")", ":", "return", "x", "if", "At", "is", "None", ":", "def", "At", "(", "x", ")", ":", "return", "x", "tight", "=", "0", "l1_nu", "=", "2", "*", "G", ".", "lmax", "*", "nu", "if", "use_matrix", ":", "def", "l1_a", "(", "x", ")", ":", "return", "G", ".", "Diff", "*", "A", "(", "x", ")", "def", "l1_at", "(", "x", ")", ":", "return", "G", ".", "Diff", "*", "At", "(", "D", ".", "T", "*", "x", ")", "else", ":", "def", "l1_a", "(", "x", ")", ":", "return", "G", ".", "grad", "(", "A", "(", "x", ")", ")", "def", "l1_at", "(", "x", ")", ":", "return", "G", ".", "div", "(", "x", ")", "functions", ",", "_", "=", "_import_pyunlocbox", "(", ")", "functions", ".", "norm_l1", "(", "x", ",", "gamma", ",", "A", "=", "l1_a", ",", "At", "=", "l1_at", ",", "tight", "=", "tight", ",", "maxit", "=", "maxit", ",", "verbose", "=", "verbose", ",", "tol", "=", "tol", ")" ]

[ "r", "Total", "Variation", "proximal", "operator", "for", "graphs", "." ]

[ "def", "_iexplode_path", "(", "path", ")", ":", "(", "head", ",", "tail", ")", "=", "os", ".", "path", ".", "split", "(", "path", ")", "if", "not", "head", "or", "(", "not", "tail", "and", "head", "==", "path", ")", ":", "if", "head", ":", "yield", "head", "if", "tail", "or", "not", "head", ":", "yield", "tail", "return", "for", "p", "in", "_iexplode_path", "(", "head", ")", ":", "yield", "p", "yield", "tail" ]

[ "Iterate", "over", "all", "the", "parts", "of", "a", "path", "." ]

[ "def", "load_yaml_from_docstring", "(", "docstring", ")", ":", "split_lines", "=", "trim_docstring", "(", "docstring", ")", ".", "split", "(", "\"\\n\"", ")", "# Cut YAML from rest of docstring", "for", "index", ",", "line", "in", "enumerate", "(", "split_lines", ")", ":", "line", "=", "line", ".", "strip", "(", ")", "if", "line", ".", "startswith", "(", "\"---\"", ")", ":", "cut_from", "=", "index", "break", "else", ":", "return", "{", "}", "yaml_string", "=", "\"\\n\"", ".", "join", "(", "split_lines", "[", "cut_from", ":", "]", ")", "yaml_string", "=", "dedent", "(", "yaml_string", ")", "return", "yaml", ".", "safe_load", "(", "yaml_string", ")", "or", "{", "}" ]

[ "Loads", "YAML", "from", "docstring", "." ]

[ "def", "get_prob", "(", "self", ",", "src", ",", "tgt", ",", "mask", ",", "pre_compute", ",", "return_logits", "=", "False", ")", ":", "s_shape", "=", "src", ".", "get_shape", "(", ")", ".", "as_list", "(", ")", "h_shape", "=", "tgt", ".", "get_shape", "(", ")", ".", "as_list", "(", ")", "src_dim", "=", "s_shape", "[", "-", "1", "]", "tgt_dim", "=", "h_shape", "[", "-", "1", "]", "assert", "src_dim", "is", "not", "None", ",", "'src dimension must be defined'", "assert", "tgt_dim", "is", "not", "None", ",", "'tgt dimension must be defined'", "self", ".", "_define_params", "(", "src_dim", ",", "tgt_dim", ")", "if", "len", "(", "h_shape", ")", "==", "2", ":", "tgt", "=", "tf", ".", "expand_dims", "(", "tgt", ",", "0", ")", "if", "pre_compute", "is", "None", ":", "pre_compute", "=", "self", ".", "get_pre_compute", "(", "src", ")", "buf0", "=", "pre_compute", "buf1", "=", "tf", ".", "tensordot", "(", "tgt", ",", "self", ".", "var", "[", "'U'", "]", ",", "axes", "=", "[", "[", "2", "]", ",", "[", "0", "]", "]", ")", "buf2", "=", "tf", ".", "tanh", "(", "tf", ".", "expand_dims", "(", "buf0", ",", "0", ")", "+", "tf", ".", "expand_dims", "(", "buf1", ",", "1", ")", ")", "if", "not", "self", ".", "is_vanilla", ":", "xh1", "=", "tgt", "xh2", "=", "tgt", "s1", "=", "src", "if", "self", ".", "need_padding", ":", "xh1", "=", "tf", ".", "tensordot", "(", "xh1", ",", "self", ".", "var", "[", "'V_t'", "]", ",", "1", ")", "xh2", "=", "tf", ".", "tensordot", "(", "xh2", ",", "self", ".", "var", "[", "'S_t'", "]", ",", "1", ")", "s1", "=", "tf", ".", "tensordot", "(", "s1", ",", "self", ".", "var", "[", "'V_s'", "]", ",", "1", ")", "if", "not", "self", ".", "is_identity_transform", ":", "xh1", "=", "tf", ".", "tensordot", "(", "xh1", ",", "self", ".", "var", "[", "'T'", "]", ",", "1", ")", "xh2", "=", "tf", ".", "tensordot", "(", "xh2", ",", "self", ".", "var", "[", "'T'", "]", ",", "1", ")", "buf3", "=", "tf", ".", "expand_dims", "(", "s1", ",", "0", ")", "*", "tf", ".", "expand_dims", "(", "xh1", ",", "1", ")", "buf3", "=", "tf", ".", "tanh", "(", "tf", ".", "tensordot", "(", "buf3", ",", "self", ".", "var", "[", "'V'", "]", ",", "axes", "=", "[", "[", "3", "]", ",", "[", "0", "]", "]", ")", ")", "buf", "=", "tf", ".", "reshape", "(", "tf", ".", "tanh", "(", "buf2", "+", "buf3", ")", ",", "shape", "=", "tf", ".", "shape", "(", "buf3", ")", ")", "else", ":", "buf", "=", "buf2", "v", "=", "self", ".", "var", "[", "'v'", "]", "e", "=", "tf", ".", "tensordot", "(", "buf", ",", "v", ",", "[", "[", "3", "]", ",", "[", "0", "]", "]", ")", "e", "=", "tf", ".", "squeeze", "(", "e", ",", "axis", "=", "[", "3", "]", ")", "tmp", "=", "tf", ".", "reshape", "(", "e", "+", "(", "mask", "-", "1", ")", "*", "10000.0", ",", "shape", "=", "tf", ".", "shape", "(", "e", ")", ")", "prob", "=", "tf", ".", "nn", ".", "softmax", "(", "tmp", ",", "1", ")", "if", "len", "(", "h_shape", ")", "==", "2", ":", "prob", "=", "tf", ".", "squeeze", "(", "prob", ",", "axis", "=", "[", "0", "]", ")", "tmp", "=", "tf", ".", "squeeze", "(", "tmp", ",", "axis", "=", "[", "0", "]", ")", "if", "return_logits", ":", "return", "prob", ",", "tmp", "return", "prob" ]

[ ":", "param", "s", ":", "[", "src_sequence_length", "batch_size", "src_dim", "]", ":", "param", "h", ":", "[", "batch_size", "tgt_dim", "]", "or", "[", "tgt_sequence_length", "batch_size", "tgt_dim", "]", ":", "param", "mask", ":", "[", "src_sequence_length", "batch_size", "]", "\\", "or", "[", "tgt_sequence_length", "src_sequence_length", "batch_sizse", "]", ":", "param", "pre_compute", ":", "[", "src_sequence_length", "batch_size", "hidden_dim", "]", ":", "return", ":", "[", "src_sequence_length", "batch_size", "]", "\\", "or", "[", "tgt_sequence_length", "src_sequence_length", "batch_size", "]" ]

[ "def", "publish", "(", "self", ",", "topic", ",", "payload", ",", "qos", ",", "retain", ")", ":", "self", ".", "_mqttc", ".", "publish", "(", "topic", ",", "payload", ",", "qos", ",", "retain", ")" ]

[ "Publish", "an", "MQTT", "message", "." ]

[ "def", "_build_vocab", "(", "self", ",", "sentences", ",", "markers", "=", "[", "]", ")", ":", "from", "snorkel", ".", "learning", ".", "pytorch", ".", "rnn", ".", "utils", "import", "SymbolTable", "vocab", "=", "Counter", "(", ")", "for", "sent", "in", "sentences", ":", "for", "w", "in", "sent", ":", "vocab", "[", "w", "]", "+=", "1", "word_dict", "=", "SymbolTable", "(", ")", "list", "(", "map", "(", "word_dict", ".", "get", ",", "vocab", ")", ")", "list", "(", "map", "(", "word_dict", ".", "get", ",", "markers", ")", ")", "return", "word_dict" ]

[ "Initalize", "symbol", "table", "dictionary" ]

[ "async", "def", "become", "(", "self", ",", "layer_type", ":", "Type", "[", "L", "]", ",", "request", ":", "'Request'", ")", "->", "L", ":", "raise", "ValueError", "(", "'Cannot become \"{}\"'", ".", "format", "(", "layer_type", ".", "__name__", ")", ")" ]

[ "Transform", "this", "layer", "into", "another", "layer", "type" ]

[ "def", "_fill_mi_header", "(", "row", ",", "control_row", ")", ":", "last", "=", "row", "[", "0", "]", "for", "i", "in", "range", "(", "1", ",", "len", "(", "row", ")", ")", ":", "if", "not", "control_row", "[", "i", "]", ":", "last", "=", "row", "[", "i", "]", "if", "row", "[", "i", "]", "==", "''", "or", "row", "[", "i", "]", "is", "None", ":", "row", "[", "i", "]", "=", "last", "else", ":", "control_row", "[", "i", "]", "=", "False", "last", "=", "row", "[", "i", "]", "return", "row", ",", "control_row" ]

[ "Forward", "fill", "blank", "entries", "in", "row", "but", "only", "inside", "the", "same", "parent", "index", "." ]

[ "def", "_model_fit_to_table", "(", "fit", ")", ":", "fit_parameters", "=", "pd", ".", "DataFrame", "(", "{", "'Coefficient'", ":", "fit", ".", "params", ",", "'Std. Error'", ":", "fit", ".", "bse", ",", "'T-Score'", ":", "fit", ".", "tvalues", "}", ")", "fit_parameters", ".", "rsquared", "=", "fit", ".", "rsquared", "fit_parameters", ".", "rsquared_adj", "=", "fit", ".", "rsquared_adj", "return", "fit_parameters" ]

[ "Produce", "a", "pandas", "DataFrame", "of", "model", "fit", "results", "from", "a", "statsmodels", "fit", "result", "object", "." ]

[ "def", "get_cytoband_coord", "(", "chrom", ",", "pos", ")", ":", "chrom", "=", "chrom", ".", "strip", "(", "'chr'", ")", "pos", "=", "int", "(", "pos", ")", "result", "=", "None", "logger", ".", "debug", "(", "\"Finding Cytoband for chrom:{0} pos:{1}\"", ".", "format", "(", "chrom", ",", "pos", ")", ")", "if", "chrom", "in", "CYTOBANDS", ":", "for", "interval", "in", "CYTOBANDS", "[", "chrom", "]", "[", "pos", "]", ":", "result", "=", "\"{0}{1}\"", ".", "format", "(", "chrom", ",", "interval", ".", "data", ")", "return", "result" ]

[ "Get", "the", "cytoband", "coordinate", "for", "a", "position" ]

[ "def", "proxy_upload", "(", "self", ",", "path", ",", "filename", ",", "content_type", "=", "None", ",", "content_encoding", "=", "None", ",", "cb", "=", "None", ",", "num_cb", "=", "None", ")", ":", "from", "boto", ".", "connection", "import", "AWSAuthConnection", "import", "mimetypes", "from", "hashlib", "import", "md5", "import", "base64", "BufferSize", "=", "65536", "## set to something very small to make sure", "## chunking is working properly", "fp", "=", "open", "(", "filename", ")", "headers", "=", "{", "'Content-Type'", ":", "content_type", "}", "if", "content_type", "is", "None", ":", "content_type", "=", "mimetypes", ".", "guess_type", "(", "filename", ")", "[", "0", "]", "or", "\"text/plain\"", "headers", "[", "'Content-Type'", "]", "=", "content_type", "if", "content_encoding", "is", "not", "None", ":", "headers", "[", "'Content-Encoding'", "]", "=", "content_encoding", "m", "=", "md5", "(", ")", "fp", ".", "seek", "(", "0", ")", "s", "=", "fp", ".", "read", "(", "BufferSize", ")", "while", "s", ":", "m", ".", "update", "(", "s", ")", "s", "=", "fp", ".", "read", "(", "BufferSize", ")", "self", ".", "size", "=", "fp", ".", "tell", "(", ")", "fp", ".", "seek", "(", "0", ")", "self", ".", "md5", "=", "m", ".", "hexdigest", "(", ")", "headers", "[", "'Content-MD5'", "]", "=", "base64", ".", "encodestring", "(", "m", ".", "digest", "(", ")", ")", ".", "rstrip", "(", "'\\n'", ")", "headers", "[", "'Content-Length'", "]", "=", "str", "(", "self", ".", "size", ")", "headers", "[", "'Expect'", "]", "=", "'100-Continue'", "host", ",", "headers", "=", "self", ".", "get_proxy_config", "(", "headers", ",", "path", ")", "### how to do this same thing with curl instead...", "print", "(", "\"curl -i --trace-ascii foo.log -T %s -H %s https://%s%s\"", "%", "(", "filename", ",", "\" -H \"", ".", "join", "(", "\"'%s: %s'\"", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "headers", ".", "items", "(", ")", ")", ",", "host", ",", "path", ")", ")", "def", "sender", "(", "http_conn", ",", "method", ",", "path", ",", "data", ",", "headers", ")", ":", "http_conn", ".", "putrequest", "(", "method", ",", "path", ")", "for", "key", "in", "headers", ":", "http_conn", ".", "putheader", "(", "key", ",", "headers", "[", "key", "]", ")", "http_conn", ".", "endheaders", "(", ")", "fp", ".", "seek", "(", "0", ")", "http_conn", ".", "set_debuglevel", "(", "0", ")", "### XXX set to e.g. 4 to see what going on", "if", "cb", ":", "if", "num_cb", ">", "2", ":", "cb_count", "=", "self", ".", "size", "/", "BufferSize", "/", "(", "num_cb", "-", "2", ")", "elif", "num_cb", "<", "0", ":", "cb_count", "=", "-", "1", "else", ":", "cb_count", "=", "0", "i", "=", "total_bytes", "=", "0", "cb", "(", "total_bytes", ",", "self", ".", "size", ")", "l", "=", "fp", ".", "read", "(", "BufferSize", ")", "while", "len", "(", "l", ")", ">", "0", ":", "http_conn", ".", "send", "(", "l", ")", "if", "cb", ":", "total_bytes", "+=", "len", "(", "l", ")", "i", "+=", "1", "if", "i", "==", "cb_count", "or", "cb_count", "==", "-", "1", ":", "cb", "(", "total_bytes", ",", "self", ".", "size", ")", "i", "=", "0", "l", "=", "fp", ".", "read", "(", "BufferSize", ")", "if", "cb", ":", "cb", "(", "total_bytes", ",", "self", ".", "size", ")", "response", "=", "http_conn", ".", "getresponse", "(", ")", "body", "=", "response", ".", "read", "(", ")", "fp", ".", "seek", "(", "0", ")", "if", "response", ".", "status", "==", "500", "or", "response", ".", "status", "==", "503", "or", "response", ".", "getheader", "(", "'location'", ")", ":", "# we'll try again", "return", "response", "elif", "response", ".", "status", ">=", "200", "and", "response", ".", "status", "<=", "299", ":", "self", ".", "etag", "=", "response", ".", "getheader", "(", "'etag'", ")", "if", "self", ".", "etag", "!=", "'\"%s\"'", "%", "self", ".", "md5", ":", "raise", "Exception", "(", "'ETag from S3 did not match computed MD5'", ")", "return", "response", "else", ":", "#raise provider.storage_response_error(", "# response.status, response.reason, body)", "raise", "Exception", "(", "response", ".", "status", ",", "response", ".", "reason", ",", "body", ")", "awsc", "=", "AWSAuthConnection", "(", "host", ",", "aws_access_key_id", "=", "\"key_id\"", ",", "aws_secret_access_key", "=", "\"secret\"", ")", "awsc", ".", "_mexe", "(", "'PUT'", ",", "path", ",", "None", ",", "headers", ",", "sender", "=", "sender", ")" ]

[ "This", "is", "the", "main", "function", "that", "uploads", ".", "We", "assume", "the", "bucket", "and", "key", "(", "==", "path", ")", "exists", ".", "What", "we", "do", "here", "is", "simple", ".", "Calculate", "the", "headers", "we", "will", "need", "(", "e", ".", "g", ".", "md5", "content", "-", "type", "etc", ")", ".", "Then", "we", "ask", "the", "self", ".", "get_proxy_config", "method", "to", "fill", "in", "the", "authentication", "information", "and", "tell", "us", "which", "remote", "host", "we", "should", "talk", "to", "for", "the", "upload", ".", "From", "there", "the", "rest", "is", "ripped", "from", "boto", ".", "key", ".", "Key", ".", "send_file" ]

[ "def", "ssh_invite", "(", "ctx", ",", "code_length", ",", "user", ",", "*", "*", "kwargs", ")", ":", "for", "name", ",", "value", "in", "kwargs", ".", "items", "(", ")", ":", "setattr", "(", "ctx", ".", "obj", ",", "name", ",", "value", ")", "from", ".", "import", "cmd_ssh", "ctx", ".", "obj", ".", "code_length", "=", "code_length", "ctx", ".", "obj", ".", "ssh_user", "=", "user", "return", "go", "(", "cmd_ssh", ".", "invite", ",", "ctx", ".", "obj", ")" ]

[ "Add", "a", "public", "-", "key", "to", "a", "~", "/", ".", "ssh", "/", "authorized_keys", "file" ]

[ "def", "resource_collection_create", "(", "self", ",", "data", ",", "*", "*", "kwargs", ")", ":", "api_path", "=", "\"/api/v2/resource_collections.json\"", "return", "self", ".", "call", "(", "api_path", ",", "method", "=", "\"POST\"", ",", "data", "=", "data", ",", "*", "*", "kwargs", ")" ]

[ "https", ":", "//", "developer", ".", "zendesk", ".", "com", "/", "rest_api", "/", "docs", "/", "core", "/", "resource_collections#create", "-", "a", "-", "resource", "-", "collection" ]

[ "def", "get_allowed_plugins", "(", "self", ",", "placeholder_slot", ")", ":", "# See if there is a limit imposed.", "slot_config", "=", "appsettings", ".", "FLUENT_CONTENTS_PLACEHOLDER_CONFIG", ".", "get", "(", "placeholder_slot", ")", "or", "{", "}", "plugins", "=", "slot_config", ".", "get", "(", "'plugins'", ")", "if", "not", "plugins", ":", "return", "self", ".", "get_plugins", "(", ")", "else", ":", "try", ":", "return", "self", ".", "get_plugins_by_name", "(", "*", "plugins", ")", "except", "PluginNotFound", "as", "e", ":", "raise", "PluginNotFound", "(", "str", "(", "e", ")", "+", "\" Update the plugin list of the FLUENT_CONTENTS_PLACEHOLDER_CONFIG['{0}'] setting.\"", ".", "format", "(", "placeholder_slot", ")", ")" ]

[ "Return", "the", "plugins", "which", "are", "supported", "in", "the", "given", "placeholder", "name", "." ]

[ "def", "index", "(", "self", ",", "state", ",", "code", "=", "None", ",", "error", "=", "None", ")", ":", "error", "=", "None", "if", "code", ":", "try", ":", "auth_token", "=", "self", ".", "fetch_token", "(", "code", ",", "state", ")", "except", "MissingTokenError", ":", "error", "=", "self", ".", "_fmt_failure", "(", "'Missing access token parameter.</br>Please check that '", "'you are using the correct client_secret'", ")", "except", "MismatchingStateError", ":", "error", "=", "self", ".", "_fmt_failure", "(", "'CSRF Warning! Mismatching state'", ")", "else", ":", "error", "=", "self", ".", "_fmt_failure", "(", "'Unknown error while authenticating'", ")", "# Use a thread to shutdown cherrypy so we can return HTML first", "self", ".", "_shutdown_cherrypy", "(", ")", "return", "error", "if", "error", "else", "self", ".", "success_html", "%", "(", "auth_token", ")" ]

[ "Receive", "a", "Exist", "response", "containing", "a", "verification", "code", ".", "Use", "the", "code", "to", "fetch", "the", "access_token", "." ]

[ "def", "create_comment", "(", "self", ",", "post_id", ",", "body", ")", ":", "path", "=", "'/msg/create_comment'", "req", "=", "ET", ".", "Element", "(", "'request'", ")", "comment", "=", "ET", ".", "SubElement", "(", "req", ",", "'comment'", ")", "ET", ".", "SubElement", "(", "comment", ",", "'post-id'", ")", ".", "text", "=", "str", "(", "int", "(", "post_id", ")", ")", "ET", ".", "SubElement", "(", "comment", ",", "'body'", ")", ".", "text", "=", "str", "(", "body", ")", "return", "self", ".", "_request", "(", "path", ",", "req", ")" ]

[ "Create", "a", "new", "comment", "associating", "it", "with", "a", "specific", "message", "." ]

[ "def", "add_ini_profile", "(", "self", ",", "cp", ",", "sec", ")", ":", "for", "opt", "in", "cp", ".", "options", "(", "sec", ")", ":", "namespace", "=", "opt", ".", "split", "(", "'|'", ")", "[", "0", "]", "if", "namespace", "==", "'pycbc'", "or", "namespace", "==", "'container'", ":", "continue", "value", "=", "string", ".", "strip", "(", "cp", ".", "get", "(", "sec", ",", "opt", ")", ")", "key", "=", "opt", ".", "split", "(", "'|'", ")", "[", "1", "]", "self", ".", "add_profile", "(", "namespace", ",", "key", ",", "value", ",", "force", "=", "True", ")", "# Remove if Pegasus can apply this hint in the TC", "if", "namespace", "==", "'hints'", "and", "key", "==", "'execution.site'", ":", "self", ".", "execution_site", "=", "value" ]

[ "Add", "profile", "from", "configuration", "file", "." ]

[ "def", "setup_task_signals", "(", "self", ",", ")", ":", "log", ".", "debug", "(", "\"Setting up task page signals.\"", ")", "self", ".", "task_user_view_pb", ".", "clicked", ".", "connect", "(", "self", ".", "task_view_user", ")", "self", ".", "task_user_add_pb", ".", "clicked", ".", "connect", "(", "self", ".", "task_add_user", ")", "self", ".", "task_user_remove_pb", ".", "clicked", ".", "connect", "(", "self", ".", "task_remove_user", ")", "self", ".", "task_dep_view_pb", ".", "clicked", ".", "connect", "(", "self", ".", "task_view_dep", ")", "self", ".", "task_link_view_pb", ".", "clicked", ".", "connect", "(", "self", ".", "task_view_link", ")", "self", ".", "task_deadline_de", ".", "dateChanged", ".", "connect", "(", "self", ".", "task_save", ")", "self", ".", "task_status_cb", ".", "currentIndexChanged", ".", "connect", "(", "self", ".", "task_save", ")" ]

[ "Setup", "the", "signals", "for", "the", "task", "page" ]

[ "def", "replace", "(", "self", ",", "entity_id", ",", "property_name", ",", "old_value", ",", "value", ")", ":", "if", "not", "entity_id", ".", "startswith", "(", "\"http\"", ")", ":", "entity_uri", "=", "'/'", ".", "join", "(", "[", "self", ".", "base_url", ",", "self", ".", "transaction", ",", "entity_id", "]", ")", "else", ":", "entity_uri", "=", "entity_id", "sparql_template", "=", "Template", "(", "\"\"\"$prefix\n DELETE {\n <$entity> $prop_name $old_value\n } INSERT {\n <$entity> $prop_name $new_value\n } WHERE {\n }\"\"\"", ")", "sparql", "=", "sparql_template", ".", "substitute", "(", "prefix", "=", "build_prefixes", "(", "self", ".", "namespaces", ")", ",", "entity", "=", "entity_uri", ",", "prop_name", "=", "property_name", ",", "old_value", "=", "self", ".", "__value_format__", "(", "old_value", ")", ",", "new_value", "=", "self", ".", "__value_format__", "(", "value", ")", ")", "update_request", "=", "urllib", ".", "request", ".", "Request", "(", "entity_uri", ",", "data", "=", "sparql", ".", "encode", "(", ")", ",", "method", "=", "'PATCH'", ",", "headers", "=", "{", "'Content-Type'", ":", "'application/sparql-update'", "}", ")", "response", "=", "urllib", ".", "request", ".", "urlopen", "(", "update_request", ")", "if", "response", ".", "code", "<", "400", ":", "return", "True", "return", "False" ]

[ "Method", "replaces", "a", "triple", "for", "the", "given", "entity", "/", "subject", ".", "Property", "name", "is", "from", "the", "schema", ".", "org", "vocabulary", "." ]

[ "def", "to_server_timezone", "(", "self", ",", "timezones", ",", "for_year", ")", ":", "candidates", "=", "set", "(", ")", "for", "tz_id", ",", "tz_name", ",", "tz_periods", ",", "tz_transitions", ",", "tz_transitions_groups", "in", "timezones", ":", "candidate", "=", "self", ".", "from_server_timezone", "(", "tz_periods", ",", "tz_transitions", ",", "tz_transitions_groups", ",", "for_year", ")", "if", "candidate", "==", "self", ":", "log", ".", "debug", "(", "'Found exact candidate: %s (%s)'", ",", "tz_id", ",", "tz_name", ")", "# We prefer this timezone over anything else. Return immediately.", "return", "tz_id", "# Reduce list based on base bias and standard / daylight bias values", "if", "candidate", ".", "bias", "!=", "self", ".", "bias", ":", "continue", "if", "candidate", ".", "standard_time", "is", "None", ":", "if", "self", ".", "standard_time", "is", "not", "None", ":", "continue", "else", ":", "if", "self", ".", "standard_time", "is", "None", ":", "continue", "if", "candidate", ".", "standard_time", ".", "bias", "!=", "self", ".", "standard_time", ".", "bias", ":", "continue", "if", "candidate", ".", "daylight_time", "is", "None", ":", "if", "self", ".", "daylight_time", "is", "not", "None", ":", "continue", "else", ":", "if", "self", ".", "daylight_time", "is", "None", ":", "continue", "if", "candidate", ".", "daylight_time", ".", "bias", "!=", "self", ".", "daylight_time", ".", "bias", ":", "continue", "log", ".", "debug", "(", "'Found candidate with matching biases: %s (%s)'", ",", "tz_id", ",", "tz_name", ")", "candidates", ".", "add", "(", "tz_id", ")", "if", "not", "candidates", ":", "raise", "ValueError", "(", "'No server timezones match this timezone definition'", ")", "if", "len", "(", "candidates", ")", "==", "1", ":", "log", ".", "info", "(", "'Could not find an exact timezone match for %s. Selecting the best candidate'", ",", "self", ")", "else", ":", "log", ".", "warning", "(", "'Could not find an exact timezone match for %s. Selecting a random candidate'", ",", "self", ")", "return", "candidates", ".", "pop", "(", ")" ]

[ "Returns", "the", "Microsoft", "timezone", "ID", "corresponding", "to", "this", "timezone", ".", "There", "may", "not", "be", "a", "match", "at", "all", "and", "there", "may", "be", "multiple", "matches", ".", "If", "so", "we", "return", "a", "random", "timezone", "ID", "." ]

[ "def", "_reflow_lines", "(", "parsed_tokens", ",", "indentation", ",", "max_line_length", ",", "start_on_prefix_line", ")", ":", "if", "unicode", "(", "parsed_tokens", "[", "0", "]", ")", "==", "'def'", ":", "# A function definition gets indented a bit more.", "continued_indent", "=", "indentation", "+", "' '", "*", "2", "*", "DEFAULT_INDENT_SIZE", "else", ":", "continued_indent", "=", "indentation", "+", "' '", "*", "DEFAULT_INDENT_SIZE", "break_after_open_bracket", "=", "not", "start_on_prefix_line", "lines", "=", "ReformattedLines", "(", "max_line_length", ")", "lines", ".", "add_indent", "(", "len", "(", "indentation", ".", "lstrip", "(", "'\\r\\n'", ")", ")", ")", "if", "not", "start_on_prefix_line", ":", "# If splitting after the opening bracket will cause the first element", "# to be aligned weirdly, don't try it.", "first_token", "=", "get_item", "(", "parsed_tokens", ",", "0", ")", "second_token", "=", "get_item", "(", "parsed_tokens", ",", "1", ")", "if", "(", "first_token", "and", "second_token", "and", "unicode", "(", "second_token", ")", "[", "0", "]", "==", "'('", "and", "len", "(", "indentation", ")", "+", "len", "(", "first_token", ")", "+", "1", "==", "len", "(", "continued_indent", ")", ")", ":", "return", "None", "for", "item", "in", "parsed_tokens", ":", "lines", ".", "add_space_if_needed", "(", "unicode", "(", "item", ")", ",", "equal", "=", "True", ")", "save_continued_indent", "=", "continued_indent", "if", "start_on_prefix_line", "and", "isinstance", "(", "item", ",", "Container", ")", ":", "start_on_prefix_line", "=", "False", "continued_indent", "=", "' '", "*", "(", "lines", ".", "current_size", "(", ")", "+", "1", ")", "item", ".", "reflow", "(", "lines", ",", "continued_indent", ",", "break_after_open_bracket", ")", "continued_indent", "=", "save_continued_indent", "return", "lines", ".", "emit", "(", ")" ]

[ "Reflow", "the", "lines", "so", "that", "it", "looks", "nice", "." ]

[ "def", "tree_find", "(", "self", ",", "symbol", ",", "origin", ",", "attribute", ")", ":", "#The symbol must be accessible to the origin module, otherwise", "#it wouldn't compile. Start there, first looking at the origin", "#itself and then the other modules that it depends on.", "#Since we will be referring to this multiple times, might as ", "#well get a pointer to it.", "oattr", "=", "origin", ".", "collection", "(", "attribute", ")", "base", "=", "None", "lorigin", "=", "None", "if", "symbol", "in", "oattr", ":", "base", "=", "oattr", "[", "symbol", "]", "lorigin", "=", "origin", "else", ":", "for", "module", "in", "origin", ".", "dependencies", ":", "usespec", "=", "module", ".", "split", "(", "\".\"", ")", "if", "len", "(", "usespec", ")", ">", "1", ":", "if", "usespec", "[", "1", "]", "==", "symbol", ":", "#The dependency is to a specific element in the module,", "#and it matches.", "lorigin", "=", "self", ".", "get", "(", "usespec", "[", "0", "]", ")", "else", ":", "lorigin", "=", "None", "else", ":", "#The dependency is to the entire module!", "lorigin", "=", "self", ".", "get", "(", "usespec", "[", "0", "]", ")", "#If we have code for the origin, we can search for the", "#actual base object that we are interested in", "if", "lorigin", "is", "not", "None", ":", "lattr", "=", "lorigin", ".", "collection", "(", "attribute", ")", "if", "symbol", "in", "lattr", ":", "base", "=", "lattr", "[", "symbol", "]", "break", "#By now, we either have the item we were after or we don't have", "#code for the module it needs", "return", "(", "base", ",", "lorigin", ")" ]

[ "Finds", "the", "code", "element", "corresponding", "to", "specified", "symbol", "by", "searching", "all", "modules", "in", "the", "parser", "." ]

[ "def", "create_host_only_network_interface", "(", "self", ")", ":", "(", "progress", ",", "host_interface", ")", "=", "self", ".", "_call", "(", "\"createHostOnlyNetworkInterface\"", ")", "progress", "=", "IProgress", "(", "progress", ")", "host_interface", "=", "IHostNetworkInterface", "(", "host_interface", ")", "return", "(", "progress", ",", "host_interface", ")" ]

[ "Creates", "a", "new", "adapter", "for", "Host", "Only", "Networking", "." ]

[ "def", "validateElement", "(", "self", ",", "doc", ",", "elem", ")", ":", "if", "doc", "is", "None", ":", "doc__o", "=", "None", "else", ":", "doc__o", "=", "doc", ".", "_o", "if", "elem", "is", "None", ":", "elem__o", "=", "None", "else", ":", "elem__o", "=", "elem", ".", "_o", "ret", "=", "libxml2mod", ".", "xmlValidateElement", "(", "self", ".", "_o", ",", "doc__o", ",", "elem__o", ")", "return", "ret" ]

[ "Try", "to", "validate", "the", "subtree", "under", "an", "element" ]

[ "def", "process_orders", "(", "self", ",", "orderbook", ")", ":", "for", "stock", ",", "alloc", "in", "orderbook", ".", "iteritems", "(", ")", ":", "self", ".", "logger", ".", "info", "(", "'{}: Ordered {} {} stocks'", ".", "format", "(", "self", ".", "datetime", ",", "stock", ",", "alloc", ")", ")", "if", "isinstance", "(", "alloc", ",", "int", ")", ":", "self", ".", "order", "(", "stock", ",", "alloc", ")", "elif", "isinstance", "(", "alloc", ",", "float", ")", "and", "alloc", ">=", "-", "1", "and", "alloc", "<=", "1", ":", "self", ".", "order_percent", "(", "stock", ",", "alloc", ")", "else", ":", "self", ".", "logger", ".", "warning", "(", "'{}: invalid order for {}: {})'", ".", "format", "(", "self", ".", "datetime", ",", "stock", ",", "alloc", ")", ")" ]

[ "Default", "and", "costant", "orders", "processor", ".", "Overwrite", "it", "for", "more", "sophisticated", "strategies" ]

[ "def", "delete_dataset", "(", "self", ",", "owner", ",", "id", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'callback'", ")", ":", "return", "self", ".", "delete_dataset_with_http_info", "(", "owner", ",", "id", ",", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "self", ".", "delete_dataset_with_http_info", "(", "owner", ",", "id", ",", "*", "*", "kwargs", ")", "return", "data" ]

[ "Delete", "a", "dataset", "Permanently", "deletes", "a", "dataset", "and", "all", "data", "associated", "with", "it", ".", "This", "operation", "cannot", "be", "undone", "although", "a", "new", "dataset", "may", "be", "created", "with", "the", "same", "id", ".", "This", "method", "makes", "a", "synchronous", "HTTP", "request", "by", "default", ".", "To", "make", "an", "asynchronous", "HTTP", "request", "please", "define", "a", "callback", "function", "to", "be", "invoked", "when", "receiving", "the", "response", ".", ">>>", "def", "callback_function", "(", "response", ")", ":", ">>>", "pprint", "(", "response", ")", ">>>", ">>>", "thread", "=", "api", ".", "delete_dataset", "(", "owner", "id", "callback", "=", "callback_function", ")" ]

[ "def", "commit_input_confirmed", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "commit", "=", "ET", ".", "Element", "(", "\"commit\"", ")", "config", "=", "commit", "input", "=", "ET", ".", "SubElement", "(", "commit", ",", "\"input\"", ")", "confirmed", "=", "ET", ".", "SubElement", "(", "input", ",", "\"confirmed\"", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

[ "Auto", "Generated", "Code" ]

[ "def", "containsi", "(", "self", ",", "begin", ",", "end", ",", "data", "=", "None", ")", ":", "return", "Interval", "(", "begin", ",", "end", ",", "data", ")", "in", "self" ]

[ "Shortcut", "for", "(", "Interval", "(", "begin", "end", "data", ")", "in", "tree", ")", "." ]

[ "def", "set_state", "(", "self", ",", "state", ")", ":", "SimStatePlugin", ".", "set_state", "(", "self", ",", "state", ")", "# Delayed initialization", "stack_region_map", ",", "generic_region_map", "=", "self", ".", "_temp_stack_region_map", ",", "self", ".", "_temp_generic_region_map", "if", "stack_region_map", "or", "generic_region_map", ":", "# Inherited from its parent", "self", ".", "_stack_region_map", "=", "stack_region_map", ".", "copy", "(", ")", "self", ".", "_generic_region_map", "=", "generic_region_map", ".", "copy", "(", ")", "else", ":", "if", "not", "self", ".", "_abstract_backer", "and", "o", ".", "REGION_MAPPING", "in", "self", ".", "state", ".", "options", ":", "# Only the top-level SimMemory instance can have region maps.", "self", ".", "_stack_region_map", "=", "RegionMap", "(", "True", ")", "self", ".", "_generic_region_map", "=", "RegionMap", "(", "False", ")", "else", ":", "self", ".", "_stack_region_map", "=", "None", "self", ".", "_generic_region_map", "=", "None" ]

[ "Call", "the", "set_state", "method", "in", "SimStatePlugin", "class", "and", "then", "perform", "the", "delayed", "initialization", "." ]

[ "def", "do_GET", "(", "self", ")", ":", "handler", "=", "self", ".", "uri_map", ".", "get", "(", "self", ".", "path", ")", "or", "self", ".", "_handle_other", "content", ",", "content_type", "=", "handler", "(", ")", "compressed_content", "=", "gzip", ".", "compress", "(", "content", ")", "self", ".", "_send_response", "(", "200", ",", "headers", "=", "(", "(", "'Content-type'", ",", "'%s; charset=utf-8'", "%", "content_type", ")", ",", "(", "'Content-Encoding'", ",", "'gzip'", ")", ",", "(", "'Content-Length'", ",", "len", "(", "compressed_content", ")", ")", ")", ")", "self", ".", "wfile", ".", "write", "(", "compressed_content", ")" ]

[ "Handles", "HTTP", "GET", "requests", "." ]

[ "def", "copy", "(", "self", ")", ":", "df", "=", "super", "(", "Ensemble", ",", "self", ")", ".", "copy", "(", ")", "pe", "=", "ParameterEnsemble", ".", "from_dataframe", "(", "df", "=", "df", ",", "pst", "=", "self", ".", "pst", ".", "get", "(", ")", ")", "pe", ".", "__istransformed", "=", "self", ".", "istransformed", "return", "pe" ]

[ "overload", "of", "Ensemble", ".", "copy", "()" ]

[ "def", "load_variants", "(", "self", ",", "case_obj", ",", "variant_type", "=", "'clinical'", ",", "category", "=", "'snv'", ",", "rank_threshold", "=", "None", ",", "chrom", "=", "None", ",", "start", "=", "None", ",", "end", "=", "None", ",", "gene_obj", "=", "None", ",", "build", "=", "'37'", ")", ":", "# We need the institute object", "institute_id", "=", "self", ".", "institute", "(", "institute_id", "=", "case_obj", "[", "'owner'", "]", ")", "[", "'_id'", "]", "nr_inserted", "=", "0", "variant_file", "=", "None", "if", "variant_type", "==", "'clinical'", ":", "if", "category", "==", "'snv'", ":", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_snv'", ")", "elif", "category", "==", "'sv'", ":", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_sv'", ")", "elif", "category", "==", "'str'", ":", "LOG", ".", "debug", "(", "'Attempt to load STR VCF.'", ")", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_str'", ")", "elif", "category", "==", "'cancer'", ":", "# Currently this implies a paired tumor normal", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_cancer'", ")", "elif", "variant_type", "==", "'research'", ":", "if", "category", "==", "'snv'", ":", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_snv_research'", ")", "elif", "category", "==", "'sv'", ":", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_sv_research'", ")", "elif", "category", "==", "'cancer'", ":", "variant_file", "=", "case_obj", "[", "'vcf_files'", "]", ".", "get", "(", "'vcf_cancer_research'", ")", "if", "not", "variant_file", ":", "raise", "SyntaxError", "(", "\"Vcf file does not seem to exist\"", ")", "# Check if there are any variants in file", "try", ":", "vcf_obj", "=", "VCF", "(", "variant_file", ")", "var", "=", "next", "(", "vcf_obj", ")", "except", "StopIteration", "as", "err", ":", "LOG", ".", "warning", "(", "\"Variant file %s does not include any variants\"", ",", "variant_file", ")", "return", "nr_inserted", "# We need to reload the file", "vcf_obj", "=", "VCF", "(", "variant_file", ")", "# Parse the neccessary headers from vcf file", "rank_results_header", "=", "parse_rank_results_header", "(", "vcf_obj", ")", "vep_header", "=", "parse_vep_header", "(", "vcf_obj", ")", "# This is a dictionary to tell where ind are in vcf", "individual_positions", "=", "{", "}", "for", "i", ",", "ind", "in", "enumerate", "(", "vcf_obj", ".", "samples", ")", ":", "individual_positions", "[", "ind", "]", "=", "i", "# Dictionary for cancer analysis", "sample_info", "=", "{", "}", "if", "category", "==", "'cancer'", ":", "for", "ind", "in", "case_obj", "[", "'individuals'", "]", ":", "if", "ind", "[", "'phenotype'", "]", "==", "2", ":", "sample_info", "[", "ind", "[", "'individual_id'", "]", "]", "=", "'case'", "else", ":", "sample_info", "[", "ind", "[", "'individual_id'", "]", "]", "=", "'control'", "# Check if a region scould be uploaded", "region", "=", "\"\"", "if", "gene_obj", ":", "chrom", "=", "gene_obj", "[", "'chromosome'", "]", "# Add same padding as VEP", "start", "=", "max", "(", "gene_obj", "[", "'start'", "]", "-", "5000", ",", "0", ")", "end", "=", "gene_obj", "[", "'end'", "]", "+", "5000", "if", "chrom", ":", "# We want to load all variants in the region regardless of rank score", "rank_threshold", "=", "rank_threshold", "or", "-", "1000", "if", "not", "(", "start", "and", "end", ")", ":", "raise", "SyntaxError", "(", "\"Specify chrom start and end\"", ")", "region", "=", "\"{0}:{1}-{2}\"", ".", "format", "(", "chrom", ",", "start", ",", "end", ")", "else", ":", "rank_threshold", "=", "rank_threshold", "or", "0", "variants", "=", "vcf_obj", "(", "region", ")", "try", ":", "nr_inserted", "=", "self", ".", "_load_variants", "(", "variants", "=", "variants", ",", "variant_type", "=", "variant_type", ",", "case_obj", "=", "case_obj", ",", "individual_positions", "=", "individual_positions", ",", "rank_threshold", "=", "rank_threshold", ",", "institute_id", "=", "institute_id", ",", "build", "=", "build", ",", "rank_results_header", "=", "rank_results_header", ",", "vep_header", "=", "vep_header", ",", "category", "=", "category", ",", "sample_info", "=", "sample_info", ")", "except", "Exception", "as", "error", ":", "LOG", ".", "exception", "(", "'unexpected error'", ")", "LOG", ".", "warning", "(", "\"Deleting inserted variants\"", ")", "self", ".", "delete_variants", "(", "case_obj", "[", "'_id'", "]", ",", "variant_type", ")", "raise", "error", "self", ".", "update_variant_rank", "(", "case_obj", ",", "variant_type", ",", "category", "=", "category", ")", "return", "nr_inserted" ]

[ "Load", "variants", "for", "a", "case", "into", "scout", "." ]

[ "def", "conditions_met", "(", "self", ",", "instance", ",", "state", ")", ":", "transition", "=", "self", ".", "get_transition", "(", "state", ")", "if", "transition", "is", "None", ":", "return", "False", "elif", "transition", ".", "conditions", "is", "None", ":", "return", "True", "else", ":", "return", "all", "(", "map", "(", "lambda", "condition", ":", "condition", "(", "instance", ")", ",", "transition", ".", "conditions", ")", ")" ]

[ "Check", "if", "all", "conditions", "have", "been", "met" ]

[ "def", "import_plugin", "(", "self", ",", "plugin", ")", ":", "names", "=", "[", "'%s%s%s'", "%", "(", "namespace", ",", "''", "if", "namespace", "[", "-", "1", "]", "==", "'_'", "else", "'.'", ",", "plugin", ")", "if", "namespace", "else", "plugin", "for", "namespace", "in", "self", ".", "namespaces", "]", "for", "name", "in", "names", ":", "if", "name", "in", "sys", ".", "modules", ":", "return", "sys", ".", "modules", "[", "name", "]", "for", "name", "in", "names", ":", "try", ":", "__import__", "(", "name", ")", "return", "sys", ".", "modules", "[", "name", "]", "except", "(", "ImportError", ",", "KeyError", ")", ":", "pass", "raise", "PluginNotFoundError", "(", "'No plugin module %r found, tried %r'", "%", "(", "plugin", ",", "names", ")", ",", "plugin", ",", "names", ")" ]

[ "Import", "plugin", "by", "given", "name", "looking", "at", ":", "attr", ":", "namespaces", "." ]

[ "def", "callback_trigger", "(", "msg", ",", "arg", ")", ":", "gnlh", "=", "genlmsghdr", "(", "nlmsg_data", "(", "nlmsg_hdr", "(", "msg", ")", ")", ")", "if", "gnlh", ".", "cmd", "==", "nl80211", ".", "NL80211_CMD_SCAN_ABORTED", ":", "arg", ".", "value", "=", "1", "# The scan was aborted for some reason.", "elif", "gnlh", ".", "cmd", "==", "nl80211", ".", "NL80211_CMD_NEW_SCAN_RESULTS", ":", "arg", ".", "value", "=", "0", "# The scan completed successfully. `callback_dump` will collect the results later.", "return", "libnl", ".", "handlers", ".", "NL_SKIP" ]

[ "Called", "when", "the", "kernel", "is", "done", "scanning", ".", "Only", "signals", "if", "it", "was", "successful", "or", "if", "it", "failed", ".", "No", "other", "data", "." ]

[ "def", "get_imageblock", "(", "filename", ",", "format", "=", "''", ")", ":", "_", ",", "extension", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "with", "open", "(", "filename", ",", "\"rb\"", ")", "as", "image_file", ":", "encoded_string", "=", "base64", ".", "b64encode", "(", "image_file", ".", "read", "(", ")", ")", ".", "decode", "(", "'utf-8'", ")", "return", "'\\n\\n.. raw:: html\\n\\n\\t<img src=\"data:image/'", "+", "(", "format", "if", "format", "else", "extension", "[", "1", ":", "]", ")", "+", "';base64,'", "+", "encoded_string", "+", "'\">\\n'" ]

[ "Generates", "rst", "raw", "block", "for", "given", "image", "filename", "and", "format" ]

[ "def", "Kdiag", "(", "self", ",", "X", ")", ":", "K_ff", "=", "np", ".", "ones", "(", "X", ".", "shape", "[", "0", "]", ")", "for", "i", ",", "x", "in", "enumerate", "(", "X", ")", ":", "for", "il", ",", "l", "in", "enumerate", "(", "self", ".", "lengthscale", ")", ":", "idx", "=", "il", "*", "2", "K_ff", "[", "i", "]", "*=", "self", ".", "k_ff", "(", "x", "[", "idx", "]", ",", "x", "[", "idx", "]", ",", "l", ")", "return", "K_ff", "*", "self", ".", "variances", "[", "0", "]" ]

[ "I", "ve", "used", "the", "fact", "that", "we", "call", "this", "method", "for", "K_ff", "when", "finding", "the", "covariance", "as", "a", "hack", "so", "I", "know", "if", "I", "should", "return", "K_ff", "or", "K_xx", ".", "In", "this", "case", "we", "re", "returning", "K_ff!!", "$K_", "{", "ff", "}", "^", "{", "post", "}", "=", "K_", "{", "ff", "}", "-", "K_", "{", "fx", "}", "K_", "{", "xx", "}", "^", "{", "-", "1", "}", "K_", "{", "xf", "}", "$" ]

[ "def", "_get_val", "(", "val", ",", "full", "=", "False", ")", ":", "try", ":", "val", "=", "val", ".", "strip", "(", ")", "except", ":", "pass", "logging", ".", "debug", "(", "\"%s, type=%s\"", ",", "val", ",", "type", "(", "val", ")", ")", "if", "isinstance", "(", "val", ",", "float", ")", ":", "return", "val", "if", "isinstance", "(", "val", ",", "int", ")", ":", "return", "val", "if", "isinstance", "(", "val", ",", "np", ".", "ndarray", ")", ":", "return", "list", "(", "val", ")", "try", ":", "val", "=", "float", "(", "val", ")", "return", "val", "except", ":", "pass", "try", ":", "val", "=", "int", "(", "val", ")", "return", "val", "except", ":", "pass", "if", "type", "(", "val", ")", "==", "pd", ".", "DataFrame", ":", "if", "full", ":", "return", "val", "newval", "=", "[", "]", "values", "=", "val", ".", "values", "for", "v", "in", "values", ":", "newv", "=", "_get_val", "(", "v", ")", "if", "type", "(", "newv", ")", "==", "list", ":", "newval", ".", "extend", "(", "newv", ")", "else", ":", "newval", ".", "append", "(", "newv", ")", "val", "=", "newval", "elif", "type", "(", "val", ")", "==", "dict", ":", "if", "full", ":", "return", "val", "newval", "=", "[", "]", "for", "v", "in", "val", ".", "values", "(", ")", ":", "newv", "=", "_get_val", "(", "v", ")", "if", "type", "(", "newv", ")", "==", "list", ":", "newval", ".", "extend", "(", "newv", ")", "else", ":", "newval", ".", "append", "(", "newv", ")", "val", "=", "newval", "elif", "type", "(", "val", ")", "==", "list", "or", "type", "(", "val", ")", "==", "np", ".", "ndarray", ":", "newval", "=", "[", "]", "for", "arr_val", "in", "val", ":", "v", "=", "_get_val", "(", "arr_val", ")", "newval", ".", "append", "(", "v", ")", "val", "=", "newval", "return", "val" ]

[ "Get", "the", "value", "(", "s", ")", "of", "a", "dataset", "as", "a", "single", "value", "or", "as", "1", "-", "d", "list", "of", "values", ".", "In", "the", "special", "case", "of", "timeseries", "when", "a", "check", "is", "for", "time", "-", "based", "criteria", "you", "can", "return", "the", "entire", "timeseries", "." ]

[ "def", "clear_to_reset", "(", "self", ",", "config_vars", ")", ":", "super", "(", "TileManagerState", ",", "self", ")", ".", "clear_to_reset", "(", "config_vars", ")", "self", ".", "registered_tiles", "=", "self", ".", "registered_tiles", "[", ":", "1", "]", "self", ".", "safe_mode", "=", "False", "self", ".", "debug_mode", "=", "False" ]

[ "Clear", "to", "the", "state", "immediately", "after", "a", "reset", "." ]

[ "def", "_compile_arithmetic_expression", "(", "self", ",", "expr", ":", "Expression", ",", "scope", ":", "Dict", "[", "str", ",", "TensorFluent", "]", ",", "batch_size", ":", "Optional", "[", "int", "]", "=", "None", ",", "noise", ":", "Optional", "[", "List", "[", "tf", ".", "Tensor", "]", "]", "=", "None", ")", "->", "TensorFluent", ":", "etype", "=", "expr", ".", "etype", "args", "=", "expr", ".", "args", "if", "len", "(", "args", ")", "==", "1", ":", "etype2op", "=", "{", "'+'", ":", "lambda", "x", ":", "x", ",", "'-'", ":", "lambda", "x", ":", "-", "x", "}", "if", "etype", "[", "1", "]", "not", "in", "etype2op", ":", "raise", "ValueError", "(", "'Invalid binary arithmetic expression:\\n{}'", ".", "format", "(", "expr", ")", ")", "op", "=", "etype2op", "[", "etype", "[", "1", "]", "]", "x", "=", "self", ".", "_compile_expression", "(", "args", "[", "0", "]", ",", "scope", ",", "batch_size", ",", "noise", ")", "fluent", "=", "op", "(", "x", ")", "else", ":", "etype2op", "=", "{", "'+'", ":", "lambda", "x", ",", "y", ":", "x", "+", "y", ",", "'-'", ":", "lambda", "x", ",", "y", ":", "x", "-", "y", ",", "'*'", ":", "lambda", "x", ",", "y", ":", "x", "*", "y", ",", "'/'", ":", "lambda", "x", ",", "y", ":", "x", "/", "y", ",", "}", "if", "etype", "[", "1", "]", "not", "in", "etype2op", ":", "raise", "ValueError", "(", "'Invalid binary arithmetic expression:\\n{}'", ".", "format", "(", "expr", ")", ")", "op", "=", "etype2op", "[", "etype", "[", "1", "]", "]", "x", "=", "self", ".", "_compile_expression", "(", "args", "[", "0", "]", ",", "scope", ",", "batch_size", ",", "noise", ")", "y", "=", "self", ".", "_compile_expression", "(", "args", "[", "1", "]", ",", "scope", ",", "batch_size", ",", "noise", ")", "fluent", "=", "op", "(", "x", ",", "y", ")", "return", "fluent" ]

[ "Compile", "an", "arithmetic", "expression", "expr", "into", "a", "TensorFluent", "in", "the", "given", "scope", "with", "optional", "batch", "size", "." ]

[ "def", "list_datastore_full", "(", "kwargs", "=", "None", ",", "call", "=", "None", ",", "datastore", "=", "None", ")", ":", "if", "call", "!=", "'function'", ":", "raise", "SaltCloudSystemExit", "(", "'The list_datastore_full function must be called with '", "'-f or --function.'", ")", "if", "kwargs", ":", "datastore", "=", "kwargs", ".", "get", "(", "'datastore'", ",", "None", ")", "if", "not", "datastore", ":", "raise", "SaltCloudSystemExit", "(", "'The list_datastore_full function requires a datastore'", ")", "return", "{", "datastore", ":", "salt", ".", "utils", ".", "vmware", ".", "list_datastore_full", "(", "_get_si", "(", ")", ",", "datastore", ")", "}" ]

[ "Returns", "a", "dictionary", "with", "basic", "information", "for", "the", "given", "datastore" ]

[ "def", "_vid_pid_path_to_usb_info", "(", "vid_pid_path", ")", ":", "result", "=", "{", "\"vendor_id\"", ":", "None", ",", "\"product_id\"", ":", "None", "}", "for", "component", "in", "vid_pid_path", ".", "split", "(", "\"&\"", ")", ":", "component_part", "=", "component", ".", "lower", "(", ")", ".", "split", "(", "\"_\"", ")", "if", "len", "(", "component_part", ")", "!=", "2", ":", "logger", ".", "debug", "(", "\"Unexpected VID/PID string structure %s\"", ",", "component", ")", "break", "if", "component_part", "[", "0", "]", "==", "\"vid\"", ":", "result", "[", "\"vendor_id\"", "]", "=", "component_part", "[", "1", "]", "elif", "component_part", "[", "0", "]", "==", "\"pid\"", ":", "result", "[", "\"product_id\"", "]", "=", "component_part", "[", "1", "]", "return", "result" ]

[ "!", "Provide", "the", "vendor", "ID", "and", "product", "ID", "of", "a", "device", "based", "on", "its", "entry", "in", "the", "registry" ]

[ "def", "rna_bases", "(", "rna_cov", ",", "scaffold", ",", "bases", ",", "line", ")", ":", "start", "=", "int", "(", "line", "[", "3", "]", ")", "stop", "=", "start", "+", "bases", "-", "1", "if", "scaffold", "not", "in", "rna_cov", ":", "return", "rna_cov", "for", "pos", "in", "rna_cov", "[", "scaffold", "]", "[", "2", "]", ":", "ol", "=", "get_overlap", "(", "[", "start", ",", "stop", "]", ",", "pos", ")", "rna_cov", "[", "scaffold", "]", "[", "0", "]", "+=", "ol", "return", "rna_cov" ]

[ "determine", "if", "read", "overlaps", "with", "rna", "if", "so", "count", "bases" ]

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

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

[ "def", "_detect_loop", "(", "self", ")", ":", "for", "source", ",", "dests", "in", "self", ".", "flowtable", ".", "items", "(", ")", ":", "if", "source", "in", "dests", ":", "raise", "conferr", "(", "'Loops detected: %s --> %s'", "%", "(", "source", ",", "source", ")", ")" ]

[ "detect", "loops", "in", "flow", "table", "raise", "error", "if", "being", "present" ]

[ "def", "color", "(", "ip", ",", "mac", ",", "hue", ",", "saturation", ",", "value", ")", ":", "bulb", "=", "MyStromBulb", "(", "ip", ",", "mac", ")", "bulb", ".", "set_color_hsv", "(", "hue", ",", "saturation", ",", "value", ")" ]

[ "Switch", "the", "bulb", "on", "with", "the", "given", "color", "." ]

[ "def", "answer_callback_query", "(", "self", ",", "callback_query_id", ":", "str", ",", "text", ":", "str", "=", "None", ",", "show_alert", ":", "bool", "=", "None", ",", "url", ":", "str", "=", "None", ",", "cache_time", ":", "int", "=", "0", ")", ":", "return", "self", ".", "send", "(", "functions", ".", "messages", ".", "SetBotCallbackAnswer", "(", "query_id", "=", "int", "(", "callback_query_id", ")", ",", "cache_time", "=", "cache_time", ",", "alert", "=", "show_alert", "or", "None", ",", "message", "=", "text", ",", "url", "=", "url", ")", ")" ]

[ "Use", "this", "method", "to", "send", "answers", "to", "callback", "queries", "sent", "from", "inline", "keyboards", ".", "The", "answer", "will", "be", "displayed", "to", "the", "user", "as", "a", "notification", "at", "the", "top", "of", "the", "chat", "screen", "or", "as", "an", "alert", "." ]

[ "def", "localize_file", "(", "path_or_buffer", ")", ":", "path_or_buffer", "=", "_stringify_path", "(", "path_or_buffer", ")", "if", "_is_url", "(", "path_or_buffer", ")", ":", "req", "=", "urlopen", "(", "path_or_buffer", ")", "filename", "=", "os", ".", "path", ".", "basename", "(", "req", ".", "geturl", "(", ")", ")", "if", "os", ".", "path", ".", "splitext", "(", "filename", ")", "[", "-", "1", "]", "is", "not", "\".pdf\"", ":", "pid", "=", "os", ".", "getpid", "(", ")", "filename", "=", "\"{0}.pdf\"", ".", "format", "(", "pid", ")", "with", "open", "(", "filename", ",", "'wb'", ")", "as", "f", ":", "shutil", ".", "copyfileobj", "(", "req", ",", "f", ")", "return", "filename", ",", "True", "elif", "is_file_like", "(", "path_or_buffer", ")", ":", "pid", "=", "os", ".", "getpid", "(", ")", "filename", "=", "\"{0}.pdf\"", ".", "format", "(", "pid", ")", "with", "open", "(", "filename", ",", "'wb'", ")", "as", "f", ":", "shutil", ".", "copyfileobj", "(", "path_or_buffer", ",", "f", ")", "return", "filename", ",", "True", "# File path case", "else", ":", "return", "os", ".", "path", ".", "expanduser", "(", "path_or_buffer", ")", ",", "False" ]

[ "Ensure", "localize", "target", "file", "." ]

[ "def", "create_folder", "(", "kwargs", "=", "None", ",", "call", "=", "None", ")", ":", "if", "call", "!=", "'function'", ":", "raise", "SaltCloudSystemExit", "(", "'The create_folder function must be called with '", "'-f or --function.'", ")", "# Get the service instance object", "si", "=", "_get_si", "(", ")", "folder_path", "=", "kwargs", ".", "get", "(", "'path'", ")", "if", "kwargs", "and", "'path'", "in", "kwargs", "else", "None", "if", "not", "folder_path", ":", "raise", "SaltCloudSystemExit", "(", "'You must specify a non empty folder path.'", ")", "folder_refs", "=", "[", "]", "inventory_path", "=", "'/'", "path_exists", "=", "True", "# Split the path in a list and loop over it to check for its existence", "for", "index", ",", "folder_name", "in", "enumerate", "(", "os", ".", "path", ".", "normpath", "(", "folder_path", ".", "strip", "(", "'/'", ")", ")", ".", "split", "(", "'/'", ")", ")", ":", "inventory_path", "=", "os", ".", "path", ".", "join", "(", "inventory_path", ",", "folder_name", ")", "folder_ref", "=", "si", ".", "content", ".", "searchIndex", ".", "FindByInventoryPath", "(", "inventoryPath", "=", "inventory_path", ")", "if", "isinstance", "(", "folder_ref", ",", "vim", ".", "Folder", ")", ":", "# This is a folder that exists so just append and skip it", "log", ".", "debug", "(", "\"Path %s/ exists in the inventory\"", ",", "inventory_path", ")", "folder_refs", ".", "append", "(", "folder_ref", ")", "elif", "isinstance", "(", "folder_ref", ",", "vim", ".", "Datacenter", ")", ":", "# This is a datacenter that exists so just append and skip it", "log", ".", "debug", "(", "\"Path %s/ exists in the inventory\"", ",", "inventory_path", ")", "folder_refs", ".", "append", "(", "folder_ref", ")", "else", ":", "path_exists", "=", "False", "if", "not", "folder_refs", ":", "# If this is the first folder, create it under the rootFolder", "log", ".", "debug", "(", "\"Creating folder %s under rootFolder in the inventory\"", ",", "folder_name", ")", "folder_refs", ".", "append", "(", "si", ".", "content", ".", "rootFolder", ".", "CreateFolder", "(", "folder_name", ")", ")", "else", ":", "# Create the folder under the parent folder", "log", ".", "debug", "(", "\"Creating path %s/ in the inventory\"", ",", "inventory_path", ")", "folder_refs", ".", "append", "(", "folder_refs", "[", "index", "-", "1", "]", ".", "CreateFolder", "(", "folder_name", ")", ")", "if", "path_exists", ":", "return", "{", "inventory_path", ":", "'specfied path already exists'", "}", "return", "{", "inventory_path", ":", "'created the specified path'", "}" ]

[ "Create", "the", "specified", "folder", "path", "in", "this", "VMware", "environment" ]

[ "def", "flush_zone", "(", "cls", ",", "zone_name", ")", ":", "cls", ".", "log", ".", "debug", "(", "'flush_zone: zone_name=%s'", ",", "zone_name", ")", "try", ":", "del", "cls", ".", "_cache", "[", "zone_name", "]", "except", "KeyError", ":", "pass" ]

[ "Flushes", "the", "zone", "cache", "if", "there", "is", "one" ]

[ "def", "get_version", "(", ")", ":", "setup_versioneer", "(", ")", "clean_cache", "(", ")", "import", "versioneer", "version", "=", "versioneer", ".", "get_version", "(", ")", "parsed_version", "=", "parse_version", "(", "version", ")", "if", "'*@'", "in", "str", "(", "parsed_version", ")", ":", "import", "time", "version", "+=", "str", "(", "int", "(", "time", ".", "time", "(", ")", ")", ")", "return", "version" ]

[ "Get", "project", "version", "(", "using", "versioneer", ")", ":", "return", ":", "string", "containing", "version" ]

[ "def", "sequence", "(", "self", ",", "per_exon", "=", "False", ")", ":", "db", "=", "self", ".", "db", "if", "not", "per_exon", ":", "start", "=", "self", ".", "txStart", "+", "1", "return", "_sequence", "(", "db", ",", "self", ".", "chrom", ",", "start", ",", "self", ".", "txEnd", ")", "else", ":", "# TODO: use same strategy as cds_sequence to reduce # of requests.", "seqs", "=", "[", "]", "for", "start", ",", "end", "in", "self", ".", "exons", ":", "seqs", ".", "append", "(", "_sequence", "(", "db", ",", "self", ".", "chrom", ",", "start", "+", "1", ",", "end", ")", ")", "return", "seqs" ]

[ "Return", "the", "sequence", "for", "this", "feature", ".", "if", "per", "-", "exon", "is", "True", "return", "an", "array", "of", "exon", "sequences", "This", "sequence", "is", "never", "reverse", "complemented" ]

[ "def", "createSummary", "(", "self", ",", "log", ")", ":", "warnings", "=", "self", ".", "obs", ".", "warnings", "errors", "=", "self", ".", "obs", ".", "errors", "if", "warnings", ":", "self", ".", "addCompleteLog", "(", "'%d Warnings'", "%", "len", "(", "warnings", ")", ",", "\"\\n\"", ".", "join", "(", "warnings", ")", ")", "self", ".", "warnCount", "=", "len", "(", "warnings", ")", "if", "errors", ":", "self", ".", "addCompleteLog", "(", "'%d Errors'", "%", "len", "(", "errors", ")", ",", "\"\\n\"", ".", "join", "(", "errors", ")", ")", "self", ".", "errCount", "=", "len", "(", "errors", ")" ]

[ "Create", "nice", "summary", "logs", "." ]

[ "def", "wait", "(", "self", ")", ":", "self", ".", "_write_footer", "(", ")", "super", "(", "ColumnFormat", ",", "self", ")", ".", "wait", "(", ")", "self", ".", "_write_header", "(", ")" ]

[ "Block", "for", "user", "input" ]

[ "def", "get_module_logger", "(", "moduleName", ",", "defaultToVerbose", "=", "False", ")", ":", "# moduleName = moduleName.split(\".\")[-1]", "if", "not", "moduleName", ".", "startswith", "(", "BASE_LOGGER_NAME", "+", "\".\"", ")", ":", "moduleName", "=", "BASE_LOGGER_NAME", "+", "\".\"", "+", "moduleName", "logger", "=", "logging", ".", "getLogger", "(", "moduleName", ")", "# if logger.level == logging.NOTSET and not defaultToVerbose:", "# logger.setLevel(logging.INFO) # Disable debug messages by default", "return", "logger" ]

[ "Create", "a", "module", "logger", "that", "can", "be", "en", "/", "disabled", "by", "configuration", "." ]

[ "def", "bias_correct", "(", "params", ",", "data", ",", "acf", "=", "None", ")", ":", "bias", "=", "RB_bias", "(", "data", ",", "params", ",", "acf", "=", "acf", ")", "i", "=", "0", "for", "p", "in", "params", ":", "if", "'theta'", "in", "p", ":", "continue", "if", "params", "[", "p", "]", ".", "vary", ":", "params", "[", "p", "]", ".", "value", "-=", "bias", "[", "i", "]", "i", "+=", "1", "return" ]

[ "Calculate", "and", "apply", "a", "bias", "correction", "to", "the", "given", "fit", "parameters" ]

[ "def", "onLeftClickLabel", "(", "self", ",", "event", ")", ":", "if", "event", ".", "Col", "==", "-", "1", "and", "event", ".", "Row", "==", "-", "1", ":", "pass", "elif", "event", ".", "Col", "<", "0", ":", "self", ".", "onSelectRow", "(", "event", ")", "elif", "event", ".", "Row", "<", "0", ":", "self", ".", "drop_down_menu", ".", "on_label_click", "(", "event", ")" ]

[ "When", "user", "clicks", "on", "a", "grid", "label", "determine", "if", "it", "is", "a", "row", "label", "or", "a", "col", "label", ".", "Pass", "along", "the", "event", "to", "the", "appropriate", "function", ".", "(", "It", "will", "either", "highlight", "a", "column", "for", "editing", "all", "values", "or", "highlight", "a", "row", "for", "deletion", ")", "." ]

[ "def", "get_field_visibility_mode", "(", "self", ",", "field", ")", ":", "fallback_mode", "=", "(", "\"hidden\"", ",", "\"hidden\"", ")", "widget", "=", "field", ".", "widget", "# TODO This needs to be done differently", "# Check where the field has to be located", "layout", "=", "widget", ".", "isVisible", "(", "self", ".", "context", ",", "\"header_table\"", ")", "if", "layout", "in", "[", "\"invisible\"", ",", "\"hidden\"", "]", ":", "return", "fallback_mode", "# Check permissions. We want to display field (either in view or edit", "# modes) only if the current user has enough privileges.", "if", "field", ".", "checkPermission", "(", "\"edit\"", ",", "self", ".", "context", ")", ":", "mode", "=", "\"edit\"", "sm", "=", "getSecurityManager", "(", ")", "if", "not", "sm", ".", "checkPermission", "(", "ModifyPortalContent", ",", "self", ".", "context", ")", ":", "logger", ".", "warn", "(", "\"Permission '{}' granted for the edition of '{}', \"", "\"but 'Modify portal content' not granted\"", ".", "format", "(", "field", ".", "write_permission", ",", "field", ".", "getName", "(", ")", ")", ")", "elif", "field", ".", "checkPermission", "(", "\"view\"", ",", "self", ".", "context", ")", ":", "mode", "=", "\"view\"", "else", ":", "return", "fallback_mode", "# Check if the field needs to be displayed or not, even if the user has", "# the permissions for edit or view. This may depend on criteria other", "# than permissions (e.g. visibility depending on a setup setting, etc.)", "if", "widget", ".", "isVisible", "(", "self", ".", "context", ",", "mode", ",", "field", "=", "field", ")", "!=", "\"visible\"", ":", "if", "mode", "==", "\"view\"", ":", "return", "fallback_mode", "# The field cannot be rendered in edit mode, but maybe can be", "# rendered in view mode.", "mode", "=", "\"view\"", "if", "widget", ".", "isVisible", "(", "self", ".", "context", ",", "mode", ",", "field", "=", "field", ")", "!=", "\"visible\"", ":", "return", "fallback_mode", "return", "(", "mode", ",", "layout", ")" ]

[ "Returns", "view", "or", "edit", "modes", "together", "with", "the", "place", "within", "where", "this", "field", "has", "to", "be", "rendered", "based", "on", "the", "permissions", "the", "current", "user", "has", "for", "the", "context", "and", "the", "field", "passed", "in" ]

[ "def", "check_tweet", "(", "tweet", ",", "validation_checking", "=", "False", ")", ":", "if", "\"id\"", "not", "in", "tweet", ":", "raise", "NotATweetError", "(", "\"This text has no 'id' key\"", ")", "original_format", "=", "is_original_format", "(", "tweet", ")", "if", "original_format", ":", "_check_original_format_tweet", "(", "tweet", ",", "validation_checking", "=", "validation_checking", ")", "else", ":", "_check_activity_streams_tweet", "(", "tweet", ",", "validation_checking", "=", "validation_checking", ")", "return", "original_format" ]

[ "Ensures", "a", "tweet", "is", "valid", "and", "determines", "the", "type", "of", "format", "for", "the", "tweet", "." ]

[ "def", "reload", "(", "self", ",", "reload_timeout", "=", "300", ",", "save_config", "=", "True", ")", ":", "SAVE_CONFIG", "=", "re", ".", "compile", "(", "re", ".", "escape", "(", "\"System configuration has been modified. Save? [yes/no]: \"", ")", ")", "PROCEED", "=", "re", ".", "compile", "(", "re", ".", "escape", "(", "\"Proceed with reload? [confirm]\"", ")", ")", "IMAGE", "=", "re", ".", "compile", "(", "\"Passing control to the main image\"", ")", "BOOTSTRAP", "=", "re", ".", "compile", "(", "\"System Bootstrap\"", ")", "LOCATED", "=", "re", ".", "compile", "(", "\"Located .*\"", ")", "RETURN", "=", "re", ".", "compile", "(", "re", ".", "escape", "(", "\"Press RETURN to get started!\"", ")", ")", "response", "=", "\"yes\"", "if", "save_config", "else", "\"no\"", "# 0 1 2 3 4", "events", "=", "[", "SAVE_CONFIG", ",", "PROCEED", ",", "LOCATED", ",", "RETURN", ",", "self", ".", "username_re", ",", "self", ".", "password_re", ",", "BOOTSTRAP", ",", "IMAGE", ",", "TIMEOUT", ",", "EOF", "]", "# 5 6 7 8 9", "transitions", "=", "[", "(", "SAVE_CONFIG", ",", "[", "0", "]", ",", "1", ",", "partial", "(", "a_send_line", ",", "response", ")", ",", "60", ")", ",", "(", "PROCEED", ",", "[", "0", ",", "1", "]", ",", "2", ",", "partial", "(", "a_send", ",", "\"\\r\"", ")", ",", "reload_timeout", ")", ",", "(", "LOCATED", ",", "[", "2", "]", ",", "2", ",", "a_message_callback", ",", "reload_timeout", ")", ",", "# if timeout try to send the reload command again", "(", "TIMEOUT", ",", "[", "0", "]", ",", "0", ",", "partial", "(", "a_send_line", ",", "self", ".", "reload_cmd", ")", ",", "10", ")", ",", "(", "BOOTSTRAP", ",", "[", "2", "]", ",", "-", "1", ",", "a_disconnect", ",", "reload_timeout", ")", ",", "(", "IMAGE", ",", "[", "2", "]", ",", "3", ",", "a_message_callback", ",", "reload_timeout", ")", ",", "(", "self", ".", "username_re", ",", "[", "3", "]", ",", "-", "1", ",", "a_return_and_reconnect", ",", "0", ")", ",", "(", "self", ".", "password_re", ",", "[", "3", "]", ",", "-", "1", ",", "a_return_and_reconnect", ",", "0", ")", ",", "(", "RETURN", ",", "[", "3", "]", ",", "-", "1", ",", "a_return_and_reconnect", ",", "0", ")", ",", "(", "TIMEOUT", ",", "[", "2", "]", ",", "-", "1", ",", "a_disconnect", ",", "0", ")", ",", "(", "EOF", ",", "[", "0", ",", "1", ",", "2", ",", "3", "]", ",", "-", "1", ",", "a_disconnect", ",", "0", ")", "]", "fsm", "=", "FSM", "(", "\"IOS-RELOAD\"", ",", "self", ".", "device", ",", "events", ",", "transitions", ",", "timeout", "=", "10", ")", "return", "fsm", ".", "run", "(", ")" ]

[ "Reload", "the", "device", "." ]

[ "def", "gen_ordered_statistics", "(", "transaction_manager", ",", "record", ")", ":", "items", "=", "record", ".", "items", "for", "combination_set", "in", "combinations", "(", "sorted", "(", "items", ")", ",", "len", "(", "items", ")", "-", "1", ")", ":", "items_base", "=", "frozenset", "(", "combination_set", ")", "items_add", "=", "frozenset", "(", "items", ".", "difference", "(", "items_base", ")", ")", "confidence", "=", "(", "record", ".", "support", "/", "transaction_manager", ".", "calc_support", "(", "items_base", ")", ")", "lift", "=", "confidence", "/", "transaction_manager", ".", "calc_support", "(", "items_add", ")", "yield", "OrderedStatistic", "(", "frozenset", "(", "items_base", ")", ",", "frozenset", "(", "items_add", ")", ",", "confidence", ",", "lift", ")" ]

[ "Returns", "a", "generator", "of", "ordered", "statistics", "as", "OrderedStatistic", "instances", "." ]

[ "def", "app_size", "(", "self", ")", ":", "if", "self", ".", "_nodes", "is", "None", ":", "return", "self", ".", "_app_size", "return", "sum", "(", "i", ".", "app_size", "(", ")", "for", "i", "in", "self", ".", "_nodes", ")" ]

[ "Return", "the", "total", "apparent", "size", "including", "children", "." ]

[ "def", "_get_params_for_optimizer", "(", "self", ",", "prefix", ",", "named_parameters", ")", ":", "kwargs", "=", "self", ".", "_get_params_for", "(", "prefix", ")", "params", "=", "list", "(", "named_parameters", ")", "pgroups", "=", "[", "]", "for", "pattern", ",", "group", "in", "kwargs", ".", "pop", "(", "'param_groups'", ",", "[", "]", ")", ":", "matches", "=", "[", "i", "for", "i", ",", "(", "name", ",", "_", ")", "in", "enumerate", "(", "params", ")", "if", "fnmatch", ".", "fnmatch", "(", "name", ",", "pattern", ")", "]", "if", "matches", ":", "p", "=", "[", "params", ".", "pop", "(", "i", ")", "[", "1", "]", "for", "i", "in", "reversed", "(", "matches", ")", "]", "pgroups", ".", "append", "(", "{", "'params'", ":", "p", ",", "*", "*", "group", "}", ")", "if", "params", ":", "pgroups", ".", "append", "(", "{", "'params'", ":", "[", "p", "for", "_", ",", "p", "in", "params", "]", "}", ")", "return", "[", "pgroups", "]", ",", "kwargs" ]

[ "Parse", "kwargs", "configuration", "for", "the", "optimizer", "identified", "by", "the", "given", "prefix", ".", "Supports", "param", "group", "assignment", "using", "wildcards", ":" ]