Datasets:

tomekkorbak

/

code_search_data-pep8

like 0

[ "def", "_get_task_target", "(", ")", ":", "# Break circular dependency.", "# pylint: disable=g-import-not-at-top", "import", "pipeline", "if", "pipeline", ".", "_TEST_MODE", ":", "return", "None", "# Further protect against test cases that doesn't set env vars", "# propertly.", "if", "(", "\"CURRENT_VERSION_ID\"", "not", "in", "os", ".", "environ", "or", "\"CURRENT_MODULE_ID\"", "not", "in", "os", ".", "environ", ")", ":", "logging", ".", "warning", "(", "\"Running Pipeline in non TEST_MODE but important \"", "\"env vars are not set.\"", ")", "return", "None", "version", "=", "os", ".", "environ", "[", "\"CURRENT_VERSION_ID\"", "]", ".", "split", "(", "\".\"", ")", "[", "0", "]", "module", "=", "os", ".", "environ", "[", "\"CURRENT_MODULE_ID\"", "]", "return", "\"%s.%s\"", "%", "(", "version", ",", "module", ")" ]

[ "Get", "the", "default", "target", "for", "a", "pipeline", "task", "." ]

[ "def", "start_new", "(", "cls", ",", "estimator", ",", "inputs", ")", ":", "local_mode", "=", "estimator", ".", "sagemaker_session", ".", "local_mode", "model_uri", "=", "estimator", ".", "model_uri", "# Allow file:// input only in local mode", "if", "cls", ".", "_is_local_channel", "(", "inputs", ")", "or", "cls", ".", "_is_local_channel", "(", "model_uri", ")", ":", "if", "not", "local_mode", ":", "raise", "ValueError", "(", "'File URIs are supported in local mode only. Please use a S3 URI instead.'", ")", "config", "=", "_Job", ".", "_load_config", "(", "inputs", ",", "estimator", ")", "if", "estimator", ".", "hyperparameters", "(", ")", "is", "not", "None", ":", "hyperparameters", "=", "{", "str", "(", "k", ")", ":", "str", "(", "v", ")", "for", "(", "k", ",", "v", ")", "in", "estimator", ".", "hyperparameters", "(", ")", ".", "items", "(", ")", "}", "train_args", "=", "config", ".", "copy", "(", ")", "train_args", "[", "'input_mode'", "]", "=", "estimator", ".", "input_mode", "train_args", "[", "'job_name'", "]", "=", "estimator", ".", "_current_job_name", "train_args", "[", "'hyperparameters'", "]", "=", "hyperparameters", "train_args", "[", "'tags'", "]", "=", "estimator", ".", "tags", "train_args", "[", "'metric_definitions'", "]", "=", "estimator", ".", "metric_definitions", "if", "estimator", ".", "enable_network_isolation", "(", ")", ":", "train_args", "[", "'enable_network_isolation'", "]", "=", "True", "if", "estimator", ".", "encrypt_inter_container_traffic", ":", "train_args", "[", "'encrypt_inter_container_traffic'", "]", "=", "True", "if", "isinstance", "(", "estimator", ",", "sagemaker", ".", "algorithm", ".", "AlgorithmEstimator", ")", ":", "train_args", "[", "'algorithm_arn'", "]", "=", "estimator", ".", "algorithm_arn", "else", ":", "train_args", "[", "'image'", "]", "=", "estimator", ".", "train_image", "(", ")", "estimator", ".", "sagemaker_session", ".", "train", "(", "*", "*", "train_args", ")", "return", "cls", "(", "estimator", ".", "sagemaker_session", ",", "estimator", ".", "_current_job_name", ")" ]

[ "Create", "a", "new", "Amazon", "SageMaker", "training", "job", "from", "the", "estimator", "." ]

[ "def", "no_operation", "(", "self", ",", "onerror", "=", "None", ")", ":", "request", ".", "NoOperation", "(", "display", "=", "self", ".", "display", ",", "onerror", "=", "onerror", ")" ]

[ "Do", "nothing", "but", "send", "a", "request", "to", "the", "server", "." ]

[ "def", "mse", "(", "mean", ",", "estimator", ")", ":", "return", "np", ".", "mean", "(", "(", "np", ".", "asarray", "(", "estimator", ")", "-", "np", ".", "asarray", "(", "mean", ")", ")", "**", "2", ",", "axis", "=", "0", ")" ]

[ "Description", ":", "Calculates", "the", "Mean", "Squared", "Error", "(", "MSE", ")", "of", "an", "estimation", "on", "flat", "numpy", "ndarrays", ".", "Parameters", ":", "mean", ":", "actual", "value", "(", "numpy", "ndarray", ")", "estimator", ":", "estimated", "value", "of", "the", "mean", "(", "numpy", "ndarray", ")" ]

[ "def", "get_id_by_name", "(", "tag_name", ",", "kind", "=", "'z'", ")", ":", "recs", "=", "TabTag", ".", "select", "(", ")", ".", "where", "(", "(", "TabTag", ".", "name", "==", "tag_name", ")", "&", "(", "TabTag", ".", "kind", "==", "kind", ")", ")", "logger", ".", "info", "(", "'tag count of {0}: {1} '", ".", "format", "(", "tag_name", ",", "recs", ".", "count", "(", ")", ")", ")", "# the_id = ''", "if", "recs", ".", "count", "(", ")", "==", "1", ":", "the_id", "=", "recs", ".", "get", "(", ")", ".", "uid", "elif", "recs", ".", "count", "(", ")", ">", "1", ":", "rec0", "=", "None", "for", "rec", "in", "recs", ":", "# Only keep one.", "if", "rec0", ":", "TabPost2Tag", ".", "delete", "(", ")", ".", "where", "(", "TabPost2Tag", ".", "tag_id", "==", "rec", ".", "uid", ")", ".", "execute", "(", ")", "TabTag", ".", "delete", "(", ")", ".", "where", "(", "TabTag", ".", "uid", "==", "rec", ".", "uid", ")", ".", "execute", "(", ")", "else", ":", "rec0", "=", "rec", "the_id", "=", "rec0", ".", "uid", "else", ":", "the_id", "=", "MLabel", ".", "create_tag", "(", "tag_name", ")", "return", "the_id" ]

[ "Get", "ID", "by", "tag_name", "of", "the", "label", "." ]

[ "def", "read_http", "(", "self", ",", "length", ")", ":", "if", "length", "is", "None", ":", "length", "=", "len", "(", "self", ")", "if", "length", "<", "9", ":", "raise", "ProtocolError", "(", "f'HTTP/2: invalid format'", ",", "quiet", "=", "True", ")", "_tlen", "=", "self", ".", "_read_unpack", "(", "3", ")", "_type", "=", "self", ".", "_read_unpack", "(", "1", ")", "_flag", "=", "self", ".", "_read_binary", "(", "1", ")", "_rsid", "=", "self", ".", "_read_binary", "(", "4", ")", "if", "_tlen", "!=", "length", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "if", "int", "(", "_rsid", "[", "0", "]", ",", "base", "=", "2", ")", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "http", "=", "dict", "(", "length", "=", "_tlen", ",", "type", "=", "_HTTP_TYPE", ".", "get", "(", "_type", ")", ",", "sid", "=", "int", "(", "_rsid", "[", "1", ":", "]", ",", "base", "=", "2", ")", ",", "packet", "=", "self", ".", "_read_packet", "(", "_tlen", ")", ",", ")", "if", "http", "[", "'type'", "]", "is", "None", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "if", "http", "[", "'type'", "]", "in", "(", "'SETTINGS'", ",", "'PING'", ")", "and", "http", "[", "'sid'", "]", "!=", "0", ":", "raise", "ProtocolError", "(", "f'HTTP/2: [Type {_type}] invalid format'", ",", "quiet", "=", "True", ")", "_http", "=", "_HTTP_FUNC", "[", "_type", "]", "(", "self", ",", "_tlen", ",", "_type", ",", "_flag", ")", "http", ".", "update", "(", "_http", ")", "return", "http" ]

[ "Read", "Hypertext", "Transfer", "Protocol", "(", "HTTP", "/", "2", ")", "." ]

[ "def", "_catalog_validation_to_list", "(", "response", ")", ":", "# crea una lista de dicts para volcarse en una tabla (catalog)", "rows_catalog", "=", "[", "]", "validation_result", "=", "{", "\"catalog_title\"", ":", "response", "[", "\"error\"", "]", "[", "\"catalog\"", "]", "[", "\"title\"", "]", ",", "\"catalog_status\"", ":", "response", "[", "\"error\"", "]", "[", "\"catalog\"", "]", "[", "\"status\"", "]", ",", "}", "for", "error", "in", "response", "[", "\"error\"", "]", "[", "\"catalog\"", "]", "[", "\"errors\"", "]", ":", "catalog_result", "=", "dict", "(", "validation_result", ")", "catalog_result", ".", "update", "(", "{", "\"catalog_error_message\"", ":", "error", "[", "\"message\"", "]", ",", "\"catalog_error_location\"", ":", "\", \"", ".", "join", "(", "error", "[", "\"path\"", "]", ")", ",", "}", ")", "rows_catalog", ".", "append", "(", "catalog_result", ")", "if", "len", "(", "response", "[", "\"error\"", "]", "[", "\"catalog\"", "]", "[", "\"errors\"", "]", ")", "==", "0", ":", "catalog_result", "=", "dict", "(", "validation_result", ")", "catalog_result", ".", "update", "(", "{", "\"catalog_error_message\"", ":", "None", ",", "\"catalog_error_location\"", ":", "None", "}", ")", "rows_catalog", ".", "append", "(", "catalog_result", ")", "# crea una lista de dicts para volcarse en una tabla (dataset)", "rows_dataset", "=", "[", "]", "for", "dataset", "in", "response", "[", "\"error\"", "]", "[", "\"dataset\"", "]", ":", "validation_result", "=", "{", "\"dataset_title\"", ":", "dataset", "[", "\"title\"", "]", ",", "\"dataset_identifier\"", ":", "dataset", "[", "\"identifier\"", "]", ",", "\"dataset_list_index\"", ":", "dataset", "[", "\"list_index\"", "]", ",", "\"dataset_status\"", ":", "dataset", "[", "\"status\"", "]", "}", "for", "error", "in", "dataset", "[", "\"errors\"", "]", ":", "dataset_result", "=", "dict", "(", "validation_result", ")", "dataset_result", ".", "update", "(", "{", "\"dataset_error_message\"", ":", "error", "[", "\"message\"", "]", ",", "\"dataset_error_location\"", ":", "error", "[", "\"path\"", "]", "[", "-", "1", "]", "}", ")", "rows_dataset", ".", "append", "(", "dataset_result", ")", "if", "len", "(", "dataset", "[", "\"errors\"", "]", ")", "==", "0", ":", "dataset_result", "=", "dict", "(", "validation_result", ")", "dataset_result", ".", "update", "(", "{", "\"dataset_error_message\"", ":", "None", ",", "\"dataset_error_location\"", ":", "None", "}", ")", "rows_dataset", ".", "append", "(", "dataset_result", ")", "return", "{", "\"catalog\"", ":", "rows_catalog", ",", "\"dataset\"", ":", "rows_dataset", "}" ]

[ "Formatea", "la", "validación", "de", "un", "catálogo", "a", "dos", "listas", "de", "errores", "." ]

[ "def", "pb_id", "(", "self", ",", "pb_id", ":", "str", ")", ":", "# FIXME(BMo) instead of creating the object to check if the PB exists", "# use a method on PB List?", "# ProcessingBlock(pb_id)", "self", ".", "set_state", "(", "DevState", ".", "ON", ")", "self", ".", "_pb_id", "=", "pb_id" ]

[ "Set", "the", "PB", "Id", "for", "this", "device", "." ]

[ "def", "format_to_json", "(", "data", ")", ":", "if", "sys", ".", "stdout", ".", "isatty", "(", ")", ":", "return", "json", ".", "dumps", "(", "data", ",", "indent", "=", "4", ",", "separators", "=", "(", "','", ",", "': '", ")", ")", "else", ":", "return", "json", ".", "dumps", "(", "data", ")" ]

[ "Converts", "data", "into", "json", "If", "stdout", "is", "a", "tty", "it", "performs", "a", "pretty", "print", "." ]

[ "def", "add_term", "(", "self", ",", "t", ")", ":", "if", "t", "not", "in", "self", ".", "terms", ":", "if", "t", ".", "parent_term_lc", "==", "'root'", ":", "self", ".", "terms", ".", "append", "(", "t", ")", "self", ".", "doc", ".", "add_term", "(", "t", ",", "add_section", "=", "False", ")", "t", ".", "set_ownership", "(", ")", "else", ":", "raise", "GenerateError", "(", "\"Can only add or move root-level terms. Term '{}' parent is '{}' \"", ".", "format", "(", "t", ",", "t", ".", "parent_term_lc", ")", ")", "assert", "t", ".", "section", "or", "t", ".", "join_lc", "==", "'root.root'", ",", "t" ]

[ "Add", "a", "term", "to", "this", "section", "and", "set", "it", "s", "ownership", ".", "Should", "only", "be", "used", "on", "root", "level", "terms" ]

[ "def", "benchmark_gops", "(", "N", ",", "gates", ",", "reps", ")", ":", "t", "=", "timeit", ".", "timeit", "(", "lambda", ":", "benchmark", "(", "N", ",", "gates", ")", ",", "number", "=", "reps", ")", "gops", "=", "(", "GATES", "*", "REPS", ")", "/", "t", "gops", "=", "int", "(", "(", "gops", "*", "100", ")", "+", "0.5", ")", "/", "100.0", "return", "gops" ]

[ "Return", "benchmark", "performance", "in", "GOPS", "(", "Gate", "operations", "per", "second", ")" ]

[ "def", "render_diagram", "(", "out_base", ")", ":", "import", "codecs", "import", "subprocess", "import", "sadisplay", "# generate class descriptions", "desc", "=", "sadisplay", ".", "describe", "(", "list", "(", "model_registry", ".", "values", "(", ")", ")", ",", "show_methods", "=", "False", ",", "show_properties", "=", "True", ",", "show_indexes", "=", "True", ",", ")", "# write description in DOT format", "with", "codecs", ".", "open", "(", "out_base", "+", "'.dot'", ",", "'w'", ",", "encoding", "=", "'utf-8'", ")", "as", "f", ":", "f", ".", "write", "(", "sadisplay", ".", "dot", "(", "desc", ")", ")", "# check existence of DOT_EXECUTABLE variable and file", "if", "not", "hasattr", "(", "config", ",", "'DOT_EXECUTABLE'", ")", ":", "raise", "RuntimeError", "(", "\"Please configure the 'DOT_EXECUTABLE' variable in your 'project_config.py'\"", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "config", ".", "DOT_EXECUTABLE", ")", ":", "raise", "IOError", "(", "\"Could not find file pointed to by 'DOT_EXECUTABLE': \"", "+", "str", "(", "config", ".", "DOT_EXECUTABLE", ")", ")", "# render to image using DOT", "# noinspection PyUnresolvedReferences", "subprocess", ".", "check_call", "(", "[", "config", ".", "DOT_EXECUTABLE", ",", "'-T'", ",", "'png'", ",", "'-o'", ",", "out_base", "+", "'.png'", ",", "out_base", "+", "'.dot'", "]", ")" ]

