Datasets:

kejian

/

codesearchnet-python-rebalanced

like 1

[ "def", "visit_Capture", "(", "self", ",", "node", ":", "parsing", ".", "Capture", ")", "->", "[", "ast", ".", "stmt", "]", "or", "ast", ".", "expr", ":", "begintag", "=", "ast", ".", "Attribute", "(", "ast", ".", "Name", "(", "'self'", ",", "ast", ".", "Load", "(", ")", ")", ",", "'beginTag'", ",", "ast", ".", "Load", "(", ")", ")", "endtag", "=", "ast", ".", "Attribute", "(", "ast", ".", "Name", "(", "'self'", ",", "ast", ".", "Load", "(", ")", ")", ",", "'endTag'", ",", "ast", ".", "Load", "(", ")", ")", "begin", "=", "ast", ".", "Call", "(", "begintag", ",", "[", "ast", ".", "Str", "(", "node", ".", "tagname", ")", "]", ",", "[", "]", ",", "None", ",", "None", ")", "end", "=", "ast", ".", "Call", "(", "endtag", ",", "[", "ast", ".", "Str", "(", "node", ".", "tagname", ")", "]", ",", "[", "]", ",", "None", ",", "None", ")", "result", "=", "[", "begin", ",", "self", ".", "visit", "(", "node", ".", "pt", ")", ",", "end", "]", "for", "clause", "in", "result", ":", "if", "not", "isinstance", "(", "clause", ",", "ast", ".", "expr", ")", ":", "break", "else", ":", "return", "ast", ".", "BoolOp", "(", "ast", ".", "And", "(", ")", ",", "result", ")", "res", "=", "[", "]", "for", "stmt", "in", "map", "(", "self", ".", "_clause", ",", "result", ")", ":", "res", ".", "extend", "(", "stmt", ")", "return", "res" ]

[ "def", "get_pstats_print2list", "(", "fnames", ",", "filter_fnames", "=", "None", ",", "exclude_fnames", "=", "None", ",", "sort", "=", "None", ",", "sort_reverse", "=", "None", ",", "limit", "=", "None", ")", ":", "if", "isinstance", "(", "fnames", ",", "basestring", ")", ":", "fnames", "=", "[", "fnames", "]", "fnames_expanded", "=", "[", "os", ".", "path", ".", "expandvars", "(", "os", ".", "path", ".", "expanduser", "(", "fname", ")", ")", "for", "fname", "in", "fnames", "]", "stream", "=", "StringIO", "(", ")", "try", ":", "stats", "=", "pstats", ".", "Stats", "(", "fnames", "[", "0", "]", ",", "stream", "=", "stream", ")", "for", "fname", "in", "fnames_expanded", "[", "1", ":", "]", ":", "stats", ".", "add", "(", "fname", ")", "except", "TypeError", ":", "print", "(", "\"No cProfile stats valid.\"", ")", "return", "False", "except", "EOFError", ":", "print", "(", "\"Empty file cProfile stats valid.\"", ")", "return", "False", "except", "IOError", ":", "print", "(", "\"Error to open file.\"", ")", "return", "False", "stats", ".", "print_stats", "(", ")", "stream", ".", "seek", "(", "0", ")", "field_list", "=", "get_field_list", "(", ")", "line_stats_re", "=", "re", ".", "compile", "(", "r'(?P<%s>\\d+/?\\d+|\\d+)\\s+(?P<%s>\\d+\\.?\\d+)\\s+(?P<%s>\\d+\\.?\\d+)\\s+'", "r'(?P<%s>\\d+\\.?\\d+)\\s+(?P<%s>\\d+\\.?\\d+)\\s+(?P<%s>.*):(?P<%s>\\d+)'", "r'\\((?P<%s>.*)\\)'", "%", "tuple", "(", "field_list", ")", ")", "stats_list", "=", "[", "]", "count", "=", "0", "for", "line", "in", "stream", ":", "line", "=", "line", ".", "strip", "(", "'\\r\\n '", ")", "line_stats_match", "=", "line_stats_re", ".", "match", "(", "line", ")", "if", "line", "else", "None", "fname", "=", "line_stats_match", ".", "group", "(", "'file'", ")", "if", "line_stats_match", "else", "None", "if", "fname", "and", "is_fname_match", "(", "fname", ",", "filter_fnames", ")", "and", "not", "is_exclude", "(", "fname", ",", "exclude_fnames", ")", ":", "data", "=", "dict", "(", "[", "(", "field", ",", "line_stats_match", ".", "group", "(", "field", ")", ")", "for", "field", "in", "field_list", "]", ")", "data", "[", "'rcalls'", "]", ",", "data", "[", "'calls'", "]", "=", "(", "data", ".", "get", "(", "'ncalls'", ",", "''", ")", "+", "'/'", "+", "data", ".", "get", "(", "'ncalls'", ",", "''", ")", ")", ".", "split", "(", "'/'", ")", "[", ":", "2", "]", "data", "[", "'factor'", "]", "=", "\"%.2f\"", "%", "(", "(", "float", "(", "data", "[", "'rcalls'", "]", ")", "-", "float", "(", "data", "[", "'calls'", "]", ")", "+", "1", ")", "*", "float", "(", "data", "[", "'cumtime'", "]", ")", ")", "data", "[", "'cumulative'", "]", "=", "data", "[", "'cumtime'", "]", "stats_list", ".", "append", "(", "data", ")", "count", "+=", "1", "return", "sorted", "(", "stats_list", ",", "key", "=", "lambda", "key", ":", "float", "(", "key", "[", "sort", "or", "'factor'", "]", ")", ",", "reverse", "=", "not", "sort_reverse", ")", "[", ":", "limit", "]" ]

[ "def", "mtf_transformer_lm_baseline", "(", ")", ":", "hparams", "=", "mtf_transformer_paper_lm", "(", "-", "1", ")", "hparams", ".", "batch_size", "=", "128", "hparams", ".", "learning_rate_decay_steps", "=", "27200", "# one epoch on lm1b", "hparams", ".", "mesh_shape", "=", "\"batch:8\"", "return", "hparams" ]

[ "def", "whois_list", "(", "request", ",", "format", "=", "None", ")", ":", "results", "=", "[", "]", "# layer3 results", "for", "ip", "in", "Ip", ".", "objects", ".", "select_related", "(", ")", ".", "all", "(", ")", ":", "interface", "=", "ip", ".", "interface", "user", "=", "interface", ".", "device", ".", "node", ".", "user", "device", "=", "interface", ".", "device", "results", ".", "append", "(", "{", "'address'", ":", "str", "(", "ip", ".", "address", ")", ",", "'user'", ":", "user", ".", "username", ",", "'name'", ":", "user", ".", "get_full_name", "(", ")", ",", "'device'", ":", "device", ".", "name", ",", "'node'", ":", "device", ".", "node", ".", "name", "}", ")", "# layer2 results", "for", "interface", "in", "Interface", ".", "objects", ".", "select_related", "(", ")", ".", "all", "(", ")", ":", "if", "interface", ".", "mac", "is", "None", ":", "continue", "user", "=", "interface", ".", "device", ".", "node", ".", "user", "device", "=", "interface", ".", "device", "results", ".", "append", "(", "{", "'address'", ":", "str", "(", "interface", ".", "mac", ")", ".", "replace", "(", "'-'", ",", "':'", ")", ",", "'user'", ":", "user", ".", "username", ",", "'name'", ":", "user", ".", "get_full_name", "(", ")", ",", "'device'", ":", "device", ".", "name", ",", "'node'", ":", "device", ".", "node", ".", "name", "}", ")", "return", "Response", "(", "results", ")" ]

[ "def", "load_modules", "(", "self", ",", "data", "=", "None", ",", "proxy", "=", "None", ")", ":", "log", ".", "info", "(", "'Loading fresh modules for state activity'", ")", "self", ".", "utils", "=", "salt", ".", "loader", ".", "utils", "(", "self", ".", "opts", ")", "self", ".", "functions", "=", "salt", ".", "loader", ".", "minion_mods", "(", "self", ".", "opts", ",", "self", ".", "state_con", ",", "utils", "=", "self", ".", "utils", ",", "proxy", "=", "self", ".", "proxy", ")", "if", "isinstance", "(", "data", ",", "dict", ")", ":", "if", "data", ".", "get", "(", "'provider'", ",", "False", ")", ":", "if", "isinstance", "(", "data", "[", "'provider'", "]", ",", "six", ".", "string_types", ")", ":", "providers", "=", "[", "{", "data", "[", "'state'", "]", ":", "data", "[", "'provider'", "]", "}", "]", "elif", "isinstance", "(", "data", "[", "'provider'", "]", ",", "list", ")", ":", "providers", "=", "data", "[", "'provider'", "]", "else", ":", "providers", "=", "{", "}", "for", "provider", "in", "providers", ":", "for", "mod", "in", "provider", ":", "funcs", "=", "salt", ".", "loader", ".", "raw_mod", "(", "self", ".", "opts", ",", "provider", "[", "mod", "]", ",", "self", ".", "functions", ")", "if", "funcs", ":", "for", "func", "in", "funcs", ":", "f_key", "=", "'{0}{1}'", ".", "format", "(", "mod", ",", "func", "[", "func", ".", "rindex", "(", "'.'", ")", ":", "]", ")", "self", ".", "functions", "[", "f_key", "]", "=", "funcs", "[", "func", "]", "self", ".", "serializers", "=", "salt", ".", "loader", ".", "serializers", "(", "self", ".", "opts", ")", "self", ".", "_load_states", "(", ")", "self", ".", "rend", "=", "salt", ".", "loader", ".", "render", "(", "self", ".", "opts", ",", "self", ".", "functions", ",", "states", "=", "self", ".", "states", ",", "proxy", "=", "self", ".", "proxy", ",", "context", "=", "self", ".", "state_con", ")" ]