[ "Render", "a", "data", "model", "diagram" ]

[ "def", "root", "(", "self", ")", ":", "node", "=", "self", "while", "node", ".", "package", "is", "not", "None", ":", "node", "=", "node", ".", "package", "return", "node" ]

[ "Property", "to", "return", "the", "root", "of", "this", "node", "." ]

[ "def", "cont_c", "(", "self", ",", "percent", "=", "0.9", ",", "N", "=", "None", ")", ":", "# bug? check axis number 0 vs 1 here", "if", "not", "hasattr", "(", "self", ",", "'G'", ")", ":", "self", ".", "fs_c", "(", "N", "=", "self", ".", "rank", ")", "# generate G", "return", "apply_along_axis", "(", "lambda", "_", ":", "_", "/", "self", ".", "L", "[", ":", "N", "]", ",", "1", ",", "apply_along_axis", "(", "lambda", "_", ":", "_", "*", "self", ".", "c", ",", "0", ",", "self", ".", "G", "[", ":", ",", ":", "N", "]", "**", "2", ")", ")" ]

[ "Return", "the", "contribution", "of", "each", "column", "." ]

[ "def", "get_DIR", "(", "self", ")", ":", "dlg", "=", "wx", ".", "DirDialog", "(", "self", ",", "\"Choose a directory:\"", ",", "defaultPath", "=", "self", ".", "currentDirectory", ",", "style", "=", "wx", ".", "DD_DEFAULT_STYLE", "|", "wx", ".", "DD_NEW_DIR_BUTTON", "|", "wx", ".", "DD_CHANGE_DIR", ")", "ok", "=", "self", ".", "show_dlg", "(", "dlg", ")", "if", "ok", "==", "wx", ".", "ID_OK", ":", "new_WD", "=", "dlg", ".", "GetPath", "(", ")", "dlg", ".", "Destroy", "(", ")", "else", ":", "new_WD", "=", "os", ".", "getcwd", "(", ")", "dlg", ".", "Destroy", "(", ")", "return", "new_WD" ]

[ "Dialog", "that", "allows", "user", "to", "choose", "a", "working", "directory" ]

[ "def", "get_project", "(", "self", ",", "name", ")", ":", "uri", "=", "'{base}/{project}'", ".", "format", "(", "base", "=", "self", ".", "BASE_URI", ",", "project", "=", "name", ")", "resp", "=", "self", ".", "_client", ".", "get", "(", "uri", ",", "model", "=", "models", ".", "Project", ")", "return", "resp" ]

[ "Retrives", "project", "information", "by", "name" ]

[ "def", "make_score_structure", "(", "molecules", ",", "ensemble", ")", ":", "# sort molecules by their ensemble score", "#sort_order = get_sort_order(molecules)", "sort_order", "=", "'asc'", "sorted_molecules", "=", "screener", ".", "screener", "(", "molecules", ",", "ensemble", ",", "sort_order", ")", "# initiate variables", "score_structure", "=", "[", "]", "net_active_count", "=", "0", "net_decoy_count", "=", "0", "for", "mol", "in", "sorted_molecules", ":", "# determine net active count & net decoy count", "status", "=", "mol", ".", "GetProp", "(", "'status'", ")", "if", "status", "==", "'1'", ":", "net_active_count", "+=", "1", "elif", "status", "==", "'0'", ":", "net_decoy_count", "+=", "1", "else", ":", "continue", "score_structure", ".", "append", "(", "(", "mol", ".", "GetProp", "(", "'id'", ")", ",", "mol", ".", "GetProp", "(", "'best_score'", ")", ",", "mol", ".", "GetProp", "(", "'best_query'", ")", ",", "status", ",", "net_decoy_count", ",", "net_active_count", ")", ")", "return", "score_structure" ]

[ "puts", "data", "in", "the", "score_structure", "format", "for", "subsequent", "processing", ":", "param", "molecules", ":", "list", "[", "mol_object_1", "mol_object_2", "....", "]", "mol_objects", "are", "instances", "of", "common_tools", ".", "molecules", ":", "return", "score_structure", ":", "list", "[", "(", "id", "best_score", "best_query", "status", "net", "decoy", "count", "net", "active", "count", ")", "...", "]" ]

[ "def", "set_contrast", "(", "self", ",", "contrast", ")", ":", "if", "contrast", "<", "0", "or", "contrast", ">", "255", ":", "raise", "ValueError", "(", "'Contrast must be a value from 0 to 255 (inclusive).'", ")", "self", ".", "command", "(", "SSD1306_SETCONTRAST", ")", "self", ".", "command", "(", "contrast", ")" ]

[ "Sets", "the", "contrast", "of", "the", "display", ".", "Contrast", "should", "be", "a", "value", "between", "0", "and", "255", "." ]

[ "def", "show_content", "(", "self", ",", "state_model", ")", ":", "upper_most_lib_state_m", "=", "None", "if", "isinstance", "(", "state_model", ",", "LibraryStateModel", ")", ":", "uppermost_library_root_state", "=", "state_model", ".", "state", ".", "get_uppermost_library_root_state", "(", ")", "if", "uppermost_library_root_state", "is", "None", ":", "upper_most_lib_state_m", "=", "state_model", "else", ":", "upper_lib_state", "=", "uppermost_library_root_state", ".", "parent", "upper_most_lib_state_m", "=", "self", ".", "_selected_sm_model", ".", "get_state_model_by_path", "(", "upper_lib_state", ".", "get_path", "(", ")", ")", "if", "upper_most_lib_state_m", ":", "return", "upper_most_lib_state_m", ".", "show_content", "(", ")", "else", ":", "return", "True" ]

[ "Check", "state", "machine", "tree", "specific", "show", "content", "flag", "." ]

[ "def", "_set_attr", "(", "self", ",", "*", "*", "kwargs", ")", ":", "for", "key", ",", "value", "in", "kwargs", ".", "items", "(", ")", ":", "if", "not", "isinstance", "(", "value", ",", "string_types", ")", ":", "raise", "ValueError", "(", "\"Set Attr only accepts string values\"", ")", "check_call", "(", "_LIB", ".", "MXSymbolSetAttr", "(", "self", ".", "handle", ",", "c_str", "(", "key", ")", ",", "c_str", "(", "str", "(", "value", ")", ")", ")", ")" ]

[ "Sets", "an", "attribute", "of", "the", "symbol", "." ]

[ "def", "get_site_url", "(", "site_url", "=", "None", ",", "request", "=", "None", ")", ":", "site_url", "=", "site_url", "or", "settings", ".", "get", "(", "'SITE_URL'", ")", "if", "site_url", ":", "return", "site_url", "elif", "request", ":", "return", "'{}://{}'", ".", "format", "(", "request", ".", "scheme", ",", "request", ".", "get_host", "(", ")", ")", "else", ":", "raise", "Exception", "(", "'Either pass `site_url`, '", "'or set `SITE_URL` in settings, '", "'or pass `request` object.'", ")" ]

[ "Construct", "the", "site", "url", "." ]

[ "def", "get_client", "(", "self", ",", "service", ",", "region", ",", "public", "=", "True", ",", "cached", "=", "True", ",", "client_class", "=", "None", ")", ":", "if", "not", "self", ".", "authenticated", ":", "raise", "exc", ".", "NotAuthenticated", "(", "\"You must authenticate before trying \"", "\"to create clients.\"", ")", "clt", "=", "ep", "=", "None", "mapped_service", "=", "self", ".", "service_mapping", ".", "get", "(", "service", ")", "or", "service", "svc", "=", "self", ".", "services", ".", "get", "(", "mapped_service", ")", "if", "svc", ":", "ep", "=", "svc", ".", "endpoints", ".", "get", "(", "region", ")", "if", "ep", ":", "clt", "=", "ep", ".", "_get_client", "(", "public", "=", "public", ",", "cached", "=", "cached", ",", "client_class", "=", "client_class", ")", "if", "not", "clt", ":", "raise", "exc", ".", "NoSuchClient", "(", "\"There is no client available for the \"", "\"service '%s' in the region '%s'.\"", "%", "(", "service", ",", "region", ")", ")", "return", "clt" ]

[ "Returns", "the", "client", "object", "for", "the", "specified", "service", "and", "region", "." ]

[ "def", "queue", "(", "ctx", ",", "message", ")", ":", "if", "not", "valid_tweet", "(", "message", ")", ":", "click", ".", "echo", "(", "\"Message is too long for twitter.\"", ")", "click", ".", "echo", "(", "\"Message: \"", "+", "message", ")", "ctx", ".", "exit", "(", "2", ")", "if", "ctx", ".", "obj", "[", "'DRYRUN'", "]", ":", "click", ".", "echo", "(", "\"Message not queue due to dry-run mode.\"", ")", "ctx", ".", "exit", "(", "0", ")", "ctx", ".", "obj", "[", "'TWEETLIST'", "]", ".", "append", "(", "message", ")" ]

[ "Adds", "a", "message", "to", "your", "twitter", "queue" ]

[ "def", "orientnii", "(", "imfile", ")", ":", "strorient", "=", "[", "'L-R'", ",", "'S-I'", ",", "'A-P'", "]", "niiorient", "=", "[", "]", "niixyz", "=", "np", ".", "zeros", "(", "3", ",", "dtype", "=", "np", ".", "int8", ")", "if", "os", ".", "path", ".", "isfile", "(", "imfile", ")", ":", "nim", "=", "nib", ".", "load", "(", "imfile", ")", "pct", "=", "nim", ".", "get_data", "(", ")", "A", "=", "nim", ".", "get_sform", "(", ")", "for", "i", "in", "range", "(", "3", ")", ":", "niixyz", "[", "i", "]", "=", "np", ".", "argmax", "(", "abs", "(", "A", "[", "i", ",", ":", "-", "1", "]", ")", ")", "niiorient", ".", "append", "(", "strorient", "[", "niixyz", "[", "i", "]", "]", ")", "print", "niiorient" ]

[ "Get", "the", "orientation", "from", "NIfTI", "sform", ".", "Not", "fully", "functional", "yet", "." ]

[ "def", "convert_labels", "(", "Y", ",", "source", ",", "dest", ")", ":", "if", "Y", "is", "None", ":", "return", "Y", "if", "isinstance", "(", "Y", ",", "np", ".", "ndarray", ")", ":", "Y", "=", "Y", ".", "copy", "(", ")", "assert", "isinstance", "(", "Y", ",", "int", ")", "elif", "isinstance", "(", "Y", ",", "torch", ".", "Tensor", ")", ":", "Y", "=", "Y", ".", "clone", "(", ")", "assert", "np", ".", "sum", "(", "Y", ".", "numpy", "(", ")", "-", "Y", ".", "numpy", "(", ")", ".", "astype", "(", "int", ")", ")", "==", "0.0", "else", ":", "raise", "ValueError", "(", "\"Unrecognized label data type.\"", ")", "negative_map", "=", "{", "\"categorical\"", ":", "2", ",", "\"plusminus\"", ":", "-", "1", ",", "\"onezero\"", ":", "0", "}", "Y", "[", "Y", "==", "negative_map", "[", "source", "]", "]", "=", "negative_map", "[", "dest", "]", "return", "Y" ]

[ "Convert", "a", "matrix", "from", "one", "label", "type", "to", "another" ]

[ "def", "_compute_gas_price", "(", "probabilities", ",", "desired_probability", ")", ":", "first", "=", "probabilities", "[", "0", "]", "last", "=", "probabilities", "[", "-", "1", "]", "if", "desired_probability", ">=", "first", ".", "prob", ":", "return", "int", "(", "first", ".", "gas_price", ")", "elif", "desired_probability", "<=", "last", ".", "prob", ":", "return", "int", "(", "last", ".", "gas_price", ")", "for", "left", ",", "right", "in", "sliding_window", "(", "2", ",", "probabilities", ")", ":", "if", "desired_probability", "<", "right", ".", "prob", ":", "continue", "elif", "desired_probability", ">", "left", ".", "prob", ":", "# This code block should never be reachable as it would indicate", "# that we already passed by the probability window in which our", "# `desired_probability` is located.", "raise", "Exception", "(", "'Invariant'", ")", "adj_prob", "=", "desired_probability", "-", "right", ".", "prob", "window_size", "=", "left", ".", "prob", "-", "right", ".", "prob", "position", "=", "adj_prob", "/", "window_size", "gas_window_size", "=", "left", ".", "gas_price", "-", "right", ".", "gas_price", "gas_price", "=", "int", "(", "math", ".", "ceil", "(", "right", ".", "gas_price", "+", "gas_window_size", "*", "position", ")", ")", "return", "gas_price", "else", ":", "# The initial `if/else` clause in this function handles the case where", "# the `desired_probability` is either above or below the min/max", "# probability found in the `probabilities`.", "#", "# With these two cases handled, the only way this code block should be", "# reachable would be if the `probabilities` were not sorted correctly.", "# Otherwise, the `desired_probability` **must** fall between two of the", "# values in the `probabilities``.", "raise", "Exception", "(", "'Invariant'", ")" ]

[ "Given", "a", "sorted", "range", "of", "Probability", "named", "-", "tuples", "returns", "a", "gas", "price", "computed", "based", "on", "where", "the", "desired_probability", "would", "fall", "within", "the", "range", "." ]

[ "def", "within_ipv4_network", "(", "self", ",", "field", ",", "values", ")", ":", "v", "=", "[", "'ipv4_net(\"%s\")'", "%", "net", "for", "net", "in", "values", "]", "self", ".", "update_filter", "(", "'{} IN union({})'", ".", "format", "(", "field", ",", "','", ".", "join", "(", "v", ")", ")", ")" ]

[ "This", "filter", "adds", "specified", "networks", "to", "a", "filter", "to", "check", "for", "inclusion", ".", ":", "param", "str", "field", ":", "name", "of", "field", "to", "filter", "on", ".", "Taken", "from", "Show", "Filter", "Expression", "within", "SMC", ".", ":", "param", "list", "values", ":", "network", "definitions", "in", "cidr", "format", "i", ".", "e", ":", "1", ".", "1", ".", "1", ".", "0", "/", "24", "." ]

[ "def", "kick_chat_member", "(", "self", ",", "user_id", ")", ":", "return", "self", ".", "bot", ".", "api_call", "(", "\"kickChatMember\"", ",", "chat_id", "=", "self", ".", "id", ",", "user_id", "=", "user_id", ")" ]

[ "Use", "this", "method", "to", "kick", "a", "user", "from", "a", "group", "or", "a", "supergroup", ".", "The", "bot", "must", "be", "an", "administrator", "in", "the", "group", "for", "this", "to", "work", "." ]

[ "def", "call_no_reply", "(", "self", ",", "fn", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "self", ".", "default_call_chain", ".", "call_no_reply", "(", "fn", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "See", ":", "meth", ":", "CallChain", ".", "call_no_reply", "." ]

[ "def", "predict", "(", "self", ",", "X", ")", ":", "X", "=", "numpy", ".", "asarray", "(", "X", ")", "Xt", "=", "self", ".", "_predict_estimators", "(", "X", ")", "return", "self", ".", "meta_estimator", ".", "predict", "(", "Xt", ")" ]

[ "Perform", "prediction", "." ]

[ "def", "prepare", "(", "self", ")", ":", "p", "=", "PreparedSearch", "(", ")", "p", ".", "prepare", "(", "engine", "=", "self", ".", "engine", ",", "mode", "=", "self", ".", "mode", ",", "model", "=", "self", ".", "model", ",", "index", "=", "self", ".", "index", ",", "key", "=", "self", ".", "key", ",", "filter", "=", "self", ".", "filter", ",", "projection", "=", "self", ".", "projection", ",", "consistent", "=", "self", ".", "consistent", ",", "forward", "=", "self", ".", "forward", ",", "parallel", "=", "self", ".", "parallel", ")", "return", "p" ]

[ "Constructs", "a", ":", "class", ":", "~bloop", ".", "search", ".", "PreparedSearch", "." ]

[ "def", "logical_form_to_action_sequence", "(", "self", ",", "logical_form", ":", "str", ")", "->", "List", "[", "str", "]", ":", "expression", "=", "util", ".", "lisp_to_nested_expression", "(", "logical_form", ")", "try", ":", "transitions", ",", "start_type", "=", "self", ".", "_get_transitions", "(", "expression", ",", "expected_type", "=", "None", ")", "if", "self", ".", "_start_types", "and", "start_type", "not", "in", "self", ".", "_start_types", ":", "raise", "ParsingError", "(", "f\"Expression had unallowed start type of {start_type}: {expression}\"", ")", "except", "ParsingError", ":", "logger", ".", "error", "(", "f'Error parsing logical form: {logical_form}'", ")", "raise", "transitions", ".", "insert", "(", "0", ",", "f'@start@ -> {start_type}'", ")", "return", "transitions" ]

[ "Converts", "a", "logical", "form", "into", "a", "linearization", "of", "the", "production", "rules", "from", "its", "abstract", "syntax", "tree", ".", "The", "linearization", "is", "top", "-", "down", "depth", "-", "first", "." ]

[ "def", "_check_inv_operation_for_date", "(", "self", ",", "item", ",", "timestamp", ",", "data_dict", ",", "data_index_dict", ")", ":", "if", "item", "in", "data_index_dict", ":", "for", "item", "in", "data_index_dict", "[", "item", "]", ":", "# startdate < timestamp", "if", "const", ".", "START", "in", "data_dict", "[", "item", "]", "and", "not", "const", ".", "END", "in", "data_dict", "[", "item", "]", ":", "if", "data_dict", "[", "item", "]", "[", "const", ".", "START", "]", "<", "timestamp", ":", "return", "True", "# enddate > timestamp", "elif", "not", "const", ".", "START", "in", "data_dict", "[", "item", "]", "and", "const", ".", "END", "in", "data_dict", "[", "item", "]", ":", "if", "data_dict", "[", "item", "]", "[", "const", ".", "END", "]", ">", "timestamp", ":", "return", "True", "# startdate > timestamp > enddate", "elif", "const", ".", "START", "in", "data_dict", "[", "item", "]", "and", "const", ".", "END", "in", "data_dict", "[", "item", "]", ":", "if", "data_dict", "[", "item", "]", "[", "const", ".", "START", "]", "<", "timestamp", "and", "data_dict", "[", "item", "]", "[", "const", ".", "END", "]", ">", "timestamp", ":", "return", "True", "# no startdate or enddate available", "elif", "not", "const", ".", "START", "in", "data_dict", "[", "item", "]", "and", "not", "const", ".", "END", "in", "data_dict", "[", "item", "]", ":", "return", "True", "raise", "KeyError" ]

[ "Checks", "if", "the", "callsign", "is", "marked", "as", "an", "invalid", "operation", "for", "a", "given", "timestamp", ".", "In", "case", "the", "operation", "is", "invalid", "True", "is", "returned", ".", "Otherwise", "a", "KeyError", "is", "raised", "." ]

[ "def", "get_local_file", "(", "file", ")", ":", "try", ":", "with", "open", "(", "file", ".", "path", ")", ":", "yield", "file", ".", "path", "except", "NotImplementedError", ":", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "file", ".", "name", ")", "with", "NamedTemporaryFile", "(", "prefix", "=", "'wagtailvideo-'", ",", "suffix", "=", "ext", ")", "as", "tmp", ":", "try", ":", "file", ".", "open", "(", "'rb'", ")", "for", "chunk", "in", "file", ".", "chunks", "(", ")", ":", "tmp", ".", "write", "(", "chunk", ")", "finally", ":", "file", ".", "close", "(", ")", "tmp", ".", "flush", "(", ")", "yield", "tmp", ".", "name" ]

[ "Get", "a", "local", "version", "of", "the", "file", "downloading", "it", "from", "the", "remote", "storage", "if", "required", ".", "The", "returned", "value", "should", "be", "used", "as", "a", "context", "manager", "to", "ensure", "any", "temporary", "files", "are", "cleaned", "up", "afterwards", "." ]

[ "def", "session_start_pb", "(", "hparams", ",", "model_uri", "=", "''", ",", "monitor_url", "=", "''", ",", "group_name", "=", "''", ",", "start_time_secs", "=", "None", ")", ":", "if", "start_time_secs", "is", "None", ":", "start_time_secs", "=", "time", ".", "time", "(", ")", "session_start_info", "=", "plugin_data_pb2", ".", "SessionStartInfo", "(", "model_uri", "=", "model_uri", ",", "monitor_url", "=", "monitor_url", ",", "group_name", "=", "group_name", ",", "start_time_secs", "=", "start_time_secs", ")", "for", "(", "hp_name", ",", "hp_val", ")", "in", "six", ".", "iteritems", "(", "hparams", ")", ":", "if", "isinstance", "(", "hp_val", ",", "(", "float", ",", "int", ")", ")", ":", "session_start_info", ".", "hparams", "[", "hp_name", "]", ".", "number_value", "=", "hp_val", "elif", "isinstance", "(", "hp_val", ",", "six", ".", "string_types", ")", ":", "session_start_info", ".", "hparams", "[", "hp_name", "]", ".", "string_value", "=", "hp_val", "elif", "isinstance", "(", "hp_val", ",", "bool", ")", ":", "session_start_info", ".", "hparams", "[", "hp_name", "]", ".", "bool_value", "=", "hp_val", "elif", "isinstance", "(", "hp_val", ",", "(", "list", ",", "tuple", ")", ")", ":", "session_start_info", ".", "hparams", "[", "hp_name", "]", ".", "string_value", "=", "str", "(", "hp_val", ")", "else", ":", "raise", "TypeError", "(", "'hparams[%s]=%s has type: %s which is not supported'", "%", "(", "hp_name", ",", "hp_val", ",", "type", "(", "hp_val", ")", ")", ")", "return", "_summary", "(", "metadata", ".", "SESSION_START_INFO_TAG", ",", "plugin_data_pb2", ".", "HParamsPluginData", "(", "session_start_info", "=", "session_start_info", ")", ")" ]

[ "Constructs", "a", "SessionStartInfo", "protobuffer", "." ]

[ "def", "start", "(", "self", ",", "on_add", ",", "on_update", ",", "on_delete", ")", ":", "handler", "=", "ConfigFileChangeHandler", "(", "self", ".", "target_class", ",", "on_add", ",", "on_update", ",", "on_delete", ")", "for", "file_name", "in", "os", ".", "listdir", "(", "self", ".", "file_path", ")", ":", "if", "os", ".", "path", ".", "isdir", "(", "os", ".", "path", ".", "join", "(", "self", ".", "file_path", ",", "file_name", ")", ")", ":", "continue", "if", "(", "not", "self", ".", "target_class", ".", "config_subdirectory", "and", "not", "(", "file_name", ".", "endswith", "(", "\".yaml\"", ")", "or", "file_name", ".", "endswith", "(", "\".yml\"", ")", ")", ")", ":", "continue", "handler", ".", "on_created", "(", "events", ".", "FileCreatedEvent", "(", "os", ".", "path", ".", "join", "(", "self", ".", "file_path", ",", "file_name", ")", ")", ")", "observer", "=", "observers", ".", "Observer", "(", ")", "observer", ".", "schedule", "(", "handler", ",", "self", ".", "file_path", ")", "observer", ".", "start", "(", ")", "return", "observer" ]

[ "Starts", "monitoring", "the", "file", "path", "passing", "along", "on_", "(", "add|update|delete", ")", "callbacks", "to", "a", "watchdog", "observer", "." ]

[ "def", "_conditional", "(", "Xnew", ",", "X", ",", "kern", ",", "f", ",", "*", ",", "full_cov", "=", "False", ",", "q_sqrt", "=", "None", ",", "white", "=", "False", ",", "full_output_cov", "=", "None", ")", ":", "logger", ".", "debug", "(", "\"Conditional: Kernel\"", ")", "num_data", "=", "tf", ".", "shape", "(", "X", ")", "[", "-", "2", "]", "# M", "Kmm", "=", "kern", ".", "K", "(", "X", ")", "+", "tf", ".", "eye", "(", "num_data", ",", "dtype", "=", "settings", ".", "float_type", ")", "*", "settings", ".", "numerics", ".", "jitter_level", "# [..., M, M]", "Kmn", "=", "kern", ".", "K", "(", "X", ",", "Xnew", ")", "# [M, ..., N]", "if", "full_cov", ":", "Knn", "=", "kern", ".", "K", "(", "Xnew", ")", "# [...,N,N]", "else", ":", "Knn", "=", "kern", ".", "Kdiag", "(", "Xnew", ")", "# [...,N]", "mean", ",", "var", "=", "base_conditional", "(", "Kmn", ",", "Kmm", ",", "Knn", ",", "f", ",", "full_cov", "=", "full_cov", ",", "q_sqrt", "=", "q_sqrt", ",", "white", "=", "white", ")", "return", "mean", ",", "var" ]

[ "Given", "f", "representing", "the", "GP", "at", "the", "points", "X", "produce", "the", "mean", "and", "(", "co", "-", ")", "variance", "of", "the", "GP", "at", "the", "points", "Xnew", "." ]

[ "def", "par_y1step", "(", "i", ")", ":", "global", "mp_Y1", "grpind", "=", "slice", "(", "mp_grp", "[", "i", "]", ",", "mp_grp", "[", "i", "+", "1", "]", ")", "XU1", "=", "mp_X", "[", "grpind", "]", "+", "1", "/", "mp_alpha", "*", "mp_U1", "[", "grpind", "]", "if", "mp_wl1", ".", "shape", "[", "mp_axisM", "]", "is", "1", ":", "gamma", "=", "mp_lmbda", "/", "(", "mp_alpha", "**", "2", "*", "mp_rho", ")", "*", "mp_wl1", "else", ":", "gamma", "=", "mp_lmbda", "/", "(", "mp_alpha", "**", "2", "*", "mp_rho", ")", "*", "mp_wl1", "[", "grpind", "]", "Y1", "=", "sp", ".", "prox_l1", "(", "XU1", ",", "gamma", ")", "if", "mp_NonNegCoef", ":", "Y1", "[", "Y1", "<", "0.0", "]", "=", "0.0", "if", "mp_NoBndryCross", ":", "for", "n", "in", "range", "(", "len", "(", "mp_Nv", ")", ")", ":", "Y1", "[", "(", "slice", "(", "None", ")", ",", ")", "+", "(", "slice", "(", "None", ")", ",", ")", "*", "n", "+", "(", "slice", "(", "1", "-", "mp_Dshp", "[", "n", "]", ",", "None", ")", ",", ")", "]", "=", "0.0", "mp_Y1", "[", "mp_grp", "[", "i", "]", ":", "mp_grp", "[", "i", "+", "1", "]", "]", "=", "Y1" ]

[ "r", "Minimise", "Augmented", "Lagrangian", "with", "respect", "to", ":", "math", ":", "\\", "mathbf", "{", "y", "}", "_", "{", "1", "G_i", "}", "one", "of", "the", "disjoint", "problems", "of", "optimizing", ":", "math", ":", "\\", "mathbf", "{", "y", "}", "_1", "." ]

[ "def", "project", "(", "self", ",", "attribute_list", ",", "named_attributes", "=", "None", ",", "force_primary_key", "=", "None", ")", ":", "try", ":", "# check for missing attributes", "raise", "DataJointError", "(", "'Attribute `%s` is not found'", "%", "next", "(", "a", "for", "a", "in", "attribute_list", "if", "a", "not", "in", "self", ".", "names", ")", ")", "except", "StopIteration", ":", "if", "named_attributes", "is", "None", ":", "named_attributes", "=", "{", "}", "if", "force_primary_key", "is", "None", ":", "force_primary_key", "=", "set", "(", ")", "rename_map", "=", "{", "v", ":", "k", "for", "k", ",", "v", "in", "named_attributes", ".", "items", "(", ")", "if", "v", "in", "self", ".", "attributes", "}", "# copied and renamed attributes", "copy_attrs", "=", "(", "dict", "(", "self", ".", "attributes", "[", "k", "]", ".", "todict", "(", ")", ",", "in_key", "=", "self", ".", "attributes", "[", "k", "]", ".", "in_key", "or", "k", "in", "force_primary_key", ",", "*", "*", "(", "{", "'name'", ":", "rename_map", "[", "k", "]", ",", "'sql_expression'", ":", "'`%s`'", "%", "k", "}", "if", "k", "in", "rename_map", "else", "{", "}", ")", ")", "for", "k", "in", "self", ".", "attributes", "if", "k", "in", "rename_map", "or", "k", "in", "attribute_list", ")", "compute_attrs", "=", "(", "dict", "(", "default_attribute_properties", ",", "name", "=", "new_name", ",", "sql_expression", "=", "expr", ")", "for", "new_name", ",", "expr", "in", "named_attributes", ".", "items", "(", ")", "if", "expr", "not", "in", "rename_map", ")", "return", "Heading", "(", "chain", "(", "copy_attrs", ",", "compute_attrs", ")", ")" ]

[ "derive", "a", "new", "heading", "by", "selecting", "renaming", "or", "computing", "attributes", ".", "In", "relational", "algebra", "these", "operators", "are", "known", "as", "project", "rename", "and", "extend", ".", ":", "param", "attribute_list", ":", "the", "full", "list", "of", "existing", "attributes", "to", "include", ":", "param", "force_primary_key", ":", "attributes", "to", "force", "to", "be", "converted", "to", "primary", ":", "param", "named_attributes", ":", "dictionary", "of", "renamed", "attributes" ]