[ "def", "handle_processing_packets", "(", ")", ":", "host", "=", "os", ".", "getenv", "(", "\"LISTEN_ON_HOST\"", ",", "\"127.0.0.1\"", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", "port", "=", "int", "(", "os", ".", "getenv", "(", "\"LISTEN_ON_PORT\"", ",", "\"80\"", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", ")", "backlog", "=", "int", "(", "os", ".", "getenv", "(", "\"LISTEN_BACKLOG\"", ",", "\"5\"", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", ")", "size", "=", "int", "(", "os", ".", "getenv", "(", "\"LISTEN_SIZE\"", ",", "\"102400\"", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", ")", "sleep_in_seconds", "=", "float", "(", "os", ".", "getenv", "(", "\"LISTEN_SLEEP\"", ",", "\"0.5\"", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", ")", "needs_response", "=", "bool", "(", "os", ".", "getenv", "(", "\"LISTEN_SEND_RESPONSE\"", ",", "\"0\"", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", "==", "\"1\"", ")", "shutdown_hook", "=", "os", ".", "getenv", "(", "\"LISTEN_SHUTDOWN_HOOK\"", ",", "\"/tmp/shutdown-listen-server-{}-{}\"", ".", "format", "(", "host", ",", "port", ")", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", "filter_key", "=", "os", ".", "getenv", "(", "\"IGNORE_KEY\"", ",", "INCLUDED_IGNORE_KEY", ")", ".", "strip", "(", ")", ".", "lstrip", "(", ")", "if", "os", ".", "path", ".", "exists", "(", "shutdown_hook", ")", ":", "log", ".", "info", "(", "(", "\"Please remove the shutdown hook file: \"", "\"\\nrm -f {}\"", ")", ".", "format", "(", "shutdown_hook", ")", ")", "sys", ".", "exit", "(", "1", ")", "default_filter_key", "=", "filter_key", "bytes_for_filter_key", "=", "len", "(", "default_filter_key", ")", "offset_to_filter_key", "=", "(", "-", "1", "*", "bytes_for_filter_key", ")", "offset_to_msg", "=", "offset_to_filter_key", "-", "1", "now", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "isoformat", "(", ")", "log", ".", "info", "(", "(", "\"{} - Starting Server address={}:{} \"", "\"backlog={} size={} sleep={} shutdown={} \"", "\"filter_key={}\"", ")", ".", "format", "(", "now", ",", "host", ",", "port", ",", "backlog", ",", "size", ",", "sleep_in_seconds", ",", "shutdown_hook", ",", "default_filter_key", ")", ")", "s", "=", "socket", ".", "socket", "(", "socket", ".", "AF_INET", ",", "socket", ".", "SOCK_STREAM", ")", "s", ".", "bind", "(", "(", "host", ",", "port", ")", ")", "s", ".", "listen", "(", "backlog", ")", "client", ",", "address", "=", "s", ".", "accept", "(", ")", "midx", "=", "0", "while", "1", ":", "data", "=", "None", "address", "=", "None", "ignore_key", "=", "None", "try", ":", "if", "not", "client", ":", "client", ",", "address", "=", "s", ".", "accept", "(", ")", "except", "Exception", "as", "e", ":", "log", ".", "error", "(", "(", "\"socket accept with ex={}\"", ")", ".", "format", "(", "e", ")", ")", "try", ":", "if", "client", ":", "data", "=", "client", ".", "recv", "(", "size", ")", "except", "Exception", "as", "e", ":", "log", ".", "error", "(", "(", "\"recv - disconnected with ex={}\"", ")", ".", "format", "(", "e", ")", ")", "if", "data", ":", "now", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "isoformat", "(", ")", "packet_to_process", "=", "data", "[", "0", ":", "offset_to_msg", "]", "ignore_key", "=", "data", "[", "offset_to_filter_key", ":", "]", "log", ".", "info", "(", "(", "\"decoding data={} key={}\"", ")", ".", "format", "(", "packet_to_process", ",", "ignore_key", ")", ")", "msg", "=", "None", "try", ":", "msg", "=", "json", ".", "loads", "(", "packet_to_process", ".", "decode", "(", "\"utf-8\"", ")", ")", "except", "Exception", "as", "e", ":", "msg", "=", "None", "log", ".", "error", "(", "(", "\"Invalid data={} with ex={}\"", ")", ".", "format", "(", "packet_to_process", ",", "e", ")", ")", "if", "msg", ":", "log", ".", "info", "(", "(", "\"received msg={} \"", "\"data={} replying - ignore='{}'\"", ")", ".", "format", "(", "ppj", "(", "msg", ")", ",", "packet_to_process", ",", "ignore_key", ")", ")", "if", "msg", "[", "\"status\"", "]", "==", "VALID", ":", "if", "msg", "[", "\"data_type\"", "]", "==", "TCP", ":", "log", ".", "info", "(", "\"TCP\"", ")", "elif", "msg", "[", "\"data_type\"", "]", "==", "UDP", ":", "log", ".", "info", "(", "\"TCP\"", ")", "elif", "msg", "[", "\"data_type\"", "]", "==", "ARP", ":", "log", ".", "info", "(", "\"TCP\"", ")", "elif", "msg", "[", "\"data_type\"", "]", "==", "ICMP", ":", "log", ".", "info", "(", "\"TCP\"", ")", "else", ":", "log", ".", "error", "(", "(", "\"unsuppported type={}\"", ")", ".", "format", "(", "msg", "[", "\"data_type\"", "]", ")", ")", "# end of supported eth protocol message types", "else", ":", "log", ".", "error", "(", "(", "\"unsuppported msg status={}\"", ")", ".", "format", "(", "msg", "[", "\"status\"", "]", ")", ")", "# end if msg was VALID", "# end of if found msg", "midx", "+=", "1", "if", "midx", ">", "1000000", ":", "midx", "=", "0", "else", ":", "log", ".", "debug", "(", "\"ignoring invalid data\"", ")", "# end of if valid msg or not", "if", "needs_response", ":", "client", ".", "send", "(", "ignore_key", ")", "else", ":", "log", ".", "info", "(", "\"no response\"", ")", "time", ".", "sleep", "(", "sleep_in_seconds", ")", "if", "os", ".", "path", ".", "exists", "(", "shutdown_hook", ")", ":", "now", "=", "datetime", ".", "datetime", ".", "now", "(", ")", ".", "isoformat", "(", ")", "log", ".", "info", "(", "(", "\"{} detected shutdown \"", "\"file={}\"", ")", ".", "format", "(", "now", ",", "shutdown_hook", ")", ")", "# end of loop", "log", ".", "info", "(", "\"shutting down\"", ")", "client", ".", "close", "(", ")", "log", ".", "info", "(", "\"done\"", ")" ]

[ "def", "price_dataframe", "(", "symbols", "=", "'sp5002012'", ",", "start", "=", "datetime", ".", "datetime", "(", "2008", ",", "1", ",", "1", ")", ",", "end", "=", "datetime", ".", "datetime", "(", "2009", ",", "12", ",", "31", ")", ",", "price_type", "=", "'actual_close'", ",", "cleaner", "=", "clean_dataframe", ",", ")", ":", "if", "isinstance", "(", "price_type", ",", "basestring", ")", ":", "price_type", "=", "[", "price_type", "]", "start", "=", "util", ".", "normalize_date", "(", "start", "or", "datetime", ".", "date", "(", "2008", ",", "1", ",", "1", ")", ")", "end", "=", "util", ".", "normalize_date", "(", "end", "or", "datetime", ".", "date", "(", "2009", ",", "12", ",", "31", ")", ")", "symbols", "=", "normalize_symbols", "(", "symbols", ")", "t", "=", "du", ".", "getNYSEdays", "(", "start", ",", "end", ",", "datetime", ".", "timedelta", "(", "hours", "=", "16", ")", ")", "df", "=", "clean_dataframes", "(", "dataobj", ".", "get_data", "(", "t", ",", "symbols", ",", "price_type", ")", ")", "if", "not", "df", "or", "len", "(", "df", ")", ">", "1", ":", "return", "cleaner", "(", "df", ")", "else", ":", "return", "cleaner", "(", "df", "[", "0", "]", ")" ]

[ "def", "disvec", "(", "self", ",", "x", ",", "y", ",", "aq", "=", "None", ")", ":", "if", "aq", "is", "None", ":", "aq", "=", "self", ".", "model", ".", "aq", ".", "find_aquifer_data", "(", "x", ",", "y", ")", "return", "np", ".", "sum", "(", "self", ".", "parameters", "*", "self", ".", "disvecinf", "(", "x", ",", "y", ",", "aq", ")", ",", "1", ")" ]

[ "def", "parse_localclasspath", "(", "self", ",", "tup_tree", ")", ":", "self", ".", "check_node", "(", "tup_tree", ",", "'LOCALCLASSPATH'", ")", "k", "=", "kids", "(", "tup_tree", ")", "if", "len", "(", "k", ")", "!=", "2", ":", "raise", "CIMXMLParseError", "(", "_format", "(", "\"Element {0!A} has invalid number of child elements \"", "\"{1!A} (expecting two child elements \"", "\"(LOCALNAMESPACEPATH, CLASSNAME))\"", ",", "name", "(", "tup_tree", ")", ",", "k", ")", ",", "conn_id", "=", "self", ".", "conn_id", ")", "namespace", "=", "self", ".", "parse_localnamespacepath", "(", "k", "[", "0", "]", ")", "class_path", "=", "self", ".", "parse_classname", "(", "k", "[", "1", "]", ")", "class_path", ".", "namespace", "=", "namespace", "return", "class_path" ]

[ "def", "is_highlink_density", "(", "self", ",", "element", ")", ":", "links", "=", "self", ".", "parser", ".", "getElementsByTag", "(", "element", ",", "tag", "=", "'a'", ")", "if", "not", "links", ":", "return", "False", "text", "=", "self", ".", "parser", ".", "getText", "(", "element", ")", "words", "=", "text", ".", "split", "(", "' '", ")", "words_number", "=", "float", "(", "len", "(", "words", ")", ")", "link_text_parts", "=", "[", "]", "for", "link", "in", "links", ":", "link_text_parts", ".", "append", "(", "self", ".", "parser", ".", "getText", "(", "link", ")", ")", "link_text", "=", "''", ".", "join", "(", "link_text_parts", ")", "link_words", "=", "link_text", ".", "split", "(", "' '", ")", "number_of_link_words", "=", "float", "(", "len", "(", "link_words", ")", ")", "number_of_links", "=", "float", "(", "len", "(", "links", ")", ")", "link_divisor", "=", "float", "(", "number_of_link_words", "/", "words_number", ")", "score", "=", "float", "(", "link_divisor", "*", "number_of_links", ")", "if", "score", ">=", "1.0", ":", "return", "True", "return", "False" ]

[ "def", "random_link", "(", "self", ",", "dataset", ",", "state", ",", "backward", "=", "False", ")", ":", "links", "=", "self", ".", "get_links", "(", "dataset", ",", "state", ",", "backward", ")", "if", "not", "links", ":", "return", "None", ",", "None", "x", "=", "randint", "(", "0", ",", "sum", "(", "link", "[", "0", "]", "for", "link", "in", "links", ")", "-", "1", ")", "for", "link", "in", "links", ":", "count", "=", "link", "[", "0", "]", "if", "x", "<", "count", ":", "return", "link", "[", "1", "]", ",", "self", ".", "follow_link", "(", "link", ",", "state", ",", "backward", ")", "x", "-=", "count", "raise", "RuntimeError", "(", "'invalid link sum'", ")" ]

[ "def", "copystat", "(", "self", ",", "target", ")", ":", "shutil", ".", "copystat", "(", "self", ".", "path", ",", "self", ".", "_to_backend", "(", "target", ")", ")" ]

[ "def", "pb_for_delete", "(", "document_path", ",", "option", ")", ":", "write_pb", "=", "write_pb2", ".", "Write", "(", "delete", "=", "document_path", ")", "if", "option", "is", "not", "None", ":", "option", ".", "modify_write", "(", "write_pb", ")", "return", "write_pb" ]

[ "def", "_convert_filetime_to_timestamp", "(", "filetime", ")", ":", "hundreds_nano_seconds", "=", "struct", ".", "unpack", "(", "b'>Q'", ",", "struct", ".", "pack", "(", "b'>LL'", ",", "filetime", ".", "dwHighDateTime", ",", "filetime", ".", "dwLowDateTime", ")", ")", "[", "0", "]", "seconds_since_1601", "=", "hundreds_nano_seconds", "/", "10000000", "return", "seconds_since_1601", "-", "11644473600" ]

[ "def", "modulename", "(", "cls", ",", "depth", "=", "1", ")", ":", "depth", "+=", "cls", ".", "extra_depth", "frame", "=", "sys", ".", "_getframe", "(", "depth", ")", "return", "frame", ".", "f_globals", "[", "'__name__'", "]" ]

[ "def", "_synthesize_multiple_generic", "(", "self", ",", "helper_function", ",", "text_file", ",", "output_file_path", ",", "quit_after", "=", "None", ",", "backwards", "=", "False", ")", ":", "self", ".", "log", "(", "u\"Calling TTS engine using multiple generic function...\"", ")", "# get sample rate and codec", "self", ".", "log", "(", "u\"Determining codec and sample rate...\"", ")", "if", "(", "self", ".", "OUTPUT_AUDIO_FORMAT", "is", "None", ")", "or", "(", "len", "(", "self", ".", "OUTPUT_AUDIO_FORMAT", ")", "!=", "3", ")", ":", "self", ".", "log", "(", "u\"Determining codec and sample rate with dummy text...\"", ")", "succeeded", ",", "data", "=", "helper_function", "(", "text", "=", "u\"Dummy text to get sample_rate\"", ",", "voice_code", "=", "self", ".", "_language_to_voice_code", "(", "self", ".", "DEFAULT_LANGUAGE", ")", ",", "output_file_path", "=", "None", ")", "if", "not", "succeeded", ":", "self", ".", "log_crit", "(", "u\"An unexpected error occurred in helper_function\"", ")", "return", "(", "False", ",", "None", ")", "du_nu", ",", "sample_rate", ",", "codec", ",", "da_nu", "=", "data", "self", ".", "log", "(", "u\"Determining codec and sample rate with dummy text... done\"", ")", "else", ":", "self", ".", "log", "(", "u\"Reading codec and sample rate from OUTPUT_AUDIO_FORMAT\"", ")", "codec", ",", "channels_nu", ",", "sample_rate", "=", "self", ".", "OUTPUT_AUDIO_FORMAT", "self", ".", "log", "(", "u\"Determining codec and sample rate... done\"", ")", "self", ".", "log", "(", "[", "u\" codec: %s\"", ",", "codec", "]", ")", "self", ".", "log", "(", "[", "u\" sample rate: %d\"", ",", "sample_rate", "]", ")", "# open output file", "output_file", "=", "AudioFile", "(", "rconf", "=", "self", ".", "rconf", ",", "logger", "=", "self", ".", "logger", ")", "output_file", ".", "audio_format", "=", "codec", "output_file", ".", "audio_channels", "=", "1", "output_file", ".", "audio_sample_rate", "=", "sample_rate", "# create output", "anchors", "=", "[", "]", "current_time", "=", "TimeValue", "(", "\"0.000\"", ")", "num_chars", "=", "0", "fragments", "=", "text_file", ".", "fragments", "if", "backwards", ":", "fragments", "=", "fragments", "[", ":", ":", "-", "1", "]", "loop_function", "=", "self", ".", "_loop_use_cache", "if", "self", ".", "use_cache", "else", "self", ".", "_loop_no_cache", "for", "num", ",", "fragment", "in", "enumerate", "(", "fragments", ")", ":", "succeeded", ",", "data", "=", "loop_function", "(", "helper_function", "=", "helper_function", ",", "num", "=", "num", ",", "fragment", "=", "fragment", ")", "if", "not", "succeeded", ":", "self", ".", "log_crit", "(", "u\"An unexpected error occurred in loop_function\"", ")", "return", "(", "False", ",", "None", ")", "duration", ",", "sr_nu", ",", "enc_nu", ",", "samples", "=", "data", "# store for later output", "anchors", ".", "append", "(", "[", "current_time", ",", "fragment", ".", "identifier", ",", "fragment", ".", "text", "]", ")", "# increase the character counter", "num_chars", "+=", "fragment", ".", "characters", "# concatenate new samples", "self", ".", "log", "(", "[", "u\"Fragment %d starts at: %.3f\"", ",", "num", ",", "current_time", "]", ")", "if", "duration", ">", "0", ":", "self", ".", "log", "(", "[", "u\"Fragment %d duration: %.3f\"", ",", "num", ",", "duration", "]", ")", "current_time", "+=", "duration", "output_file", ".", "add_samples", "(", "samples", ",", "reverse", "=", "backwards", ")", "else", ":", "self", ".", "log", "(", "[", "u\"Fragment %d has zero duration\"", ",", "num", "]", ")", "# check if we must stop synthesizing because we have enough audio", "if", "(", "quit_after", "is", "not", "None", ")", "and", "(", "current_time", ">", "quit_after", ")", ":", "self", ".", "log", "(", "[", "u\"Quitting after reached duration %.3f\"", ",", "current_time", "]", ")", "break", "# minimize memory", "self", ".", "log", "(", "u\"Minimizing memory...\"", ")", "output_file", ".", "minimize_memory", "(", ")", "self", ".", "log", "(", "u\"Minimizing memory... done\"", ")", "# if backwards, we need to reverse the audio samples again", "if", "backwards", ":", "self", ".", "log", "(", "u\"Reversing audio samples...\"", ")", "output_file", ".", "reverse", "(", ")", "self", ".", "log", "(", "u\"Reversing audio samples... done\"", ")", "# write output file", "self", ".", "log", "(", "[", "u\"Writing audio file '%s'\"", ",", "output_file_path", "]", ")", "output_file", ".", "write", "(", "file_path", "=", "output_file_path", ")", "# return output", "if", "backwards", ":", "self", ".", "log_warn", "(", "u\"Please note that anchor time values do not make sense since backwards=True\"", ")", "self", ".", "log", "(", "[", "u\"Returning %d time anchors\"", ",", "len", "(", "anchors", ")", "]", ")", "self", ".", "log", "(", "[", "u\"Current time %.3f\"", ",", "current_time", "]", ")", "self", ".", "log", "(", "[", "u\"Synthesized %d characters\"", ",", "num_chars", "]", ")", "self", ".", "log", "(", "u\"Calling TTS engine using multiple generic function... done\"", ")", "return", "(", "True", ",", "(", "anchors", ",", "current_time", ",", "num_chars", ")", ")" ]

[ "def", "convertImages", "(", "self", ")", ":", "# copy over JPGs (and such)", "exts", "=", "[", "'.jpg'", ",", "'.png'", "]", "for", "fname", "in", "[", "x", "for", "x", "in", "self", ".", "files1", "if", "cm", ".", "ext", "(", "x", ")", "in", "exts", "]", ":", "ID", "=", "\"UNKNOWN\"", "if", "len", "(", "fname", ")", ">", "8", "and", "fname", "[", ":", "8", "]", "in", "self", ".", "IDs", ":", "ID", "=", "fname", "[", ":", "8", "]", "fname2", "=", "ID", "+", "\"_jpg_\"", "+", "fname", "if", "not", "fname2", "in", "self", ".", "files2", ":", "self", ".", "log", ".", "info", "(", "\"copying over [%s]\"", "%", "fname2", ")", "shutil", ".", "copy", "(", "os", ".", "path", ".", "join", "(", "self", ".", "folder1", ",", "fname", ")", ",", "os", ".", "path", ".", "join", "(", "self", ".", "folder2", ",", "fname2", ")", ")", "if", "not", "fname", "[", ":", "8", "]", "+", "\".abf\"", "in", "self", ".", "files1", ":", "self", ".", "log", ".", "error", "(", "\"orphan image: %s\"", ",", "fname", ")", "# convert TIFs (and such) to JPGs", "exts", "=", "[", "'.tif'", ",", "'.tiff'", "]", "for", "fname", "in", "[", "x", "for", "x", "in", "self", ".", "files1", "if", "cm", ".", "ext", "(", "x", ")", "in", "exts", "]", ":", "ID", "=", "\"UNKNOWN\"", "if", "len", "(", "fname", ")", ">", "8", "and", "fname", "[", ":", "8", "]", "in", "self", ".", "IDs", ":", "ID", "=", "fname", "[", ":", "8", "]", "fname2", "=", "ID", "+", "\"_tif_\"", "+", "fname", "+", "\".jpg\"", "if", "not", "fname2", "in", "self", ".", "files2", ":", "self", ".", "log", ".", "info", "(", "\"converting micrograph [%s]\"", "%", "fname2", ")", "imaging", ".", "TIF_to_jpg", "(", "os", ".", "path", ".", "join", "(", "self", ".", "folder1", ",", "fname", ")", ",", "saveAs", "=", "os", ".", "path", ".", "join", "(", "self", ".", "folder2", ",", "fname2", ")", ")", "if", "not", "fname", "[", ":", "8", "]", "+", "\".abf\"", "in", "self", ".", "files1", ":", "self", ".", "log", ".", "error", "(", "\"orphan image: %s\"", ",", "fname", ")" ]

[ "def", "value_counts", "(", "self", ",", "dropna", "=", "True", ")", ":", "from", "pandas", "import", "Index", ",", "Series", "keys", ",", "counts", "=", "algos", ".", "_value_counts_arraylike", "(", "self", ".", "sp_values", ",", "dropna", "=", "dropna", ")", "fcounts", "=", "self", ".", "sp_index", ".", "ngaps", "if", "fcounts", ">", "0", ":", "if", "self", ".", "_null_fill_value", "and", "dropna", ":", "pass", "else", ":", "if", "self", ".", "_null_fill_value", ":", "mask", "=", "isna", "(", "keys", ")", "else", ":", "mask", "=", "keys", "==", "self", ".", "fill_value", "if", "mask", ".", "any", "(", ")", ":", "counts", "[", "mask", "]", "+=", "fcounts", "else", ":", "keys", "=", "np", ".", "insert", "(", "keys", ",", "0", ",", "self", ".", "fill_value", ")", "counts", "=", "np", ".", "insert", "(", "counts", ",", "0", ",", "fcounts", ")", "if", "not", "isinstance", "(", "keys", ",", "ABCIndexClass", ")", ":", "keys", "=", "Index", "(", "keys", ")", "result", "=", "Series", "(", "counts", ",", "index", "=", "keys", ")", "return", "result" ]

[ "def", "get_last", "(", "self", ")", ":", "query", "=", "self", ".", "table", "(", ")", ".", "where", "(", "'batch'", ",", "self", ".", "get_last_batch_number", "(", ")", ")", "return", "query", ".", "order_by", "(", "'migration'", ",", "'desc'", ")", ".", "get", "(", ")" ]

[ "def", "refresh", "(", "self", ",", "token", ",", "timeout", "=", "None", ")", ":", "if", "timeout", "is", "None", ":", "timeout", "=", "LockManager", ".", "LOCK_TIME_OUT_DEFAULT", "return", "self", ".", "storage", ".", "refresh", "(", "token", ",", "timeout", ")" ]

[ "def", "gradev", "(", "data", ",", "rate", "=", "1.0", ",", "data_type", "=", "\"phase\"", ",", "taus", "=", "None", ",", "ci", "=", "0.9", ",", "noisetype", "=", "'wp'", ")", ":", "if", "(", "data_type", "==", "\"freq\"", ")", ":", "print", "(", "\"Warning : phase data is preferred as input to gradev()\"", ")", "phase", "=", "input_to_phase", "(", "data", ",", "rate", ",", "data_type", ")", "(", "data", ",", "m", ",", "taus_used", ")", "=", "tau_generator", "(", "phase", ",", "rate", ",", "taus", ")", "ad", "=", "np", ".", "zeros_like", "(", "taus_used", ")", "ade_l", "=", "np", ".", "zeros_like", "(", "taus_used", ")", "ade_h", "=", "np", ".", "zeros_like", "(", "taus_used", ")", "adn", "=", "np", ".", "zeros_like", "(", "taus_used", ")", "for", "idx", ",", "mj", "in", "enumerate", "(", "m", ")", ":", "(", "dev", ",", "deverr", ",", "n", ")", "=", "calc_gradev_phase", "(", "data", ",", "rate", ",", "mj", ",", "1", ",", "ci", ",", "noisetype", ")", "# stride=1 for overlapping ADEV", "ad", "[", "idx", "]", "=", "dev", "ade_l", "[", "idx", "]", "=", "deverr", "[", "0", "]", "ade_h", "[", "idx", "]", "=", "deverr", "[", "1", "]", "adn", "[", "idx", "]", "=", "n", "# Note that errors are split in 2 arrays", "return", "remove_small_ns", "(", "taus_used", ",", "ad", ",", "[", "ade_l", ",", "ade_h", "]", ",", "adn", ")" ]

[ "def", "U", "(", "self", ")", ":", "if", "getattr", "(", "self", ".", "data", ",", "'tzinfo'", ",", "None", ")", ":", "return", "int", "(", "calendar", ".", "timegm", "(", "self", ".", "data", ".", "utctimetuple", "(", ")", ")", ")", "else", ":", "return", "int", "(", "time", ".", "mktime", "(", "self", ".", "data", ".", "timetuple", "(", ")", ")", ")" ]

[ "def", "paga_adjacency", "(", "adata", ",", "adjacency", "=", "'connectivities'", ",", "adjacency_tree", "=", "'connectivities_tree'", ",", "as_heatmap", "=", "True", ",", "color_map", "=", "None", ",", "show", "=", "None", ",", "save", "=", "None", ")", ":", "connectivity", "=", "adata", ".", "uns", "[", "adjacency", "]", ".", "toarray", "(", ")", "connectivity_select", "=", "adata", ".", "uns", "[", "adjacency_tree", "]", "if", "as_heatmap", ":", "matrix", "(", "connectivity", ",", "color_map", "=", "color_map", ",", "show", "=", "False", ")", "for", "i", "in", "range", "(", "connectivity_select", ".", "shape", "[", "0", "]", ")", ":", "neighbors", "=", "connectivity_select", "[", "i", "]", ".", "nonzero", "(", ")", "[", "1", "]", "pl", ".", "scatter", "(", "[", "i", "for", "j", "in", "neighbors", "]", ",", "neighbors", ",", "color", "=", "'black'", ",", "s", "=", "1", ")", "# as a stripplot", "else", ":", "pl", ".", "figure", "(", ")", "for", "i", ",", "cs", "in", "enumerate", "(", "connectivity", ")", ":", "x", "=", "[", "i", "for", "j", ",", "d", "in", "enumerate", "(", "cs", ")", "if", "i", "!=", "j", "]", "y", "=", "[", "c", "for", "j", ",", "c", "in", "enumerate", "(", "cs", ")", "if", "i", "!=", "j", "]", "pl", ".", "scatter", "(", "x", ",", "y", ",", "color", "=", "'gray'", ",", "s", "=", "1", ")", "neighbors", "=", "connectivity_select", "[", "i", "]", ".", "nonzero", "(", ")", "[", "1", "]", "pl", ".", "scatter", "(", "[", "i", "for", "j", "in", "neighbors", "]", ",", "cs", "[", "neighbors", "]", ",", "color", "=", "'black'", ",", "s", "=", "1", ")", "utils", ".", "savefig_or_show", "(", "'paga_connectivity'", ",", "show", "=", "show", ",", "save", "=", "save", ")" ]

[ "def", "_get_filehandler_with_formatter", "(", "logname", ",", "formatter", "=", "None", ")", ":", "handler", "=", "logging", ".", "FileHandler", "(", "logname", ")", "if", "formatter", "is", "not", "None", ":", "handler", ".", "setFormatter", "(", "formatter", ")", "return", "handler" ]

[ "def", "_validate_frequency", "(", "cls", ",", "index", ",", "freq", ",", "*", "*", "kwargs", ")", ":", "if", "is_period_dtype", "(", "cls", ")", ":", "# Frequency validation is not meaningful for Period Array/Index", "return", "None", "inferred", "=", "index", ".", "inferred_freq", "if", "index", ".", "size", "==", "0", "or", "inferred", "==", "freq", ".", "freqstr", ":", "return", "None", "try", ":", "on_freq", "=", "cls", ".", "_generate_range", "(", "start", "=", "index", "[", "0", "]", ",", "end", "=", "None", ",", "periods", "=", "len", "(", "index", ")", ",", "freq", "=", "freq", ",", "*", "*", "kwargs", ")", "if", "not", "np", ".", "array_equal", "(", "index", ".", "asi8", ",", "on_freq", ".", "asi8", ")", ":", "raise", "ValueError", "except", "ValueError", "as", "e", ":", "if", "\"non-fixed\"", "in", "str", "(", "e", ")", ":", "# non-fixed frequencies are not meaningful for timedelta64;", "# we retain that error message", "raise", "e", "# GH#11587 the main way this is reached is if the `np.array_equal`", "# check above is False. This can also be reached if index[0]", "# is `NaT`, in which case the call to `cls._generate_range` will", "# raise a ValueError, which we re-raise with a more targeted", "# message.", "raise", "ValueError", "(", "'Inferred frequency {infer} from passed values '", "'does not conform to passed frequency {passed}'", ".", "format", "(", "infer", "=", "inferred", ",", "passed", "=", "freq", ".", "freqstr", ")", ")" ]

[ "def", "stream_bytes", "(", "data", ",", "chunk_size", "=", "default_chunk_size", ")", ":", "stream", "=", "BytesStream", "(", "data", ",", "chunk_size", "=", "chunk_size", ")", "return", "stream", ".", "body", "(", ")", ",", "stream", ".", "headers" ]

[ "def", "compute_screen_line_counts", "(", "feed", ":", "\"Feed\"", ",", "linestring", ":", "LineString", ",", "dates", ":", "List", "[", "str", "]", ",", "geo_shapes", "=", "None", ")", "->", "DataFrame", ":", "dates", "=", "feed", ".", "restrict_dates", "(", "dates", ")", "if", "not", "dates", ":", "return", "pd", ".", "DataFrame", "(", ")", "# Get all shapes that intersect the screen line", "shapes", "=", "feed", ".", "get_shapes_intersecting_geometry", "(", "linestring", ",", "geo_shapes", ",", "geometrized", "=", "True", ")", "# Convert shapes to UTM", "lat", ",", "lon", "=", "feed", ".", "shapes", ".", "loc", "[", "0", ",", "[", "\"shape_pt_lat\"", ",", "\"shape_pt_lon\"", "]", "]", ".", "values", "crs", "=", "hp", ".", "get_utm_crs", "(", "lat", ",", "lon", ")", "shapes", "=", "shapes", ".", "to_crs", "(", "crs", ")", "# Convert linestring to UTM", "linestring", "=", "hp", ".", "linestring_to_utm", "(", "linestring", ")", "# Get all intersection points of shapes and linestring", "shapes", "[", "\"intersection\"", "]", "=", "shapes", ".", "intersection", "(", "linestring", ")", "# Make a vector in the direction of the screen line", "# to later calculate trip orientation.", "# Does not work in case of a bent screen line.", "p1", "=", "sg", ".", "Point", "(", "linestring", ".", "coords", "[", "0", "]", ")", "p2", "=", "sg", ".", "Point", "(", "linestring", ".", "coords", "[", "-", "1", "]", ")", "w", "=", "np", ".", "array", "(", "[", "p2", ".", "x", "-", "p1", ".", "x", ",", "p2", ".", "y", "-", "p1", ".", "y", "]", ")", "# Build a dictionary from the shapes DataFrame of the form", "# shape ID -> list of pairs (d, v), one for each intersection point,", "# where d is the distance of the intersection point along shape,", "# and v is a tiny vectors from the point in direction of shape.", "# Assume here that trips travel in the same direction as their shapes.", "dv_by_shape", "=", "{", "}", "eps", "=", "1", "convert_dist", "=", "hp", ".", "get_convert_dist", "(", "\"m\"", ",", "feed", ".", "dist_units", ")", "for", "__", ",", "sid", ",", "geom", ",", "intersection", "in", "shapes", ".", "itertuples", "(", ")", ":", "# Get distances along shape of intersection points (in meters)", "distances", "=", "[", "geom", ".", "project", "(", "p", ")", "for", "p", "in", "intersection", "]", "# Build tiny vectors", "vectors", "=", "[", "]", "for", "i", ",", "p", "in", "enumerate", "(", "intersection", ")", ":", "q", "=", "geom", ".", "interpolate", "(", "distances", "[", "i", "]", "+", "eps", ")", "vector", "=", "np", ".", "array", "(", "[", "q", ".", "x", "-", "p", ".", "x", ",", "q", ".", "y", "-", "p", ".", "y", "]", ")", "vectors", ".", "append", "(", "vector", ")", "# Convert distances to units used in feed", "distances", "=", "[", "convert_dist", "(", "d", ")", "for", "d", "in", "distances", "]", "dv_by_shape", "[", "sid", "]", "=", "list", "(", "zip", "(", "distances", ",", "vectors", ")", ")", "# Get trips with those shapes", "t", "=", "feed", ".", "trips", "t", "=", "t", "[", "t", "[", "\"shape_id\"", "]", ".", "isin", "(", "dv_by_shape", ".", "keys", "(", ")", ")", "]", ".", "copy", "(", ")", "# Merge in route short names and stop times", "t", "=", "t", ".", "merge", "(", "feed", ".", "routes", "[", "[", "\"route_id\"", ",", "\"route_short_name\"", "]", "]", ")", ".", "merge", "(", "feed", ".", "stop_times", ")", "# Drop NaN departure times and convert to seconds past midnight", "t", "=", "t", "[", "t", "[", "\"departure_time\"", "]", ".", "notnull", "(", ")", "]", ".", "copy", "(", ")", "t", "[", "\"departure_time\"", "]", "=", "t", "[", "\"departure_time\"", "]", ".", "map", "(", "hp", ".", "timestr_to_seconds", ")", "# Compile crossings by date", "a", "=", "feed", ".", "compute_trip_activity", "(", "dates", ")", "rows", "=", "[", "]", "for", "date", "in", "dates", ":", "# Slice to trips active on date", "ids", "=", "a", ".", "loc", "[", "a", "[", "date", "]", "==", "1", ",", "\"trip_id\"", "]", "f", "=", "t", "[", "t", "[", "\"trip_id\"", "]", ".", "isin", "(", "ids", ")", "]", ".", "copy", "(", ")", "# For each shape find the trips that cross the screen line", "# and get crossing times and orientation", "f", "=", "f", ".", "sort_values", "(", "[", "\"trip_id\"", ",", "\"stop_sequence\"", "]", ")", "for", "tid", ",", "group", "in", "f", ".", "groupby", "(", "\"trip_id\"", ")", ":", "sid", "=", "group", "[", "\"shape_id\"", "]", ".", "iat", "[", "0", "]", "rid", "=", "group", "[", "\"route_id\"", "]", ".", "iat", "[", "0", "]", "rsn", "=", "group", "[", "\"route_short_name\"", "]", ".", "iat", "[", "0", "]", "stop_times", "=", "group", "[", "\"departure_time\"", "]", ".", "values", "stop_distances", "=", "group", "[", "\"shape_dist_traveled\"", "]", ".", "values", "for", "d", ",", "v", "in", "dv_by_shape", "[", "sid", "]", ":", "# Interpolate crossing time", "time", "=", "np", ".", "interp", "(", "d", ",", "stop_distances", ",", "stop_times", ")", "# Compute direction of trip travel relative to", "# screen line by looking at the sign of the cross", "# product of tiny shape vector and screen line vector", "det", "=", "np", ".", "linalg", ".", "det", "(", "np", ".", "array", "(", "[", "v", ",", "w", "]", ")", ")", "if", "det", ">=", "0", ":", "orientation", "=", "1", "else", ":", "orientation", "=", "-", "1", "# Update rows", "rows", ".", "append", "(", "[", "date", ",", "tid", ",", "rid", ",", "rsn", ",", "time", ",", "orientation", "]", ")", "# Create DataFrame", "cols", "=", "[", "\"date\"", ",", "\"trip_id\"", ",", "\"route_id\"", ",", "\"route_short_name\"", ",", "\"crossing_time\"", ",", "\"orientation\"", ",", "]", "g", "=", "pd", ".", "DataFrame", "(", "rows", ",", "columns", "=", "cols", ")", ".", "sort_values", "(", "[", "\"date\"", ",", "\"crossing_time\"", "]", ")", "# Convert departure times back to time strings", "g", "[", "\"crossing_time\"", "]", "=", "g", "[", "\"crossing_time\"", "]", ".", "map", "(", "lambda", "x", ":", "hp", ".", "timestr_to_seconds", "(", "x", ",", "inverse", "=", "True", ")", ")", "return", "g" ]

[ "def", "pposition", "(", "hd", ",", "details", "=", "False", ")", ":", "# :TODO: split two angles based on user entered separator and process each part separately.", "# Split at any character other than a digit, \".\", \"-\", and \"+\".", "p", "=", "re", ".", "split", "(", "r\"[^\\d\\-+.]*\"", ",", "hd", ")", "if", "len", "(", "p", ")", "not", "in", "[", "2", ",", "6", "]", ":", "raise", "ValueError", "(", "\"Input must contain either 2 or 6 numbers.\"", ")", "# Two floating point numbers if string has 2 numbers.", "if", "len", "(", "p", ")", "==", "2", ":", "x", ",", "y", "=", "float", "(", "p", "[", "0", "]", ")", ",", "float", "(", "p", "[", "1", "]", ")", "if", "details", ":", "numvals", "=", "2", "raw_x", "=", "p", "[", "0", "]", "raw_y", "=", "p", "[", "1", "]", "# Two sexagesimal numbers if string has 6 numbers.", "elif", "len", "(", "p", ")", "==", "6", ":", "x_p", "=", "phmsdms", "(", "\" \"", ".", "join", "(", "p", "[", ":", "3", "]", ")", ")", "x", "=", "sexa2deci", "(", "x_p", "[", "'sign'", "]", ",", "*", "x_p", "[", "'vals'", "]", ")", "y_p", "=", "phmsdms", "(", "\" \"", ".", "join", "(", "p", "[", "3", ":", "]", ")", ")", "y", "=", "sexa2deci", "(", "y_p", "[", "'sign'", "]", ",", "*", "y_p", "[", "'vals'", "]", ")", "if", "details", ":", "raw_x", "=", "x_p", "raw_y", "=", "y_p", "numvals", "=", "6", "if", "details", ":", "result", "=", "dict", "(", "x", "=", "x", ",", "y", "=", "y", ",", "numvals", "=", "numvals", ",", "raw_x", "=", "raw_x", ",", "raw_y", "=", "raw_y", ")", "else", ":", "result", "=", "x", ",", "y", "return", "result" ]

[ "def", "get_command", "(", "self", ",", "command", ")", ":", "shutit_global", ".", "shutit_global_object", ".", "yield_to_draw", "(", ")", "if", "command", "in", "(", "'md5sum'", ",", "'sed'", ",", "'head'", ")", ":", "if", "self", ".", "get_current_shutit_pexpect_session_environment", "(", ")", ".", "distro", "==", "'osx'", ":", "return", "'g'", "+", "command", "return", "command" ]

[ "def", "_normalizeImpurityMatrix", "(", "matrix", ")", ":", "newMatrix", "=", "list", "(", ")", "for", "line", "in", "matrix", ":", "total", "=", "sum", "(", "line", ")", "if", "total", "!=", "0", ":", "newMatrix", ".", "append", "(", "[", "i", "/", "total", "for", "i", "in", "line", "]", ")", "else", ":", "newMatrix", ".", "append", "(", "line", ")", "return", "newMatrix" ]

[ "def", "select_right", "(", "self", ")", ":", "r", ",", "c", "=", "self", ".", "_index", "self", ".", "_select_index", "(", "r", ",", "c", "+", "1", ")" ]

[ "def", "_get_variable_value", "(", "defined_variables", ",", "name", ")", ":", "def", "fallback", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "raise", "AssertionError", "(", "\"Variable {0} is not defined in class {1}\"", ".", "format", "(", "name", ",", "defined_variables", ".", "__class__", ".", "__name__", ")", ")", "method", "=", "getattr", "(", "defined_variables", ",", "name", ",", "fallback", ")", "val", "=", "method", "(", ")", "return", "method", ".", "field_type", "(", "val", ")" ]

[ "def", "_parse_docstring", "(", "fh", ")", ":", "find_fades", "=", "re", ".", "compile", "(", "r'\\b(fades)\\b:'", ")", ".", "search", "for", "line", "in", "fh", ":", "if", "line", ".", "startswith", "(", "\"'\"", ")", ":", "quote", "=", "\"'\"", "break", "if", "line", ".", "startswith", "(", "'\"'", ")", ":", "quote", "=", "'\"'", "break", "else", ":", "return", "{", "}", "if", "line", "[", "1", "]", "==", "quote", ":", "# comment start with triple quotes", "endquote", "=", "quote", "*", "3", "else", ":", "endquote", "=", "quote", "if", "endquote", "in", "line", "[", "len", "(", "endquote", ")", ":", "]", ":", "docstring_lines", "=", "[", "line", "[", ":", "line", ".", "index", "(", "endquote", ")", "]", "]", "else", ":", "docstring_lines", "=", "[", "line", "]", "for", "line", "in", "fh", ":", "if", "endquote", "in", "line", ":", "docstring_lines", ".", "append", "(", "line", "[", ":", "line", ".", "index", "(", "endquote", ")", "]", ")", "break", "docstring_lines", ".", "append", "(", "line", ")", "docstring_lines", "=", "iter", "(", "docstring_lines", ")", "for", "doc_line", "in", "docstring_lines", ":", "if", "find_fades", "(", "doc_line", ")", ":", "break", "else", ":", "return", "{", "}", "return", "_parse_requirement", "(", "list", "(", "docstring_lines", ")", ")" ]

[ "def", "segment_curvature", "(", "self", ",", "t", ",", "use_inf", "=", "False", ")", ":", "dz", "=", "self", ".", "derivative", "(", "t", ")", "ddz", "=", "self", ".", "derivative", "(", "t", ",", "n", "=", "2", ")", "dx", ",", "dy", "=", "dz", ".", "real", ",", "dz", ".", "imag", "ddx", ",", "ddy", "=", "ddz", ".", "real", ",", "ddz", ".", "imag", "old_np_seterr", "=", "np", ".", "seterr", "(", "invalid", "=", "'raise'", ")", "try", ":", "kappa", "=", "abs", "(", "dx", "*", "ddy", "-", "dy", "*", "ddx", ")", "/", "sqrt", "(", "dx", "*", "dx", "+", "dy", "*", "dy", ")", "**", "3", "except", "(", "ZeroDivisionError", ",", "FloatingPointError", ")", ":", "# tangent vector is zero at t, use polytools to find limit", "p", "=", "self", ".", "poly", "(", ")", "dp", "=", "p", ".", "deriv", "(", ")", "ddp", "=", "dp", ".", "deriv", "(", ")", "dx", ",", "dy", "=", "real", "(", "dp", ")", ",", "imag", "(", "dp", ")", "ddx", ",", "ddy", "=", "real", "(", "ddp", ")", ",", "imag", "(", "ddp", ")", "f2", "=", "(", "dx", "*", "ddy", "-", "dy", "*", "ddx", ")", "**", "2", "g2", "=", "(", "dx", "*", "dx", "+", "dy", "*", "dy", ")", "**", "3", "lim2", "=", "rational_limit", "(", "f2", ",", "g2", ",", "t", ")", "if", "lim2", "<", "0", ":", "# impossible, must be numerical error", "return", "0", "kappa", "=", "sqrt", "(", "lim2", ")", "finally", ":", "np", ".", "seterr", "(", "*", "*", "old_np_seterr", ")", "return", "kappa" ]

[ "def", "MAFFT", "(", "sequences", ",", "gap_open", "=", "1.53", ",", "gap_extension", "=", "0.0", ",", "retree", "=", "2", ")", ":", "arguments", "=", "[", "'mafft'", "]", "arguments", "+=", "[", "'--op'", ",", "str", "(", "gap_open", ")", "]", "arguments", "+=", "[", "'--ep'", ",", "str", "(", "gap_extension", ")", "]", "arguments", "+=", "[", "'--retree'", ",", "str", "(", "retree", ")", "]", "arguments", ".", "append", "(", "'input.fasta'", ")", "tempdir", "=", "tempfile", ".", "mkdtemp", "(", ")", "try", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "tempdir", ",", "'input.fasta'", ")", ",", "'w'", ")", "as", "f", ":", "for", "i", ",", "sequence", "in", "enumerate", "(", "sequences", ")", ":", "if", "hasattr", "(", "sequence", ",", "'name'", ")", ":", "name", "=", "sequence", ".", "name", "else", ":", "name", "=", "'sequence{}'", ".", "format", "(", "i", ")", "f", ".", "write", "(", "'>{}\\n'", ".", "format", "(", "name", ")", ")", "f", ".", "write", "(", "str", "(", "sequence", ")", "+", "'\\n'", ")", "process", "=", "subprocess", ".", "Popen", "(", "arguments", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "open", "(", "os", ".", "devnull", ",", "'w'", ")", ",", "cwd", "=", "tempdir", ")", "stdout", "=", "process", ".", "communicate", "(", ")", "[", "0", "]", "finally", ":", "shutil", ".", "rmtree", "(", "tempdir", ")", "# Process stdout into something downstream process can use", "records", "=", "stdout", ".", "split", "(", "'>'", ")", "# First line is now blank", "records", ".", "pop", "(", "0", ")", "aligned_list", "=", "[", "]", "for", "record", "in", "records", ":", "lines", "=", "record", ".", "split", "(", "'\\n'", ")", "name", "=", "lines", ".", "pop", "(", "0", ")", "aligned_list", ".", "append", "(", "coral", ".", "DNA", "(", "''", ".", "join", "(", "lines", ")", ")", ")", "return", "aligned_list" ]

[ "def", "cmpToDataStore_uri", "(", "base", ",", "ds1", ",", "ds2", ")", ":", "ret", "=", "difflib", ".", "get_close_matches", "(", "base", ".", "uri", ",", "[", "ds1", ".", "uri", ",", "ds2", ".", "uri", "]", ",", "1", ",", "cutoff", "=", "0.5", ")", "if", "len", "(", "ret", ")", "<=", "0", ":", "return", "0", "if", "ret", "[", "0", "]", "==", "ds1", ".", "uri", ":", "return", "-", "1", "return", "1" ]

[ "def", "get_pydoc_completions", "(", "modulename", ")", ":", "modulename", "=", "compat", ".", "ensure_not_unicode", "(", "modulename", ")", "modulename", "=", "modulename", ".", "rstrip", "(", "\".\"", ")", "if", "modulename", "==", "\"\"", ":", "return", "sorted", "(", "get_modules", "(", ")", ")", "candidates", "=", "get_completions", "(", "modulename", ")", "if", "candidates", ":", "return", "sorted", "(", "candidates", ")", "needle", "=", "modulename", "if", "\".\"", "in", "needle", ":", "modulename", ",", "part", "=", "needle", ".", "rsplit", "(", "\".\"", ",", "1", ")", "candidates", "=", "get_completions", "(", "modulename", ")", "else", ":", "candidates", "=", "get_modules", "(", ")", "return", "sorted", "(", "candidate", "for", "candidate", "in", "candidates", "if", "candidate", ".", "startswith", "(", "needle", ")", ")" ]

[ "def", "get_condition", "(", "self", ",", "service_id", ",", "version_number", ",", "name", ")", ":", "content", "=", "self", ".", "_fetch", "(", "\"/service/%s/version/%d/condition/%s\"", "%", "(", "service_id", ",", "version_number", ",", "name", ")", ")", "return", "FastlyCondition", "(", "self", ",", "content", ")" ]

[ "def", "Rank", "(", "a", ")", ":", "return", "np", ".", "array", "(", "[", "len", "(", "a", ".", "shape", ")", "]", ",", "dtype", "=", "np", ".", "int32", ")", "," ]

[ "def", "process_connection", "(", "connection", ",", "my_socket", ")", ":", "if", "connection", ".", "closed", ":", "return", "False", "work", "=", "False", "readfd", "=", "[", "]", "writefd", "=", "[", "]", "if", "connection", ".", "needs_input", ">", "0", ":", "readfd", "=", "[", "my_socket", "]", "work", "=", "True", "if", "connection", ".", "has_output", ">", "0", ":", "writefd", "=", "[", "my_socket", "]", "work", "=", "True", "timeout", "=", "None", "deadline", "=", "connection", ".", "next_tick", "if", "deadline", ":", "work", "=", "True", "now", "=", "time", ".", "time", "(", ")", "timeout", "=", "0", "if", "deadline", "<=", "now", "else", "deadline", "-", "now", "if", "not", "work", ":", "return", "False", "readable", ",", "writable", ",", "ignore", "=", "select", ".", "select", "(", "readfd", ",", "writefd", ",", "[", "]", ",", "timeout", ")", "if", "readable", ":", "try", ":", "pyngus", ".", "read_socket_input", "(", "connection", ",", "my_socket", ")", "except", "Exception", "as", "e", ":", "# treat any socket error as", "LOG", ".", "error", "(", "\"Socket error on read: %s\"", ",", "str", "(", "e", ")", ")", "connection", ".", "close_input", "(", ")", "# make an attempt to cleanly close", "connection", ".", "close", "(", ")", "connection", ".", "process", "(", "time", ".", "time", "(", ")", ")", "if", "writable", ":", "try", ":", "pyngus", ".", "write_socket_output", "(", "connection", ",", "my_socket", ")", "except", "Exception", "as", "e", ":", "LOG", ".", "error", "(", "\"Socket error on write %s\"", ",", "str", "(", "e", ")", ")", "connection", ".", "close_output", "(", ")", "# this may not help, but it won't hurt:", "connection", ".", "close", "(", ")", "return", "True" ]

[ "def", "take", "(", "list_", ",", "index_list", ")", ":", "try", ":", "return", "[", "list_", "[", "index", "]", "for", "index", "in", "index_list", "]", "except", "TypeError", ":", "return", "list_", "[", "index_list", "]" ]

[ "def", "download_as_file", "(", "fn", ",", "data", "=", "None", ")", ":", "if", "data", "is", "None", ":", "raise", "HTTPError", "(", "500", ",", "\"This service require POST `data` parameter.\"", ")", "response", ".", "set_header", "(", "\"Content-Type\"", ",", "\"application/octet-stream\"", ")", "response", ".", "set_header", "(", "\"Content-Disposition\"", ",", "'attachment; filename=\"%s\"'", "%", "fn", ")", "return", "StringIO", "(", "data", ")" ]

[ "def", "_EncodeUnknownFields", "(", "message", ")", ":", "source", "=", "_UNRECOGNIZED_FIELD_MAPPINGS", ".", "get", "(", "type", "(", "message", ")", ")", "if", "source", "is", "None", ":", "return", "message", "# CopyProtoMessage uses _ProtoJsonApiTools, which uses this message. Use", "# the vanilla protojson-based copy function to avoid infinite recursion.", "result", "=", "_CopyProtoMessageVanillaProtoJson", "(", "message", ")", "pairs_field", "=", "message", ".", "field_by_name", "(", "source", ")", "if", "not", "isinstance", "(", "pairs_field", ",", "messages", ".", "MessageField", ")", ":", "raise", "exceptions", ".", "InvalidUserInputError", "(", "'Invalid pairs field %s'", "%", "pairs_field", ")", "pairs_type", "=", "pairs_field", ".", "message_type", "value_field", "=", "pairs_type", ".", "field_by_name", "(", "'value'", ")", "value_variant", "=", "value_field", ".", "variant", "pairs", "=", "getattr", "(", "message", ",", "source", ")", "codec", "=", "_ProtoJsonApiTools", ".", "Get", "(", ")", "for", "pair", "in", "pairs", ":", "encoded_value", "=", "codec", ".", "encode_field", "(", "value_field", ",", "pair", ".", "value", ")", "result", ".", "set_unrecognized_field", "(", "pair", ".", "key", ",", "encoded_value", ",", "value_variant", ")", "setattr", "(", "result", ",", "source", ",", "[", "]", ")", "return", "result" ]

[ "def", "process_from_file", "(", "signor_data_file", ",", "signor_complexes_file", "=", "None", ")", ":", "# Get generator over the CSV file", "data_iter", "=", "read_unicode_csv", "(", "signor_data_file", ",", "delimiter", "=", "';'", ",", "skiprows", "=", "1", ")", "complexes_iter", "=", "None", "if", "signor_complexes_file", ":", "complexes_iter", "=", "read_unicode_csv", "(", "signor_complexes_file", ",", "delimiter", "=", "';'", ",", "skiprows", "=", "1", ")", "else", ":", "logger", ".", "warning", "(", "'Signor complex mapping file not provided, Statements '", "'involving complexes will not be expanded to members.'", ")", "return", "_processor_from_data", "(", "data_iter", ",", "complexes_iter", ")" ]

[ "def", "lowstate_file_refs", "(", "chunks", ",", "extras", "=", "''", ")", ":", "refs", "=", "{", "}", "for", "chunk", "in", "chunks", ":", "if", "not", "isinstance", "(", "chunk", ",", "dict", ")", ":", "continue", "saltenv", "=", "'base'", "crefs", "=", "[", "]", "for", "state", "in", "chunk", ":", "if", "state", "==", "'__env__'", ":", "saltenv", "=", "chunk", "[", "state", "]", "elif", "state", ".", "startswith", "(", "'__'", ")", ":", "continue", "crefs", ".", "extend", "(", "salt_refs", "(", "chunk", "[", "state", "]", ")", ")", "if", "saltenv", "not", "in", "refs", ":", "refs", "[", "saltenv", "]", "=", "[", "]", "if", "crefs", ":", "refs", "[", "saltenv", "]", ".", "append", "(", "crefs", ")", "if", "extras", ":", "extra_refs", "=", "extras", ".", "split", "(", "','", ")", "if", "extra_refs", ":", "for", "env", "in", "refs", ":", "for", "x", "in", "extra_refs", ":", "refs", "[", "env", "]", ".", "append", "(", "[", "x", "]", ")", "return", "refs" ]

[ "def", "ADDMOD", "(", "self", ",", "a", ",", "b", ",", "c", ")", ":", "try", ":", "result", "=", "Operators", ".", "ITEBV", "(", "256", ",", "c", "==", "0", ",", "0", ",", "(", "a", "+", "b", ")", "%", "c", ")", "except", "ZeroDivisionError", ":", "result", "=", "0", "return", "result" ]

[ "def", "_process_dataset", "(", "name", ",", "directory", ",", "num_shards", ",", "labels_file", ")", ":", "filenames", ",", "texts", ",", "labels", "=", "_find_image_files", "(", "directory", ",", "labels_file", ")", "_process_image_files", "(", "name", ",", "filenames", ",", "texts", ",", "labels", ",", "num_shards", ")" ]

[ "def", "add_provide", "(", "self", ",", "provide", ")", ":", "for", "p", "in", "self", ".", "provides", ":", "if", "p", ".", "value", "==", "provide", ".", "value", ":", "return", "self", ".", "provides", ".", "append", "(", "provide", ")" ]

[ "def", "_parseHeader", "(", "self", ",", "line", ",", "lineno", ",", "log", ")", ":", "if", "line", ".", "startswith", "(", "'#'", ")", "and", "line", ".", "find", "(", "':'", ")", ">", "0", ":", "tokens", "=", "[", "t", ".", "strip", "(", ")", ".", "lower", "(", ")", "for", "t", "in", "line", "[", "1", ":", "]", ".", "split", "(", "\":\"", ",", "1", ")", "]", "name", "=", "tokens", "[", "0", "]", "pos", "=", "SeqPos", "(", "line", ",", "lineno", ")", "if", "name", "in", "self", ".", "header", ":", "msg", "=", "'Ignoring duplicate header parameter: %s'", "log", ".", "warning", "(", "msg", "%", "name", ",", "pos", ")", "else", ":", "for", "expected", "in", "[", "'seqid'", ",", "'version'", "]", ":", "if", "name", "==", "expected", ":", "value", "=", "util", ".", "toNumber", "(", "tokens", "[", "1", "]", ",", "None", ")", "if", "value", "is", "None", ":", "msg", "=", "'Parameter \"%s\" value \"%s\" is not a number.'", "log", ".", "error", "(", "msg", "%", "(", "name", ",", "tokens", "[", "1", "]", ")", ",", "poss", ")", "else", ":", "self", ".", "header", "[", "name", "]", "=", "value" ]

[ "def", "get_grp2codes", "(", "self", ")", ":", "grp2codes", "=", "cx", ".", "defaultdict", "(", "set", ")", "for", "code", ",", "ntd", "in", "self", ".", "code2nt", ".", "items", "(", ")", ":", "grp2codes", "[", "ntd", ".", "group", "]", ".", "add", "(", "code", ")", "return", "dict", "(", "grp2codes", ")" ]

[ "def", "add_bollinger_bands", "(", "self", ",", "periods", "=", "20", ",", "boll_std", "=", "2", ",", "fill", "=", "True", ",", "column", "=", "None", ",", "name", "=", "''", ",", "str", "=", "'{name}({column},{period})'", ",", "*", "*", "kwargs", ")", ":", "if", "not", "column", ":", "column", "=", "self", ".", "_d", "[", "'close'", "]", "study", "=", "{", "'kind'", ":", "'boll'", ",", "'name'", ":", "name", ",", "'params'", ":", "{", "'periods'", ":", "periods", ",", "'boll_std'", ":", "boll_std", ",", "'column'", ":", "column", ",", "'str'", ":", "str", "}", ",", "'display'", ":", "utils", ".", "merge_dict", "(", "{", "'legendgroup'", ":", "True", ",", "'fill'", ":", "fill", "}", ",", "kwargs", ")", "}", "self", ".", "_add_study", "(", "study", ")" ]

[ "def", "from_analysis_period", "(", "cls", ",", "analysis_period", ",", "tau_b", ",", "tau_d", ",", "daylight_savings_indicator", "=", "'No'", ")", ":", "_check_analysis_period", "(", "analysis_period", ")", "return", "cls", "(", "analysis_period", ".", "st_month", ",", "analysis_period", ".", "st_day", ",", "tau_b", ",", "tau_d", ",", "daylight_savings_indicator", ")" ]

[ "def", "init_defaults", "(", "self", ")", ":", "if", "\"WARC-Record-ID\"", "not", "in", "self", ":", "self", "[", "'WARC-Record-ID'", "]", "=", "\"<urn:uuid:%s>\"", "%", "uuid", ".", "uuid1", "(", ")", "if", "\"WARC-Date\"", "not", "in", "self", ":", "self", "[", "'WARC-Date'", "]", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", ".", "strftime", "(", "'%Y-%m-%dT%H:%M:%SZ'", ")", "if", "\"Content-Type\"", "not", "in", "self", ":", "self", "[", "'Content-Type'", "]", "=", "WARCHeader", ".", "CONTENT_TYPES", ".", "get", "(", "self", ".", "type", ",", "\"application/octet-stream\"", ")" ]

[ "def", "branches", "(", "self", ")", ":", "for", "branch", "in", "self", ".", "_grid", ".", "graph_edges", "(", ")", ":", "if", "branch", "[", "'branch'", "]", ".", "ring", "==", "self", ":", "yield", "branch" ]

[ "def", "build_job", "(", "name", "=", "None", ",", "parameters", "=", "None", ")", ":", "if", "not", "name", ":", "raise", "SaltInvocationError", "(", "'Required parameter \\'name\\' is missing'", ")", "server", "=", "_connect", "(", ")", "if", "not", "job_exists", "(", "name", ")", ":", "raise", "CommandExecutionError", "(", "'Job \\'{0}\\' does not exist.'", ".", "format", "(", "name", ")", ")", "try", ":", "server", ".", "build_job", "(", "name", ",", "parameters", ")", "except", "jenkins", ".", "JenkinsException", "as", "err", ":", "raise", "CommandExecutionError", "(", "'Encountered error building job \\'{0}\\': {1}'", ".", "format", "(", "name", ",", "err", ")", ")", "return", "True" ]

[ "def", "sca_intensity", "(", "scatterer", ",", "h_pol", "=", "True", ")", ":", "Z", "=", "scatterer", ".", "get_Z", "(", ")", "return", "(", "Z", "[", "0", ",", "0", "]", "-", "Z", "[", "0", ",", "1", "]", ")", "if", "h_pol", "else", "(", "Z", "[", "0", ",", "0", "]", "+", "Z", "[", "0", ",", "1", "]", ")" ]

[ "def", "_instantiate_target", "(", "self", ",", "target_adaptor", ")", ":", "target_cls", "=", "self", ".", "_target_types", "[", "target_adaptor", ".", "type_alias", "]", "try", ":", "# Pop dependencies, which were already consumed during construction.", "kwargs", "=", "target_adaptor", ".", "kwargs", "(", ")", "kwargs", ".", "pop", "(", "'dependencies'", ")", "# Instantiate.", "if", "issubclass", "(", "target_cls", ",", "AppBase", ")", ":", "return", "self", ".", "_instantiate_app", "(", "target_cls", ",", "kwargs", ")", "elif", "target_cls", "is", "RemoteSources", ":", "return", "self", ".", "_instantiate_remote_sources", "(", "kwargs", ")", "return", "target_cls", "(", "build_graph", "=", "self", ",", "*", "*", "kwargs", ")", "except", "TargetDefinitionException", ":", "raise", "except", "Exception", "as", "e", ":", "raise", "TargetDefinitionException", "(", "target_adaptor", ".", "address", ",", "'Failed to instantiate Target with type {}: {}'", ".", "format", "(", "target_cls", ",", "e", ")", ")" ]

[ "def", "nnz_obs_names", "(", "self", ")", ":", "if", "self", ".", "__pst", "is", "not", "None", ":", "return", "self", ".", "pst", ".", "nnz_obs_names", "else", ":", "return", "self", ".", "jco", ".", "obs_names" ]

[ "def", "_pre_request", "(", "self", ",", "url", ",", "method", "=", "u\"get\"", ",", "data", "=", "None", ",", "headers", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "(", "url", ",", "method", ",", "data", ",", "headers", ",", "kwargs", ")" ]

[ "def", "_gpdfit", "(", "x", ")", ":", "prior_bs", "=", "3", "prior_k", "=", "10", "len_x", "=", "len", "(", "x", ")", "m_est", "=", "30", "+", "int", "(", "len_x", "**", "0.5", ")", "b_ary", "=", "1", "-", "np", ".", "sqrt", "(", "m_est", "/", "(", "np", ".", "arange", "(", "1", ",", "m_est", "+", "1", ",", "dtype", "=", "float", ")", "-", "0.5", ")", ")", "b_ary", "/=", "prior_bs", "*", "x", "[", "int", "(", "len_x", "/", "4", "+", "0.5", ")", "-", "1", "]", "b_ary", "+=", "1", "/", "x", "[", "-", "1", "]", "k_ary", "=", "np", ".", "log1p", "(", "-", "b_ary", "[", ":", ",", "None", "]", "*", "x", ")", ".", "mean", "(", "axis", "=", "1", ")", "# pylint: disable=no-member", "len_scale", "=", "len_x", "*", "(", "np", ".", "log", "(", "-", "(", "b_ary", "/", "k_ary", ")", ")", "-", "k_ary", "-", "1", ")", "weights", "=", "1", "/", "np", ".", "exp", "(", "len_scale", "-", "len_scale", "[", ":", ",", "None", "]", ")", ".", "sum", "(", "axis", "=", "1", ")", "# remove negligible weights", "real_idxs", "=", "weights", ">=", "10", "*", "np", ".", "finfo", "(", "float", ")", ".", "eps", "if", "not", "np", ".", "all", "(", "real_idxs", ")", ":", "weights", "=", "weights", "[", "real_idxs", "]", "b_ary", "=", "b_ary", "[", "real_idxs", "]", "# normalise weights", "weights", "/=", "weights", ".", "sum", "(", ")", "# posterior mean for b", "b_post", "=", "np", ".", "sum", "(", "b_ary", "*", "weights", ")", "# estimate for k", "k_post", "=", "np", ".", "log1p", "(", "-", "b_post", "*", "x", ")", ".", "mean", "(", ")", "# pylint: disable=invalid-unary-operand-type,no-member", "# add prior for k_post", "k_post", "=", "(", "len_x", "*", "k_post", "+", "prior_k", "*", "0.5", ")", "/", "(", "len_x", "+", "prior_k", ")", "sigma", "=", "-", "k_post", "/", "b_post", "return", "k_post", ",", "sigma" ]

[ "def", "get_conn", "(", "self", ")", ":", "http_authorized", "=", "self", ".", "_authorize", "(", ")", "return", "build", "(", "'dataproc'", ",", "self", ".", "api_version", ",", "http", "=", "http_authorized", ",", "cache_discovery", "=", "False", ")" ]

[ "def", "create_logger", "(", "name", ",", "formatter", "=", "None", ",", "handler", "=", "None", ",", "level", "=", "None", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", "name", ")", "#: remove existing handlers", "logger", ".", "handlers", "=", "[", "]", "#: use a standard out handler", "if", "handler", "is", "None", ":", "handler", "=", "logging", ".", "StreamHandler", "(", "sys", ".", "stdout", ")", "#: set the formatter when a formatter is given", "if", "formatter", "is", "not", "None", ":", "handler", ".", "setFormatter", "(", "formatter", ")", "#: set DEBUG level if no level is specified", "if", "level", "is", "None", ":", "level", "=", "logging", ".", "DEBUG", "handler", ".", "setLevel", "(", "level", ")", "logger", ".", "setLevel", "(", "level", ")", "logger", ".", "addHandler", "(", "handler", ")", "return", "logger" ]

[ "def", "get_row_by_fsid", "(", "self", ",", "fs_id", ")", ":", "for", "row", "in", "self", ".", "liststore", ":", "if", "row", "[", "FSID_COL", "]", "==", "fs_id", ":", "return", "row", "return", "None" ]

[ "def", "register_preprocessed_file", "(", "self", ",", "infile", ",", "pmid", ",", "extra_annotations", ")", ":", "infile_base", "=", "os", ".", "path", ".", "basename", "(", "infile", ")", "outfile", "=", "os", ".", "path", ".", "join", "(", "self", ".", "preprocessed_dir", ",", "infile_base", ")", "shutil", ".", "copyfile", "(", "infile", ",", "outfile", ")", "infile_key", "=", "os", ".", "path", ".", "splitext", "(", "infile_base", ")", "[", "0", "]", "self", ".", "pmids", "[", "infile_key", "]", "=", "pmid", "self", ".", "extra_annotations", "[", "infile_key", "]", "=", "extra_annotations" ]

[ "def", "serialize_to_xml", "(", "root", ",", "block", ")", ":", "root", ".", "tag", "=", "'ubcpi'", "if", "block", ".", "rationale_size", "is", "not", "None", ":", "if", "block", ".", "rationale_size", ".", "get", "(", "'min'", ")", ":", "root", ".", "set", "(", "'rationale_size_min'", ",", "unicode", "(", "block", ".", "rationale_size", ".", "get", "(", "'min'", ")", ")", ")", "if", "block", ".", "rationale_size", ".", "get", "(", "'max'", ")", ":", "root", ".", "set", "(", "'rationale_size_max'", ",", "unicode", "(", "block", ".", "rationale_size", "[", "'max'", "]", ")", ")", "if", "block", ".", "algo", ":", "if", "block", ".", "algo", ".", "get", "(", "'name'", ")", ":", "root", ".", "set", "(", "'algorithm'", ",", "block", ".", "algo", ".", "get", "(", "'name'", ")", ")", "if", "block", ".", "algo", ".", "get", "(", "'num_responses'", ")", ":", "root", ".", "set", "(", "'num_responses'", ",", "unicode", "(", "block", ".", "algo", ".", "get", "(", "'num_responses'", ")", ")", ")", "display_name", "=", "etree", ".", "SubElement", "(", "root", ",", "'display_name'", ")", "display_name", ".", "text", "=", "block", ".", "display_name", "question", "=", "etree", ".", "SubElement", "(", "root", ",", "'question'", ")", "question_text", "=", "etree", ".", "SubElement", "(", "question", ",", "'text'", ")", "question_text", ".", "text", "=", "block", ".", "question_text", "[", "'text'", "]", "serialize_image", "(", "block", ".", "question_text", ",", "question", ")", "options", "=", "etree", ".", "SubElement", "(", "root", ",", "'options'", ")", "serialize_options", "(", "options", ",", "block", ")", "seeds", "=", "etree", ".", "SubElement", "(", "root", ",", "'seeds'", ")", "serialize_seeds", "(", "seeds", ",", "block", ")" ]

[ "def", "make_name", "(", "super_name", ",", "default_super_name", ",", "sub_name", ")", ":", "name", "=", "super_name", "if", "super_name", "is", "not", "None", "else", "default_super_name", "if", "sub_name", "is", "not", "None", ":", "name", "+=", "'_'", "+", "sub_name", "return", "name" ]

[ "def", "getCenter", "(", "self", ")", ":", "return", "Location", "(", "self", ".", "x", "+", "(", "self", ".", "w", "/", "2", ")", ",", "self", ".", "y", "+", "(", "self", ".", "h", "/", "2", ")", ")" ]

[ "def", "decode", "(", "token", ",", "certs", "=", "None", ",", "verify", "=", "True", ",", "audience", "=", "None", ")", ":", "header", ",", "payload", ",", "signed_section", ",", "signature", "=", "_unverified_decode", "(", "token", ")", "if", "not", "verify", ":", "return", "payload", "# If certs is specified as a dictionary of key IDs to certificates, then", "# use the certificate identified by the key ID in the token header.", "if", "isinstance", "(", "certs", ",", "collections", ".", "Mapping", ")", ":", "key_id", "=", "header", ".", "get", "(", "'kid'", ")", "if", "key_id", ":", "if", "key_id", "not", "in", "certs", ":", "raise", "ValueError", "(", "'Certificate for key id {} not found.'", ".", "format", "(", "key_id", ")", ")", "certs_to_check", "=", "[", "certs", "[", "key_id", "]", "]", "# If there's no key id in the header, check against all of the certs.", "else", ":", "certs_to_check", "=", "certs", ".", "values", "(", ")", "else", ":", "certs_to_check", "=", "certs", "# Verify that the signature matches the message.", "if", "not", "crypt", ".", "verify_signature", "(", "signed_section", ",", "signature", ",", "certs_to_check", ")", ":", "raise", "ValueError", "(", "'Could not verify token signature.'", ")", "# Verify the issued at and created times in the payload.", "_verify_iat_and_exp", "(", "payload", ")", "# Check audience.", "if", "audience", "is", "not", "None", ":", "claim_audience", "=", "payload", ".", "get", "(", "'aud'", ")", "if", "audience", "!=", "claim_audience", ":", "raise", "ValueError", "(", "'Token has wrong audience {}, expected {}'", ".", "format", "(", "claim_audience", ",", "audience", ")", ")", "return", "payload" ]

[ "def", "logscale", "(", "x_min", ",", "x_max", ",", "n", ")", ":", "if", "not", "(", "isinstance", "(", "n", ",", "int", ")", "and", "n", ">", "0", ")", ":", "raise", "ValueError", "(", "'n must be a positive integer, got %s'", "%", "n", ")", "if", "x_min", "<=", "0", ":", "raise", "ValueError", "(", "'x_min must be positive, got %s'", "%", "x_min", ")", "if", "x_max", "<=", "x_min", ":", "raise", "ValueError", "(", "'x_max (%s) must be bigger than x_min (%s)'", "%", "(", "x_max", ",", "x_min", ")", ")", "delta", "=", "numpy", ".", "log", "(", "x_max", "/", "x_min", ")", "return", "numpy", ".", "exp", "(", "delta", "*", "numpy", ".", "arange", "(", "n", ")", "/", "(", "n", "-", "1", ")", ")", "*", "x_min" ]

[ "def", "_outer_error_is_decreasing", "(", "self", ")", ":", "is_decreasing", ",", "self", ".", "_last_outer_error", "=", "self", ".", "_error_is_decreasing", "(", "self", ".", "_last_outer_error", ")", "return", "is_decreasing" ]

[ "def", "_getshapes_2d", "(", "center", ",", "max_radius", ",", "shape", ")", ":", "index_mean", "=", "shape", "*", "center", "index_radius", "=", "max_radius", "/", "2.0", "*", "np", ".", "array", "(", "shape", ")", "# Avoid negative indices", "min_idx", "=", "np", ".", "maximum", "(", "np", ".", "floor", "(", "index_mean", "-", "index_radius", ")", ",", "0", ")", ".", "astype", "(", "int", ")", "max_idx", "=", "np", ".", "ceil", "(", "index_mean", "+", "index_radius", ")", ".", "astype", "(", "int", ")", "idx", "=", "[", "slice", "(", "minx", ",", "maxx", ")", "for", "minx", ",", "maxx", "in", "zip", "(", "min_idx", ",", "max_idx", ")", "]", "shapes", "=", "[", "(", "idx", "[", "0", "]", ",", "slice", "(", "None", ")", ")", ",", "(", "slice", "(", "None", ")", ",", "idx", "[", "1", "]", ")", "]", "return", "tuple", "(", "idx", ")", ",", "tuple", "(", "shapes", ")" ]

[ "def", "_get_queue_for_the_action", "(", "self", ",", "action", ")", ":", "# get the module name, if not, take fork", "mod", "=", "getattr", "(", "action", ",", "'module_type'", ",", "'fork'", ")", "queues", "=", "list", "(", "self", ".", "q_by_mod", "[", "mod", "]", ".", "items", "(", ")", ")", "# Maybe there is no more queue, it's very bad!", "if", "not", "queues", ":", "return", "(", "0", ",", "None", ")", "# if not get action round robin index to get action queue based", "# on the action id", "self", ".", "rr_qid", "=", "(", "self", ".", "rr_qid", "+", "1", ")", "%", "len", "(", "queues", ")", "(", "worker_id", ",", "queue", ")", "=", "queues", "[", "self", ".", "rr_qid", "]", "# return the id of the worker (i), and its queue", "return", "(", "worker_id", ",", "queue", ")" ]

[ "def", "dict_from_cookiejar", "(", "cj", ")", ":", "cookie_dict", "=", "{", "}", "for", "_", ",", "cookies", "in", "cj", ".", "_cookies", ".", "items", "(", ")", ":", "for", "_", ",", "cookies", "in", "cookies", ".", "items", "(", ")", ":", "for", "cookie", "in", "cookies", ".", "values", "(", ")", ":", "# print cookie", "cookie_dict", "[", "cookie", ".", "name", "]", "=", "cookie", ".", "value", "return", "cookie_dict" ]

[ "def", "rgb", "(", "red", ",", "green", ",", "blue", ",", "content", ")", ":", "color", "=", "16", "+", "36", "*", "red", "+", "6", "*", "green", "+", "blue", "return", "encode", "(", "'38;5;'", "+", "str", "(", "color", ")", ")", "+", "content", "+", "encode", "(", "DEFAULT", ")" ]

[ "def", "get_polygons", "(", "self", ",", "by_spec", "=", "False", ",", "depth", "=", "None", ")", ":", "if", "depth", "is", "not", "None", "and", "depth", "<", "0", ":", "bb", "=", "self", ".", "get_bounding_box", "(", ")", "if", "bb", "is", "None", ":", "return", "{", "}", "if", "by_spec", "else", "[", "]", "pts", "=", "[", "numpy", ".", "array", "(", "[", "(", "bb", "[", "0", ",", "0", "]", ",", "bb", "[", "0", ",", "1", "]", ")", ",", "(", "bb", "[", "0", ",", "0", "]", ",", "bb", "[", "1", ",", "1", "]", ")", ",", "(", "bb", "[", "1", ",", "0", "]", ",", "bb", "[", "1", ",", "1", "]", ")", ",", "(", "bb", "[", "1", ",", "0", "]", ",", "bb", "[", "0", ",", "1", "]", ")", "]", ")", "]", "polygons", "=", "{", "self", ".", "name", ":", "pts", "}", "if", "by_spec", "else", "pts", "else", ":", "if", "by_spec", ":", "polygons", "=", "{", "}", "for", "element", "in", "self", ".", "elements", ":", "if", "isinstance", "(", "element", ",", "PolygonSet", ")", ":", "for", "ii", "in", "range", "(", "len", "(", "element", ".", "polygons", ")", ")", ":", "key", "=", "(", "element", ".", "layers", "[", "ii", "]", ",", "element", ".", "datatypes", "[", "ii", "]", ")", "if", "key", "in", "polygons", ":", "polygons", "[", "key", "]", ".", "append", "(", "numpy", ".", "array", "(", "element", ".", "polygons", "[", "ii", "]", ")", ")", "else", ":", "polygons", "[", "key", "]", "=", "[", "numpy", ".", "array", "(", "element", ".", "polygons", "[", "ii", "]", ")", "]", "else", ":", "cell_polygons", "=", "element", ".", "get_polygons", "(", "True", ",", "None", "if", "depth", "is", "None", "else", "depth", "-", "1", ")", "for", "kk", "in", "cell_polygons", ".", "keys", "(", ")", ":", "if", "kk", "in", "polygons", ":", "polygons", "[", "kk", "]", ".", "extend", "(", "cell_polygons", "[", "kk", "]", ")", "else", ":", "polygons", "[", "kk", "]", "=", "cell_polygons", "[", "kk", "]", "else", ":", "polygons", "=", "[", "]", "for", "element", "in", "self", ".", "elements", ":", "if", "isinstance", "(", "element", ",", "PolygonSet", ")", ":", "for", "points", "in", "element", ".", "polygons", ":", "polygons", ".", "append", "(", "numpy", ".", "array", "(", "points", ")", ")", "else", ":", "polygons", ".", "extend", "(", "element", ".", "get_polygons", "(", "depth", "=", "None", "if", "depth", "is", "None", "else", "depth", "-", "1", ")", ")", "return", "polygons" ]

[ "def", "assemble", "(", "self", ")", ":", "instruction", "=", "super", "(", ")", ".", "assemble", "(", ")", "if", "self", ".", "label", ":", "instruction", ".", "label", "=", "self", ".", "label", "return", "instruction" ]

[ "def", "longest_monotonic_subseq_length", "(", "xs", ")", ":", "li", "=", "longest_increasing_subseq_length", "(", "xs", ")", "ld", "=", "longest_decreasing_subseq_length", "(", "xs", ")", "return", "max", "(", "li", ",", "ld", ")", ",", "li", "-", "ld" ]

[ "def", "docker_to_uuid", "(", "uuid", ")", ":", "if", "_is_uuid", "(", "uuid", ")", ":", "return", "uuid", "if", "_is_docker_uuid", "(", "uuid", ")", ":", "images", "=", "list_installed", "(", "verbose", "=", "True", ")", "for", "image_uuid", "in", "images", ":", "if", "'name'", "not", "in", "images", "[", "image_uuid", "]", ":", "continue", "if", "images", "[", "image_uuid", "]", "[", "'name'", "]", "==", "uuid", ":", "return", "image_uuid", "return", "None" ]

[ "def", "tplot_options", "(", "option", ",", "value", ")", ":", "option", "=", "option", ".", "lower", "(", ")", "temp", "=", "tplot_utilities", ".", "set_tplot_options", "(", "option", ",", "value", ",", "pytplot", ".", "tplot_opt_glob", ")", "pytplot", ".", "tplot_opt_glob", "=", "temp", "return" ]

[ "def", "stripe_to_db", "(", "self", ",", "data", ")", ":", "val", "=", "data", ".", "get", "(", "self", ".", "name", ")", "# Note: 0 is a possible return value, which is 'falseish'", "if", "val", "is", "not", "None", ":", "return", "convert_tstamp", "(", "val", ")" ]

[ "def", "update_limits", "(", "self", ",", "change_source_lower_limit", "=", "None", ",", "change_source_upper_limit", "=", "None", ")", ":", "if", "not", "change_source_lower_limit", "is", "None", ":", "self", ".", "_source_lower", "=", "self", ".", "_update_limit", "(", "change_source_lower_limit", ",", "self", ".", "_source_lower", ")", "if", "not", "change_source_upper_limit", "is", "None", ":", "self", ".", "_source_upper", "=", "self", ".", "_update_limit", "(", "change_source_upper_limit", ",", "self", ".", "_source_upper", ")" ]

[ "def", "validate_capacity", "(", "capacity", ")", ":", "if", "capacity", "not", "in", "VALID_SCALING_CONFIGURATION_CAPACITIES", ":", "raise", "ValueError", "(", "\"ScalingConfiguration capacity must be one of: {}\"", ".", "format", "(", "\", \"", ".", "join", "(", "map", "(", "str", ",", "VALID_SCALING_CONFIGURATION_CAPACITIES", ")", ")", ")", ")", "return", "capacity" ]

[ "def", "project_status", "(", ")", ":", "r", "=", "Response", "(", ")", "try", ":", "project", "=", "cauldron", ".", "project", ".", "get_internal_project", "(", ")", "if", "project", ":", "r", ".", "update", "(", "project", "=", "project", ".", "status", "(", ")", ")", "else", ":", "r", ".", "update", "(", "project", "=", "None", ")", "except", "Exception", "as", "err", ":", "r", ".", "fail", "(", "code", "=", "'PROJECT_STATUS_ERROR'", ",", "message", "=", "'Unable to check status of currently opened project'", ",", "error", "=", "err", ")", "r", ".", "update", "(", "server", "=", "server_runner", ".", "get_server_data", "(", ")", ")", "return", "flask", ".", "jsonify", "(", "r", ".", "serialize", "(", ")", ")" ]

[ "def", "addai", "(", "argname", ",", "condition", "=", "None", ")", ":", "# pylint: disable=C0123", "if", "not", "isinstance", "(", "argname", ",", "str", ")", ":", "raise", "RuntimeError", "(", "\"Argument `argname` is not valid\"", ")", "if", "(", "condition", "is", "not", "None", ")", "and", "(", "type", "(", "condition", ")", "!=", "bool", ")", ":", "raise", "RuntimeError", "(", "\"Argument `condition` is not valid\"", ")", "obj", "=", "_ExObj", "(", "RuntimeError", ",", "\"Argument `{0}` is not valid\"", ".", "format", "(", "argname", ")", ",", "condition", ")", "return", "obj", ".", "craise" ]

[ "def", "spawn", "(", "func", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "t", "=", "Task", "(", "target", "=", "func", ",", "args", "=", "args", ",", "kwargs", "=", "kwargs", ")", "t", ".", "start", "(", ")", "return", "t" ]

[ "def", "get_overlapping_ranges", "(", "self", ",", "collection_link", ",", "partition_key_ranges", ")", ":", "cl", "=", "self", ".", "_documentClient", "collection_id", "=", "base", ".", "GetResourceIdOrFullNameFromLink", "(", "collection_link", ")", "collection_routing_map", "=", "self", ".", "_collection_routing_map_by_item", ".", "get", "(", "collection_id", ")", "if", "collection_routing_map", "is", "None", ":", "collection_pk_ranges", "=", "list", "(", "cl", ".", "_ReadPartitionKeyRanges", "(", "collection_link", ")", ")", "# for large collections, a split may complete between the read partition key ranges query page responses, ", "# causing the partitionKeyRanges to have both the children ranges and their parents. Therefore, we need ", "# to discard the parent ranges to have a valid routing map.", "collection_pk_ranges", "=", "_PartitionKeyRangeCache", ".", "_discard_parent_ranges", "(", "collection_pk_ranges", ")", "collection_routing_map", "=", "_CollectionRoutingMap", ".", "CompleteRoutingMap", "(", "[", "(", "r", ",", "True", ")", "for", "r", "in", "collection_pk_ranges", "]", ",", "collection_id", ")", "self", ".", "_collection_routing_map_by_item", "[", "collection_id", "]", "=", "collection_routing_map", "return", "collection_routing_map", ".", "get_overlapping_ranges", "(", "partition_key_ranges", ")" ]

[ "def", "list_config_map_for_all_namespaces", "(", "self", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async_req'", ")", ":", "return", "self", ".", "list_config_map_for_all_namespaces_with_http_info", "(", "*", "*", "kwargs", ")", "else", ":", "(", "data", ")", "=", "self", ".", "list_config_map_for_all_namespaces_with_http_info", "(", "*", "*", "kwargs", ")", "return", "data" ]

[ "def", "protocols", "(", "self", ")", ":", "if", "self", ".", "__protocols", "is", "None", ":", "self", ".", "__protocols", "=", "self", ".", "proto_tree_model", ".", "protocols", "return", "self", ".", "__protocols" ]

[ "def", "local_manager_gid", "(", "self", ")", ":", "config", "=", "self", ".", "root", "[", "'settings'", "]", "[", "'ugm_localmanager'", "]", ".", "attrs", "user", "=", "security", ".", "authenticated_user", "(", "get_current_request", "(", ")", ")", "if", "not", "user", ":", "return", "None", "gids", "=", "user", ".", "group_ids", "adm_gids", "=", "list", "(", ")", "for", "gid", "in", "gids", ":", "rule", "=", "config", ".", "get", "(", "gid", ")", "if", "rule", ":", "adm_gids", ".", "append", "(", "gid", ")", "if", "len", "(", "adm_gids", ")", "==", "0", ":", "return", "None", "if", "len", "(", "adm_gids", ")", ">", "1", ":", "msg", "=", "(", "u\"Authenticated member defined in local manager \"", "u\"groups %s but only one management group allowed for \"", "u\"each user. Please contact System Administrator in \"", "u\"order to fix this problem.\"", ")", "exc", "=", "msg", "%", "', '", ".", "join", "(", "[", "\"'%s'\"", "%", "gid", "for", "gid", "in", "adm_gids", "]", ")", "raise", "Exception", "(", "exc", ")", "return", "adm_gids", "[", "0", "]" ]

[ "def", "layout", "(", "self", ")", ":", "if", "self", ".", "shadowed", ":", "shadow_size", "=", "theme", ".", "current", ".", "shadow_size", "shadowed_frame_size", "=", "(", "self", ".", "frame", ".", "w", "+", "shadow_size", ",", "self", ".", "frame", ".", "h", "+", "shadow_size", ")", "self", ".", "surface", "=", "pygame", ".", "Surface", "(", "shadowed_frame_size", ",", "pygame", ".", "SRCALPHA", ",", "32", ")", "shadow_image", "=", "resource", ".", "get_image", "(", "'shadow'", ")", "self", ".", "shadow_image", "=", "resource", ".", "scale_image", "(", "shadow_image", ",", "shadowed_frame_size", ")", "else", ":", "self", ".", "surface", "=", "pygame", ".", "Surface", "(", "self", ".", "frame", ".", "size", ",", "pygame", ".", "SRCALPHA", ",", "32", ")", "self", ".", "shadow_image", "=", "None" ]

[ "def", "ui_label", "(", "self", ")", ":", "return", "': '", ".", "join", "(", "filter", "(", "None", ",", "[", "self", ".", "ui_device_presentation", ",", "self", ".", "ui_id_label", "or", "self", ".", "ui_id_uuid", "or", "self", ".", "drive_label", "]", ")", ")" ]

[ "def", "get_value", "(", "self", ",", "dictionary", ")", ":", "if", "html", ".", "is_html_input", "(", "dictionary", ")", ":", "# HTML forms will represent empty fields as '', and cannot", "# represent None or False values directly.", "if", "self", ".", "field_name", "not", "in", "dictionary", ":", "if", "getattr", "(", "self", ".", "root", ",", "'partial'", ",", "False", ")", ":", "return", "empty", "return", "self", ".", "default_empty_html", "ret", "=", "dictionary", "[", "self", ".", "field_name", "]", "if", "ret", "==", "''", "and", "self", ".", "allow_null", ":", "# If the field is blank, and null is a valid value then", "# determine if we should use null instead.", "return", "''", "if", "getattr", "(", "self", ",", "'allow_blank'", ",", "False", ")", "else", "None", "elif", "ret", "==", "''", "and", "not", "self", ".", "required", ":", "# If the field is blank, and emptyness is valid then", "# determine if we should use emptyness instead.", "return", "''", "if", "getattr", "(", "self", ",", "'allow_blank'", ",", "False", ")", "else", "empty", "return", "ret", "return", "dictionary", ".", "get", "(", "self", ".", "field_name", ",", "empty", ")" ]

[ "def", "user", "(", "name", ",", "id", "=", "''", ",", "user", "=", "''", ",", "priv", "=", "''", ",", "password", "=", "''", ",", "status", "=", "'active'", ")", ":", "ret", "=", "_default_ret", "(", "name", ")", "user_conf", "=", "__salt__", "[", "'cimc.get_users'", "]", "(", ")", "try", ":", "for", "entry", "in", "user_conf", "[", "'outConfigs'", "]", "[", "'aaaUser'", "]", ":", "if", "entry", "[", "'id'", "]", "==", "str", "(", "id", ")", ":", "conf", "=", "entry", "if", "not", "conf", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "\"Unable to find requested user id on device. Please verify id is valid.\"", "return", "ret", "updates", "=", "__salt__", "[", "'cimc.set_user'", "]", "(", "str", "(", "id", ")", ",", "user", ",", "password", ",", "priv", ",", "status", ")", "if", "'outConfig'", "in", "updates", ":", "ret", "[", "'changes'", "]", "[", "'before'", "]", "=", "conf", "ret", "[", "'changes'", "]", "[", "'after'", "]", "=", "updates", "[", "'outConfig'", "]", "[", "'aaaUser'", "]", "ret", "[", "'comment'", "]", "=", "\"User settings modified.\"", "else", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "\"Error setting user configuration.\"", "return", "ret", "except", "Exception", "as", "err", ":", "ret", "[", "'result'", "]", "=", "False", "ret", "[", "'comment'", "]", "=", "\"Error setting user configuration.\"", "log", ".", "error", "(", "err", ")", "return", "ret", "ret", "[", "'result'", "]", "=", "True", "return", "ret" ]

[ "def", "get_account_tokens", "(", "self", ",", "address", ")", ":", "cur", "=", "self", ".", "db", ".", "cursor", "(", ")", "return", "namedb_get_account_tokens", "(", "cur", ",", "address", ")" ]

[ "def", "toJSONFilters", "(", "actions", ")", ":", "try", ":", "input_stream", "=", "io", ".", "TextIOWrapper", "(", "sys", ".", "stdin", ".", "buffer", ",", "encoding", "=", "'utf-8'", ")", "except", "AttributeError", ":", "# Python 2 does not have sys.stdin.buffer.", "# REF: https://stackoverflow.com/questions/2467928/python-unicodeencode", "input_stream", "=", "codecs", ".", "getreader", "(", "\"utf-8\"", ")", "(", "sys", ".", "stdin", ")", "source", "=", "input_stream", ".", "read", "(", ")", "if", "len", "(", "sys", ".", "argv", ")", ">", "1", ":", "format", "=", "sys", ".", "argv", "[", "1", "]", "else", ":", "format", "=", "\"\"", "sys", ".", "stdout", ".", "write", "(", "applyJSONFilters", "(", "actions", ",", "source", ",", "format", ")", ")" ]

[ "def", "getCalculationDependencies", "(", "self", ",", "flat", "=", "False", ",", "deps", "=", "None", ")", ":", "if", "deps", "is", "None", ":", "deps", "=", "[", "]", "if", "flat", "is", "True", "else", "{", "}", "for", "service", "in", "self", ".", "getDependentServices", "(", ")", ":", "calc", "=", "service", ".", "getCalculation", "(", ")", "if", "calc", ":", "calc", ".", "getCalculationDependencies", "(", "flat", ",", "deps", ")", "if", "flat", ":", "deps", ".", "append", "(", "service", ")", "else", ":", "deps", "[", "service", ".", "UID", "(", ")", "]", "=", "{", "}", "return", "deps" ]

[ "def", "_sub16", "(", "ins", ")", ":", "op1", ",", "op2", "=", "tuple", "(", "ins", ".", "quad", "[", "2", ":", "4", "]", ")", "if", "is_int", "(", "op2", ")", ":", "op", "=", "int16", "(", "op2", ")", "output", "=", "_16bit_oper", "(", "op1", ")", "if", "op", "==", "0", ":", "output", ".", "append", "(", "'push hl'", ")", "return", "output", "if", "op", "<", "4", ":", "output", ".", "extend", "(", "[", "'dec hl'", "]", "*", "op", ")", "output", ".", "append", "(", "'push hl'", ")", "return", "output", "if", "op", ">", "65531", ":", "output", ".", "extend", "(", "[", "'inc hl'", "]", "*", "(", "0x10000", "-", "op", ")", ")", "output", ".", "append", "(", "'push hl'", ")", "return", "output", "output", ".", "append", "(", "'ld de, -%i'", "%", "op", ")", "output", ".", "append", "(", "'add hl, de'", ")", "output", ".", "append", "(", "'push hl'", ")", "return", "output", "if", "op2", "[", "0", "]", "==", "'_'", ":", "# Optimization when 2nd operand is an id", "rev", "=", "True", "op1", ",", "op2", "=", "op2", ",", "op1", "else", ":", "rev", "=", "False", "output", "=", "_16bit_oper", "(", "op1", ",", "op2", ",", "rev", ")", "output", ".", "append", "(", "'or a'", ")", "output", ".", "append", "(", "'sbc hl, de'", ")", "output", ".", "append", "(", "'push hl'", ")", "return", "output" ]

[ "def", "connectivity_map", "(", "dset", ",", "prefix", ",", "x", ",", "y", ",", "z", ",", "radius", "=", "2", ")", ":", "seed_series", "=", "nl", ".", "sphere_average", "(", "dset", ",", "x", ",", "y", ",", "z", ",", "radius", ")", "with", "tempfile", ".", "NamedTemporaryFile", "(", "delete", "=", "False", ")", "as", "temp", ":", "temp", ".", "write", "(", "'\\n'", ".", "join", "(", "[", "str", "(", "x", ")", "for", "x", "in", "seed_series", "]", ")", ")", "decon", "=", "nl", ".", "Decon", "(", ")", "decon", ".", "input_dsets", "=", "dset", "decon", ".", "stim_files", "=", "{", "'seed'", ":", "temp", ".", "name", "}", "decon", ".", "prefix", "=", "prefix", "decon", ".", "run", "(", ")", "try", ":", "os", ".", "remove", "(", "temp", ".", "name", ")", "except", ":", "pass" ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "curr_idx", "=", "0", "random", ".", "shuffle", "(", "self", ".", "idx", ")", "for", "buck", "in", "self", ".", "data", ":", "np", ".", "random", ".", "shuffle", "(", "buck", ")" ]

[ "def", "set_position", "(", "self", ",", "x", ",", "y", ",", "speed", "=", "None", ")", ":", "if", "speed", ":", "self", ".", "_intf", ".", "write", "(", "'MoveChuckSubsite %1.1f %1.1f R Y %d'", "%", "(", "x", ",", "y", ",", "speed", ")", ")", "else", ":", "self", ".", "_intf", ".", "write", "(", "'MoveChuckSubsite %1.1f %1.1f R Y'", "%", "(", "x", ",", "y", ")", ")" ]