[ "def", "DatabaseDirectorySize", "(", "root_path", ",", "extension", ")", ":", "directories", "=", "collections", ".", "deque", "(", "[", "root_path", "]", ")", "total_size", "=", "0", "total_files", "=", "0", "while", "directories", ":", "directory", "=", "directories", ".", "popleft", "(", ")", "try", ":", "items", "=", "os", ".", "listdir", "(", "directory", ")", "except", "OSError", ":", "continue", "for", "comp", "in", "items", ":", "path", "=", "os", ".", "path", ".", "join", "(", "directory", ",", "comp", ")", "try", ":", "statinfo", "=", "os", ".", "lstat", "(", "path", ")", "if", "stat", ".", "S_ISLNK", "(", "statinfo", ".", "st_mode", ")", ":", "continue", "if", "stat", ".", "S_ISDIR", "(", "statinfo", ".", "st_mode", ")", ":", "directories", ".", "append", "(", "path", ")", "elif", "stat", ".", "S_ISREG", "(", "statinfo", ".", "st_mode", ")", ":", "if", "comp", ".", "endswith", "(", "extension", ")", ":", "total_size", "+=", "statinfo", ".", "st_size", "total_files", "+=", "1", "except", "OSError", ":", "continue", "return", "total_size", ",", "total_files" ]

[ "Compute", "size", "(", "in", "bytes", ")", "and", "number", "of", "files", "of", "a", "file", "-", "based", "data", "store", "." ]

[ "def", "get_key_state", "(", "self", ",", "status", ",", "state_dict", ")", ":", "for", "key", ",", "val", "in", "state_dict", ".", "items", "(", ")", ":", "if", "val", "==", "status", ":", "return", "key" ]

[ "Returns", "the", "key", "associated", "with", "the", "dict", "." ]

[ "def", "cars_profile", "(", "filename", ",", "doy", ",", "latitude", ",", "longitude", ",", "depth", ")", ":", "assert", "np", ".", "size", "(", "doy", ")", "==", "1", "assert", "np", ".", "size", "(", "latitude", ")", "==", "1", "assert", "np", ".", "size", "(", "longitude", ")", "==", "1", "#assert np.size(depth) == 1", "assert", "(", "longitude", ">=", "0", ")", "&", "(", "longitude", "<=", "360", ")", "assert", "depth", ">=", "0", "nc", "=", "netCDF4", ".", "Dataset", "(", "filename", ")", "t", "=", "2", "*", "np", ".", "pi", "*", "doy", "/", "366", "# Improve this. Optimize to get only necessary Z", "Z", "=", "slice", "(", "0", ",", "nc", "[", "'depth'", "]", ".", "size", ")", "I", "=", "np", ".", "absolute", "(", "nc", "[", "'lat'", "]", "[", ":", "]", "-", "latitude", ")", ".", "argmin", "(", ")", "J", "=", "np", ".", "absolute", "(", "nc", "[", "'lon'", "]", "[", ":", "]", "-", "longitude", ")", ".", "argmin", "(", ")", "# Not efficient, but it works", "assert", "(", "nc", "[", "'depth'", "]", "[", ":", "64", "]", "==", "nc", "[", "'depth_ann'", "]", "[", ":", "]", ")", ".", "all", "(", ")", "assert", "(", "nc", "[", "'depth'", "]", "[", ":", "55", "]", "==", "nc", "[", "'depth_semiann'", "]", "[", ":", "]", ")", ".", "all", "(", ")", "value", "=", "nc", "[", "'mean'", "]", "[", ":", ",", "I", ",", "J", "]", "value", "[", ":", "64", "]", "+=", "nc", "[", "'an_cos'", "]", "[", "Z", ",", "I", ",", "J", "]", "*", "np", ".", "cos", "(", "t", ")", "+", "nc", "[", "'an_sin'", "]", "[", ":", ",", "I", ",", "J", "]", "*", "np", ".", "sin", "(", "t", ")", "value", "[", ":", "55", "]", "+=", "nc", "[", "'sa_cos'", "]", "[", "Z", ",", "I", ",", "J", "]", "*", "np", ".", "cos", "(", "2", "*", "t", ")", "+", "nc", "[", "'sa_sin'", "]", "[", ":", ",", "I", ",", "J", "]", "*", "np", ".", "sin", "(", "2", "*", "t", ")", "value", "=", "value", "output", "=", "{", "'depth'", ":", "np", ".", "asanyarray", "(", "depth", ")", "}", "from", "scipy", ".", "interpolate", "import", "griddata", "output", "[", "'value'", "]", "=", "griddata", "(", "nc", "[", "'depth'", "]", "[", "Z", "]", ",", "value", "[", "Z", "]", ",", "depth", ")", "for", "v", "in", "[", "'std_dev'", "]", ":", "output", "[", "v", "]", "=", "griddata", "(", "nc", "[", "'depth'", "]", "[", "Z", "]", ",", "nc", "[", "v", "]", "[", "Z", ",", "I", ",", "J", "]", ",", "depth", ")", "return", "output" ]

[ "For", "now", "only", "the", "nearest", "value", "For", "now", "only", "for", "one", "position", "not", "an", "array", "of", "positions", "longitude", "0", "-", "360" ]

[ "def", "track_change", "(", "self", ",", "instance", ",", "resolution_level", "=", "0", ")", ":", "tobj", "=", "self", ".", "objects", "[", "id", "(", "instance", ")", "]", "tobj", ".", "set_resolution_level", "(", "resolution_level", ")" ]

[ "Change", "tracking", "options", "for", "the", "already", "tracked", "object", "instance", ".", "If", "instance", "is", "not", "tracked", "a", "KeyError", "will", "be", "raised", "." ]

[ "def", "save", "(", "self", ",", "filename", "=", "None", ")", ":", "if", "filename", "is", "None", ":", "filename", "=", "\"morse_smale_complex.json\"", "with", "open", "(", "filename", ",", "\"w\"", ")", "as", "fp", ":", "fp", ".", "write", "(", "self", ".", "to_json", "(", ")", ")" ]

[ "Saves", "a", "constructed", "Morse", "-", "Smale", "Complex", "in", "json", "file" ]

[ "def", "update_category", "(", "uid", ",", "postdata", ",", "kwargs", ")", ":", "catid", "=", "kwargs", "[", "'catid'", "]", "if", "(", "'catid'", "in", "kwargs", "and", "MCategory", ".", "get_by_uid", "(", "kwargs", "[", "'catid'", "]", ")", ")", "else", "None", "post_data", "=", "postdata", "current_infos", "=", "MPost2Catalog", ".", "query_by_entity_uid", "(", "uid", ",", "kind", "=", "''", ")", ".", "objects", "(", ")", "new_category_arr", "=", "[", "]", "# Used to update post2category, to keep order.", "def_cate_arr", "=", "[", "'gcat{0}'", ".", "format", "(", "x", ")", "for", "x", "in", "range", "(", "10", ")", "]", "# for old page.", "def_cate_arr", ".", "append", "(", "'def_cat_uid'", ")", "# Used to update post extinfo.", "cat_dic", "=", "{", "}", "for", "key", "in", "def_cate_arr", ":", "if", "key", "not", "in", "post_data", ":", "continue", "if", "post_data", "[", "key", "]", "==", "''", "or", "post_data", "[", "key", "]", "==", "'0'", ":", "continue", "# 有可能选重复了。保留前面的", "if", "post_data", "[", "key", "]", "in", "new_category_arr", ":", "continue", "new_category_arr", ".", "append", "(", "post_data", "[", "key", "]", "+", "' '", "*", "(", "4", "-", "len", "(", "post_data", "[", "key", "]", ")", ")", ")", "cat_dic", "[", "key", "]", "=", "post_data", "[", "key", "]", "+", "' '", "*", "(", "4", "-", "len", "(", "post_data", "[", "key", "]", ")", ")", "if", "catid", ":", "def_cat_id", "=", "catid", "elif", "new_category_arr", ":", "def_cat_id", "=", "new_category_arr", "[", "0", "]", "else", ":", "def_cat_id", "=", "None", "if", "def_cat_id", ":", "cat_dic", "[", "'def_cat_uid'", "]", "=", "def_cat_id", "cat_dic", "[", "'def_cat_pid'", "]", "=", "MCategory", ".", "get_by_uid", "(", "def_cat_id", ")", ".", "pid", "print", "(", "'='", "*", "40", ")", "print", "(", "uid", ")", "print", "(", "cat_dic", ")", "MPost", ".", "update_jsonb", "(", "uid", ",", "cat_dic", ")", "for", "index", ",", "catid", "in", "enumerate", "(", "new_category_arr", ")", ":", "MPost2Catalog", ".", "add_record", "(", "uid", ",", "catid", ",", "index", ")", "# Delete the old category if not in post requests.", "for", "cur_info", "in", "current_infos", ":", "if", "cur_info", ".", "tag_id", "not", "in", "new_category_arr", ":", "MPost2Catalog", ".", "remove_relation", "(", "uid", ",", "cur_info", ".", "tag_id", ")" ]

[ "Update", "the", "category", "of", "the", "post", "." ]

[ "def", "_GetNormalizedTimestamp", "(", "self", ")", ":", "if", "self", ".", "_normalized_timestamp", "is", "None", ":", "if", "self", ".", "_timestamp", "is", "not", "None", ":", "self", ".", "_normalized_timestamp", "=", "decimal", ".", "Decimal", "(", "self", ".", "_timestamp", ")", "return", "self", ".", "_normalized_timestamp" ]

[ "Retrieves", "the", "normalized", "timestamp", "." ]

[ "def", "_meta_fitness_func", "(", "parameters", ",", "_optimizer", ",", "_problems", ",", "_master_fitness_dict", ",", "_runs", "=", "20", ")", ":", "# Create the optimizer with parameters encoded in solution", "optimizer", "=", "copy", ".", "deepcopy", "(", "_optimizer", ")", "optimizer", ".", "_set_hyperparameters", "(", "parameters", ")", "optimizer", ".", "logging", "=", "False", "# Preload fitness dictionary from master, and disable clearing dict", "# NOTE: master_fitness_dict will be modified inline, and therefore,", "# we do not need to take additional steps to update it", "if", "_master_fitness_dict", "!=", "None", ":", "# None means low memory mode", "optimizer", ".", "clear_cache", "=", "False", "optimizer", ".", "_Optimizer__encoded_cache", "=", "_master_fitness_dict", "# Because metaheuristics are stochastic, we run the optimizer multiple times,", "# to obtain an average of performance", "all_evaluation_runs", "=", "[", "]", "solutions_found", "=", "[", "]", "for", "_", "in", "range", "(", "_runs", ")", ":", "for", "problem", "in", "_problems", ":", "# Get performance for problem", "optimizer", ".", "optimize", "(", "problem", ")", "all_evaluation_runs", ".", "append", "(", "optimizer", ".", "fitness_runs", ")", "if", "optimizer", ".", "solution_found", ":", "solutions_found", ".", "append", "(", "1.0", ")", "else", ":", "solutions_found", ".", "append", "(", "0.0", ")", "# Our main goal is to minimize time the optimizer takes", "fitness", "=", "1.0", "/", "helpers", ".", "avg", "(", "all_evaluation_runs", ")", "# Optimizer is heavily penalized for missing solutions", "# To avoid 0 fitness", "fitness", "=", "fitness", "*", "helpers", ".", "avg", "(", "solutions_found", ")", "**", "2", "+", "1e-19", "return", "fitness" ]

[ "Test", "a", "metaheuristic", "with", "parameters", "encoded", "in", "solution", "." ]

[ "def", "retrieve", "(", "cls", ",", "id", ",", "api_key", "=", "None", ",", "*", "*", "params", ")", ":", "instance", "=", "cls", "(", "id", ",", "api_key", ",", "*", "*", "params", ")", "d", "=", "instance", ".", "refresh", "(", ")", "return", "d", ".", "addCallback", "(", "lambda", "_", ":", "instance", ")" ]

[ "Return", "a", "deferred", "." ]

[ "def", "array_bytes", "(", "array", ")", ":", "return", "np", ".", "product", "(", "array", ".", "shape", ")", "*", "np", ".", "dtype", "(", "array", ".", "dtype", ")", ".", "itemsize" ]

[ "Estimates", "the", "memory", "of", "the", "supplied", "array", "in", "bytes" ]

[ "def", "_unescape_match", "(", "self", ",", "match", ")", ":", "char", "=", "match", ".", "group", "(", "1", ")", "if", "char", "in", "self", ".", "ESCAPE_LOOKUP", ":", "return", "self", ".", "ESCAPE_LOOKUP", "[", "char", "]", "elif", "not", "char", ":", "raise", "KatcpSyntaxError", "(", "\"Escape slash at end of argument.\"", ")", "else", ":", "raise", "KatcpSyntaxError", "(", "\"Invalid escape character %r.\"", "%", "(", "char", ",", ")", ")" ]

[ "Given", "an", "re", ".", "Match", "unescape", "the", "escape", "code", "it", "represents", "." ]

[ "def", "create", "(", "self", ",", "instance", ",", "cidr_mask", ",", "description", ",", "*", "*", "kwargs", ")", ":", "# Build up request data.", "url", "=", "self", ".", "_url", ".", "format", "(", "instance", "=", "instance", ")", "request_data", "=", "{", "'cidr_mask'", ":", "cidr_mask", ",", "'description'", ":", "description", "}", "request_data", ".", "update", "(", "kwargs", ")", "# Call to create an instance.", "response", "=", "requests", ".", "post", "(", "url", ",", "data", "=", "json", ".", "dumps", "(", "request_data", ")", ",", "*", "*", "self", ".", "_default_request_kwargs", ")", "# Log outcome of instance creation request.", "if", "response", ".", "status_code", "==", "200", ":", "logger", ".", "info", "(", "'Successfully created a new ACL for instance {} with: {}.'", ".", "format", "(", "instance", ",", "request_data", ")", ")", "else", ":", "logger", ".", "info", "(", "'Failed to create a new ACL for instance {} with: {}.'", ".", "format", "(", "instance", ",", "request_data", ")", ")", "data", "=", "self", ".", "_get_response_data", "(", "response", ")", "return", "self", ".", "_concrete_acl", "(", "data", ")" ]

[ "Create", "an", "ACL", "entry", "for", "the", "specified", "instance", "." ]

[ "def", "edit_rwhois", "(", "self", ",", "abuse_email", "=", "None", ",", "address1", "=", "None", ",", "address2", "=", "None", ",", "city", "=", "None", ",", "company_name", "=", "None", ",", "country", "=", "None", ",", "first_name", "=", "None", ",", "last_name", "=", "None", ",", "postal_code", "=", "None", ",", "private_residence", "=", "None", ",", "state", "=", "None", ")", ":", "update", "=", "{", "}", "for", "key", ",", "value", "in", "[", "(", "'abuseEmail'", ",", "abuse_email", ")", ",", "(", "'address1'", ",", "address1", ")", ",", "(", "'address2'", ",", "address2", ")", ",", "(", "'city'", ",", "city", ")", ",", "(", "'companyName'", ",", "company_name", ")", ",", "(", "'country'", ",", "country", ")", ",", "(", "'firstName'", ",", "first_name", ")", ",", "(", "'lastName'", ",", "last_name", ")", ",", "(", "'privateResidenceFlag'", ",", "private_residence", ")", ",", "(", "'state'", ",", "state", ")", ",", "(", "'postalCode'", ",", "postal_code", ")", "]", ":", "if", "value", "is", "not", "None", ":", "update", "[", "key", "]", "=", "value", "# If there's anything to update, update it", "if", "update", ":", "rwhois", "=", "self", ".", "get_rwhois", "(", ")", "return", "self", ".", "client", "[", "'Network_Subnet_Rwhois_Data'", "]", ".", "editObject", "(", "update", ",", "id", "=", "rwhois", "[", "'id'", "]", ")", "return", "True" ]

[ "Edit", "rwhois", "record", "." ]

[ "def", "bias_variable", "(", "shape", ")", ":", "initial", "=", "tf", ".", "constant", "(", "0.1", ",", "shape", "=", "shape", ")", "return", "tf", ".", "Variable", "(", "initial", ")" ]

[ "bias_variable", "generates", "a", "bias", "variable", "of", "a", "given", "shape", "." ]

[ "def", "insert", "(", "self", ",", "doc_or_docs", ",", "manipulate", "=", "True", ",", "safe", "=", "True", ",", "check_keys", "=", "True", ",", "callback", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "not", "isinstance", "(", "safe", ",", "bool", ")", ":", "raise", "TypeError", "(", "\"safe must be an instance of bool\"", ")", "docs", "=", "doc_or_docs", "# return_one = False", "if", "isinstance", "(", "docs", ",", "dict", ")", ":", "# return_one = True", "docs", "=", "[", "docs", "]", "# if manipulate:", "# docs = [self.__database._fix_incoming(doc, self) for doc in docs]", "self", ".", "__limit", "=", "None", "if", "kwargs", ":", "safe", "=", "True", "if", "safe", "and", "not", "callable", "(", "callback", ")", ":", "raise", "TypeError", "(", "\"callback must be callable\"", ")", "if", "not", "safe", "and", "callback", "is", "not", "None", ":", "raise", "TypeError", "(", "\"callback can not be used with safe=False\"", ")", "if", "callback", ":", "callback", "=", "functools", ".", "partial", "(", "self", ".", "_handle_response", ",", "orig_callback", "=", "callback", ")", "connection", "=", "self", ".", "__pool", ".", "connection", "(", ")", "try", ":", "connection", ".", "send_message", "(", "message", ".", "insert", "(", "self", ".", "full_collection_name", ",", "docs", ",", "check_keys", ",", "safe", ",", "kwargs", ")", ",", "callback", "=", "callback", ")", "except", ":", "connection", ".", "close", "(", ")", "raise" ]

[ "Insert", "a", "document", "(", "s", ")", "into", "this", "collection", ".", "If", "manipulate", "is", "set", "the", "document", "(", "s", ")", "are", "manipulated", "using", "any", ":", "class", ":", "~pymongo", ".", "son_manipulator", ".", "SONManipulator", "instances", "that", "have", "been", "added", "to", "this", ":", "class", ":", "~pymongo", ".", "database", ".", "Database", ".", "Returns", "the", "_id", "of", "the", "inserted", "document", "or", "a", "list", "of", "_id", "values", "of", "the", "inserted", "documents", ".", "If", "the", "document", "(", "s", ")", "does", "not", "already", "contain", "an", "_id", "one", "will", "be", "added", ".", "If", "safe", "is", "True", "then", "the", "insert", "will", "be", "checked", "for", "errors", "raising", ":", "class", ":", "~pymongo", ".", "errors", ".", "OperationFailure", "if", "one", "occurred", ".", "Safe", "inserts", "wait", "for", "a", "response", "from", "the", "database", "while", "normal", "inserts", "do", "not", ".", "Any", "additional", "keyword", "arguments", "imply", "safe", "=", "True", "and", "will", "be", "used", "as", "options", "for", "the", "resultant", "getLastError", "command", ".", "For", "example", "to", "wait", "for", "replication", "to", "3", "nodes", "pass", "w", "=", "3", ".", ":", "Parameters", ":", "-", "doc_or_docs", ":", "a", "document", "or", "list", "of", "documents", "to", "be", "inserted", "-", "manipulate", "(", "optional", ")", ":", "manipulate", "the", "documents", "before", "inserting?", "-", "safe", "(", "optional", ")", ":", "check", "that", "the", "insert", "succeeded?", "-", "check_keys", "(", "optional", ")", ":", "check", "if", "keys", "start", "with", "$", "or", "contain", ".", "raising", ":", "class", ":", "~pymongo", ".", "errors", ".", "InvalidName", "in", "either", "case", "-", "**", "kwargs", "(", "optional", ")", ":", "any", "additional", "arguments", "imply", "safe", "=", "True", "and", "will", "be", "used", "as", "options", "for", "the", "getLastError", "command", "..", "mongodoc", "::", "insert" ]

[ "def", "wait_until_element_not_contain_text", "(", "self", ",", "element", ",", "text", ",", "timeout", "=", "None", ")", ":", "return", "self", ".", "_wait_until", "(", "self", ".", "_expected_condition_find_element_not_containing_text", ",", "(", "element", ",", "text", ")", ",", "timeout", ")" ]

[ "Search", "element", "and", "wait", "until", "it", "does", "not", "contain", "the", "expected", "text" ]

[ "def", "Print", "(", "self", ",", "output_writer", ")", ":", "if", "self", ".", "_file_scanner", ":", "output_writer", ".", "Write", "(", "'\\tsignature identifiers: {0:s}\\n'", ".", "format", "(", "', '", ".", "join", "(", "self", ".", "_signature_identifiers", ")", ")", ")" ]

[ "Prints", "a", "human", "readable", "version", "of", "the", "filter", "." ]

[ "def", "create_network", "(", "batch_size", ",", "update_freq", ")", ":", "import", "logging", "head", "=", "'%(asctime)-15s %(message)s'", "logging", ".", "basicConfig", "(", "level", "=", "logging", ".", "INFO", ",", "format", "=", "head", ")", "train_data", "=", "np", ".", "random", ".", "randint", "(", "1", ",", "5", ",", "[", "1000", ",", "2", "]", ")", "weights", "=", "np", ".", "array", "(", "[", "1.0", ",", "2.0", "]", ")", "train_label", "=", "train_data", ".", "dot", "(", "weights", ")", "di", "=", "mx", ".", "io", ".", "NDArrayIter", "(", "train_data", ",", "train_label", ",", "batch_size", "=", "batch_size", ",", "shuffle", "=", "True", ",", "label_name", "=", "'lin_reg_label'", ")", "X", "=", "mx", ".", "sym", ".", "Variable", "(", "'data'", ")", "Y", "=", "mx", ".", "symbol", ".", "Variable", "(", "'lin_reg_label'", ")", "fully_connected_layer", "=", "mx", ".", "sym", ".", "FullyConnected", "(", "data", "=", "X", ",", "name", "=", "'fc1'", ",", "num_hidden", "=", "1", ")", "lro", "=", "mx", ".", "sym", ".", "LinearRegressionOutput", "(", "data", "=", "fully_connected_layer", ",", "label", "=", "Y", ",", "name", "=", "\"lro\"", ")", "mod", "=", "SVRGModule", "(", "symbol", "=", "lro", ",", "data_names", "=", "[", "'data'", "]", ",", "label_names", "=", "[", "'lin_reg_label'", "]", ",", "update_freq", "=", "update_freq", ",", "logger", "=", "logging", ")", "return", "di", ",", "mod" ]

[ "Create", "a", "linear", "regression", "network", "for", "performing", "SVRG", "optimization", ".", "Parameters", "----------", "batch_size", ":", "int", "Size", "of", "data", "split", "update_freq", ":", "int", "Update", "Frequency", "for", "calculating", "full", "gradients" ]

[ "def", "change_range", "(", "self", ",", "min_port", "=", "1025", ",", "max_port", "=", "2000", ",", "port_sequence", "=", "None", ")", ":", "self", ".", "__init_range", "(", "min_port", ",", "max_port", ",", "port_sequence", ")" ]

[ "change", "Pool", "port", "range" ]

[ "def", "revoke_access_token", "(", "self", ",", "access_token", ")", ":", "payload", "=", "{", "'access_token'", ":", "access_token", ",", "}", "req", "=", "requests", ".", "post", "(", "settings", ".", "API_DEAUTHORIZATION_URL", ",", "data", "=", "payload", ")" ]

[ "Revokes", "the", "Access", "Token", "by", "accessing", "the", "De", "-", "authorization", "Endpoint", "of", "Health", "Graph", "API", "." ]

[ "async", "def", "unban", "(", "self", ",", "user", ",", "*", ",", "reason", "=", "None", ")", ":", "await", "self", ".", "_state", ".", "http", ".", "unban", "(", "user", ".", "id", ",", "self", ".", "id", ",", "reason", "=", "reason", ")" ]

[ "|coro|" ]

[ "def", "add_files", "(", "self", ",", "files", ")", ":", "for", "file", "in", "files", ":", "file", ".", "copy", "(", "project", "=", "self", ".", "id", ")" ]

[ "Adds", "files", "to", "this", "project", ".", ":", "param", "files", ":", "List", "of", "files", "or", "a", "Collection", "object", "." ]

[ "def", "on_menu_exit", "(", "self", ",", "event", ")", ":", "if", "self", ".", "close_warning", ":", "TEXT", "=", "\"Data is not saved to a file yet!\\nTo properly save your data:\\n1) Analysis --> Save current interpretations to a redo file.\\nor\\n1) File --> Save MagIC tables.\\n\\n Press OK to exit without saving.\"", "dlg1", "=", "wx", ".", "MessageDialog", "(", "None", ",", "caption", "=", "\"Warning:\"", ",", "message", "=", "TEXT", ",", "style", "=", "wx", ".", "OK", "|", "wx", ".", "CANCEL", "|", "wx", ".", "ICON_EXCLAMATION", ")", "if", "self", ".", "show_dlg", "(", "dlg1", ")", "==", "wx", ".", "ID_OK", ":", "dlg1", ".", "Destroy", "(", ")", "self", ".", "GUI_log", ".", "close", "(", ")", "self", ".", "Destroy", "(", ")", "# if a custom quit event is specified, fire it", "if", "self", ".", "evt_quit", ":", "event", "=", "self", ".", "evt_quit", "(", "self", ".", "GetId", "(", ")", ")", "self", ".", "GetEventHandler", "(", ")", ".", "ProcessEvent", "(", "event", ")", "if", "self", ".", "standalone", ":", "sys", ".", "exit", "(", ")", "else", ":", "self", ".", "GUI_log", ".", "close", "(", ")", "self", ".", "Destroy", "(", ")", "# if a custom quit event is specified, fire it", "if", "self", ".", "evt_quit", ":", "event", "=", "self", ".", "evt_quit", "(", "self", ".", "GetId", "(", ")", ")", "self", ".", "GetEventHandler", "(", ")", ".", "ProcessEvent", "(", "event", ")", "if", "self", ".", "standalone", ":", "sys", ".", "exit", "(", ")" ]

[ "Runs", "whenever", "Thellier", "GUI", "exits" ]

[ "def", "structure", "(", "self", ")", ":", "masses", "=", "self", ".", "masses", "atoms", "=", "self", ".", "atoms", ".", "copy", "(", ")", "if", "\"nx\"", "in", "atoms", ".", "columns", ":", "atoms", ".", "drop", "(", "[", "\"nx\"", ",", "\"ny\"", ",", "\"nz\"", "]", ",", "axis", "=", "1", ",", "inplace", "=", "True", ")", "atoms", "[", "\"molecule-ID\"", "]", "=", "1", "ld_copy", "=", "self", ".", "__class__", "(", "self", ".", "box", ",", "masses", ",", "atoms", ")", "topologies", "=", "ld_copy", ".", "disassemble", "(", ")", "[", "-", "1", "]", "molecule", "=", "topologies", "[", "0", "]", ".", "sites", "coords", "=", "molecule", ".", "cart_coords", "-", "np", ".", "array", "(", "self", ".", "box", ".", "bounds", ")", "[", ":", ",", "0", "]", "species", "=", "molecule", ".", "species", "latt", "=", "self", ".", "box", ".", "to_lattice", "(", ")", "site_properties", "=", "{", "}", "if", "\"q\"", "in", "atoms", ":", "site_properties", "[", "\"charge\"", "]", "=", "atoms", "[", "\"q\"", "]", ".", "values", "if", "self", ".", "velocities", "is", "not", "None", ":", "site_properties", "[", "\"velocities\"", "]", "=", "self", ".", "velocities", ".", "values", "return", "Structure", "(", "latt", ",", "species", ",", "coords", ",", "coords_are_cartesian", "=", "True", ",", "site_properties", "=", "site_properties", ")" ]

[ "Exports", "a", "periodic", "structure", "object", "representing", "the", "simulation", "box", "." ]

[ "def", "get_HEAD_SHA1", "(", "git_dir", ")", ":", "head_file", "=", "os", ".", "path", ".", "join", "(", "git_dir", ",", "'HEAD'", ")", "with", "open", "(", "head_file", ",", "'r'", ")", "as", "hf", ":", "head_contents", "=", "hf", ".", "read", "(", ")", ".", "strip", "(", ")", "assert", "head_contents", ".", "startswith", "(", "'ref: '", ")", "ref_filename", "=", "head_contents", "[", "5", ":", "]", "# strip off \"ref: \"", "real_ref", "=", "os", ".", "path", ".", "join", "(", "git_dir", ",", "ref_filename", ")", "with", "open", "(", "real_ref", ",", "'r'", ")", "as", "rf", ":", "return", "rf", ".", "read", "(", ")", ".", "strip", "(", ")" ]

[ "Not", "locked!" ]

[ "def", "get_connection", "(", "self", ",", "command", ",", "args", "=", "(", ")", ")", ":", "# TODO: find a better way to determine if connection is free", "# and not havily used.", "command", "=", "command", ".", "upper", "(", ")", ".", "strip", "(", ")", "is_pubsub", "=", "command", "in", "_PUBSUB_COMMANDS", "if", "is_pubsub", "and", "self", ".", "_pubsub_conn", ":", "if", "not", "self", ".", "_pubsub_conn", ".", "closed", ":", "return", "self", ".", "_pubsub_conn", ",", "self", ".", "_pubsub_conn", ".", "address", "self", ".", "_pubsub_conn", "=", "None", "for", "i", "in", "range", "(", "self", ".", "freesize", ")", ":", "conn", "=", "self", ".", "_pool", "[", "0", "]", "self", ".", "_pool", ".", "rotate", "(", "1", ")", "if", "conn", ".", "closed", ":", "# or conn._waiters: (eg: busy connection)", "continue", "if", "conn", ".", "in_pubsub", ":", "continue", "if", "is_pubsub", ":", "self", ".", "_pubsub_conn", "=", "conn", "self", ".", "_pool", ".", "remove", "(", "conn", ")", "self", ".", "_used", ".", "add", "(", "conn", ")", "return", "conn", ",", "conn", ".", "address", "return", "None", ",", "self", ".", "_address" ]

[ "Get", "free", "connection", "from", "pool", "." ]

[ "def", "_fit_and_score", "(", "estimator", ",", "X", ",", "y", ",", "scorer", ",", "train", ",", "test", ",", "verbose", ",", "parameters", ",", "fit_params", ",", "return_train_score", "=", "False", ",", "return_parameters", "=", "False", ")", ":", "if", "verbose", ">", "1", ":", "if", "parameters", "is", "None", ":", "msg", "=", "\"no parameters to be set\"", "else", ":", "msg", "=", "'%s'", "%", "(", "', '", ".", "join", "(", "'%s=%s'", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "list", "(", "parameters", ".", "items", "(", ")", ")", ")", ")", "print", "(", "\"[CV] %s %s\"", "%", "(", "msg", ",", "(", "64", "-", "len", "(", "msg", ")", ")", "*", "'.'", ")", ")", "# Adjust lenght of sample weights", "n_samples", "=", "_num_samples", "(", "X", ")", "fit_params", "=", "fit_params", "if", "fit_params", "is", "not", "None", "else", "{", "}", "fit_params", "=", "dict", "(", "[", "(", "k", ",", "np", ".", "asarray", "(", "v", ")", "[", "train", "]", "if", "hasattr", "(", "v", ",", "'__len__'", ")", "and", "len", "(", "v", ")", "==", "n_samples", "else", "v", ")", "for", "k", ",", "v", "in", "list", "(", "fit_params", ".", "items", "(", ")", ")", "]", ")", "if", "parameters", "is", "not", "None", ":", "estimator", ".", "set_params", "(", "*", "*", "parameters", ")", "start_time", "=", "time", ".", "time", "(", ")", "X_train", ",", "y_train", "=", "_safe_split", "(", "estimator", ",", "X", ",", "y", ",", "train", ")", "X_test", ",", "y_test", "=", "_safe_split", "(", "estimator", ",", "X", ",", "y", ",", "test", ",", "train", ")", "if", "y_train", "is", "None", ":", "estimator", ".", "fit", "(", "X_train", ",", "*", "*", "fit_params", ")", "else", ":", "estimator", ".", "fit", "(", "X_train", ",", "y_train", ",", "*", "*", "fit_params", ")", "test_score", "=", "_score", "(", "estimator", ",", "X_test", ",", "y_test", ",", "scorer", ")", "if", "return_train_score", ":", "train_score", "=", "_score", "(", "estimator", ",", "X_train", ",", "y_train", ",", "scorer", ")", "scoring_time", "=", "time", ".", "time", "(", ")", "-", "start_time", "if", "verbose", ">", "2", ":", "msg", "+=", "\", score=%f\"", "%", "test_score", "if", "verbose", ">", "1", ":", "end_msg", "=", "\"%s -%s\"", "%", "(", "msg", ",", "logger", ".", "short_format_time", "(", "scoring_time", ")", ")", "print", "(", "\"[CV] %s %s\"", "%", "(", "(", "64", "-", "len", "(", "end_msg", ")", ")", "*", "'.'", ",", "end_msg", ")", ")", "ret", "=", "[", "train_score", "]", "if", "return_train_score", "else", "[", "]", "ret", ".", "extend", "(", "[", "test_score", ",", "_num_samples", "(", "X_test", ")", ",", "scoring_time", "]", ")", "if", "return_parameters", ":", "ret", ".", "append", "(", "parameters", ")", "return", "ret" ]

[ "Fit", "estimator", "and", "compute", "scores", "for", "a", "given", "dataset", "split", "." ]

[ "def", "link_methods", "(", "self", ")", ":", "from", ".", ".", "compiler", "import", "Compiler", "for", "method", "in", "self", ".", "methods", ":", "method", ".", "prepare", "(", ")", "self", ".", "all_vm_tokens", "=", "OrderedDict", "(", ")", "address", "=", "0", "for", "method", "in", "self", ".", "orderered_methods", ":", "if", "not", "method", ".", "is_interop", ":", "# print(\"ADDING METHOD %s \" % method.full_name)", "method", ".", "address", "=", "address", "for", "key", ",", "vmtoken", "in", "method", ".", "vm_tokens", ".", "items", "(", ")", ":", "self", ".", "all_vm_tokens", "[", "address", "]", "=", "vmtoken", "address", "+=", "1", "if", "vmtoken", ".", "data", "is", "not", "None", "and", "vmtoken", ".", "vm_op", "!=", "VMOp", ".", "NOP", ":", "address", "+=", "len", "(", "vmtoken", ".", "data", ")", "vmtoken", ".", "addr", "=", "vmtoken", ".", "addr", "+", "method", ".", "address", "for", "key", ",", "vmtoken", "in", "self", ".", "all_vm_tokens", ".", "items", "(", ")", ":", "if", "vmtoken", ".", "src_method", "is", "not", "None", ":", "target_method", "=", "self", ".", "method_by_name", "(", "vmtoken", ".", "target_method", ")", "if", "target_method", ":", "jump_len", "=", "target_method", ".", "address", "-", "vmtoken", ".", "addr", "param_ret_counts", "=", "bytearray", "(", ")", "if", "Compiler", ".", "instance", "(", ")", ".", "nep8", ":", "param_ret_counts", "=", "vmtoken", ".", "data", "[", "0", ":", "2", "]", "jump_len", "-=", "2", "if", "jump_len", ">", "-", "32767", "and", "jump_len", "<", "32767", ":", "vmtoken", ".", "data", "=", "param_ret_counts", "+", "jump_len", ".", "to_bytes", "(", "2", ",", "'little'", ",", "signed", "=", "True", ")", "else", ":", "vmtoken", ".", "data", "=", "param_ret_counts", "+", "jump_len", ".", "to_bytes", "(", "4", ",", "'little'", ",", "signed", "=", "True", ")", "else", ":", "raise", "Exception", "(", "\"Target method %s not found\"", "%", "vmtoken", ".", "target_method", ")" ]

[ "Perform", "linkage", "of", "addresses", "between", "methods", "." ]

[ "def", "persist", "(", "self", ")", ":", "self", ".", "persisted_nodes", "=", "self", ".", "graph", ".", "dump_nodes", "(", ")", "self", ".", "persisted_streamers", "=", "self", ".", "graph", ".", "dump_streamers", "(", ")", "self", ".", "persisted_exists", "=", "True", "self", ".", "persisted_constants", "=", "self", ".", "_sensor_log", ".", "dump_constants", "(", ")" ]

[ "Trigger", "saving", "the", "current", "sensorgraph", "to", "persistent", "storage", "." ]

[ "def", "get_nowait", "(", "self", ")", ":", "new_get", "=", "Future", "(", ")", "with", "self", ".", "_lock", ":", "if", "not", "self", ".", "_get", ".", "done", "(", ")", ":", "raise", "QueueEmpty", "get", ",", "self", ".", "_get", "=", "self", ".", "_get", ",", "new_get", "hole", "=", "get", ".", "result", "(", ")", "if", "not", "hole", ".", "done", "(", ")", ":", "# Restore the unfinished hole.", "new_get", ".", "set_result", "(", "hole", ")", "raise", "QueueEmpty", "node", "=", "hole", ".", "result", "(", ")", "value", "=", "node", ".", "value", "new_hole", ",", "node", ".", "next", "=", "node", ".", "next", ",", "None", "new_get", ".", "set_result", "(", "new_hole", ")", "return", "value" ]

[ "Returns", "a", "value", "from", "the", "queue", "without", "waiting", "." ]

[ "def", "randval", "(", "self", ")", ":", "fmtt", "=", "self", ".", "fmt", "[", "-", "1", "]", "if", "fmtt", "in", "\"BHIQ\"", ":", "return", "{", "\"B\"", ":", "RandByte", ",", "\"H\"", ":", "RandShort", ",", "\"I\"", ":", "RandInt", ",", "\"Q\"", ":", "RandLong", "}", "[", "fmtt", "]", "(", ")", "elif", "fmtt", "==", "\"s\"", ":", "if", "self", ".", "fmt", "[", "0", "]", "in", "\"0123456789\"", ":", "l", "=", "int", "(", "self", ".", "fmt", "[", ":", "-", "1", "]", ")", "else", ":", "l", "=", "int", "(", "self", ".", "fmt", "[", "1", ":", "-", "1", "]", ")", "return", "RandBin", "(", "l", ")", "else", ":", "warning", "(", "\"no random class for [%s] (fmt=%s).\"", "%", "(", "self", ".", "name", ",", "self", ".", "fmt", ")", ")" ]

[ "Return", "a", "volatile", "object", "whose", "value", "is", "both", "random", "and", "suitable", "for", "this", "field" ]

[ "def", "trigger_event", "(", "self", ",", "module_name", ",", "event", ")", ":", "if", "module_name", ":", "self", ".", "_py3_wrapper", ".", "events_thread", ".", "process_event", "(", "module_name", ",", "event", ")" ]

[ "Trigger", "an", "event", "on", "a", "named", "module", "." ]

[ "def", "get_indicators_metadata", "(", "self", ",", "indicators", ")", ":", "data", "=", "[", "{", "'value'", ":", "i", ".", "value", ",", "'indicatorType'", ":", "i", ".", "type", "}", "for", "i", "in", "indicators", "]", "resp", "=", "self", ".", "_client", ".", "post", "(", "\"indicators/metadata\"", ",", "data", "=", "json", ".", "dumps", "(", "data", ")", ")", "return", "[", "Indicator", ".", "from_dict", "(", "x", ")", "for", "x", "in", "resp", ".", "json", "(", ")", "]" ]

[ "Provide", "metadata", "associated", "with", "an", "list", "of", "indicators", "including", "value", "indicatorType", "noteCount", "sightings", "lastSeen", "enclaveIds", "and", "tags", ".", "The", "metadata", "is", "determined", "based", "on", "the", "enclaves", "the", "user", "making", "the", "request", "has", "READ", "access", "to", "." ]

[ "def", "simxGetObjectOrientation", "(", "clientID", ",", "objectHandle", ",", "relativeToObjectHandle", ",", "operationMode", ")", ":", "eulerAngles", "=", "(", "ct", ".", "c_float", "*", "3", ")", "(", ")", "ret", "=", "c_GetObjectOrientation", "(", "clientID", ",", "objectHandle", ",", "relativeToObjectHandle", ",", "eulerAngles", ",", "operationMode", ")", "arr", "=", "[", "]", "for", "i", "in", "range", "(", "3", ")", ":", "arr", ".", "append", "(", "eulerAngles", "[", "i", "]", ")", "return", "ret", ",", "arr" ]

[ "Please", "have", "a", "look", "at", "the", "function", "description", "/", "documentation", "in", "the", "V", "-", "REP", "user", "manual" ]

[ "def", "run", "(", "self", ",", "*", "*", "kwargs", ")", ":", "from", "calculate", "import", "compute", "self", ".", "app_main", "(", "*", "*", "kwargs", ")", "# get the default output name", "output", "=", "osp", ".", "join", "(", "self", ".", "exp_config", "[", "'expdir'", "]", ",", "'output.dat'", ")", "# save the paths in the configuration", "self", ".", "exp_config", "[", "'output'", "]", "=", "output", "# run the model", "data", "=", "np", ".", "loadtxt", "(", "self", ".", "exp_config", "[", "'infile'", "]", ")", "out", "=", "compute", "(", "data", ")", "# save the output", "self", ".", "logger", ".", "info", "(", "'Saving output data to %s'", ",", "osp", ".", "relpath", "(", "output", ")", ")", "np", ".", "savetxt", "(", "output", ",", "out", ")", "# store some additional information in the configuration of the", "# experiment", "self", ".", "exp_config", "[", "'mean'", "]", "=", "mean", "=", "float", "(", "out", ".", "mean", "(", ")", ")", "self", ".", "exp_config", "[", "'std'", "]", "=", "std", "=", "float", "(", "out", ".", "std", "(", ")", ")", "self", ".", "logger", ".", "debug", "(", "'Mean: %s, Standard deviation: %s'", ",", "mean", ",", "std", ")" ]

[ "Run", "the", "model" ]

[ "def", "update", "(", "self", ")", ":", "# Init new stats", "stats", "=", "self", ".", "get_init_value", "(", ")", "# IRQ plugin only available on GNU/Linux", "if", "not", "LINUX", ":", "return", "self", ".", "stats", "if", "self", ".", "input_method", "==", "'local'", ":", "# Grab the stats", "stats", "=", "self", ".", "irq", ".", "get", "(", ")", "elif", "self", ".", "input_method", "==", "'snmp'", ":", "# not available", "pass", "# Get the TOP 5 (by rate/s)", "stats", "=", "sorted", "(", "stats", ",", "key", "=", "operator", ".", "itemgetter", "(", "'irq_rate'", ")", ",", "reverse", "=", "True", ")", "[", ":", "5", "]", "# Update the stats", "self", ".", "stats", "=", "stats", "return", "self", ".", "stats" ]

[ "Update", "the", "IRQ", "stats", "." ]

[ "def", "load", "(", "self", ",", "code", ",", "setup", "=", "''", ",", "teardown", "=", "''", ")", ":", "super", "(", ")", ".", "load", "(", "code", ",", "setup", ",", "teardown", ")", "self", ".", "_frame", "=", "self", ".", "_original_frame", ".", "copy", "(", ")" ]

[ "Prepares", "a", "set", "of", "setup", "test", "and", "teardown", "code", "to", "be", "run", "in", "the", "console", "." ]

[ "def", "_ParseAndValidateRecord", "(", "self", ",", "parser_mediator", ",", "text_file_object", ")", ":", "try", ":", "title", "=", "text_file_object", ".", "readline", "(", "size", "=", "self", ".", "_MAXIMUM_LINE_SIZE", ")", "url", "=", "text_file_object", ".", "readline", "(", "size", "=", "self", ".", "_MAXIMUM_LINE_SIZE", ")", "timestamp", "=", "text_file_object", ".", "readline", "(", "size", "=", "self", ".", "_MAXIMUM_LINE_SIZE", ")", "popularity_index", "=", "text_file_object", ".", "readline", "(", "size", "=", "self", ".", "_MAXIMUM_LINE_SIZE", ")", "except", "UnicodeDecodeError", ":", "return", "False", "if", "len", "(", "title", ")", "==", "self", ".", "_MAXIMUM_LINE_SIZE", "and", "title", "[", "-", "1", "]", "!=", "'\\n'", ":", "return", "False", "if", "len", "(", "url", ")", "==", "self", ".", "_MAXIMUM_LINE_SIZE", "and", "url", "[", "-", "1", "]", "!=", "'\\n'", ":", "return", "False", "if", "len", "(", "timestamp", ")", "==", "self", ".", "_MAXIMUM_LINE_SIZE", "and", "timestamp", "[", "-", "1", "]", "!=", "'\\n'", ":", "return", "False", "if", "(", "len", "(", "popularity_index", ")", "==", "self", ".", "_MAXIMUM_LINE_SIZE", "and", "popularity_index", "[", "-", "1", "]", "!=", "'\\n'", ")", ":", "return", "False", "title", "=", "title", ".", "strip", "(", ")", "url", "=", "url", ".", "strip", "(", ")", "timestamp", "=", "timestamp", ".", "strip", "(", ")", "popularity_index", "=", "popularity_index", ".", "strip", "(", ")", "if", "not", "title", "or", "not", "url", "or", "not", "timestamp", "or", "not", "popularity_index", ":", "return", "False", "event_data", "=", "OperaGlobalHistoryEventData", "(", ")", "if", "not", "self", ".", "_IsValidUrl", "(", "url", ")", ":", "return", "False", "event_data", ".", "url", "=", "url", "if", "title", "!=", "url", ":", "event_data", ".", "title", "=", "title", "try", ":", "event_data", ".", "popularity_index", "=", "int", "(", "popularity_index", ",", "10", ")", "timestamp", "=", "int", "(", "timestamp", ",", "10", ")", "except", "ValueError", ":", "return", "False", "if", "event_data", ".", "popularity_index", "<", "0", ":", "event_data", ".", "description", "=", "'First and Only Visit'", "else", ":", "event_data", ".", "description", "=", "'Last Visit'", "date_time", "=", "dfdatetime_posix_time", ".", "PosixTime", "(", "timestamp", "=", "timestamp", ")", "event", "=", "time_events", ".", "DateTimeValuesEvent", "(", "date_time", ",", "definitions", ".", "TIME_DESCRIPTION_LAST_VISITED", ")", "parser_mediator", ".", "ProduceEventWithEventData", "(", "event", ",", "event_data", ")", "return", "True" ]

[ "Parses", "and", "validates", "an", "Opera", "global", "history", "record", "." ]

[ "def", "add_heading", "(", "self", ",", "text", "=", "\"\"", ",", "level", "=", "1", ")", ":", "if", "not", "0", "<=", "level", "<=", "9", ":", "raise", "ValueError", "(", "\"level must be in range 0-9, got %d\"", "%", "level", ")", "style", "=", "\"Title\"", "if", "level", "==", "0", "else", "\"Heading %d\"", "%", "level", "return", "self", ".", "add_paragraph", "(", "text", ",", "style", ")" ]

[ "Return", "a", "heading", "paragraph", "newly", "added", "to", "the", "end", "of", "the", "document", "." ]

[ "def", "get_outbox_fax", "(", "self", ",", "outbox_fax_id", ",", "*", "*", "kwargs", ")", ":", "# noqa: E501", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async'", ")", ":", "return", "self", ".", "get_outbox_fax_with_http_info", "(", "outbox_fax_id", ",", "*", "*", "kwargs", ")", "# noqa: E501", "else", ":", "(", "data", ")", "=", "self", ".", "get_outbox_fax_with_http_info", "(", "outbox_fax_id", ",", "*", "*", "kwargs", ")", "# noqa: E501", "return", "data" ]

[ "Get", "an", "outbox", "record", "#", "noqa", ":", "E501" ]

[ "def", "lookup_comment_by_wordpress_id", "(", "self", ",", "comment_id", ",", "comments", ")", ":", "for", "comment", "in", "comments", ":", "if", "comment", ".", "wordpress_id", "==", "comment_id", ":", "return", "comment" ]

[ "Returns", "Django", "comment", "object", "with", "this", "wordpress", "id" ]

[ "def", "confirm_registration", "(", "request", ",", "key", ",", "template", "=", "\"locksmith/confirmed.html\"", ")", ":", "context", "=", "{", "'LOCKSMITH_BASE_TEMPLATE'", ":", "settings", ".", "LOCKSMITH_BASE_TEMPLATE", "}", "try", ":", "context", "[", "'key'", "]", "=", "key_obj", "=", "Key", ".", "objects", ".", "get", "(", "key", "=", "key", ")", "if", "key_obj", ".", "status", "!=", "'U'", ":", "context", "[", "'error'", "]", "=", "'Key Already Activated'", "else", ":", "key_obj", ".", "status", "=", "'A'", "key_obj", ".", "save", "(", ")", "key_obj", ".", "mark_for_update", "(", ")", "except", "Key", ".", "DoesNotExist", ":", "context", "[", "'error'", "]", "=", "'Invalid Key'", "return", "render_to_response", "(", "template", ",", "context", ",", "context_instance", "=", "RequestContext", "(", "request", ")", ")" ]

[ "API", "key", "confirmation" ]

[ "def", "_ensure_data", "(", "values", ",", "dtype", "=", "None", ")", ":", "# we check some simple dtypes first", "try", ":", "if", "is_object_dtype", "(", "dtype", ")", ":", "return", "ensure_object", "(", "np", ".", "asarray", "(", "values", ")", ")", ",", "'object'", ",", "'object'", "if", "is_bool_dtype", "(", "values", ")", "or", "is_bool_dtype", "(", "dtype", ")", ":", "# we are actually coercing to uint64", "# until our algos support uint8 directly (see TODO)", "return", "np", ".", "asarray", "(", "values", ")", ".", "astype", "(", "'uint64'", ")", ",", "'bool'", ",", "'uint64'", "elif", "is_signed_integer_dtype", "(", "values", ")", "or", "is_signed_integer_dtype", "(", "dtype", ")", ":", "return", "ensure_int64", "(", "values", ")", ",", "'int64'", ",", "'int64'", "elif", "(", "is_unsigned_integer_dtype", "(", "values", ")", "or", "is_unsigned_integer_dtype", "(", "dtype", ")", ")", ":", "return", "ensure_uint64", "(", "values", ")", ",", "'uint64'", ",", "'uint64'", "elif", "is_float_dtype", "(", "values", ")", "or", "is_float_dtype", "(", "dtype", ")", ":", "return", "ensure_float64", "(", "values", ")", ",", "'float64'", ",", "'float64'", "elif", "is_object_dtype", "(", "values", ")", "and", "dtype", "is", "None", ":", "return", "ensure_object", "(", "np", ".", "asarray", "(", "values", ")", ")", ",", "'object'", ",", "'object'", "elif", "is_complex_dtype", "(", "values", ")", "or", "is_complex_dtype", "(", "dtype", ")", ":", "# ignore the fact that we are casting to float", "# which discards complex parts", "with", "catch_warnings", "(", ")", ":", "simplefilter", "(", "\"ignore\"", ",", "np", ".", "ComplexWarning", ")", "values", "=", "ensure_float64", "(", "values", ")", "return", "values", ",", "'float64'", ",", "'float64'", "except", "(", "TypeError", ",", "ValueError", ",", "OverflowError", ")", ":", "# if we are trying to coerce to a dtype", "# and it is incompat this will fall thru to here", "return", "ensure_object", "(", "values", ")", ",", "'object'", ",", "'object'", "# datetimelike", "if", "(", "needs_i8_conversion", "(", "values", ")", "or", "is_period_dtype", "(", "dtype", ")", "or", "is_datetime64_any_dtype", "(", "dtype", ")", "or", "is_timedelta64_dtype", "(", "dtype", ")", ")", ":", "if", "is_period_dtype", "(", "values", ")", "or", "is_period_dtype", "(", "dtype", ")", ":", "from", "pandas", "import", "PeriodIndex", "values", "=", "PeriodIndex", "(", "values", ")", "dtype", "=", "values", ".", "dtype", "elif", "is_timedelta64_dtype", "(", "values", ")", "or", "is_timedelta64_dtype", "(", "dtype", ")", ":", "from", "pandas", "import", "TimedeltaIndex", "values", "=", "TimedeltaIndex", "(", "values", ")", "dtype", "=", "values", ".", "dtype", "else", ":", "# Datetime", "from", "pandas", "import", "DatetimeIndex", "values", "=", "DatetimeIndex", "(", "values", ")", "dtype", "=", "values", ".", "dtype", "return", "values", ".", "asi8", ",", "dtype", ",", "'int64'", "elif", "(", "is_categorical_dtype", "(", "values", ")", "and", "(", "is_categorical_dtype", "(", "dtype", ")", "or", "dtype", "is", "None", ")", ")", ":", "values", "=", "getattr", "(", "values", ",", "'values'", ",", "values", ")", "values", "=", "values", ".", "codes", "dtype", "=", "'category'", "# we are actually coercing to int64", "# until our algos support int* directly (not all do)", "values", "=", "ensure_int64", "(", "values", ")", "return", "values", ",", "dtype", ",", "'int64'", "# we have failed, return object", "values", "=", "np", ".", "asarray", "(", "values", ",", "dtype", "=", "np", ".", "object", ")", "return", "ensure_object", "(", "values", ")", ",", "'object'", ",", "'object'" ]

[ "routine", "to", "ensure", "that", "our", "data", "is", "of", "the", "correct", "input", "dtype", "for", "lower", "-", "level", "routines" ]

[ "def", "confusion_matrix", "(", "exp", ",", "obs", ")", ":", "assert", "len", "(", "exp", ")", "==", "len", "(", "obs", ")", "# Expected in the first dimension (0;rows), observed in the second (1;cols)", "lbls", "=", "sorted", "(", "set", "(", "exp", ")", ")", "res", "=", "numpy", ".", "zeros", "(", "shape", "=", "(", "len", "(", "lbls", ")", ",", "len", "(", "lbls", ")", ")", ")", "for", "i", "in", "range", "(", "len", "(", "exp", ")", ")", ":", "res", "[", "lbls", ".", "index", "(", "exp", "[", "i", "]", ")", ",", "lbls", ".", "index", "(", "obs", "[", "i", "]", ")", "]", "+=", "1", "return", "res", ",", "lbls" ]

[ "Create", "a", "confusion", "matrix", "In", "each", "axis", "of", "the", "resulting", "confusion", "matrix", "the", "negative", "case", "is", "0", "-", "index", "and", "the", "positive", "case", "1", "-", "index", ".", "The", "labels", "get", "sorted", "in", "a", "True", "/", "False", "scenario", "true", "positives", "will", "occur", "at", "(", "1", "1", ")", ".", "The", "first", "dimension", "(", "rows", ")", "of", "the", "resulting", "matrix", "is", "the", "expected", "class", "and", "the", "second", "dimension", "(", "columns", ")", "is", "the", "observed", "class", ".", ":", "param", "exp", ":", "expected", "values", ":", "type", "exp", ":", "list", "of", "float", ":", "param", "obs", ":", "observed", "values", ":", "type", "obs", ":", "list", "of", "float", ":", "rtype", ":", "tuple", "of", "square", "matrix", "and", "sorted", "labels" ]

[ "def", "get_outcome_probs", "(", "self", ")", ":", "outcome_dict", "=", "{", "}", "qubit_num", "=", "len", "(", "self", ")", "for", "index", ",", "amplitude", "in", "enumerate", "(", "self", ".", "amplitudes", ")", ":", "outcome", "=", "get_bitstring_from_index", "(", "index", ",", "qubit_num", ")", "outcome_dict", "[", "outcome", "]", "=", "abs", "(", "amplitude", ")", "**", "2", "return", "outcome_dict" ]

[ "Parses", "a", "wavefunction", "(", "array", "of", "complex", "amplitudes", ")", "and", "returns", "a", "dictionary", "of", "outcomes", "and", "associated", "probabilities", "." ]

[ "def", "reformat", "(", "found_sequences", ")", ":", "for", "(", "pdb_id", ",", "chain", ",", "file_name", ")", ",", "sequence", "in", "sorted", "(", "found_sequences", ".", "iteritems", "(", ")", ")", ":", "header", "=", "sequence", "[", "0", "]", "assert", "(", "header", "[", "0", "]", "==", "'>'", ")", "tokens", "=", "header", ".", "split", "(", "'|'", ")", "tokens", "[", "0", "]", "=", "tokens", "[", "0", "]", "[", ":", "5", "]", "assert", "(", "len", "(", "tokens", "[", "0", "]", ")", "==", "5", ")", "sequence", "[", "0", "]", "=", "\"|\"", ".", "join", "(", "tokens", ")" ]

[ "Truncate", "the", "FASTA", "headers", "so", "that", "the", "first", "field", "is", "a", "4", "-", "character", "ID", "." ]

[ "def", "BooleanTake", "(", "input_vertex", ":", "vertex_constructor_param_types", ",", "index", ":", "Collection", "[", "int", "]", ",", "label", ":", "Optional", "[", "str", "]", "=", "None", ")", "->", "Vertex", ":", "return", "Boolean", "(", "context", ".", "jvm_view", "(", ")", ".", "BooleanTakeVertex", ",", "label", ",", "cast_to_vertex", "(", "input_vertex", ")", ",", "cast_to_long_array", "(", "index", ")", ")" ]

[ "A", "vertex", "that", "extracts", "a", "scalar", "at", "a", "given", "index", ":", "param", "input_vertex", ":", "the", "input", "vertex", "to", "extract", "from", ":", "param", "index", ":", "the", "index", "to", "extract", "at" ]

[ "def", "_gen_delta_depend", "(", "self", ",", "path", ",", "derivative", ",", "multiplier", ",", "prettyname", ",", "device", ")", ":", "primary_delta", "=", "derivative", "[", "path", "]", "shortpath", "=", "\".\"", ".", "join", "(", "path", ".", "split", "(", "\".\"", ")", "[", ":", "-", "1", "]", ")", "basename", "=", "path", ".", "split", "(", "\".\"", ")", "[", "-", "1", "]", "secondary_delta", "=", "None", "if", "basename", "in", "self", ".", "DIVIDERS", ".", "keys", "(", ")", ":", "mateKey", "=", "\".\"", ".", "join", "(", "[", "shortpath", ",", "self", ".", "DIVIDERS", "[", "basename", "]", "]", ")", "else", ":", "return", "if", "mateKey", "in", "derivative", ".", "keys", "(", ")", ":", "secondary_delta", "=", "derivative", "[", "mateKey", "]", "else", ":", "return", "# If we find a corresponding secondary_delta, publish a metric", "if", "primary_delta", ">", "0", "and", "secondary_delta", ">", "0", ":", "value", "=", "(", "float", "(", "primary_delta", ")", "/", "secondary_delta", ")", "*", "multiplier", "self", ".", "_replace_and_publish", "(", "path", ",", "prettyname", ",", "value", ",", "device", ")" ]

[ "For", "some", "metrics", "we", "need", "to", "divide", "the", "delta", "for", "one", "metric", "with", "the", "delta", "of", "another", ".", "Publishes", "a", "metric", "if", "the", "convertion", "goes", "well", "." ]

[ "def", "calculateTaxes", "(", "self", ")", ":", "tax_rate", "=", "(", "getConstant", "(", "'registration__salesTaxRate'", ")", "or", "0", ")", "/", "100", "if", "tax_rate", ">", "0", ":", "if", "self", ".", "buyerPaysSalesTax", ":", "# If the buyer pays taxes, then taxes are just added as a fraction of the price", "self", ".", "taxes", "=", "self", ".", "total", "*", "tax_rate", "else", ":", "# If the seller pays sales taxes, then adjusted_total will be their net revenue,", "# and under this calculation adjusted_total + taxes = the price charged", "adjusted_total", "=", "self", ".", "total", "/", "(", "1", "+", "tax_rate", ")", "self", ".", "taxes", "=", "adjusted_total", "*", "tax_rate" ]

[ "Updates", "the", "tax", "field", "to", "reflect", "the", "amount", "of", "taxes", "depending", "on", "the", "local", "rate", "as", "well", "as", "whether", "the", "buyer", "or", "seller", "pays", "sales", "tax", "." ]

[ "def", "update", "(", "self", ")", ":", "self", ".", "_controller", ".", "update", "(", "self", ".", "_id", ",", "wake_if_asleep", "=", "False", ")", "data", "=", "self", ".", "_controller", ".", "get_drive_params", "(", "self", ".", "_id", ")", "if", "data", ":", "self", ".", "__longitude", "=", "data", "[", "'longitude'", "]", "self", ".", "__latitude", "=", "data", "[", "'latitude'", "]", "self", ".", "__heading", "=", "data", "[", "'heading'", "]", "if", "self", ".", "__longitude", "and", "self", ".", "__latitude", "and", "self", ".", "__heading", ":", "self", ".", "__location", "=", "{", "'longitude'", ":", "self", ".", "__longitude", ",", "'latitude'", ":", "self", ".", "__latitude", ",", "'heading'", ":", "self", ".", "__heading", "}" ]

[ "Update", "the", "current", "GPS", "location", "." ]

[ "def", "createRtiFromFileName", "(", "fileName", ")", ":", "cls", ",", "rtiRegItem", "=", "detectRtiFromFileName", "(", "fileName", ")", "if", "cls", "is", "None", ":", "logger", ".", "warn", "(", "\"Unable to import plugin {}: {}\"", ".", "format", "(", "rtiRegItem", ".", "fullName", ",", "rtiRegItem", ".", "exception", ")", ")", "rti", "=", "UnknownFileRti", ".", "createFromFileName", "(", "fileName", ")", "rti", ".", "setException", "(", "rtiRegItem", ".", "exception", ")", "else", ":", "rti", "=", "cls", ".", "createFromFileName", "(", "fileName", ")", "assert", "rti", ",", "\"Sanity check failed (createRtiFromFileName). Please report this bug.\"", "return", "rti" ]

[ "Determines", "the", "type", "of", "RepoTreeItem", "to", "use", "given", "a", "file", "name", "and", "creates", "it", ".", "Uses", "a", "DirectoryRti", "for", "directories", "and", "an", "UnknownFileRti", "if", "the", "file", "extension", "doesn", "t", "match", "one", "of", "the", "registered", "RTI", "extensions", "." ]

[ "def", "safe_compare_digest", "(", "val1", ",", "val2", ")", ":", "if", "len", "(", "val1", ")", "!=", "len", "(", "val2", ")", ":", "return", "False", "result", "=", "0", "if", "PY3", "and", "isinstance", "(", "val1", ",", "bytes", ")", "and", "isinstance", "(", "val2", ",", "bytes", ")", ":", "for", "i", ",", "j", "in", "zip", "(", "val1", ",", "val2", ")", ":", "result", "|=", "i", "^", "j", "else", ":", "for", "i", ",", "j", "in", "zip", "(", "val1", ",", "val2", ")", ":", "result", "|=", "(", "ord", "(", "i", ")", "^", "ord", "(", "j", ")", ")", "return", "result", "==", "0" ]

[ "safe_compare_digest", "method", "." ]

[ "def", "get_model", "(", "name", ",", "*", "*", "kwargs", ")", ":", "models", "=", "{", "'resnet18_v1'", ":", "resnet18_v1", ",", "'resnet34_v1'", ":", "resnet34_v1", ",", "'resnet50_v1'", ":", "resnet50_v1", ",", "'resnet101_v1'", ":", "resnet101_v1", ",", "'resnet152_v1'", ":", "resnet152_v1", ",", "'resnet18_v2'", ":", "resnet18_v2", ",", "'resnet34_v2'", ":", "resnet34_v2", ",", "'resnet50_v2'", ":", "resnet50_v2", ",", "'resnet101_v2'", ":", "resnet101_v2", ",", "'resnet152_v2'", ":", "resnet152_v2", ",", "'vgg11'", ":", "vgg11", ",", "'vgg13'", ":", "vgg13", ",", "'vgg16'", ":", "vgg16", ",", "'vgg19'", ":", "vgg19", ",", "'vgg11_bn'", ":", "vgg11_bn", ",", "'vgg13_bn'", ":", "vgg13_bn", ",", "'vgg16_bn'", ":", "vgg16_bn", ",", "'vgg19_bn'", ":", "vgg19_bn", ",", "'alexnet'", ":", "alexnet", ",", "'densenet121'", ":", "densenet121", ",", "'densenet161'", ":", "densenet161", ",", "'densenet169'", ":", "densenet169", ",", "'densenet201'", ":", "densenet201", ",", "'squeezenet1.0'", ":", "squeezenet1_0", ",", "'squeezenet1.1'", ":", "squeezenet1_1", ",", "'inceptionv3'", ":", "inception_v3", ",", "'mobilenet1.0'", ":", "mobilenet1_0", ",", "'mobilenet0.75'", ":", "mobilenet0_75", ",", "'mobilenet0.5'", ":", "mobilenet0_5", ",", "'mobilenet0.25'", ":", "mobilenet0_25", ",", "'mobilenetv2_1.0'", ":", "mobilenet_v2_1_0", ",", "'mobilenetv2_0.75'", ":", "mobilenet_v2_0_75", ",", "'mobilenetv2_0.5'", ":", "mobilenet_v2_0_5", ",", "'mobilenetv2_0.25'", ":", "mobilenet_v2_0_25", "}", "name", "=", "name", ".", "lower", "(", ")", "if", "name", "not", "in", "models", ":", "raise", "ValueError", "(", "'Model %s is not supported. Available options are\\n\\t%s'", "%", "(", "name", ",", "'\\n\\t'", ".", "join", "(", "sorted", "(", "models", ".", "keys", "(", ")", ")", ")", ")", ")", "return", "models", "[", "name", "]", "(", "*", "*", "kwargs", ")" ]

[ "Returns", "a", "pre", "-", "defined", "model", "by", "name" ]

[ "def", "run", "(", "self", ")", "->", "None", ":", "if", "self", ".", "_logging_level", ":", "logging", ".", "basicConfig", "(", "level", "=", "getattr", "(", "logging", ",", "self", ".", "_logging_level", ".", "upper", "(", ")", ")", ",", "format", "=", "\"%(levelname).1s %(name)s.%(funcName)s:%(lineno)d - %(message)s\"", ")", "signal", ".", "signal", "(", "signal", ".", "SIGINT", ",", "self", ".", "_handle_sigint", ")", "signal", ".", "signal", "(", "signal", ".", "SIGTERM", ",", "self", ".", "_handle_sigterm", ")", "if", "platform", ".", "system", "(", ")", "!=", "'Windows'", ":", "# These features will not be available on Windows, but that is OK.", "# Read this issue for more details:", "# https://github.com/cenkalti/kuyruk/issues/54", "signal", ".", "signal", "(", "signal", ".", "SIGHUP", ",", "self", ".", "_handle_sighup", ")", "signal", ".", "signal", "(", "signal", ".", "SIGUSR1", ",", "self", ".", "_handle_sigusr1", ")", "signal", ".", "signal", "(", "signal", ".", "SIGUSR2", ",", "self", ".", "_handle_sigusr2", ")", "self", ".", "_started_at", "=", "os", ".", "times", "(", ")", ".", "elapsed", "for", "t", "in", "self", ".", "_threads", ":", "t", ".", "start", "(", ")", "try", ":", "signals", ".", "worker_start", ".", "send", "(", "self", ".", "kuyruk", ",", "worker", "=", "self", ")", "self", ".", "_consume_messages", "(", ")", "signals", ".", "worker_shutdown", ".", "send", "(", "self", ".", "kuyruk", ",", "worker", "=", "self", ")", "finally", ":", "self", ".", "shutdown_pending", ".", "set", "(", ")", "for", "t", "in", "self", ".", "_threads", ":", "t", ".", "join", "(", ")", "logger", ".", "debug", "(", "\"End run worker\"", ")" ]

[ "Runs", "the", "worker", "and", "consumes", "messages", "from", "RabbitMQ", ".", "Returns", "only", "after", "shutdown", "()", "is", "called", "." ]

[ "def", "user_has_permission", "(", "self", ",", "user", ",", "name", ")", ":", "targetRecord", "=", "AuthMembership", ".", "objects", "(", "creator", "=", "self", ".", "client", ",", "user", "=", "user", ")", ".", "first", "(", ")", "if", "not", "targetRecord", ":", "return", "False", "for", "group", "in", "targetRecord", ".", "groups", ":", "if", "self", ".", "has_permission", "(", "group", ".", "role", ",", "name", ")", ":", "return", "True", "return", "False" ]

[ "verify", "user", "has", "permission" ]

[ "def", "bqm_index_labels", "(", "f", ")", ":", "@", "wraps", "(", "f", ")", "def", "_index_label", "(", "sampler", ",", "bqm", ",", "*", "*", "kwargs", ")", ":", "if", "not", "hasattr", "(", "bqm", ",", "'linear'", ")", ":", "raise", "TypeError", "(", "'expected input to be a BinaryQuadraticModel'", ")", "linear", "=", "bqm", ".", "linear", "# if already index-labelled, just continue", "if", "all", "(", "v", "in", "linear", "for", "v", "in", "range", "(", "len", "(", "bqm", ")", ")", ")", ":", "return", "f", "(", "sampler", ",", "bqm", ",", "*", "*", "kwargs", ")", "try", ":", "inverse_mapping", "=", "dict", "(", "enumerate", "(", "sorted", "(", "linear", ")", ")", ")", "except", "TypeError", ":", "# in python3 unlike types cannot be sorted", "inverse_mapping", "=", "dict", "(", "enumerate", "(", "linear", ")", ")", "mapping", "=", "{", "v", ":", "i", "for", "i", ",", "v", "in", "iteritems", "(", "inverse_mapping", ")", "}", "response", "=", "f", "(", "sampler", ",", "bqm", ".", "relabel_variables", "(", "mapping", ",", "inplace", "=", "False", ")", ",", "*", "*", "kwargs", ")", "# unapply the relabeling", "return", "response", ".", "relabel_variables", "(", "inverse_mapping", ",", "inplace", "=", "True", ")", "return", "_index_label" ]

[ "Decorator", "to", "convert", "a", "bqm", "to", "index", "-", "labels", "and", "relabel", "the", "sample", "set", "output", "." ]

[ "def", "tag_torsion_angles", "(", "self", ",", "force", "=", "False", ")", ":", "tagged", "=", "[", "'omega'", "in", "x", ".", "tags", ".", "keys", "(", ")", "for", "x", "in", "self", ".", "_monomers", "]", "if", "(", "not", "all", "(", "tagged", ")", ")", "or", "force", ":", "tas", "=", "measure_torsion_angles", "(", "self", ".", "_monomers", ")", "for", "monomer", ",", "(", "omega", ",", "phi", ",", "psi", ")", "in", "zip", "(", "self", ".", "_monomers", ",", "tas", ")", ":", "monomer", ".", "tags", "[", "'omega'", "]", "=", "omega", "monomer", ".", "tags", "[", "'phi'", "]", "=", "phi", "monomer", ".", "tags", "[", "'psi'", "]", "=", "psi", "monomer", ".", "tags", "[", "'tas'", "]", "=", "(", "omega", ",", "phi", ",", "psi", ")", "return" ]

[ "Tags", "each", "Monomer", "of", "the", "Polymer", "with", "its", "omega", "phi", "and", "psi", "torsion", "angle", "." ]

[ "def", "get_repository_query_session", "(", "self", ")", ":", "if", "not", "self", ".", "supports_repository_query", "(", ")", ":", "raise", "Unimplemented", "(", ")", "try", ":", "from", ".", "import", "sessions", "except", "ImportError", ":", "raise", "# OperationFailed()", "try", ":", "session", "=", "sessions", ".", "RepositoryQuerySession", "(", "proxy", "=", "self", ".", "_proxy", ",", "runtime", "=", "self", ".", "_runtime", ")", "except", "AttributeError", ":", "raise", "# OperationFailed()", "return", "session" ]

[ "Gets", "the", "repository", "query", "session", "." ]

[ "def", "getDateTimeFromGet", "(", "request", ",", "key", ")", ":", "if", "request", ".", "GET", ".", "get", "(", "key", ",", "''", ")", ":", "try", ":", "return", "ensure_timezone", "(", "datetime", ".", "strptime", "(", "unquote", "(", "request", ".", "GET", ".", "get", "(", "key", ",", "''", ")", ")", ",", "'%Y-%m-%d'", ")", ")", "except", "(", "ValueError", ",", "TypeError", ")", ":", "pass", "return", "None" ]

[ "This", "function", "just", "parses", "the", "request", "GET", "data", "for", "the", "requested", "key", "and", "returns", "it", "in", "datetime", "format", "returning", "none", "if", "the", "key", "is", "not", "available", "or", "is", "in", "incorrect", "format", "." ]

[ "def", "update_offset", "(", "self", ",", "new_offset", ")", ":", "self", ".", "offset", "=", "new_offset", "self", ".", "data_points", "=", "self", ".", "_data_points", "[", "self", ".", "offset", ":", "]", "self", ".", "timestamps", "=", "self", ".", "_timestamps", "[", "self", ".", "offset", ":", "]" ]

[ "Updates", "how", "many", "data", "points", "to", "skip", "in", "caculations", "." ]

[ "def", "connect", "(", "self", ")", ":", "HTTPConnection", ".", "connect", "(", "self", ")", "self", ".", "sock", ".", "setsockopt", "(", "socket", ".", "IPPROTO_TCP", ",", "socket", ".", "TCP_NODELAY", ",", "1", ")" ]

[ "Set", "TCP_NODELAY", "on", "socket" ]