Datasets:

tomekkorbak

/

code_search_data-pep8

like 0

[ "def", "post_data", "(", "api_key", "=", "None", ",", "name", "=", "'OpsGenie Execution Module'", ",", "reason", "=", "None", ",", "action_type", "=", "None", ")", ":", "if", "api_key", "is", "None", "or", "reason", "is", "None", ":", "raise", "salt", ".", "exceptions", ".", "SaltInvocationError", "(", "'API Key or Reason cannot be None.'", ")", "data", "=", "dict", "(", ")", "data", "[", "'alias'", "]", "=", "name", "data", "[", "'message'", "]", "=", "reason", "# data['actions'] = action_type", "data", "[", "'cpuModel'", "]", "=", "__grains__", "[", "'cpu_model'", "]", "data", "[", "'cpuArch'", "]", "=", "__grains__", "[", "'cpuarch'", "]", "data", "[", "'fqdn'", "]", "=", "__grains__", "[", "'fqdn'", "]", "data", "[", "'host'", "]", "=", "__grains__", "[", "'host'", "]", "data", "[", "'id'", "]", "=", "__grains__", "[", "'id'", "]", "data", "[", "'kernel'", "]", "=", "__grains__", "[", "'kernel'", "]", "data", "[", "'kernelRelease'", "]", "=", "__grains__", "[", "'kernelrelease'", "]", "data", "[", "'master'", "]", "=", "__grains__", "[", "'master'", "]", "data", "[", "'os'", "]", "=", "__grains__", "[", "'os'", "]", "data", "[", "'saltPath'", "]", "=", "__grains__", "[", "'saltpath'", "]", "data", "[", "'saltVersion'", "]", "=", "__grains__", "[", "'saltversion'", "]", "data", "[", "'username'", "]", "=", "__grains__", "[", "'username'", "]", "data", "[", "'uuid'", "]", "=", "__grains__", "[", "'uuid'", "]", "log", ".", "debug", "(", "'Below data will be posted:\\n%s'", ",", "data", ")", "log", ".", "debug", "(", "'API Key: %s \\t API Endpoint: %s'", ",", "api_key", ",", "API_ENDPOINT", ")", "if", "action_type", "==", "\"Create\"", ":", "response", "=", "requests", ".", "post", "(", "url", "=", "API_ENDPOINT", ",", "data", "=", "salt", ".", "utils", ".", "json", ".", "dumps", "(", "data", ")", ",", "headers", "=", "{", "'Content-Type'", ":", "'application/json'", ",", "'Authorization'", ":", "'GenieKey '", "+", "api_key", "}", ")", "else", ":", "response", "=", "requests", ".", "post", "(", "url", "=", "API_ENDPOINT", "+", "\"/\"", "+", "name", "+", "\"/close?identifierType=alias\"", ",", "data", "=", "salt", ".", "utils", ".", "json", ".", "dumps", "(", "data", ")", ",", "headers", "=", "{", "'Content-Type'", ":", "'application/json'", ",", "'Authorization'", ":", "'GenieKey '", "+", "api_key", "}", ")", "return", "response", ".", "status_code", ",", "response", ".", "text" ]

[ "Post", "data", "to", "OpsGenie", ".", "It", "s", "designed", "for", "Salt", "s", "Event", "Reactor", "." ]

[ "def", "get_state_id_for_port", "(", "port", ")", ":", "parent", "=", "port", ".", "parent", "from", "rafcon", ".", "gui", ".", "mygaphas", ".", "items", ".", "state", "import", "StateView", "if", "isinstance", "(", "parent", ",", "StateView", ")", ":", "return", "parent", ".", "model", ".", "state", ".", "state_id" ]

[ "This", "method", "returns", "the", "state", "ID", "of", "the", "state", "containing", "the", "given", "port" ]

[ "def", "connect_to_database_odbc_mysql", "(", "self", ",", "database", ":", "str", ",", "user", ":", "str", ",", "password", ":", "str", ",", "server", ":", "str", "=", "\"localhost\"", ",", "port", ":", "int", "=", "3306", ",", "driver", ":", "str", "=", "\"{MySQL ODBC 5.1 Driver}\"", ",", "autocommit", ":", "bool", "=", "True", ")", "->", "None", ":", "self", ".", "connect", "(", "engine", "=", "ENGINE_MYSQL", ",", "interface", "=", "INTERFACE_ODBC", ",", "database", "=", "database", ",", "user", "=", "user", ",", "password", "=", "password", ",", "host", "=", "server", ",", "port", "=", "port", ",", "driver", "=", "driver", ",", "autocommit", "=", "autocommit", ")" ]

[ "Connects", "to", "a", "MySQL", "database", "via", "ODBC", "." ]

[ "def", "get_auth_server_name", "(", "host_override", "=", "None", ",", "port_override", "=", "None", ",", "protocol", "=", "'https'", ")", ":", "if", "host_override", "is", "not", "None", "or", "port_override", "is", "not", "None", ":", "if", "host_override", "is", "None", "or", "port_override", "is", "None", ":", "raise", "exceptions", ".", "DXError", "(", "\"Both host and port must be specified if either is specified\"", ")", "return", "protocol", "+", "'://'", "+", "host_override", "+", "':'", "+", "str", "(", "port_override", ")", "elif", "APISERVER_HOST", "==", "'stagingapi.dnanexus.com'", ":", "return", "'https://stagingauth.dnanexus.com'", "elif", "APISERVER_HOST", "==", "'api.dnanexus.com'", ":", "return", "'https://auth.dnanexus.com'", "elif", "APISERVER_HOST", "==", "'stagingapi.cn.dnanexus.com'", ":", "return", "'https://stagingauth.cn.dnanexus.com:7001'", "elif", "APISERVER_HOST", "==", "'api.cn.dnanexus.com'", ":", "return", "'https://auth.cn.dnanexus.com:8001'", "elif", "APISERVER_HOST", "==", "\"localhost\"", "or", "APISERVER_HOST", "==", "\"127.0.0.1\"", ":", "if", "\"DX_AUTHSERVER_HOST\"", "not", "in", "os", ".", "environ", "or", "\"DX_AUTHSERVER_PORT\"", "not", "in", "os", ".", "environ", ":", "err_msg", "=", "\"Must set authserver env vars (DX_AUTHSERVER_HOST, DX_AUTHSERVER_PORT) if apiserver is {apiserver}.\"", "raise", "exceptions", ".", "DXError", "(", "err_msg", ".", "format", "(", "apiserver", "=", "APISERVER_HOST", ")", ")", "else", ":", "return", "os", ".", "environ", "[", "\"DX_AUTHSERVER_HOST\"", "]", "+", "\":\"", "+", "os", ".", "environ", "[", "\"DX_AUTHSERVER_PORT\"", "]", "else", ":", "err_msg", "=", "\"Could not determine which auth server is associated with {apiserver}.\"", "raise", "exceptions", ".", "DXError", "(", "err_msg", ".", "format", "(", "apiserver", "=", "APISERVER_HOST", ")", ")" ]

[ "Chooses", "the", "auth", "server", "name", "from", "the", "currently", "configured", "API", "server", "name", "." ]

[ "def", "ImportConfig", "(", "filename", ",", "config", ")", ":", "sections_to_import", "=", "[", "\"PrivateKeys\"", "]", "entries_to_import", "=", "[", "\"Client.executable_signing_public_key\"", ",", "\"CA.certificate\"", ",", "\"Frontend.certificate\"", "]", "options_imported", "=", "0", "old_config", "=", "grr_config", ".", "CONFIG", ".", "MakeNewConfig", "(", ")", "old_config", ".", "Initialize", "(", "filename", ")", "for", "entry", "in", "old_config", ".", "raw_data", ":", "try", ":", "section", "=", "entry", ".", "split", "(", "\".\"", ")", "[", "0", "]", "if", "section", "in", "sections_to_import", "or", "entry", "in", "entries_to_import", ":", "config", ".", "Set", "(", "entry", ",", "old_config", ".", "Get", "(", "entry", ")", ")", "print", "(", "\"Imported %s.\"", "%", "entry", ")", "options_imported", "+=", "1", "except", "Exception", "as", "e", ":", "# pylint: disable=broad-except", "print", "(", "\"Exception during import of %s: %s\"", "%", "(", "entry", ",", "e", ")", ")", "return", "options_imported" ]

[ "Reads", "an", "old", "config", "file", "and", "imports", "keys", "and", "user", "accounts", "." ]

[ "def", "dump_xearth_markers", "(", "markers", ",", "name", "=", "'identifier'", ")", ":", "output", "=", "[", "]", "for", "identifier", ",", "point", "in", "markers", ".", "items", "(", ")", ":", "line", "=", "[", "'%f %f '", "%", "(", "point", ".", "latitude", ",", "point", ".", "longitude", ")", ",", "]", "if", "hasattr", "(", "point", ",", "'name'", ")", "and", "point", ".", "name", ":", "if", "name", "==", "'identifier'", ":", "line", ".", "append", "(", "'\"%s\" # %s'", "%", "(", "identifier", ",", "point", ".", "name", ")", ")", "elif", "name", "==", "'name'", ":", "line", ".", "append", "(", "'\"%s\" # %s'", "%", "(", "point", ".", "name", ",", "identifier", ")", ")", "elif", "name", "==", "'comment'", ":", "line", ".", "append", "(", "'\"%s\" # %s'", "%", "(", "identifier", ",", "point", ".", "comment", ")", ")", "else", ":", "raise", "ValueError", "(", "'Unknown name type %r'", "%", "name", ")", "if", "hasattr", "(", "point", ",", "'altitude'", ")", "and", "point", ".", "altitude", ":", "line", ".", "append", "(", "', alt %im'", "%", "point", ".", "altitude", ")", "else", ":", "line", ".", "append", "(", "'\"%s\"'", "%", "identifier", ")", "output", ".", "append", "(", "''", ".", "join", "(", "line", ")", ")", "# Return the list sorted on the marker name", "return", "sorted", "(", "output", ",", "key", "=", "lambda", "x", ":", "x", ".", "split", "(", ")", "[", "2", "]", ")" ]

[ "Generate", "an", "Xearth", "compatible", "marker", "file", "." ]

[ "def", "doeqdi", "(", "x", ",", "y", ",", "UP", "=", "False", ")", ":", "xp", ",", "yp", "=", "y", ",", "x", "# need to switch into geographic convention", "r", "=", "np", ".", "sqrt", "(", "xp", "**", "2", "+", "yp", "**", "2", ")", "z", "=", "1.", "-", "r", "**", "2", "t", "=", "np", ".", "arcsin", "(", "z", ")", "if", "UP", "==", "1", ":", "t", "=", "-", "t", "p", "=", "np", ".", "arctan2", "(", "yp", ",", "xp", ")", "dec", ",", "inc", "=", "np", ".", "degrees", "(", "p", ")", "%", "360", ",", "np", ".", "degrees", "(", "t", ")", "return", "dec", ",", "inc" ]

[ "Takes", "digitized", "x", "y", "data", "and", "returns", "the", "dec", "inc", "assuming", "an", "equal", "area", "projection", "Parameters", "__________________", "x", ":", "array", "of", "digitized", "x", "from", "point", "on", "equal", "area", "projection", "y", ":", "array", "of", "igitized", "y", "from", "point", "on", "equal", "area", "projection", "UP", ":", "if", "True", "is", "an", "upper", "hemisphere", "projection", "Output", ":", "dec", ":", "declination", "inc", ":", "inclination" ]

[ "def", "prepare", "(", "self", ",", "dataframe", ")", ":", "mapping", "=", "DataFrameMapCreator", "(", ")", ".", "get_mapping_from_config", "(", "self", ".", "__config", ")", "self", ".", "__mapper", "=", "DataFrameMapper", "(", "mapping", ")", "train", ",", "test", "=", "split_dataframe_train_test", "(", "dataframe", ",", "self", ".", "__config", ".", "get_option_parameter", "(", "\"split\"", ",", "\"train_percentage\"", ")", ")", "return", "self", ".", "__get_correct_return_parameters", "(", "train", ",", "test", ")" ]

[ "Takes", "the", "already", "cleaned", "dataframe", "splits", "it", "into", "train", "and", "test", "and", "returns", "the", "train", "and", "test", "as", "numpy", "arrays", ".", "If", "the", "problem", "is", "supervised", "the", "target", "column", "will", "be", "that", "last", "one", "of", "the", "returned", "arrays", "." ]

[ "def", "display_boxes", "(", "self", ",", "tree", ",", "html_path", ",", "filename_prefix", ",", "alternate_colors", "=", "False", ")", ":", "imgs", "=", "[", "]", "colors", "=", "{", "\"section_header\"", ":", "Color", "(", "\"blue\"", ")", ",", "\"figure\"", ":", "Color", "(", "\"green\"", ")", ",", "\"figure_caption\"", ":", "Color", "(", "\"green\"", ")", ",", "\"table_caption\"", ":", "Color", "(", "\"red\"", ")", ",", "\"list\"", ":", "Color", "(", "\"yellow\"", ")", ",", "\"paragraph\"", ":", "Color", "(", "\"gray\"", ")", ",", "\"table\"", ":", "Color", "(", "\"red\"", ")", ",", "\"header\"", ":", "Color", "(", "\"brown\"", ")", ",", "}", "for", "i", ",", "page_num", "in", "enumerate", "(", "tree", ".", "keys", "(", ")", ")", ":", "img", "=", "self", ".", "pdf_to_img", "(", "page_num", ")", "draw", "=", "Drawing", "(", ")", "draw", ".", "fill_color", "=", "Color", "(", "\"rgba(0, 0, 0, 0.0)\"", ")", "for", "clust", "in", "tree", "[", "page_num", "]", ":", "for", "(", "pnum", ",", "pwidth", ",", "pheight", ",", "top", ",", "left", ",", "bottom", ",", "right", ")", "in", "tree", "[", "page_num", "]", "[", "clust", "]", ":", "draw", ".", "stroke_color", "=", "colors", "[", "clust", "]", "draw", ".", "rectangle", "(", "left", "=", "left", ",", "top", "=", "top", ",", "right", "=", "right", ",", "bottom", "=", "bottom", ")", "draw", ".", "push", "(", ")", "draw", ".", "font_size", "=", "20", "draw", ".", "font_weight", "=", "10", "draw", ".", "fill_color", "=", "colors", "[", "clust", "]", "if", "int", "(", "left", ")", ">", "0", "and", "int", "(", "top", ")", ">", "0", ":", "draw", ".", "text", "(", "x", "=", "int", "(", "left", ")", ",", "y", "=", "int", "(", "top", ")", ",", "body", "=", "clust", ")", "draw", ".", "pop", "(", ")", "draw", "(", "img", ")", "img", ".", "save", "(", "filename", "=", "html_path", "+", "filename_prefix", "+", "\"_page_\"", "+", "str", "(", "i", ")", "+", "\".png\"", ")", "imgs", ".", "append", "(", "img", ")", "return", "imgs" ]

[ "Displays", "each", "of", "the", "bounding", "boxes", "passed", "in", "boxes", "on", "images", "of", "the", "pdf", "pointed", "to", "by", "pdf_file", "boxes", "is", "a", "list", "of", "5", "-", "tuples", "(", "page", "top", "left", "bottom", "right", ")" ]

[ "def", "request", "(", "url", ",", "method", "=", "\"GET\"", ",", "params", "=", "None", ",", "data", "=", "None", ",", "headers", "=", "{", "}", ",", "timeout", "=", "None", ",", "files", "=", "{", "}", ",", "randua", "=", "False", ",", "auth", "=", "None", ",", "length_limit", "=", "None", ",", "proxies", "=", "None", ",", "trust_env", "=", "True", ",", "max_redirects", "=", "0", ",", "source_address", "=", "None", ",", "*", "*", "kwargs", ")", ":", "def", "make_connection", "(", "conn_type", ",", "host", ",", "port", ",", "timeout", ",", "source_address", ")", ":", "\"\"\"Return HTTP or HTTPS connection.\"\"\"", "if", "support_source_address", ":", "kwargs", "=", "{", "'timeout'", ":", "timeout", ",", "'source_address'", ":", "source_address", "}", "else", ":", "kwargs", "=", "{", "'timeout'", ":", "timeout", "}", "if", "source_address", "is", "not", "None", ":", "raise", "UrlfetchException", "(", "'source_address requires'", "'Python 2.7/3.2 or newer versions'", ")", "if", "conn_type", "==", "'http'", ":", "conn", "=", "HTTPConnection", "(", "host", ",", "port", ",", "*", "*", "kwargs", ")", "elif", "conn_type", "==", "'https'", ":", "conn", "=", "HTTPSConnection", "(", "host", ",", "port", ",", "*", "*", "kwargs", ")", "else", ":", "raise", "URLError", "(", "'Unknown Connection Type: %s'", "%", "conn_type", ")", "return", "conn", "via_proxy", "=", "False", "method", "=", "method", ".", "upper", "(", ")", "if", "method", "not", "in", "ALLOWED_METHODS", ":", "raise", "UrlfetchException", "(", "\"Method should be one of \"", "+", "\", \"", ".", "join", "(", "ALLOWED_METHODS", ")", ")", "if", "params", ":", "if", "isinstance", "(", "params", ",", "dict", ")", ":", "url", "=", "url_concat", "(", "url", ",", "params", ")", "elif", "isinstance", "(", "params", ",", "basestring", ")", ":", "if", "url", "[", "-", "1", "]", "not", "in", "(", "'?'", ",", "'&'", ")", ":", "url", "+=", "'&'", "if", "(", "'?'", "in", "url", ")", "else", "'?'", "url", "+=", "params", "parsed_url", "=", "parse_url", "(", "url", ")", "reqheaders", "=", "{", "'Accept'", ":", "'*/*'", ",", "'Accept-Encoding'", ":", "'gzip, deflate, compress, identity, *'", ",", "'User-Agent'", ":", "random_useragent", "(", "randua", ")", ",", "'Host'", ":", "parsed_url", "[", "'http_host'", "]", "}", "# Proxy support", "scheme", "=", "parsed_url", "[", "'scheme'", "]", "if", "proxies", "is", "None", "and", "trust_env", ":", "proxies", "=", "PROXIES", "ignore_hosts", "=", "PROXY_IGNORE_HOSTS", "if", "trust_env", ":", "no_proxy", "=", "os", ".", "getenv", "(", "'no_proxy'", ")", "or", "os", ".", "getenv", "(", "'NO_PROXY'", ")", "if", "no_proxy", ":", "ignore_hosts", "=", "no_proxy", ".", "split", "(", "\",\"", ")", "proxy", "=", "proxies", ".", "get", "(", "scheme", ")", "if", "proxy", "and", "not", "any", "(", "match_no_proxy", "(", "parsed_url", "[", "'host'", "]", ",", "host", ")", "for", "host", "in", "ignore_hosts", ")", ":", "via_proxy", "=", "True", "if", "'://'", "not", "in", "proxy", ":", "proxy", "=", "'%s://%s'", "%", "(", "scheme", ",", "proxy", ")", "parsed_proxy", "=", "parse_url", "(", "proxy", ")", "# Proxy-Authorization", "if", "parsed_proxy", "[", "'username'", "]", "and", "parsed_proxy", "[", "'password'", "]", ":", "proxyauth", "=", "'%s:%s'", "%", "(", "parsed_proxy", "[", "'username'", "]", ",", "parsed_proxy", "[", "'password'", "]", ")", "proxyauth", "=", "base64", ".", "b64encode", "(", "proxyauth", ".", "encode", "(", "'utf-8'", ")", ")", "reqheaders", "[", "'Proxy-Authorization'", "]", "=", "'Basic '", "+", "proxyauth", ".", "decode", "(", "'utf-8'", ")", "conn", "=", "make_connection", "(", "scheme", ",", "parsed_proxy", "[", "'host'", "]", ",", "parsed_proxy", "[", "'port'", "]", ",", "timeout", ",", "source_address", ")", "else", ":", "conn", "=", "make_connection", "(", "scheme", ",", "parsed_url", "[", "'host'", "]", ",", "parsed_url", "[", "'port'", "]", ",", "timeout", ",", "source_address", ")", "if", "not", "auth", "and", "parsed_url", "[", "'username'", "]", "and", "parsed_url", "[", "'password'", "]", ":", "auth", "=", "(", "parsed_url", "[", "'username'", "]", ",", "parsed_url", "[", "'password'", "]", ")", "if", "auth", ":", "if", "isinstance", "(", "auth", ",", "(", "list", ",", "tuple", ")", ")", ":", "auth", "=", "'%s:%s'", "%", "tuple", "(", "auth", ")", "auth", "=", "base64", ".", "b64encode", "(", "auth", ".", "encode", "(", "'utf-8'", ")", ")", "reqheaders", "[", "'Authorization'", "]", "=", "'Basic '", "+", "auth", ".", "decode", "(", "'utf-8'", ")", "if", "files", ":", "content_type", ",", "data", "=", "encode_multipart", "(", "data", ",", "files", ")", "reqheaders", "[", "'Content-Type'", "]", "=", "content_type", "elif", "isinstance", "(", "data", ",", "dict", ")", ":", "data", "=", "urlencode", "(", "data", ",", "1", ")", "if", "isinstance", "(", "data", ",", "basestring", ")", "and", "not", "files", ":", "# httplib will set 'Content-Length', also you can set it by yourself", "reqheaders", "[", "\"Content-Type\"", "]", "=", "\"application/x-www-form-urlencoded\"", "# what if the method is GET, HEAD or DELETE", "# just do not make so much decisions for users", "reqheaders", ".", "update", "(", "headers", ")", "start_time", "=", "time", ".", "time", "(", ")", "try", ":", "request_url", "=", "url", "if", "via_proxy", "else", "parsed_url", "[", "'uri'", "]", "conn", ".", "request", "(", "method", ",", "request_url", ",", "data", ",", "reqheaders", ")", "resp", "=", "conn", ".", "getresponse", "(", ")", "except", "socket", ".", "timeout", "as", "e", ":", "raise", "Timeout", "(", "e", ")", "except", "Exception", "as", "e", ":", "raise", "UrlfetchException", "(", "e", ")", "end_time", "=", "time", ".", "time", "(", ")", "total_time", "=", "end_time", "-", "start_time", "history", "=", "[", "]", "response", "=", "Response", ".", "from_httplib", "(", "resp", ",", "reqheaders", "=", "reqheaders", ",", "length_limit", "=", "length_limit", ",", "history", "=", "history", "[", ":", "]", ",", "url", "=", "url", ",", "total_time", "=", "total_time", ",", "start_time", "=", "start_time", ")", "while", "(", "response", ".", "status", "in", "(", "301", ",", "302", ",", "303", ",", "307", ")", "and", "'location'", "in", "response", ".", "headers", "and", "max_redirects", ")", ":", "response", ".", "body", ",", "response", ".", "close", "(", ")", ",", "history", ".", "append", "(", "response", ")", "if", "len", "(", "history", ")", ">", "max_redirects", ":", "raise", "TooManyRedirects", "(", "'max_redirects exceeded'", ")", "method", "=", "method", "if", "response", ".", "status", "==", "307", "else", "'GET'", "location", "=", "response", ".", "headers", "[", "'location'", "]", "if", "location", "[", ":", "2", "]", "==", "'//'", ":", "url", "=", "parsed_url", "[", "'scheme'", "]", "+", "':'", "+", "location", "else", ":", "url", "=", "urlparse", ".", "urljoin", "(", "url", ",", "location", ")", "parsed_url", "=", "parse_url", "(", "url", ")", "reqheaders", "[", "'Host'", "]", "=", "parsed_url", "[", "'http_host'", "]", "reqheaders", "[", "'Referer'", "]", "=", "response", ".", "url", "# Proxy", "scheme", "=", "parsed_url", "[", "'scheme'", "]", "proxy", "=", "proxies", ".", "get", "(", "scheme", ")", "if", "proxy", "and", "parsed_url", "[", "'host'", "]", "not", "in", "PROXY_IGNORE_HOSTS", ":", "via_proxy", "=", "True", "if", "'://'", "not", "in", "proxy", ":", "proxy", "=", "'%s://%s'", "%", "(", "parsed_url", "[", "'scheme'", "]", ",", "proxy", ")", "parsed_proxy", "=", "parse_url", "(", "proxy", ")", "# Proxy-Authorization", "if", "parsed_proxy", "[", "'username'", "]", "and", "parsed_proxy", "[", "'password'", "]", ":", "proxyauth", "=", "'%s:%s'", "%", "(", "parsed_proxy", "[", "'username'", "]", ",", "parsed_proxy", "[", "'username'", "]", ")", "proxyauth", "=", "base64", ".", "b64encode", "(", "proxyauth", ".", "encode", "(", "'utf-8'", ")", ")", "reqheaders", "[", "'Proxy-Authorization'", "]", "=", "'Basic '", "+", "proxyauth", ".", "decode", "(", "'utf-8'", ")", "conn", "=", "make_connection", "(", "scheme", ",", "parsed_proxy", "[", "'host'", "]", ",", "parsed_proxy", "[", "'port'", "]", ",", "timeout", ",", "source_address", ")", "else", ":", "via_proxy", "=", "False", "reqheaders", ".", "pop", "(", "'Proxy-Authorization'", ",", "None", ")", "conn", "=", "make_connection", "(", "scheme", ",", "parsed_url", "[", "'host'", "]", ",", "parsed_url", "[", "'port'", "]", ",", "timeout", ",", "source_address", ")", "try", ":", "request_url", "=", "url", "if", "via_proxy", "else", "parsed_url", "[", "'uri'", "]", "conn", ".", "request", "(", "method", ",", "request_url", ",", "data", ",", "reqheaders", ")", "resp", "=", "conn", ".", "getresponse", "(", ")", "except", "socket", ".", "timeout", "as", "e", ":", "raise", "Timeout", "(", "e", ")", "except", "Exception", "as", "e", ":", "raise", "UrlfetchException", "(", "e", ")", "response", "=", "Response", ".", "from_httplib", "(", "resp", ",", "reqheaders", "=", "reqheaders", ",", "length_limit", "=", "length_limit", ",", "history", "=", "history", "[", ":", "]", ",", "url", "=", "url", ",", "total_time", "=", "total_time", ",", "start_time", "=", "start_time", ")", "return", "response" ]

[ "request", "an", "URL" ]

[ "def", "console_save_apf", "(", "con", ":", "tcod", ".", "console", ".", "Console", ",", "filename", ":", "str", ")", "->", "bool", ":", "return", "bool", "(", "lib", ".", "TCOD_console_save_apf", "(", "_console", "(", "con", ")", ",", "filename", ".", "encode", "(", "\"utf-8\"", ")", ")", ")" ]

[ "Save", "a", "console", "to", "an", "ASCII", "Paint", ".", "apf", "file", "." ]

[ "def", "elmo_2x1024_128_2048cnn_1xhighway", "(", "dataset_name", "=", "None", ",", "pretrained", "=", "False", ",", "ctx", "=", "mx", ".", "cpu", "(", ")", ",", "root", "=", "os", ".", "path", ".", "join", "(", "get_home_dir", "(", ")", ",", "'models'", ")", ",", "*", "*", "kwargs", ")", ":", "predefined_args", "=", "{", "'rnn_type'", ":", "'lstmpc'", ",", "'output_size'", ":", "128", ",", "'filters'", ":", "[", "[", "1", ",", "32", "]", ",", "[", "2", ",", "32", "]", ",", "[", "3", ",", "64", "]", ",", "[", "4", ",", "128", "]", ",", "[", "5", ",", "256", "]", ",", "[", "6", ",", "512", "]", ",", "[", "7", ",", "1024", "]", "]", ",", "'char_embed_size'", ":", "16", ",", "'num_highway'", ":", "1", ",", "'conv_layer_activation'", ":", "'relu'", ",", "'max_chars_per_token'", ":", "50", ",", "'input_size'", ":", "128", ",", "'hidden_size'", ":", "1024", ",", "'proj_size'", ":", "128", ",", "'num_layers'", ":", "2", ",", "'cell_clip'", ":", "3", ",", "'proj_clip'", ":", "3", ",", "'skip_connection'", ":", "True", "}", "assert", "all", "(", "(", "k", "not", "in", "kwargs", ")", "for", "k", "in", "predefined_args", ")", ",", "'Cannot override predefined model settings.'", "predefined_args", ".", "update", "(", "kwargs", ")", "return", "_get_elmo_model", "(", "ELMoBiLM", ",", "'elmo_2x1024_128_2048cnn_1xhighway'", ",", "dataset_name", ",", "pretrained", ",", "ctx", ",", "root", ",", "*", "*", "predefined_args", ")" ]

[ "r", "ELMo", "2", "-", "layer", "BiLSTM", "with", "1024", "hidden", "units", "128", "projection", "size", "1", "highway", "layer", "." ]

[ "def", "init_datapackage", "(", "resource_paths", ")", ":", "dp", "=", "datapackage", ".", "Package", "(", "{", "'name'", ":", "'change-me'", ",", "'schema'", ":", "'tabular-data-package'", ",", "}", ")", "for", "path", "in", "resource_paths", ":", "dp", ".", "infer", "(", "path", ")", "return", "dp" ]

[ "Create", "tabular", "data", "package", "with", "resources", "." ]

[ "def", "_create_kraus_pragmas", "(", "name", ",", "qubit_indices", ",", "kraus_ops", ")", ":", "pragmas", "=", "[", "Pragma", "(", "\"ADD-KRAUS\"", ",", "[", "name", "]", "+", "list", "(", "qubit_indices", ")", ",", "\"({})\"", ".", "format", "(", "\" \"", ".", "join", "(", "map", "(", "format_parameter", ",", "np", ".", "ravel", "(", "k", ")", ")", ")", ")", ")", "for", "k", "in", "kraus_ops", "]", "return", "pragmas" ]

[ "Generate", "the", "pragmas", "to", "define", "a", "Kraus", "map", "for", "a", "specific", "gate", "on", "some", "qubits", "." ]

[ "def", "get_client", "(", "self", ",", "destination_params", ",", "job_id", ",", "*", "*", "kwargs", ")", ":", "destination_params", "=", "_parse_destination_params", "(", "destination_params", ")", "destination_params", ".", "update", "(", "*", "*", "kwargs", ")", "job_manager_interface_class", "=", "self", ".", "job_manager_interface_class", "job_manager_interface_args", "=", "dict", "(", "destination_params", "=", "destination_params", ",", "*", "*", "self", ".", "job_manager_interface_args", ")", "job_manager_interface", "=", "job_manager_interface_class", "(", "*", "*", "job_manager_interface_args", ")", "return", "self", ".", "client_class", "(", "destination_params", ",", "job_id", ",", "job_manager_interface", ",", "*", "*", "self", ".", "extra_client_kwds", ")" ]

[ "Build", "a", "client", "given", "specific", "destination", "parameters", "and", "job_id", "." ]

[ "def", "_mark_unknowns", "(", "self", ")", ":", "for", "obj", "in", "self", ".", "project", ".", "loader", ".", "all_objects", ":", "if", "isinstance", "(", "obj", ",", "cle", ".", "ELF", ")", ":", "# sections?", "if", "obj", ".", "sections", ":", "for", "section", "in", "obj", ".", "sections", ":", "if", "not", "section", ".", "memsize", "or", "not", "section", ".", "vaddr", ":", "continue", "min_addr", ",", "max_addr", "=", "section", ".", "min_addr", ",", "section", ".", "max_addr", "self", ".", "_mark_unknowns_core", "(", "min_addr", ",", "max_addr", "+", "1", ",", "obj", "=", "obj", ",", "section", "=", "section", ")", "elif", "obj", ".", "segments", ":", "for", "segment", "in", "obj", ".", "segments", ":", "if", "not", "segment", ".", "memsize", ":", "continue", "min_addr", ",", "max_addr", "=", "segment", ".", "min_addr", ",", "segment", ".", "max_addr", "self", ".", "_mark_unknowns_core", "(", "min_addr", ",", "max_addr", "+", "1", ",", "obj", "=", "obj", ",", "segment", "=", "segment", ")", "else", ":", "# is it empty?", "_l", ".", "warning", "(", "\"Empty ELF object %s.\"", ",", "repr", "(", "obj", ")", ")", "elif", "isinstance", "(", "obj", ",", "cle", ".", "PE", ")", ":", "if", "obj", ".", "sections", ":", "for", "section", "in", "obj", ".", "sections", ":", "if", "not", "section", ".", "memsize", ":", "continue", "min_addr", ",", "max_addr", "=", "section", ".", "min_addr", ",", "section", ".", "max_addr", "self", ".", "_mark_unknowns_core", "(", "min_addr", ",", "max_addr", "+", "1", ",", "obj", "=", "obj", ",", "section", "=", "section", ")", "else", ":", "# is it empty?", "_l", ".", "warning", "(", "\"Empty PE object %s.\"", ",", "repr", "(", "obj", ")", ")", "else", ":", "min_addr", ",", "max_addr", "=", "obj", ".", "min_addr", ",", "obj", ".", "max_addr", "self", ".", "_mark_unknowns_core", "(", "min_addr", ",", "max_addr", "+", "1", ",", "obj", "=", "obj", ")" ]

[ "Mark", "all", "unmapped", "regions", "." ]

[ "def", "GetChunk", "(", "time", ",", "breakpoints", ",", "b", ",", "mask", "=", "[", "]", ")", ":", "M", "=", "np", ".", "delete", "(", "np", ".", "arange", "(", "len", "(", "time", ")", ")", ",", "mask", ",", "axis", "=", "0", ")", "if", "b", ">", "0", ":", "res", "=", "M", "[", "(", "M", ">", "breakpoints", "[", "b", "-", "1", "]", ")", "&", "(", "M", "<=", "breakpoints", "[", "b", "]", ")", "]", "else", ":", "res", "=", "M", "[", "M", "<=", "breakpoints", "[", "b", "]", "]", "return", "res" ]

[ "Returns", "the", "indices", "corresponding", "to", "a", "given", "light", "curve", "chunk", "." ]

[ "def", "unquote_unreserved", "(", "uri", ")", ":", "parts", "=", "uri", ".", "split", "(", "'%'", ")", "for", "i", "in", "range", "(", "1", ",", "len", "(", "parts", ")", ")", ":", "h", "=", "parts", "[", "i", "]", "[", "0", ":", "2", "]", "if", "len", "(", "h", ")", "==", "2", "and", "h", ".", "isalnum", "(", ")", ":", "try", ":", "c", "=", "chr", "(", "int", "(", "h", ",", "16", ")", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "\"Invalid percent-escape sequence: '%s'\"", "%", "h", ")", "if", "c", "in", "UNRESERVED_SET", ":", "parts", "[", "i", "]", "=", "c", "+", "parts", "[", "i", "]", "[", "2", ":", "]", "else", ":", "parts", "[", "i", "]", "=", "'%'", "+", "parts", "[", "i", "]", "else", ":", "parts", "[", "i", "]", "=", "'%'", "+", "parts", "[", "i", "]", "return", "''", ".", "join", "(", "parts", ")" ]

[ "Un", "-", "escape", "any", "percent", "-", "escape", "sequences", "in", "a", "URI", "that", "are", "unreserved", "characters", ".", "This", "leaves", "all", "reserved", "illegal", "and", "non", "-", "ASCII", "bytes", "encoded", ".", ":", "rtype", ":", "str" ]

[ "def", "_winreg_getShellFolder", "(", "name", ")", ":", "k", "=", "_winreg", ".", "OpenKey", "(", "_winreg", ".", "HKEY_CURRENT_USER", ",", "r\"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders\"", ")", "try", ":", "# should check that it's valid? How?", "return", "_winreg", ".", "QueryValueEx", "(", "k", ",", "name", ")", "[", "0", "]", "finally", ":", "_winreg", ".", "CloseKey", "(", "k", ")" ]

[ "Get", "a", "shell", "folder", "by", "string", "name", "from", "the", "registry" ]

[ "def", "_read_n_samples", "(", "channel_file", ")", ":", "n_blocks", "=", "int", "(", "(", "channel_file", ".", "stat", "(", ")", ".", "st_size", "-", "HDR_LENGTH", ")", "/", "BLK_SIZE", ")", "n_samples", "=", "n_blocks", "*", "BLK_LENGTH", "return", "n_blocks", ",", "n_samples" ]

[ "Calculate", "the", "number", "of", "samples", "based", "on", "the", "file", "size" ]

[ "def", "set_by_dotted_path", "(", "d", ",", "path", ",", "value", ")", ":", "split_path", "=", "path", ".", "split", "(", "'.'", ")", "current_option", "=", "d", "for", "p", "in", "split_path", "[", ":", "-", "1", "]", ":", "if", "p", "not", "in", "current_option", ":", "current_option", "[", "p", "]", "=", "dict", "(", ")", "current_option", "=", "current_option", "[", "p", "]", "current_option", "[", "split_path", "[", "-", "1", "]", "]", "=", "value" ]

[ "Set", "an", "entry", "in", "a", "nested", "dict", "using", "a", "dotted", "path", "." ]

[ "def", "_start_http_session", "(", "self", ")", ":", "api_logger", ".", "debug", "(", "\"Starting new HTTP session...\"", ")", "self", ".", "session", "=", "FuturesSession", "(", "executor", "=", "self", ".", "executor", ",", "max_workers", "=", "self", ".", "max_workers", ")", "self", ".", "session", ".", "headers", ".", "update", "(", "{", "\"User-Agent\"", ":", "self", ".", "user_agent", "}", ")", "if", "self", ".", "username", "and", "self", ".", "password", ":", "api_logger", ".", "debug", "(", "\"Requests will use authorization.\"", ")", "self", ".", "session", ".", "auth", "=", "HTTPBasicAuth", "(", "self", ".", "username", ",", "self", ".", "password", ")" ]

[ "Start", "a", "new", "requests", "HTTP", "session", "clearing", "cookies", "and", "session", "data", ".", ":", "return", ":", "None" ]

[ "def", "get_event", "(", "self", ",", "event_key", ")", ":", "event", "=", "self", ".", "event_key_map", ".", "get", "(", "event_key", ")", "if", "event", ":", "return", "event", "self", ".", "logger", ".", "error", "(", "'Event \"%s\" is not in datafile.'", "%", "event_key", ")", "self", ".", "error_handler", ".", "handle_error", "(", "exceptions", ".", "InvalidEventException", "(", "enums", ".", "Errors", ".", "INVALID_EVENT_KEY_ERROR", ")", ")", "return", "None" ]

[ "Get", "event", "for", "the", "provided", "event", "key", "." ]

[ "def", "extract_cells", "(", "self", ",", "ind", ")", ":", "if", "not", "isinstance", "(", "ind", ",", "np", ".", "ndarray", ")", ":", "ind", "=", "np", ".", "array", "(", "ind", ",", "np", ".", "ndarray", ")", "if", "ind", ".", "dtype", "==", "np", ".", "bool", ":", "ind", "=", "ind", ".", "nonzero", "(", ")", "[", "0", "]", ".", "astype", "(", "vtki", ".", "ID_TYPE", ")", "if", "ind", ".", "dtype", "!=", "vtki", ".", "ID_TYPE", ":", "ind", "=", "ind", ".", "astype", "(", "vtki", ".", "ID_TYPE", ")", "if", "not", "ind", ".", "flags", ".", "c_contiguous", ":", "ind", "=", "np", ".", "ascontiguousarray", "(", "ind", ")", "vtk_ind", "=", "numpy_to_vtkIdTypeArray", "(", "ind", ",", "deep", "=", "False", ")", "# Create selection objects", "selectionNode", "=", "vtk", ".", "vtkSelectionNode", "(", ")", "selectionNode", ".", "SetFieldType", "(", "vtk", ".", "vtkSelectionNode", ".", "CELL", ")", "selectionNode", ".", "SetContentType", "(", "vtk", ".", "vtkSelectionNode", ".", "INDICES", ")", "selectionNode", ".", "SetSelectionList", "(", "vtk_ind", ")", "selection", "=", "vtk", ".", "vtkSelection", "(", ")", "selection", ".", "AddNode", "(", "selectionNode", ")", "# extract", "extract_sel", "=", "vtk", ".", "vtkExtractSelection", "(", ")", "extract_sel", ".", "SetInputData", "(", "0", ",", "self", ")", "extract_sel", ".", "SetInputData", "(", "1", ",", "selection", ")", "extract_sel", ".", "Update", "(", ")", "subgrid", "=", "_get_output", "(", "extract_sel", ")", "# extracts only in float32", "if", "self", ".", "points", ".", "dtype", "is", "not", "np", ".", "dtype", "(", "'float32'", ")", ":", "ind", "=", "subgrid", ".", "point_arrays", "[", "'vtkOriginalPointIds'", "]", "subgrid", ".", "points", "=", "self", ".", "points", "[", "ind", "]", "return", "subgrid" ]

[ "Returns", "a", "subset", "of", "the", "grid" ]

[ "def", "get_content", "(", "self", ",", "force_download", "=", "False", ")", ":", "return", "self", ".", "client", ".", "get_document", "(", "self", ".", "url", "(", ")", ",", "force_download", ")" ]

[ "Retrieve", "the", "content", "for", "this", "Document", "from", "the", "server" ]

[ "def", "list_all", "(", "fritz", ",", "args", ")", ":", "devices", "=", "fritz", ".", "get_devices", "(", ")", "for", "device", "in", "devices", ":", "print", "(", "'#'", "*", "30", ")", "print", "(", "'name=%s'", "%", "device", ".", "name", ")", "print", "(", "' ain=%s'", "%", "device", ".", "ain", ")", "print", "(", "' id=%s'", "%", "device", ".", "identifier", ")", "print", "(", "' productname=%s'", "%", "device", ".", "productname", ")", "print", "(", "' manufacturer=%s'", "%", "device", ".", "manufacturer", ")", "print", "(", "\" present=%s\"", "%", "device", ".", "present", ")", "print", "(", "\" lock=%s\"", "%", "device", ".", "lock", ")", "print", "(", "\" devicelock=%s\"", "%", "device", ".", "device_lock", ")", "if", "device", ".", "present", "is", "False", ":", "continue", "if", "device", ".", "has_switch", ":", "print", "(", "\" Switch:\"", ")", "print", "(", "\" switch_state=%s\"", "%", "device", ".", "switch_state", ")", "if", "device", ".", "has_switch", ":", "print", "(", "\" Powermeter:\"", ")", "print", "(", "\" power=%s\"", "%", "device", ".", "power", ")", "print", "(", "\" energy=%s\"", "%", "device", ".", "energy", ")", "print", "(", "\" voltage=%s\"", "%", "device", ".", "voltage", ")", "if", "device", ".", "has_temperature_sensor", ":", "print", "(", "\" Temperature:\"", ")", "print", "(", "\" temperature=%s\"", "%", "device", ".", "temperature", ")", "print", "(", "\" offset=%s\"", "%", "device", ".", "offset", ")", "if", "device", ".", "has_thermostat", ":", "print", "(", "\" Thermostat:\"", ")", "print", "(", "\" battery_low=%s\"", "%", "device", ".", "battery_low", ")", "print", "(", "\" battery_level=%s\"", "%", "device", ".", "battery_level", ")", "print", "(", "\" actual=%s\"", "%", "device", ".", "actual_temperature", ")", "print", "(", "\" target=%s\"", "%", "device", ".", "target_temperature", ")", "print", "(", "\" comfort=%s\"", "%", "device", ".", "comfort_temperature", ")", "print", "(", "\" eco=%s\"", "%", "device", ".", "eco_temperature", ")", "print", "(", "\" window=%s\"", "%", "device", ".", "window_open", ")", "print", "(", "\" summer=%s\"", "%", "device", ".", "summer_active", ")", "print", "(", "\" holiday=%s\"", "%", "device", ".", "holiday_active", ")", "if", "device", ".", "has_alarm", ":", "print", "(", "\" Alert:\"", ")", "print", "(", "\" alert=%s\"", "%", "device", ".", "alert_state", ")" ]

[ "Command", "that", "prints", "all", "device", "information", "." ]

[ "def", "parse_PRIK", "(", "chunk", ",", "encryption_key", ")", ":", "decrypted", "=", "decode_aes256", "(", "'cbc'", ",", "encryption_key", "[", ":", "16", "]", ",", "decode_hex", "(", "chunk", ".", "payload", ")", ",", "encryption_key", ")", "hex_key", "=", "re", ".", "match", "(", "br'^LastPassPrivateKey<(?P<hex_key>.*)>LastPassPrivateKey$'", ",", "decrypted", ")", ".", "group", "(", "'hex_key'", ")", "rsa_key", "=", "RSA", ".", "importKey", "(", "decode_hex", "(", "hex_key", ")", ")", "rsa_key", ".", "dmp1", "=", "rsa_key", ".", "d", "%", "(", "rsa_key", ".", "p", "-", "1", ")", "rsa_key", ".", "dmq1", "=", "rsa_key", ".", "d", "%", "(", "rsa_key", ".", "q", "-", "1", ")", "rsa_key", ".", "iqmp", "=", "number", ".", "inverse", "(", "rsa_key", ".", "q", ",", "rsa_key", ".", "p", ")", "return", "rsa_key" ]

[ "Parse", "PRIK", "chunk", "which", "contains", "private", "RSA", "key" ]

[ "def", "search_file", "(", "search_root", ",", "search_filename", ",", "instance_relative_root", "=", "False", ")", ":", "if", "instance_relative_root", ":", "search_root", "=", "os", ".", "path", ".", "join", "(", "current_app", ".", "instance_path", ",", "search_root", ")", "file_path", "=", "None", "file_ext", "=", "None", "for", "file", "in", "os", ".", "listdir", "(", "search_root", ")", ":", "filename", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "file", ")", "if", "filename", "==", "search_filename", "and", "ext", "and", "ext", "!=", "'.'", ":", "file_path", "=", "os", ".", "path", ".", "join", "(", "search_root", ",", "filename", "+", "ext", ")", "file_ext", "=", "ext", "[", "1", ":", "]", "# remove heading '.' (dot)", "break", "return", "file_path", ",", "file_ext" ]

[ "Search", "for", "a", "filename", "in", "a", "specific", "search", "root", "dir", "." ]

[ "def", "parse_color", "(", "src", "=", "None", ")", ":", "# type: (Optional[str]) -> Optional[Union[Tuple[int, ...], int]]", "if", "src", "is", "None", ":", "return", "None", "# Tuple.", "if", "src", "[", "0", "]", "==", "\"(\"", ":", "rgba", "=", "tuple", "(", "int", "(", "v", ")", "for", "v", "in", "src", "[", "1", ":", "-", "1", "]", ".", "split", "(", "\",\"", ")", "if", "v", ")", "if", "not", "(", "len", "(", "rgba", ")", "==", "4", "and", "all", "(", "0", "<=", "v", "<", "256", "for", "v", "in", "rgba", ")", ")", ":", "raise", "ValueError", "(", "\"Broken color tuple: {}. Must have four values from 0 to 255.\"", ".", "format", "(", "src", ")", ")", "return", "rgba", "# Constant.", "return", "int", "(", "src", ")" ]

[ "Parse", "a", "string", "representing", "a", "color", "value", "." ]

[ "def", "add_evpn_local", "(", "route_type", ",", "route_dist", ",", "next_hop", ",", "*", "*", "kwargs", ")", ":", "if", "(", "route_type", "in", "[", "EVPN_ETH_AUTO_DISCOVERY", ",", "EVPN_ETH_SEGMENT", "]", "and", "kwargs", "[", "'esi'", "]", "==", "0", ")", ":", "raise", "ConfigValueError", "(", "conf_name", "=", "EVPN_ESI", ",", "conf_value", "=", "kwargs", "[", "'esi'", "]", ")", "try", ":", "# Create new path and insert into appropriate VRF table.", "tm", "=", "CORE_MANAGER", ".", "get_core_service", "(", ")", ".", "table_manager", "label", "=", "tm", ".", "update_vrf_table", "(", "route_dist", ",", "next_hop", "=", "next_hop", ",", "route_family", "=", "VRF_RF_L2_EVPN", ",", "route_type", "=", "route_type", ",", "*", "*", "kwargs", ")", "# Currently we only allocate one label per local route,", "# so we share first label from the list.", "if", "label", ":", "label", "=", "label", "[", "0", "]", "# Send success response with new label.", "return", "[", "{", "EVPN_ROUTE_TYPE", ":", "route_type", ",", "ROUTE_DISTINGUISHER", ":", "route_dist", ",", "VRF_RF", ":", "VRF_RF_L2_EVPN", ",", "VPN_LABEL", ":", "label", "}", ".", "update", "(", "kwargs", ")", "]", "except", "BgpCoreError", "as", "e", ":", "raise", "PrefixError", "(", "desc", "=", "e", ")" ]

[ "Adds", "EVPN", "route", "from", "VRF", "identified", "by", "*", "route_dist", "*", "." ]

[ "def", "getSpec", "(", "cls", ")", ":", "spec", "=", "{", "\"description\"", ":", "\"Sensor for sending sparse data to an HTM network.\"", ",", "\"singleNodeOnly\"", ":", "True", ",", "\"outputs\"", ":", "{", "\"dataOut\"", ":", "{", "\"description\"", ":", "\"Encoded text\"", ",", "\"dataType\"", ":", "\"Real32\"", ",", "\"count\"", ":", "0", ",", "\"regionLevel\"", ":", "True", ",", "\"isDefaultOutput\"", ":", "True", ",", "}", ",", "\"resetOut\"", ":", "{", "\"description\"", ":", "\"Boolean reset output.\"", ",", "\"dataType\"", ":", "\"Real32\"", ",", "\"count\"", ":", "1", ",", "\"regionLevel\"", ":", "True", ",", "\"isDefaultOutput\"", ":", "False", ",", "}", ",", "\"sequenceIdOut\"", ":", "{", "\"description\"", ":", "\"Sequence ID\"", ",", "\"dataType\"", ":", "'Real32'", ",", "\"count\"", ":", "1", ",", "\"regionLevel\"", ":", "True", ",", "\"isDefaultOutput\"", ":", "False", ",", "}", ",", "}", ",", "\"inputs\"", ":", "{", "}", ",", "\"parameters\"", ":", "{", "\"verbosity\"", ":", "{", "\"description\"", ":", "\"Verbosity level\"", ",", "\"dataType\"", ":", "\"UInt32\"", ",", "\"accessMode\"", ":", "\"ReadWrite\"", ",", "\"count\"", ":", "1", ",", "\"constraints\"", ":", "\"\"", ",", "}", ",", "\"outputWidth\"", ":", "{", "\"description\"", ":", "\"Size of output vector\"", ",", "\"dataType\"", ":", "\"UInt32\"", ",", "\"accessMode\"", ":", "\"ReadWrite\"", ",", "\"count\"", ":", "1", ",", "\"defaultValue\"", ":", "2048", ",", "\"constraints\"", ":", "\"\"", ",", "}", ",", "}", ",", "\"commands\"", ":", "{", "\"addDataToQueue\"", ":", "{", "\"description\"", ":", "\"Add data\"", ",", "}", "}", ",", "}", "return", "spec" ]

[ "Return", "base", "spec", "for", "this", "region", ".", "See", "base", "class", "method", "for", "more", "info", "." ]

[ "def", "inform_hook_client_factory", "(", "self", ",", "host", ",", "port", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_InformHookDeviceClient", "(", "host", ",", "port", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "an", "instance", "of", ":", "class", ":", "_InformHookDeviceClient", "or", "similar" ]

[ "def", "get_element_type", "(", "_list", ",", "dimens", ")", ":", "elem", "=", "_list", "for", "_", "in", "range", "(", "len", "(", "dimens", ")", ")", ":", "elem", "=", "elem", "[", "0", "]", "return", "type", "(", "elem", ")" ]

[ "Given", "the", "dimensions", "of", "a", "nested", "list", "and", "the", "list", "returns", "the", "type", "of", "the", "elements", "in", "the", "inner", "list", "." ]

[ "def", "Run", "(", "self", ")", ":", "while", "True", ":", "try", ":", "events", "=", "self", ".", "poller", ".", "poll", "(", ")", "except", "KeyboardInterrupt", ":", "self", ".", "context", ".", "destroy", "(", ")", "sys", ".", "exit", "(", ")", "self", ".", "Handle_Events", "(", "events", ")" ]

[ "Wait", "for", "clients", "to", "connect", "and", "service", "them" ]

[ "def", "sample_forecast_max_hail", "(", "self", ",", "dist_model_name", ",", "condition_model_name", ",", "num_samples", ",", "condition_threshold", "=", "0.5", ",", "query", "=", "None", ")", ":", "if", "query", "is", "not", "None", ":", "dist_forecasts", "=", "self", ".", "matched_forecasts", "[", "\"dist\"", "]", "[", "dist_model_name", "]", ".", "query", "(", "query", ")", "dist_forecasts", "=", "dist_forecasts", ".", "reset_index", "(", "drop", "=", "True", ")", "condition_forecasts", "=", "self", ".", "matched_forecasts", "[", "\"condition\"", "]", "[", "condition_model_name", "]", ".", "query", "(", "query", ")", "condition_forecasts", "=", "condition_forecasts", ".", "reset_index", "(", "drop", "=", "True", ")", "else", ":", "dist_forecasts", "=", "self", ".", "matched_forecasts", "[", "\"dist\"", "]", "[", "dist_model_name", "]", "condition_forecasts", "=", "self", ".", "matched_forecasts", "[", "\"condition\"", "]", "[", "condition_model_name", "]", "max_hail_samples", "=", "np", ".", "zeros", "(", "(", "dist_forecasts", ".", "shape", "[", "0", "]", ",", "num_samples", ")", ")", "areas", "=", "dist_forecasts", "[", "\"Area\"", "]", ".", "values", "for", "f", "in", "np", ".", "arange", "(", "dist_forecasts", ".", "shape", "[", "0", "]", ")", ":", "condition_prob", "=", "condition_forecasts", ".", "loc", "[", "f", ",", "self", ".", "forecast_bins", "[", "\"condition\"", "]", "[", "0", "]", "]", "if", "condition_prob", ">=", "condition_threshold", ":", "max_hail_samples", "[", "f", "]", "=", "np", ".", "sort", "(", "gamma", ".", "rvs", "(", "*", "dist_forecasts", ".", "loc", "[", "f", ",", "self", ".", "forecast_bins", "[", "\"dist\"", "]", "]", ".", "values", ",", "size", "=", "(", "num_samples", ",", "areas", "[", "f", "]", ")", ")", ".", "max", "(", "axis", "=", "1", ")", ")", "return", "max_hail_samples" ]

[ "Samples", "every", "forecast", "hail", "object", "and", "returns", "an", "empirical", "distribution", "of", "possible", "maximum", "hail", "sizes", "." ]

[ "def", "from_dict", "(", "cls", ",", "dictionary", ")", ":", "query", "=", "cls", "(", "Key", "(", "dictionary", "[", "'key'", "]", ")", ")", "for", "key", ",", "value", "in", "dictionary", ".", "items", "(", ")", ":", "if", "key", "==", "'order'", ":", "for", "order", "in", "value", ":", "query", ".", "order", "(", "order", ")", "elif", "key", "==", "'filter'", ":", "for", "filter", "in", "value", ":", "if", "not", "isinstance", "(", "filter", ",", "Filter", ")", ":", "filter", "=", "Filter", "(", "*", "filter", ")", "query", ".", "filter", "(", "filter", ")", "elif", "key", "in", "[", "'limit'", ",", "'offset'", ",", "'offset_key'", "]", ":", "setattr", "(", "query", ",", "key", ",", "value", ")", "return", "query" ]

[ "Constructs", "a", "query", "from", "a", "dictionary", "." ]

[ "def", "parse", "(", "readDataInstance", ")", ":", "et", "=", "ImageExportTable", "(", ")", "et", ".", "characteristics", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "timeDateStamp", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "majorVersion", ".", "value", "=", "readDataInstance", ".", "readWord", "(", ")", "et", ".", "minorVersion", ".", "value", "=", "readDataInstance", ".", "readWord", "(", ")", "et", ".", "name", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "base", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "numberOfFunctions", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "numberOfNames", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "addressOfFunctions", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "addressOfNames", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "et", ".", "addressOfNameOrdinals", ".", "value", "=", "readDataInstance", ".", "readDword", "(", ")", "return", "et" ]

[ "Returns", "a", "new", "L", "{", "ImageExportTable", "}", "object", "." ]

[ "def", "extract_features", "(", "self", ",", "dataset", ",", "missing_value_action", "=", "'auto'", ")", ":", "_raise_error_if_not_sframe", "(", "dataset", ",", "\"dataset\"", ")", "if", "missing_value_action", "==", "'auto'", ":", "missing_value_action", "=", "select_default_missing_value_policy", "(", "self", ",", "'extract_features'", ")", "return", "self", ".", "__proxy__", ".", "extract_features", "(", "dataset", ",", "missing_value_action", ")" ]

[ "For", "each", "example", "in", "the", "dataset", "extract", "the", "leaf", "indices", "of", "each", "tree", "as", "features", "." ]

[ "def", "bincount", "(", "dig", ",", "weight", ",", "minlength", ")", ":", "if", "numpy", ".", "isscalar", "(", "weight", ")", ":", "return", "numpy", ".", "bincount", "(", "dig", ",", "minlength", "=", "minlength", ")", "*", "weight", "else", ":", "return", "numpy", ".", "bincount", "(", "dig", ",", "weight", ",", "minlength", ")" ]

[ "bincount", "supporting", "scalar", "and", "vector", "weight" ]

[ "def", "serialize_all", "(", "obj", ")", ":", "if", "'_hyperparameters'", "not", "in", "dir", "(", "obj", ")", ":", "return", "{", "}", "return", "{", "k", ":", "str", "(", "v", ")", "for", "k", ",", "v", "in", "obj", ".", "_hyperparameters", ".", "items", "(", ")", "if", "v", "is", "not", "None", "}" ]

[ "Return", "all", "non", "-", "None", "hyperparameter", "values", "on", "obj", "as", "a", "dict", "[", "str", "str", "]", "." ]

[ "def", "is_timestamp", "(", "instance", ")", ":", "if", "not", "isinstance", "(", "instance", ",", "(", "int", ",", "str", ")", ")", ":", "return", "True", "return", "datetime", ".", "fromtimestamp", "(", "int", "(", "instance", ")", ")" ]

[ "Validates", "data", "is", "a", "timestamp" ]

[ "def", "__gen_rel_anno_file", "(", "self", ",", "top_level_layer", ")", ":", "paula_id", "=", "'{0}.{1}.{2}_{3}_rel'", ".", "format", "(", "top_level_layer", ",", "self", ".", "corpus_name", ",", "self", ".", "name", ",", "top_level_layer", ")", "E", ",", "tree", "=", "gen_paula_etree", "(", "paula_id", ")", "dominance_edges", "=", "select_edges_by", "(", "self", ".", "dg", ",", "layer", "=", "top_level_layer", ",", "edge_type", "=", "EdgeTypes", ".", "dominance_relation", ",", "data", "=", "True", ")", "dominance_dict", "=", "defaultdict", "(", "lambda", ":", "defaultdict", "(", "str", ")", ")", "for", "source_id", ",", "target_id", ",", "edge_attrs", "in", "dominance_edges", ":", "if", "source_id", "!=", "top_level_layer", "+", "':root_node'", ":", "dominance_dict", "[", "source_id", "]", "[", "target_id", "]", "=", "edge_attrs", "base_paula_id", "=", "self", ".", "paulamap", "[", "'hierarchy'", "]", "[", "top_level_layer", "]", "mflist", "=", "E", "(", "'multiFeatList'", ",", "{", "XMLBASE", ":", "base_paula_id", "+", "'.xml'", "}", ")", "for", "source_id", "in", "dominance_dict", ":", "for", "target_id", "in", "dominance_dict", "[", "source_id", "]", ":", "rel_href", "=", "'#rel_{0}_{1}'", ".", "format", "(", "source_id", ",", "target_id", ")", "mfeat", "=", "E", "(", "'multiFeat'", ",", "{", "XLINKHREF", ":", "rel_href", "}", ")", "edge_attrs", "=", "dominance_dict", "[", "source_id", "]", "[", "target_id", "]", "for", "edge_attr", "in", "edge_attrs", ":", "if", "edge_attr", "not", "in", "IGNORED_EDGE_ATTRIBS", ":", "mfeat", ".", "append", "(", "E", "(", "'feat'", ",", "{", "'name'", ":", "edge_attr", ",", "'value'", ":", "edge_attrs", "[", "edge_attr", "]", "}", ")", ")", "if", "self", ".", "human_readable", ":", "# adds edge label as a <!--comment-->", "source_label", "=", "self", ".", "dg", ".", "node", "[", "source_id", "]", ".", "get", "(", "'label'", ")", "target_label", "=", "self", ".", "dg", ".", "node", "[", "target_id", "]", ".", "get", "(", "'label'", ")", "mfeat", ".", "append", "(", "Comment", "(", "u'{0} - {1}'", ".", "format", "(", "source_label", ",", "target_label", ")", ")", ")", "mflist", ".", "append", "(", "mfeat", ")", "tree", ".", "append", "(", "mflist", ")", "self", ".", "files", "[", "paula_id", "]", "=", "tree", "self", ".", "file2dtd", "[", "paula_id", "]", "=", "PaulaDTDs", ".", "multifeat", "return", "paula_id" ]

[ "A", "rel", "annotation", "file", "contains", "edge", "(", "rel", ")", "attributes", ".", "It", "is", "e", ".", "g", ".", "used", "to", "annotate", "the", "type", "of", "a", "dependency", "relation", "(", "subj", "obj", "etc", ".", ")", "." ]

[ "def", "_init_map", "(", "self", ")", ":", "QuestionFilesFormRecord", ".", "_init_map", "(", "self", ")", "FirstAngleProjectionFormRecord", ".", "_init_map", "(", "self", ")", "super", "(", "MultiChoiceOrthoQuestionFormRecord", ",", "self", ")", ".", "_init_map", "(", ")" ]

[ "stub" ]

[ "def", "_deploy_a_clone", "(", "self", ",", "si", ",", "logger", ",", "app_name", ",", "template_name", ",", "other_params", ",", "vcenter_data_model", ",", "reservation_id", ",", "cancellation_context", ",", "snapshot", "=", "''", ")", ":", "# generate unique name", "vm_name", "=", "self", ".", "name_generator", "(", "app_name", ",", "reservation_id", ")", "VCenterDetailsFactory", ".", "set_deplyment_vcenter_params", "(", "vcenter_resource_model", "=", "vcenter_data_model", ",", "deploy_params", "=", "other_params", ")", "template_name", "=", "VMLocation", ".", "combine", "(", "[", "other_params", ".", "default_datacenter", ",", "template_name", "]", ")", "params", "=", "self", ".", "pv_service", ".", "CloneVmParameters", "(", "si", "=", "si", ",", "template_name", "=", "template_name", ",", "vm_name", "=", "vm_name", ",", "vm_folder", "=", "other_params", ".", "vm_location", ",", "datastore_name", "=", "other_params", ".", "vm_storage", ",", "cluster_name", "=", "other_params", ".", "vm_cluster", ",", "resource_pool", "=", "other_params", ".", "vm_resource_pool", ",", "power_on", "=", "False", ",", "snapshot", "=", "snapshot", ")", "if", "cancellation_context", ".", "is_cancelled", ":", "raise", "Exception", "(", "\"Action 'Clone VM' was cancelled.\"", ")", "clone_vm_result", "=", "self", ".", "pv_service", ".", "clone_vm", "(", "clone_params", "=", "params", ",", "logger", "=", "logger", ",", "cancellation_context", "=", "cancellation_context", ")", "if", "clone_vm_result", ".", "error", ":", "raise", "Exception", "(", "clone_vm_result", ".", "error", ")", "# remove a new created vm due to cancellation", "if", "cancellation_context", ".", "is_cancelled", ":", "self", ".", "pv_service", ".", "destroy_vm", "(", "vm", "=", "clone_vm_result", ".", "vm", ",", "logger", "=", "logger", ")", "raise", "Exception", "(", "\"Action 'Clone VM' was cancelled.\"", ")", "vm_details_data", "=", "self", ".", "_safely_get_vm_details", "(", "clone_vm_result", ".", "vm", ",", "vm_name", ",", "vcenter_data_model", ",", "other_params", ",", "logger", ")", "return", "DeployAppResult", "(", "vmName", "=", "vm_name", ",", "vmUuid", "=", "clone_vm_result", ".", "vm", ".", "summary", ".", "config", ".", "uuid", ",", "vmDetailsData", "=", "vm_details_data", ",", "deployedAppAdditionalData", "=", "{", "'ip_regex'", ":", "other_params", ".", "ip_regex", ",", "'refresh_ip_timeout'", ":", "other_params", ".", "refresh_ip_timeout", ",", "'auto_power_off'", ":", "convert_to_bool", "(", "other_params", ".", "auto_power_off", ")", ",", "'auto_delete'", ":", "convert_to_bool", "(", "other_params", ".", "auto_delete", ")", "}", ")" ]

[ ":", "rtype", "DeployAppResult", ":" ]

[ "def", "restoreSettings", "(", "self", ",", "settings", ")", ":", "key", "=", "self", ".", "objectName", "(", ")", "value", "=", "unwrapVariant", "(", "settings", ".", "value", "(", "'%s/profile'", "%", "key", ")", ")", "if", "not", "value", ":", "self", ".", "reset", "(", "force", "=", "True", ")", "return", "False", "profile", "=", "value", "# restore the view type settings", "for", "viewType", "in", "self", ".", "viewTypes", "(", ")", ":", "viewType", ".", "restoreGlobalSettings", "(", "settings", ")", "# restore the profile", "self", ".", "restoreProfile", "(", "XViewProfile", ".", "fromString", "(", "profile", ")", ")", "if", "not", "self", ".", "views", "(", ")", ":", "self", ".", "reset", "(", "force", "=", "True", ")", "return", "True" ]

[ "Restores", "the", "current", "structure", "of", "the", "view", "widget", "from", "the", "inputed", "\\", "settings", "instance", ".", ":", "param", "settings", "|", "<QSettings", ">" ]

[ "def", "process", "(", "self", ",", "stage", ")", ":", "self", ".", "logger", ".", "info", "(", "\"Processing pipeline stage '%s'\"", ",", "self", ".", "title", ")", "output", "=", "[", "]", "for", "entry", "in", "stage", ":", "key", "=", "list", "(", "entry", ".", "keys", "(", ")", ")", "[", "0", "]", "if", "key", "==", "\"env\"", ":", "self", ".", "pipeline", ".", "data", ".", "env_list", "[", "1", "]", ".", "update", "(", "entry", "[", "key", "]", ")", "self", ".", "logger", ".", "debug", "(", "\"Updating environment at level 1 with %s\"", ",", "self", ".", "pipeline", ".", "data", ".", "env_list", "[", "1", "]", ")", "continue", "# if not \"env\" then it must be \"tasks\" (schema):", "tasks", "=", "Tasks", "(", "self", ".", "pipeline", ",", "re", ".", "match", "(", "r\"tasks\\(parallel\\)\"", ",", "key", ")", "is", "not", "None", ")", "result", "=", "tasks", ".", "process", "(", "entry", "[", "key", "]", ")", "for", "line", "in", "result", "[", "'output'", "]", ":", "output", ".", "append", "(", "line", ")", "if", "not", "result", "[", "'success'", "]", ":", "self", ".", "event", ".", "failed", "(", ")", "return", "{", "'success'", ":", "False", ",", "'output'", ":", "output", "}", "self", ".", "event", ".", "succeeded", "(", ")", "return", "{", "'success'", ":", "True", ",", "'output'", ":", "output", "}" ]

[ "Processing", "one", "stage", "." ]

[ "def", "_process_input_wcs", "(", "infiles", ",", "wcskey", ",", "updatewcs", ")", ":", "# Run parseinput though it's likely already been done in processFilenames", "outfiles", "=", "parseinput", ".", "parseinput", "(", "infiles", ")", "[", "0", "]", "# Disable parallel processing here for now until hardware I/O gets \"wider\".", "# Since this part is IO bound, parallelizing doesn't help more than a little", "# in most cases, and may actually slow this down on some desktop nodes.", "# cfgval_num_cores = None # get this from paramDict", "# pool_size = util.get_pool_size(cfgval_num_cores, len(outfiles))", "pool_size", "=", "1", "# do the WCS updating", "if", "wcskey", "in", "[", "''", ",", "' '", ",", "'INDEF'", ",", "None", "]", ":", "if", "updatewcs", ":", "log", ".", "info", "(", "'Updating input WCS using \"updatewcs\"'", ")", "else", ":", "log", ".", "info", "(", "'Resetting input WCS to be based on WCS key = %s'", "%", "wcskey", ")", "if", "pool_size", ">", "1", ":", "log", ".", "info", "(", "'Executing %d parallel workers'", "%", "pool_size", ")", "subprocs", "=", "[", "]", "for", "fname", "in", "outfiles", ":", "p", "=", "multiprocessing", ".", "Process", "(", "target", "=", "_process_input_wcs_single", ",", "name", "=", "'processInput._process_input_wcs()'", ",", "# for err msgs", "args", "=", "(", "fname", ",", "wcskey", ",", "updatewcs", ")", ")", "subprocs", ".", "append", "(", "p", ")", "mputil", ".", "launch_and_wait", "(", "subprocs", ",", "pool_size", ")", "# blocks till all done", "else", ":", "log", ".", "info", "(", "'Executing serially'", ")", "for", "fname", "in", "outfiles", ":", "_process_input_wcs_single", "(", "fname", ",", "wcskey", ",", "updatewcs", ")", "return", "outfiles" ]

[ "This", "is", "a", "subset", "of", "process_input", "()", "for", "internal", "use", "only", ".", "This", "is", "the", "portion", "of", "input", "handling", "which", "sets", "/", "updates", "WCS", "data", "and", "is", "a", "performance", "hit", "-", "a", "target", "for", "parallelization", ".", "Returns", "the", "expanded", "list", "of", "filenames", "." ]

[ "def", "he_init", "(", "n_inputs", ",", "n_outputs", ",", "activation_fn", ",", "uniform", "=", "True", ")", ":", "def", "in_relu_family", "(", "activation_fn", ")", ":", "if", "isinstance", "(", "activation_fn", ",", "collections", ".", "Sequence", ")", ":", "activation_fn", "=", "activation_fn", "[", "0", "]", "return", "activation_fn", "in", "(", "tf", ".", "nn", ".", "relu", ",", "tf", ".", "nn", ".", "relu6", ")", "if", "in_relu_family", "(", "activation_fn", ")", ":", "stddev", "=", "math", ".", "sqrt", "(", "2.0", "/", "n_inputs", ")", "# TODO(): Evaluates truncated_normal_initializer.", "return", "tf", ".", "random_normal_initializer", "(", "stddev", "=", "stddev", ")", "else", ":", "return", "xavier_init", "(", "n_inputs", ",", "n_outputs", ",", "uniform", ")" ]

[ "Sets", "the", "parameter", "initialization", "using", "the", "method", "described", "." ]

[ "def", "records", "(", "self", ")", ":", "records", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "count", "(", ")", ")", ":", "record", "=", "self", ".", "recordAt", "(", "i", ")", "if", "record", ":", "records", ".", "append", "(", "record", ")", "return", "records" ]

[ "Returns", "the", "record", "list", "that", "ist", "linked", "with", "this", "combo", "box", ".", ":", "return", "[", "<orb", ".", "Table", ">", "..", "]" ]

[ "def", "projection", "(", "self", ",", "*", "axes", ":", "AxisIdentifier", ",", "*", "*", "kwargs", ")", "->", "HistogramBase", ":", "# TODO: rename to project in 0.5", "axes", ",", "invert", "=", "self", ".", "_get_projection_axes", "(", "*", "axes", ")", "frequencies", "=", "self", ".", "frequencies", ".", "sum", "(", "axis", "=", "invert", ")", "errors2", "=", "self", ".", "errors2", ".", "sum", "(", "axis", "=", "invert", ")", "return", "self", ".", "_reduce_dimension", "(", "axes", ",", "frequencies", ",", "errors2", ",", "*", "*", "kwargs", ")" ]

[ "Reduce", "dimensionality", "by", "summing", "along", "axis", "/", "axes", "." ]

[ "def", "_obtain_lock", "(", "self", ")", ":", "starttime", "=", "time", ".", "time", "(", ")", "maxtime", "=", "starttime", "+", "float", "(", "self", ".", "_max_block_time", ")", "while", "True", ":", "try", ":", "super", "(", "BlockingLockFile", ",", "self", ")", ".", "_obtain_lock", "(", ")", "except", "IOError", ":", "# synity check: if the directory leading to the lockfile is not", "# readable anymore, raise an exception", "curtime", "=", "time", ".", "time", "(", ")", "if", "not", "osp", ".", "isdir", "(", "osp", ".", "dirname", "(", "self", ".", "_lock_file_path", "(", ")", ")", ")", ":", "msg", "=", "\"Directory containing the lockfile %r was not readable anymore after waiting %g seconds\"", "%", "(", "self", ".", "_lock_file_path", "(", ")", ",", "curtime", "-", "starttime", ")", "raise", "IOError", "(", "msg", ")", "# END handle missing directory", "if", "curtime", ">=", "maxtime", ":", "msg", "=", "\"Waited %g seconds for lock at %r\"", "%", "(", "maxtime", "-", "starttime", ",", "self", ".", "_lock_file_path", "(", ")", ")", "raise", "IOError", "(", "msg", ")", "# END abort if we wait too long", "time", ".", "sleep", "(", "self", ".", "_check_interval", ")", "else", ":", "break" ]

[ "This", "method", "blocks", "until", "it", "obtained", "the", "lock", "or", "raises", "IOError", "if", "it", "ran", "out", "of", "time", "or", "if", "the", "parent", "directory", "was", "not", "available", "anymore", ".", "If", "this", "method", "returns", "you", "are", "guaranteed", "to", "own", "the", "lock" ]

[ "def", "get_icon", "(", "self", ",", "iconset", ")", ":", "# Handle a themed icon.", "theme", "=", "iconset", ".", "attrib", ".", "get", "(", "'theme'", ")", "if", "theme", "is", "not", "None", ":", "return", "self", ".", "_object_factory", ".", "createQObject", "(", "\"QIcon.fromTheme\"", ",", "'icon'", ",", "(", "self", ".", "_object_factory", ".", "asString", "(", "theme", ")", ",", ")", ",", "is_attribute", "=", "False", ")", "# Handle an empty iconset property.", "if", "iconset", ".", "text", "is", "None", ":", "return", "None", "iset", "=", "_IconSet", "(", "iconset", ",", "self", ".", "_base_dir", ")", "try", ":", "idx", "=", "self", ".", "_cache", ".", "index", "(", "iset", ")", "except", "ValueError", ":", "idx", "=", "-", "1", "if", "idx", ">=", "0", ":", "# Return the icon from the cache.", "iset", "=", "self", ".", "_cache", "[", "idx", "]", "else", ":", "# Follow uic's naming convention.", "name", "=", "'icon'", "idx", "=", "len", "(", "self", ".", "_cache", ")", "if", "idx", ">", "0", ":", "name", "+=", "str", "(", "idx", ")", "icon", "=", "self", ".", "_object_factory", ".", "createQObject", "(", "\"QIcon\"", ",", "name", ",", "(", ")", ",", "is_attribute", "=", "False", ")", "iset", ".", "set_icon", "(", "icon", ",", "self", ".", "_qtgui_module", ")", "self", ".", "_cache", ".", "append", "(", "iset", ")", "return", "iset", ".", "icon" ]

[ "Return", "an", "icon", "described", "by", "the", "given", "iconset", "tag", "." ]

[ "def", "dst", "(", "self", ",", "dt", ")", ":", "if", "not", "self", ".", "_is_dst", "(", "dt", ")", ":", "return", "datetime", ".", "timedelta", "(", "0", ")", "offset", "=", "time", ".", "timezone", "-", "time", ".", "altzone", "return", "datetime", ".", "timedelta", "(", "seconds", "=", "-", "offset", ")" ]

[ "Returns", "a", "difference", "in", "seconds", "between", "standard", "offset", "and", "dst", "offset", "." ]

[ "def", "_queue", "(", "self", ",", "kwargs", ")", ":", "if", "not", "'hard resource_list'", "in", "kwargs", ":", "return", "'all.q'", "d", "=", "dict", "(", "[", "k", ".", "split", "(", "'='", ")", "for", "k", "in", "kwargs", "[", "'hard resource_list'", "]", ".", "split", "(", "','", ")", "]", ")", "for", "k", "in", "d", ":", "if", "k", "[", "0", "]", "==", "'q'", "and", "d", "[", "k", "]", "==", "'TRUE'", ":", "return", "k", "return", "'all.q'" ]

[ "The", "hard", "resource_list", "comes", "like", "this", ":", "<qname", ">", "=", "TRUE", "mem", "=", "128M", ".", "To", "process", "it", "we", "have", "to", "split", "it", "twice", "(", "and", "then", "on", "=", ")", "create", "a", "dictionary", "and", "extract", "just", "the", "qname" ]

[ "def", "align", "(", "self", ",", "input_path", ",", "output_path", ",", "directions", ",", "pipeline", ",", "filter_minimum", ")", ":", "# HMMalign the forward reads, and reverse complement reads.", "with", "tempfile", ".", "NamedTemporaryFile", "(", "prefix", "=", "'for_conv_file'", ",", "suffix", "=", "'.fa'", ")", "as", "fwd_fh", ":", "fwd_conv_file", "=", "fwd_fh", ".", "name", "with", "tempfile", ".", "NamedTemporaryFile", "(", "prefix", "=", "'rev_conv_file'", ",", "suffix", "=", "'.fa'", ")", "as", "rev_fh", ":", "rev_conv_file", "=", "rev_fh", ".", "name", "alignments", "=", "self", ".", "_hmmalign", "(", "input_path", ",", "directions", ",", "pipeline", ",", "fwd_conv_file", ",", "rev_conv_file", ")", "alignment_result", "=", "self", ".", "alignment_correcter", "(", "alignments", ",", "output_path", ",", "filter_minimum", ")", "return", "alignment_result" ]

[ "align", "-", "Takes", "input", "path", "to", "fasta", "of", "unaligned", "reads", "aligns", "them", "to", "a", "HMM", "and", "returns", "the", "aligned", "reads", "in", "the", "output", "path" ]

[ "def", "main", "(", ")", ":", "args", "=", "GetArgs", "(", ")", "if", "args", ".", "password", ":", "password", "=", "args", ".", "password", "else", ":", "password", "=", "getpass", ".", "getpass", "(", "prompt", "=", "'Enter password for host %s and '", "'user %s: '", "%", "(", "args", ".", "host", ",", "args", ".", "user", ")", ")", "context", "=", "None", "if", "hasattr", "(", "ssl", ",", "'_create_unverified_context'", ")", ":", "context", "=", "ssl", ".", "_create_unverified_context", "(", ")", "si", "=", "SmartConnect", "(", "host", "=", "args", ".", "host", ",", "user", "=", "args", ".", "user", ",", "pwd", "=", "password", ",", "port", "=", "int", "(", "args", ".", "port", ")", ",", "sslContext", "=", "context", ")", "if", "not", "si", ":", "print", "(", "\"Could not connect to the specified host using specified \"", "\"username and password\"", ")", "return", "-", "1", "atexit", ".", "register", "(", "Disconnect", ",", "si", ")", "content", "=", "si", ".", "RetrieveContent", "(", ")", "for", "child", "in", "content", ".", "rootFolder", ".", "childEntity", ":", "if", "hasattr", "(", "child", ",", "'vmFolder'", ")", ":", "datacenter", "=", "child", "vmFolder", "=", "datacenter", ".", "vmFolder", "vmList", "=", "vmFolder", ".", "childEntity", "for", "vm", "in", "vmList", ":", "PrintVmInfo", "(", "vm", ")", "return", "0" ]

[ "Simple", "command", "-", "line", "program", "for", "listing", "the", "virtual", "machines", "on", "a", "system", "." ]

[ "def", "update_profiles", "(", "adapter", ")", ":", "for", "case", "in", "adapter", ".", "cases", "(", ")", ":", "#If the case has a vcf_path, get the profiles and update the", "#case with new profiled individuals.", "if", "case", ".", "get", "(", "'profile_path'", ")", ":", "profiles", "=", "get_profiles", "(", "adapter", ",", "case", "[", "'profile_path'", "]", ")", "profiled_individuals", "=", "deepcopy", "(", "case", "[", "'individuals'", "]", ")", "for", "individual", "in", "profiled_individuals", ":", "ind_id", "=", "individual", "[", "'ind_id'", "]", "try", ":", "profile", "=", "profiles", "[", "ind_id", "]", "individual", "[", "'profile'", "]", "=", "profile", "except", "KeyError", ":", "LOG", ".", "warning", "(", "f\"sample IDs in vcf does not match for case {case['case_id']}\"", ")", "updated_case", "=", "deepcopy", "(", "case", ")", "updated_case", "[", "'individuals'", "]", "=", "profiled_individuals", "adapter", ".", "add_case", "(", "updated_case", ",", "update", "=", "True", ")" ]

[ "For", "all", "cases", "having", "vcf_path", "update", "the", "profile", "string", "for", "the", "samples" ]

[ "def", "check_for_invalid_columns", "(", "problems", ":", "List", ",", "table", ":", "str", ",", "df", ":", "DataFrame", ")", "->", "List", ":", "r", "=", "cs", ".", "GTFS_REF", "valid_columns", "=", "r", ".", "loc", "[", "r", "[", "\"table\"", "]", "==", "table", ",", "\"column\"", "]", ".", "values", "for", "col", "in", "df", ".", "columns", ":", "if", "col", "not", "in", "valid_columns", ":", "problems", ".", "append", "(", "[", "\"warning\"", ",", "f\"Unrecognized column {col}\"", ",", "table", ",", "[", "]", "]", ")", "return", "problems" ]

[ "Check", "for", "invalid", "columns", "in", "the", "given", "GTFS", "DataFrame", "." ]

[ "def", "list_renderers", "(", "*", "args", ")", ":", "renderers_", "=", "salt", ".", "loader", ".", "render", "(", "__opts__", ",", "[", "]", ")", "renderers", "=", "set", "(", ")", "if", "not", "args", ":", "for", "rend", "in", "six", ".", "iterkeys", "(", "renderers_", ")", ":", "renderers", ".", "add", "(", "rend", ")", "return", "sorted", "(", "renderers", ")", "for", "module", "in", "args", ":", "for", "rend", "in", "fnmatch", ".", "filter", "(", "renderers_", ",", "module", ")", ":", "renderers", ".", "add", "(", "rend", ")", "return", "sorted", "(", "renderers", ")" ]

[ "List", "the", "renderers", "loaded", "on", "the", "minion" ]

[ "def", "_at", "(", "cls", ",", "verb", ")", ":", "# Named (listed) columns are always included", "columns", "=", "cls", ".", "select", "(", "verb", ")", "final_columns_set", "=", "set", "(", "cls", ".", "select", "(", "verb", ")", ")", "groups_set", "=", "set", "(", "_get_groups", "(", "verb", ")", ")", "final_columns_set", "-=", "groups_set", "-", "set", "(", "verb", ".", "names", ")", "def", "pred", "(", "col", ")", ":", "if", "col", "not", "in", "verb", ".", "data", ":", "raise", "KeyError", "(", "\"Unknown column name, {!r}\"", ".", "format", "(", "col", ")", ")", "return", "col", "in", "final_columns_set", "return", "[", "col", "for", "col", "in", "columns", "if", "pred", "(", "col", ")", "]" ]

[ "A", "verb", "with", "a", "select", "text", "match" ]

[ "def", "human_id", "(", "self", ")", ":", "if", "self", ".", "NAME_ATTR", "in", "self", ".", "__dict__", "and", "self", ".", "HUMAN_ID", ":", "return", "utils", ".", "to_slug", "(", "getattr", "(", "self", ",", "self", ".", "NAME_ATTR", ")", ")", "return", "None" ]

[ "Subclasses", "may", "override", "this", "to", "provide", "a", "pretty", "ID", "which", "can", "be", "used", "for", "bash", "completion", "." ]

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

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

[ "def", "_days", "(", "cls", ",", "start", ",", "end", ")", ":", "days", "=", "[", "]", "# datetime", "start_day", ",", "end_day", "=", "dt", ".", "strptime", "(", "start", ",", "cls", ".", "DATE_FORMAT", ")", ",", "dt", ".", "strptime", "(", "end", ",", "cls", ".", "DATE_FORMAT", ")", "delta", "=", "end_day", "-", "start_day", "for", "day", "in", "range", "(", "delta", ".", "days", "+", "1", ")", ":", "days", ".", "append", "(", "start_day", "+", "timedelta", "(", "days", "=", "day", ")", ")", "return", "days" ]

[ "Scrape", "a", "MLBAM", "Data", ":", "param", "start", ":", "Start", "Day", "(", "YYYYMMDD", ")", ":", "param", "end", ":", "End", "Day", "(", "YYYYMMDD", ")" ]

[ "def", "_start_subspan", "(", "headers", "=", "None", ")", ":", "b3", "=", "values", "(", ")", "g", ".", "subspan", "=", "{", "# Propagate the trace ID", "b3_trace_id", ":", "b3", "[", "b3_trace_id", "]", ",", "# Start a new span for the outgoing request", "b3_span_id", ":", "_generate_identifier", "(", ")", ",", "# Set the current span as the parent span", "b3_parent_span_id", ":", "b3", "[", "b3_span_id", "]", ",", "b3_sampled", ":", "b3", "[", "b3_sampled", "]", ",", "b3_flags", ":", "b3", "[", "b3_flags", "]", ",", "}", "# Set up headers", "# NB dict() ensures we don't alter the value passed in. Maybe that's too conservative?", "result", "=", "dict", "(", "headers", "or", "{", "}", ")", "result", ".", "update", "(", "{", "b3_trace_id", ":", "g", ".", "subspan", "[", "b3_trace_id", "]", ",", "b3_span_id", ":", "g", ".", "subspan", "[", "b3_span_id", "]", ",", "b3_parent_span_id", ":", "g", ".", "subspan", "[", "b3_parent_span_id", "]", ",", "}", ")", "# Propagate only if set:", "if", "g", ".", "subspan", "[", "b3_sampled", "]", ":", "result", "[", "b3_sampled", "]", "=", "g", ".", "subspan", "[", "b3_sampled", "]", "if", "g", ".", "subspan", "[", "b3_flags", "]", ":", "result", "[", "b3_flags", "]", "=", "g", ".", "subspan", "[", "b3_flags", "]", "_info", "(", "\"Client start. Starting sub-span\"", ")", "_log", ".", "debug", "(", "\"B3 values for sub-span: {b3_headers}\"", ".", "format", "(", "b3_headers", "=", "values", "(", ")", ")", ")", "_log", ".", "debug", "(", "\"All headers for downstream request: {b3_headers}\"", ".", "format", "(", "b3_headers", "=", "result", ")", ")", "return", "result" ]

[ "Sets", "up", "a", "new", "span", "to", "contact", "a", "downstream", "service", ".", "This", "is", "used", "when", "making", "a", "downstream", "service", "call", ".", "It", "returns", "a", "dict", "containing", "the", "required", "sub", "-", "span", "headers", ".", "Each", "downstream", "call", "you", "make", "is", "handled", "as", "a", "new", "span", "so", "call", "this", "every", "time", "you", "need", "to", "contact", "another", "service", "." ]

[ "def", "summary", "(", "self", ",", "summary", ")", ":", "if", "summary", "is", "not", "None", ":", "if", "summary", "==", "'Clear'", ":", "click", ".", "secho", "(", "\"\"\"\n\n ________ \\ | /\n / ____/ /__ ____ ______ .-.\n / / / / _ \\/ __ `/ ___/ ‒ ( ) ‒\n/ /___/ / __/ /_/ / / `-᾿\n\\____/_/\\___/\\__,_/_/ / | \\\\\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "YELLOW", ")", "click", ".", "echo", "(", ")", "elif", "summary", "==", "'Partly Cloudy'", ":", "click", ".", "secho", "(", "\"\"\"\n\n ____ __ __ ________ __\n / __ \\____ ______/ /_/ /_ __ / ____/ /___ __ ______/ /_ __ \\ | /\n / /_/ / __ `/ ___/ __/ / / / / / / / / __ \\/ / / / __ / / / / .-.\n / ____/ /_/ / / / /_/ / /_/ / / /___/ / /_/ / /_/ / /_/ / /_/ / ‒ ( .-.\n/_/ \\__,_/_/ \\__/_/\\__, / \\____/_/\\____/\\__,_/\\__,_/\\__, / `( ).\n /____/ /____/ / (___(__)\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "WHITE", ")", "elif", "summary", "==", "'Flurries'", ":", "click", ".", "secho", "(", "\"\"\"\n\n ________ _ .--.\n / ____/ /_ ____________(_)__ _____ .-( ).\n / /_ / / / / / ___/ ___/ / _ \\/ ___/ (___.__)__)\n / __/ / / /_/ / / / / / / __(__ ) * *\n/_/ /_/\\__,_/_/ /_/ /_/\\___/____/ *\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "BLUE", ")", "click", ".", "echo", "(", ")", "elif", "summary", "==", "'Overcast'", "or", "summary", "==", "'Mostly Cloudy'", ":", "click", ".", "secho", "(", "\"\"\"\n\n ____ __\n / __ \\_ _____ ______________ ______/ /_ .--.\n / / / / | / / _ \\/ ___/ ___/ __ `/ ___/ __/ .( ).-.\n/ /_/ /| |/ / __/ / / /__/ /_/ (__ ) /_ (___.__( ).\n\\____/ |___/\\___/_/ \\___/\\__,_/____/\\__/ (___(__)\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "WHITE", ")", "click", ".", "echo", "(", ")", "elif", "summary", "==", "'Snow'", ":", "click", ".", "secho", "(", "\"\"\"\n\n _____ .--.\n / ___/____ ____ _ __ .-( ).\n \\__ \\/ __ \\/ __ \\ | /| / / (___.__)__)\n ___/ / / / / /_/ / |/ |/ / * * *\n/____/_/ /_/\\____/|__/|__/ * *\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "BLUE", ")", "click", ".", "echo", "(", ")", "elif", "summary", "==", "'Light Snow'", ":", "click", ".", "secho", "(", "\"\"\"\n\n __ _ __ __ _____\n / / (_)___ _/ /_ / /_ / ___/____ ____ _ __ .--.\n / / / / __ `/ __ \\/ __/ \\__ \\/ __ \\/ __ \\ | /| / / .-( ).\n / /___/ / /_/ / / / / /_ ___/ / / / / /_/ / |/ |/ / (___.__)__)\n/_____/_/\\__, /_/ /_/\\__/ /____/_/ /_/\\____/|__/|__/ * * *\n /____/\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "BLUE", ")", "click", ".", "echo", "(", ")", "elif", "summary", "==", "'Light Rain'", "or", "summary", "==", "'Drizzle'", ":", "click", ".", "secho", "(", "\"\"\"\n\n __ _ __ __ ____ _\n / / (_)___ _/ /_ / /_ / __ \\____ _(_)___ .--.\n / / / / __ `/ __ \\/ __/ / /_/ / __ `/ / __ \\ .-( ).\n / /___/ / /_/ / / / / /_ / _, _/ /_/ / / / / / (___.__)__)\n/_____/_/\\__, /_/ /_/\\__/ /_/ |_|\\__,_/_/_/ /_/ / / /\n /____/\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "BLUE", ")", "elif", "summary", "==", "'Rain'", ":", "click", ".", "secho", "(", "\"\"\"\n\n ____ _\n / __ \\____ _(_)___ .--.\n / /_/ / __ `/ / __ \\ .-( ).\n / _, _/ /_/ / / / / / (___.__)__)\n/_/ |_|\\__,_/_/_/ /_/ / / /\n\n \"\"\"", ",", "fg", "=", "self", ".", "colors", ".", "BLUE", ")", "else", ":", "click", ".", "secho", "(", "\"{:=^62}\"", ".", "format", "(", "str", "(", "summary", ")", ")", ",", "fg", "=", "self", ".", "colors", ".", "GREEN", ")" ]

[ "Prints", "the", "ASCII", "Icon" ]

[ "def", "model_getattr", "(", ")", ":", "def", "model_getattr", "(", "_value", ",", "context", ",", "*", "*", "_params", ")", ":", "value", "=", "getattr", "(", "context", "[", "\"model\"", "]", ",", "context", "[", "\"key\"", "]", ")", "return", "_attr", "(", "value", ")", "return", "model_getattr" ]

[ "Creates", "a", "getter", "that", "will", "drop", "the", "current", "value", "and", "retrieve", "the", "model", "s", "attribute", "with", "the", "context", "key", "as", "name", "." ]

[ "def", "qteRemoveMode", "(", "self", ",", "mode", ":", "str", ")", ":", "# Search through the list for ``mode``.", "for", "idx", ",", "item", "in", "enumerate", "(", "self", ".", "_qteModeList", ")", ":", "if", "item", "[", "0", "]", "==", "mode", ":", "# Remove the record and delete the label.", "self", ".", "_qteModeList", ".", "remove", "(", "item", ")", "item", "[", "2", "]", ".", "hide", "(", ")", "item", "[", "2", "]", ".", "deleteLater", "(", ")", "self", ".", "_qteUpdateLabelWidths", "(", ")", "return", "True", "return", "False" ]

[ "Remove", "mode", "and", "associated", "label", "." ]

[ "def", "get_double", "(", "self", ",", "group", ":", "str", ")", "->", "pointerutils", ".", "Double", ":", "if", "group", "in", "(", "'inlets'", ",", "'receivers'", ")", ":", "if", "self", ".", "deploymode", "!=", "'obs'", ":", "return", "self", ".", "sequences", ".", "fastaccess", ".", "sim", "return", "self", ".", "sequences", ".", "fastaccess", ".", "obs", "if", "group", "in", "(", "'outlets'", ",", "'senders'", ")", ":", "if", "self", ".", "deploymode", "!=", "'oldsim'", ":", "return", "self", ".", "sequences", ".", "fastaccess", ".", "sim", "return", "self", ".", "__blackhole", "raise", "ValueError", "(", "f'Function `get_double` of class `Node` does not '", "f'support the given group name `{group}`.'", ")" ]

[ "Return", "the", "|Double|", "object", "appropriate", "for", "the", "given", "|Element|", "input", "or", "output", "group", "and", "the", "actual", "|Node", ".", "deploymode|", "." ]

[ "def", "processMeme", "(", "imgParams", ")", ":", "template_id", "=", "findMeme", "(", "imgParams", ")", "if", "template_id", "is", "None", ":", "print", "(", "\"Couldn't find a suitable match for meme :(\"", ")", "return", "meme_not_supported", "# if template_id exists", "imgParams", "=", "imgParams", ".", "split", "(", "'|'", ")", "if", "len", "(", "imgParams", ")", "==", "2", "or", "len", "(", "imgParams", ")", "==", "1", ":", "text0", "=", "imgParams", "[", "0", "]", "if", "len", "(", "imgParams", ")", "==", "2", ":", "text1", "=", "imgParams", "[", "1", "]", "# Bottom text text1 exists", "elif", "len", "(", "imgParams", ")", "==", "1", ":", "text1", "=", "''", "# No bottom text", "imgURL", "=", "genMeme", "(", "template_id", ",", "text0", ",", "text1", ")", "if", "imgURL", "is", "None", ":", "# Couldn't generate meme", "print", "(", "\"Couldn't generate meme :(\"", ")", "return", "couldnt_create_meme", "else", ":", "# Success!", "# print(imgURL)", "return", "imgURL", "elif", "len", "(", "imgParams", ")", ">", "2", ":", "print", "(", "\"Too many lines of captions! Cannot create meme.\"", ")", "return", "too_many_lines", "elif", "len", "(", "imgParams", ")", "<", "1", ":", "# No top text text0 exists", "print", "(", "\"Too few lines of captions! Cannot create meme.\"", ")", "return", "too_few_lines" ]

[ "Wrapper", "function", "for", "genMeme", "()", "and", "findMeme", "()", "imgParams", "may", "be", "a", "string", "of", "the", "following", "forms", ":", "*", "text0", "|", "text1", "*", "text0", "*", "|", "text1" ]

[ "def", "FilePattern", "(", "pattern", ",", "settings", ",", "*", "*", "kwargs", ")", ":", "url", "=", "_urlparse", "(", "pattern", ")", "if", "url", ".", "scheme", "==", "'gs'", ":", "return", "GoogleStorageFilePattern", "(", "pattern", ",", "settings", ",", "*", "*", "kwargs", ")", "else", ":", "assert", "url", ".", "scheme", "==", "'file'", "return", "LocalFilePattern", "(", "pattern", ",", "settings", ",", "*", "*", "kwargs", ")" ]

[ "Factory", "method", "returns", "LocalFilePattern", "or", "GoogleStorageFilePattern" ]

[ "def", "fit", "(", "epochs", ":", "int", ",", "learn", ":", "BasicLearner", ",", "callbacks", ":", "Optional", "[", "CallbackList", "]", "=", "None", ",", "metrics", ":", "OptMetrics", "=", "None", ")", "->", "None", ":", "assert", "len", "(", "learn", ".", "data", ".", "train_dl", ")", "!=", "0", ",", "f\"\"\"Your training dataloader is empty, can't train a model.\n Use a smaller batch size (batch size={learn.data.train_dl.batch_size} for {len(learn.data.train_dl.dataset)} elements).\"\"\"", "cb_handler", "=", "CallbackHandler", "(", "callbacks", ",", "metrics", ")", "pbar", "=", "master_bar", "(", "range", "(", "epochs", ")", ")", "cb_handler", ".", "on_train_begin", "(", "epochs", ",", "pbar", "=", "pbar", ",", "metrics", "=", "metrics", ")", "exception", "=", "False", "try", ":", "for", "epoch", "in", "pbar", ":", "learn", ".", "model", ".", "train", "(", ")", "cb_handler", ".", "set_dl", "(", "learn", ".", "data", ".", "train_dl", ")", "cb_handler", ".", "on_epoch_begin", "(", ")", "for", "xb", ",", "yb", "in", "progress_bar", "(", "learn", ".", "data", ".", "train_dl", ",", "parent", "=", "pbar", ")", ":", "xb", ",", "yb", "=", "cb_handler", ".", "on_batch_begin", "(", "xb", ",", "yb", ")", "loss", "=", "loss_batch", "(", "learn", ".", "model", ",", "xb", ",", "yb", ",", "learn", ".", "loss_func", ",", "learn", ".", "opt", ",", "cb_handler", ")", "if", "cb_handler", ".", "on_batch_end", "(", "loss", ")", ":", "break", "if", "not", "cb_handler", ".", "skip_validate", "and", "not", "learn", ".", "data", ".", "empty_val", ":", "val_loss", "=", "validate", "(", "learn", ".", "model", ",", "learn", ".", "data", ".", "valid_dl", ",", "loss_func", "=", "learn", ".", "loss_func", ",", "cb_handler", "=", "cb_handler", ",", "pbar", "=", "pbar", ")", "else", ":", "val_loss", "=", "None", "if", "cb_handler", ".", "on_epoch_end", "(", "val_loss", ")", ":", "break", "except", "Exception", "as", "e", ":", "exception", "=", "e", "raise", "finally", ":", "cb_handler", ".", "on_train_end", "(", "exception", ")" ]

[ "Fit", "the", "model", "on", "data", "and", "learn", "using", "loss_func", "and", "opt", "." ]

[ "def", "_handle_args", "(", "self", ",", "cmd", ",", "args", ")", ":", "if", "cmd", "==", "'install'", ":", "if", "args", ".", "upgrade", ":", "# Current behaviour: install or upgrade", "if", "args", ".", "initdb", "or", "args", ".", "upgradedb", ":", "raise", "Stop", "(", "10", ",", "(", "'Deprecated --initdb --upgradedb flags '", "'are incompatible with --upgrade'", ")", ")", "newinstall", "=", "None", "else", ":", "# Current behaviour: Server must not exist", "newinstall", "=", "True", "if", "args", ".", "managedb", ":", "# Current behaviour", "if", "args", ".", "initdb", "or", "args", ".", "upgradedb", ":", "raise", "Stop", "(", "10", ",", "(", "'Deprecated --initdb --upgradedb flags '", "'are incompatible with --managedb'", ")", ")", "args", ".", "initdb", "=", "True", "args", ".", "upgradedb", "=", "True", "else", ":", "if", "args", ".", "initdb", "or", "args", ".", "upgradedb", ":", "log", ".", "warn", "(", "'--initdb and --upgradedb are deprecated, '", "'use --managedb'", ")", "elif", "cmd", "==", "'upgrade'", ":", "# Deprecated behaviour", "log", ".", "warn", "(", "'\"omero upgrade\" is deprecated, use \"omego install --upgrade\"'", ")", "cmd", "=", "'install'", "args", ".", "upgrade", "=", "True", "# Deprecated behaviour: Server must exist", "newinstall", "=", "False", "else", ":", "raise", "Exception", "(", "'Unexpected command: %s'", "%", "cmd", ")", "return", "args", ",", "newinstall" ]

[ "We", "need", "to", "support", "deprecated", "behaviour", "for", "now", "which", "makes", "this", "quite", "complicated" ]

[ "def", "_to_r", "(", "o", ",", "as_data", "=", "False", ",", "level", "=", "0", ")", ":", "if", "o", "is", "None", ":", "return", "\"NA\"", "if", "isinstance", "(", "o", ",", "basestring", ")", ":", "return", "o", "if", "hasattr", "(", "o", ",", "\"r\"", ")", ":", "# bridge to @property r on GGStatement(s)", "return", "o", ".", "r", "elif", "isinstance", "(", "o", ",", "bool", ")", ":", "return", "\"TRUE\"", "if", "o", "else", "\"FALSE\"", "elif", "isinstance", "(", "o", ",", "(", "list", ",", "tuple", ")", ")", ":", "inner", "=", "\",\"", ".", "join", "(", "[", "_to_r", "(", "x", ",", "True", ",", "level", "+", "1", ")", "for", "x", "in", "o", "]", ")", "return", "\"c({})\"", ".", "format", "(", "inner", ")", "if", "as_data", "else", "inner", "elif", "isinstance", "(", "o", ",", "dict", ")", ":", "inner", "=", "\",\"", ".", "join", "(", "[", "\"{}={}\"", ".", "format", "(", "k", ",", "_to_r", "(", "v", ",", "True", ",", "level", "+", "1", ")", ")", "for", "k", ",", "v", "in", "sorted", "(", "o", ".", "iteritems", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "0", "]", ")", "]", ")", "return", "\"list({})\"", ".", "format", "(", "inner", ")", "if", "as_data", "else", "inner", "return", "str", "(", "o", ")" ]

[ "Helper", "function", "to", "convert", "python", "data", "structures", "to", "R", "equivalents" ]

[ "def", "address", "(", "self", ")", ":", "path", "=", "urlsplit", "(", "self", ".", "target", ")", ".", "path", "suffix", "=", "'/'", "if", "not", "path", "or", "path", ".", "endswith", "(", "'/'", ")", "else", "''", "return", "'%s%s/%s%s'", "%", "(", "self", ".", "_ui_address", "[", ":", "-", "1", "]", ",", "self", ".", "_proxy_prefix", ",", "self", ".", "route", ",", "suffix", ")" ]

[ "The", "full", "proxied", "address", "to", "this", "page" ]

[ "def", "det", "(", "matrix", ")", ":", "size", "=", "len", "(", "matrix", ")", "if", "size", "==", "1", ":", "return", "matrix", "[", "0", "]", "elif", "size", "==", "2", ":", "(", "a", ",", "b", ")", ",", "(", "c", ",", "d", ")", "=", "matrix", "return", "a", "*", "d", "-", "c", "*", "b", "elif", "size", "==", "3", ":", "(", "a", ",", "b", ",", "c", ")", ",", "(", "d", ",", "e", ",", "f", ")", ",", "(", "g", ",", "h", ",", "i", ")", "=", "matrix", "return", "a", "*", "(", "e", "*", "i", "-", "h", "*", "f", ")", "-", "d", "*", "(", "b", "*", "i", "-", "h", "*", "c", ")", "+", "g", "*", "(", "b", "*", "f", "-", "e", "*", "c", ")", "elif", "size", "==", "4", ":", "(", "a", ",", "b", ",", "c", ",", "d", ")", ",", "(", "e", ",", "f", ",", "g", ",", "h", ")", ",", "(", "i", ",", "j", ",", "k", ",", "l", ")", ",", "(", "m", ",", "n", ",", "o", ",", "p", ")", "=", "matrix", "return", "(", "a", "*", "f", "*", "k", "*", "p", "-", "a", "*", "f", "*", "l", "*", "o", "-", "a", "*", "g", "*", "j", "*", "p", "+", "a", "*", "g", "*", "l", "*", "n", "+", "a", "*", "h", "*", "j", "*", "o", "-", "a", "*", "h", "*", "k", "*", "n", "-", "b", "*", "e", "*", "k", "*", "p", "+", "b", "*", "e", "*", "l", "*", "o", "+", "b", "*", "g", "*", "i", "*", "p", "-", "b", "*", "g", "*", "l", "*", "m", "-", "b", "*", "h", "*", "i", "*", "o", "+", "b", "*", "h", "*", "k", "*", "m", "+", "c", "*", "e", "*", "j", "*", "p", "-", "c", "*", "e", "*", "l", "*", "n", "-", "c", "*", "f", "*", "i", "*", "p", "+", "c", "*", "f", "*", "l", "*", "m", "+", "c", "*", "h", "*", "i", "*", "n", "-", "c", "*", "h", "*", "j", "*", "m", "-", "d", "*", "e", "*", "j", "*", "o", "+", "d", "*", "e", "*", "k", "*", "n", "+", "d", "*", "f", "*", "i", "*", "o", "-", "d", "*", "f", "*", "k", "*", "m", "-", "d", "*", "g", "*", "i", "*", "n", "+", "d", "*", "g", "*", "j", "*", "m", ")", "elif", "size", "==", "5", ":", "(", "a", ",", "b", ",", "c", ",", "d", ",", "e", ")", ",", "(", "f", ",", "g", ",", "h", ",", "i", ",", "j", ")", ",", "(", "k", ",", "l", ",", "m", ",", "n", ",", "o", ")", ",", "(", "p", ",", "q", ",", "r", ",", "s", ",", "t", ")", ",", "(", "u", ",", "v", ",", "w", ",", "x", ",", "y", ")", "=", "matrix", "x0", "=", "s", "*", "y", "x1", "=", "a", "*", "g", "*", "m", "x2", "=", "t", "*", "w", "x3", "=", "a", "*", "g", "*", "n", "x4", "=", "r", "*", "x", "x5", "=", "a", "*", "g", "*", "o", "x6", "=", "t", "*", "x", "x7", "=", "a", "*", "h", "*", "l", "x8", "=", "q", "*", "y", "x9", "=", "a", "*", "h", "*", "n", "x10", "=", "s", "*", "v", "x11", "=", "a", "*", "h", "*", "o", "x12", "=", "r", "*", "y", "x13", "=", "a", "*", "i", "*", "l", "x14", "=", "t", "*", "v", "x15", "=", "a", "*", "i", "*", "m", "x16", "=", "q", "*", "w", "x17", "=", "a", "*", "i", "*", "o", "x18", "=", "s", "*", "w", "x19", "=", "a", "*", "j", "*", "l", "x20", "=", "q", "*", "x", "x21", "=", "a", "*", "j", "*", "m", "x22", "=", "r", "*", "v", "x23", "=", "a", "*", "j", "*", "n", "x24", "=", "b", "*", "f", "*", "m", "x25", "=", "b", "*", "f", "*", "n", "x26", "=", "b", "*", "f", "*", "o", "x27", "=", "b", "*", "h", "*", "k", "x28", "=", "t", "*", "u", "x29", "=", "b", "*", "h", "*", "n", "x30", "=", "p", "*", "x", "x31", "=", "b", "*", "h", "*", "o", "x32", "=", "b", "*", "i", "*", "k", "x33", "=", "p", "*", "y", "x34", "=", "b", "*", "i", "*", "m", "x35", "=", "r", "*", "u", "x36", "=", "b", "*", "i", "*", "o", "x37", "=", "b", "*", "j", "*", "k", "x38", "=", "s", "*", "u", "x39", "=", "b", "*", "j", "*", "m", "x40", "=", "p", "*", "w", "x41", "=", "b", "*", "j", "*", "n", "x42", "=", "c", "*", "f", "*", "l", "x43", "=", "c", "*", "f", "*", "n", "x44", "=", "c", "*", "f", "*", "o", "x45", "=", "c", "*", "g", "*", "k", "x46", "=", "c", "*", "g", "*", "n", "x47", "=", "c", "*", "g", "*", "o", "x48", "=", "c", "*", "i", "*", "k", "x49", "=", "c", "*", "i", "*", "l", "x50", "=", "p", "*", "v", "x51", "=", "c", "*", "i", "*", "o", "x52", "=", "c", "*", "j", "*", "k", "x53", "=", "c", "*", "j", "*", "l", "x54", "=", "q", "*", "u", "x55", "=", "c", "*", "j", "*", "n", "x56", "=", "d", "*", "f", "*", "l", "x57", "=", "d", "*", "f", "*", "m", "x58", "=", "d", "*", "f", "*", "o", "x59", "=", "d", "*", "g", "*", "k", "x60", "=", "d", "*", "g", "*", "m", "x61", "=", "d", "*", "g", "*", "o", "x62", "=", "d", "*", "h", "*", "k", "x63", "=", "d", "*", "h", "*", "l", "x64", "=", "d", "*", "h", "*", "o", "x65", "=", "d", "*", "j", "*", "k", "x66", "=", "d", "*", "j", "*", "l", "x67", "=", "d", "*", "j", "*", "m", "x68", "=", "e", "*", "f", "*", "l", "x69", "=", "e", "*", "f", "*", "m", "x70", "=", "e", "*", "f", "*", "n", "x71", "=", "e", "*", "g", "*", "k", "x72", "=", "e", "*", "g", "*", "m", "x73", "=", "e", "*", "g", "*", "n", "x74", "=", "e", "*", "h", "*", "k", "x75", "=", "e", "*", "h", "*", "l", "x76", "=", "e", "*", "h", "*", "n", "x77", "=", "e", "*", "i", "*", "k", "x78", "=", "e", "*", "i", "*", "l", "x79", "=", "e", "*", "i", "*", "m", "return", "(", "x0", "*", "x1", "-", "x0", "*", "x24", "+", "x0", "*", "x27", "+", "x0", "*", "x42", "-", "x0", "*", "x45", "-", "x0", "*", "x7", "-", "x1", "*", "x6", "+", "x10", "*", "x11", "-", "x10", "*", "x21", "-", "x10", "*", "x44", "+", "x10", "*", "x52", "+", "x10", "*", "x69", "-", "x10", "*", "x74", "-", "x11", "*", "x20", "+", "x12", "*", "x13", "+", "x12", "*", "x25", "-", "x12", "*", "x3", "-", "x12", "*", "x32", "-", "x12", "*", "x56", "+", "x12", "*", "x59", "-", "x13", "*", "x2", "+", "x14", "*", "x15", "+", "x14", "*", "x43", "-", "x14", "*", "x48", "-", "x14", "*", "x57", "+", "x14", "*", "x62", "-", "x14", "*", "x9", "-", "x15", "*", "x8", "+", "x16", "*", "x17", "-", "x16", "*", "x23", "-", "x16", "*", "x58", "+", "x16", "*", "x65", "+", "x16", "*", "x70", "-", "x16", "*", "x77", "-", "x17", "*", "x22", "+", "x18", "*", "x19", "+", "x18", "*", "x26", "-", "x18", "*", "x37", "-", "x18", "*", "x5", "-", "x18", "*", "x68", "+", "x18", "*", "x71", "-", "x19", "*", "x4", "-", "x2", "*", "x25", "+", "x2", "*", "x3", "+", "x2", "*", "x32", "+", "x2", "*", "x56", "-", "x2", "*", "x59", "+", "x20", "*", "x21", "+", "x20", "*", "x44", "-", "x20", "*", "x52", "-", "x20", "*", "x69", "+", "x20", "*", "x74", "+", "x22", "*", "x23", "+", "x22", "*", "x58", "-", "x22", "*", "x65", "-", "x22", "*", "x70", "+", "x22", "*", "x77", "+", "x24", "*", "x6", "-", "x26", "*", "x4", "-", "x27", "*", "x6", "+", "x28", "*", "x29", "-", "x28", "*", "x34", "-", "x28", "*", "x46", "+", "x28", "*", "x49", "+", "x28", "*", "x60", "-", "x28", "*", "x63", "-", "x29", "*", "x33", "+", "x30", "*", "x31", "-", "x30", "*", "x39", "-", "x30", "*", "x47", "+", "x30", "*", "x53", "+", "x30", "*", "x72", "-", "x30", "*", "x75", "-", "x31", "*", "x38", "+", "x33", "*", "x34", "+", "x33", "*", "x46", "-", "x33", "*", "x49", "-", "x33", "*", "x60", "+", "x33", "*", "x63", "+", "x35", "*", "x36", "-", "x35", "*", "x41", "-", "x35", "*", "x61", "+", "x35", "*", "x66", "+", "x35", "*", "x73", "-", "x35", "*", "x78", "-", "x36", "*", "x40", "+", "x37", "*", "x4", "+", "x38", "*", "x39", "+", "x38", "*", "x47", "-", "x38", "*", "x53", "-", "x38", "*", "x72", "+", "x38", "*", "x75", "+", "x4", "*", "x5", "+", "x4", "*", "x68", "-", "x4", "*", "x71", "+", "x40", "*", "x41", "+", "x40", "*", "x61", "-", "x40", "*", "x66", "-", "x40", "*", "x73", "+", "x40", "*", "x78", "-", "x42", "*", "x6", "-", "x43", "*", "x8", "+", "x45", "*", "x6", "+", "x48", "*", "x8", "+", "x50", "*", "x51", "-", "x50", "*", "x55", "-", "x50", "*", "x64", "+", "x50", "*", "x67", "+", "x50", "*", "x76", "-", "x50", "*", "x79", "-", "x51", "*", "x54", "+", "x54", "*", "x55", "+", "x54", "*", "x64", "-", "x54", "*", "x67", "-", "x54", "*", "x76", "+", "x54", "*", "x79", "+", "x57", "*", "x8", "+", "x6", "*", "x7", "-", "x62", "*", "x8", "+", "x8", "*", "x9", ")", "else", ":", "# TODO algorithm?", "import", "numpy", "as", "np", "return", "float", "(", "np", ".", "linalg", ".", "det", "(", "matrix", ")", ")" ]

[ "Seem", "sto", "work", "fine", ".", ">>", "from", "sympy", "import", "*", ">>", "from", "sympy", ".", "abc", "import", "*", ">>", "Matrix", "(", "[[", "a", "b", "]", "[", "c", "d", "]]", ")", ".", "det", "()", "a", "*", "d", "-", "b", "*", "c", ">>", "Matrix", "(", "[[", "a", "b", "c", "]", "[", "d", "e", "f", "]", "[", "g", "h", "i", "]]", ")", ".", "det", "()", "a", "*", "e", "*", "i", "-", "a", "*", "f", "*", "h", "-", "b", "*", "d", "*", "i", "+", "b", "*", "f", "*", "g", "+", "c", "*", "d", "*", "h", "-", "c", "*", "e", "*", "g", "A", "few", "terms", "can", "be", "slightly", "factored", "out", "of", "the", "3x", "dim", ".", ">>", "Matrix", "(", "[[", "a", "b", "c", "d", "]", "[", "e", "f", "g", "h", "]", "[", "i", "j", "k", "l", "]", "[", "m", "n", "o", "p", "]]", ")", ".", "det", "()", "a", "*", "f", "*", "k", "*", "p", "-", "a", "*", "f", "*", "l", "*", "o", "-", "a", "*", "g", "*", "j", "*", "p", "+", "a", "*", "g", "*", "l", "*", "n", "+", "a", "*", "h", "*", "j", "*", "o", "-", "a", "*", "h", "*", "k", "*", "n", "-", "b", "*", "e", "*", "k", "*", "p", "+", "b", "*", "e", "*", "l", "*", "o", "+", "b", "*", "g", "*", "i", "*", "p", "-", "b", "*", "g", "*", "l", "*", "m", "-", "b", "*", "h", "*", "i", "*", "o", "+", "b", "*", "h", "*", "k", "*", "m", "+", "c", "*", "e", "*", "j", "*", "p", "-", "c", "*", "e", "*", "l", "*", "n", "-", "c", "*", "f", "*", "i", "*", "p", "+", "c", "*", "f", "*", "l", "*", "m", "+", "c", "*", "h", "*", "i", "*", "n", "-", "c", "*", "h", "*", "j", "*", "m", "-", "d", "*", "e", "*", "j", "*", "o", "+", "d", "*", "e", "*", "k", "*", "n", "+", "d", "*", "f", "*", "i", "*", "o", "-", "d", "*", "f", "*", "k", "*", "m", "-", "d", "*", "g", "*", "i", "*", "n", "+", "d", "*", "g", "*", "j", "*", "m" ]

[ "def", "file_matches", "(", "filename", ",", "patterns", ")", ":", "return", "any", "(", "fnmatch", ".", "fnmatch", "(", "filename", ",", "pat", ")", "or", "fnmatch", ".", "fnmatch", "(", "os", ".", "path", ".", "basename", "(", "filename", ")", ",", "pat", ")", "for", "pat", "in", "patterns", ")" ]

[ "Does", "this", "filename", "match", "any", "of", "the", "patterns?" ]

[ "def", "_getnode", "(", "self", ",", "curie", ")", ":", "# convention is lowercase names", "node", "=", "None", "if", "curie", "[", "0", "]", "==", "'_'", ":", "if", "self", ".", "are_bnodes_skized", "is", "True", ":", "node", "=", "self", ".", "skolemizeBlankNode", "(", "curie", ")", "else", ":", "# delete the leading underscore to make it cleaner", "node", "=", "BNode", "(", "re", ".", "sub", "(", "r'^_:|^_'", ",", "''", ",", "curie", ",", "1", ")", ")", "# Check if curie string is actually an IRI", "elif", "curie", "[", ":", "4", "]", "==", "'http'", "or", "curie", "[", ":", "3", "]", "==", "'ftp'", ":", "node", "=", "URIRef", "(", "curie", ")", "else", ":", "iri", "=", "RDFGraph", ".", "curie_util", ".", "get_uri", "(", "curie", ")", "if", "iri", "is", "not", "None", ":", "node", "=", "URIRef", "(", "RDFGraph", ".", "curie_util", ".", "get_uri", "(", "curie", ")", ")", "# Bind prefix map to graph", "prefix", "=", "curie", ".", "split", "(", "':'", ")", "[", "0", "]", "if", "prefix", "not", "in", "self", ".", "namespace_manager", ".", "namespaces", "(", ")", ":", "mapped_iri", "=", "self", ".", "curie_map", "[", "prefix", "]", "self", ".", "bind", "(", "prefix", ",", "Namespace", "(", "mapped_iri", ")", ")", "else", ":", "LOG", ".", "error", "(", "\"couldn't make URI for %s\"", ",", "curie", ")", "return", "node" ]

[ "This", "is", "a", "wrapper", "for", "creating", "a", "URIRef", "or", "Bnode", "object", "with", "a", "given", "a", "curie", "or", "iri", "as", "a", "string", "." ]

[ "def", "base_uri", "(", "relative_path", "=", "''", ")", ":", "try", ":", "# PyInstaller creates a temp folder and stores path in _MEIPASS", "base_path", "=", "sys", ".", "_MEIPASS", "except", "Exception", ":", "if", "'pytest'", "in", "sys", ".", "modules", ":", "for", "arg", "in", "reversed", "(", "sys", ".", "argv", ")", ":", "path", "=", "os", ".", "path", ".", "realpath", "(", "arg", ")", "if", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "base_path", "=", "path", "if", "os", ".", "path", ".", "isdir", "(", "path", ")", "else", "os", ".", "path", ".", "dirname", "(", "path", ")", "break", "else", ":", "base_path", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "realpath", "(", "sys", ".", "argv", "[", "0", "]", ")", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "base_path", ")", ":", "raise", "ValueError", "(", "'Path %s does not exist'", "%", "base_path", ")", "return", "'file://%s'", "%", "os", ".", "path", ".", "join", "(", "base_path", ",", "relative_path", ")" ]

[ "Get", "absolute", "path", "to", "resource", "works", "for", "dev", "and", "for", "PyInstaller" ]

[ "def", "run_server", "(", "self", ")", ":", "self", ".", "protocol", "=", "MeaseWebSocketServerProtocol", "reactor", ".", "listenTCP", "(", "port", "=", "self", ".", "port", ",", "factory", "=", "self", ",", "interface", "=", "self", ".", "host", ")", "logger", ".", "info", "(", "\"Websocket server listening on {address}\"", ".", "format", "(", "address", "=", "self", ".", "address", ")", ")", "reactor", ".", "run", "(", ")" ]

[ "Runs", "the", "WebSocket", "server" ]

[ "def", "_align_with_substrings", "(", "self", ",", "chains_to_skip", "=", "set", "(", ")", ")", ":", "for", "c", "in", "self", ".", "representative_chains", ":", "# Skip specified chains", "if", "c", "not", "in", "chains_to_skip", ":", "#colortext.pcyan(c)", "#colortext.warning(self.fasta[c])", "fasta_sequence", "=", "self", ".", "fasta", "[", "c", "]", "substring_matches", "=", "{", "}", "for", "uniparc_id", ",", "uniparc_sequence", "in", "sorted", "(", "self", ".", "uniparc_sequences", ".", "iteritems", "(", ")", ")", ":", "uniparc_sequence", "=", "str", "(", "uniparc_sequence", ")", "idx", "=", "uniparc_sequence", ".", "find", "(", "fasta_sequence", ")", "if", "idx", "!=", "-", "1", ":", "substring_matches", "[", "uniparc_id", "]", "=", "0", "elif", "len", "(", "fasta_sequence", ")", ">", "30", ":", "idx", "=", "uniparc_sequence", ".", "find", "(", "fasta_sequence", "[", "5", ":", "-", "5", "]", ")", "if", "idx", "!=", "-", "1", ":", "substring_matches", "[", "uniparc_id", "]", "=", "5", "else", ":", "idx", "=", "uniparc_sequence", ".", "find", "(", "fasta_sequence", "[", "7", ":", "-", "7", "]", ")", "if", "idx", "!=", "-", "1", ":", "substring_matches", "[", "uniparc_id", "]", "=", "7", "elif", "len", "(", "fasta_sequence", ")", ">", "15", ":", "idx", "=", "uniparc_sequence", ".", "find", "(", "fasta_sequence", "[", "3", ":", "-", "3", "]", ")", "if", "idx", "!=", "-", "1", ":", "substring_matches", "[", "uniparc_id", "]", "=", "3", "self", ".", "substring_matches", "[", "c", "]", "=", "substring_matches", "# Restrict the matches to a given set of UniParc IDs. This can be used to remove ambiguity when the correct mapping has been determined e.g. from the SIFTS database.", "colortext", ".", "pcyan", "(", "'*'", "*", "100", ")", "pprint", ".", "pprint", "(", "self", ".", "substring_matches", ")", "if", "self", ".", "restrict_to_uniparc_values", ":", "for", "c", "in", "self", ".", "representative_chains", ":", "#print('HERE!')", "#print(c)", "if", "set", "(", "map", "(", "str", ",", "self", ".", "substring_matches", "[", "c", "]", ".", "keys", "(", ")", ")", ")", ".", "intersection", "(", "set", "(", "self", ".", "restrict_to_uniparc_values", ")", ")", ">", "0", ":", "# Only restrict in cases where there is at least one match in self.restrict_to_uniparc_values", "# Otherwise, chains which are not considered in self.restrict_to_uniparc_values may throw away valid matches", "# e.g. when looking for structures related to 1KTZ (A -> P10600 -> UPI000000D8EC, B -> P37173 -> UPI000011DD7E),", "# we find the close match 2PJY. However, 2PJY has 3 chains: A -> P10600, B -> P37173, and C -> P36897 -> UPI000011D62A", "restricted_matches", "=", "dict", "(", "(", "str", "(", "k", ")", ",", "self", ".", "substring_matches", "[", "c", "]", "[", "k", "]", ")", "for", "k", "in", "self", ".", "substring_matches", "[", "c", "]", ".", "keys", "(", ")", "if", "str", "(", "k", ")", "in", "self", ".", "restrict_to_uniparc_values", ")", "if", "len", "(", "restricted_matches", ")", "!=", "len", "(", "self", ".", "substring_matches", "[", "c", "]", ")", ":", "removed_matches", "=", "sorted", "(", "set", "(", "self", ".", "substring_matches", "[", "c", "]", ".", "keys", "(", ")", ")", ".", "difference", "(", "set", "(", "restricted_matches", ")", ")", ")", "# todo: see above re:quiet colortext.pcyan('Ignoring {0} as those chains were not included in the list self.restrict_to_uniparc_values ({1}).'.format(', '.join(removed_matches), ', '.join(self.restrict_to_uniparc_values)))", "self", ".", "substring_matches", "[", "c", "]", "=", "restricted_matches", "#pprint.pprint(self.substring_matches)", "#colortext.pcyan('*' * 100)", "# Use the representatives' alignments for their respective equivalent classes", "for", "c_1", ",", "related_chains", "in", "self", ".", "equivalence_fiber", ".", "iteritems", "(", ")", ":", "for", "c_2", "in", "related_chains", ":", "self", ".", "substring_matches", "[", "c_2", "]", "=", "self", ".", "substring_matches", "[", "c_1", "]" ]

[ "Simple", "substring", "-", "based", "matching" ]

[ "def", "replace_nulls", "(", "hdrs", ")", ":", "ret", "=", "[", "]", "idx", "=", "0", "for", "hdr", "in", "hdrs", ":", "if", "hdr", "==", "''", ":", "ret", ".", "append", "(", "\"no_hdr{}\"", ".", "format", "(", "idx", ")", ")", "else", ":", "ret", ".", "append", "(", "hdr", ")", "return", "ret" ]

[ "Replace", "in", "hdrs", "." ]

[ "def", "post_message", "(", "message", ",", "channel", "=", "None", ",", "username", "=", "None", ",", "api_url", "=", "None", ",", "hook", "=", "None", ")", ":", "if", "not", "api_url", ":", "api_url", "=", "_get_api_url", "(", ")", "if", "not", "hook", ":", "hook", "=", "_get_hook", "(", ")", "if", "not", "username", ":", "username", "=", "_get_username", "(", ")", "if", "not", "channel", ":", "channel", "=", "_get_channel", "(", ")", "if", "not", "message", ":", "log", ".", "error", "(", "'message is a required option.'", ")", "parameters", "=", "dict", "(", ")", "if", "channel", ":", "parameters", "[", "'channel'", "]", "=", "channel", "if", "username", ":", "parameters", "[", "'username'", "]", "=", "username", "parameters", "[", "'text'", "]", "=", "'```'", "+", "message", "+", "'```'", "# pre-formatted, fixed-width text", "log", ".", "debug", "(", "'Parameters: %s'", ",", "parameters", ")", "data", "=", "salt", ".", "utils", ".", "json", ".", "dumps", "(", "parameters", ")", "result", "=", "salt", ".", "utils", ".", "mattermost", ".", "query", "(", "api_url", "=", "api_url", ",", "hook", "=", "hook", ",", "data", "=", "str", "(", "'payload={0}'", ")", ".", "format", "(", "data", ")", ")", "# future lint: blacklisted-function", "if", "result", ":", "return", "True", "else", ":", "return", "result" ]

[ "Send", "a", "message", "to", "a", "Mattermost", "channel", ".", ":", "param", "channel", ":", "The", "channel", "name", "either", "will", "work", ".", ":", "param", "username", ":", "The", "username", "of", "the", "poster", ".", ":", "param", "message", ":", "The", "message", "to", "send", "to", "the", "Mattermost", "channel", ".", ":", "param", "api_url", ":", "The", "Mattermost", "api", "url", "if", "not", "specified", "in", "the", "configuration", ".", ":", "param", "hook", ":", "The", "Mattermost", "hook", "if", "not", "specified", "in", "the", "configuration", ".", ":", "return", ":", "Boolean", "if", "message", "was", "sent", "successfully", "." ]

[ "def", "connect", "(", "self", ",", "*", "names", ")", ":", "fromName", ",", "toName", ",", "rest", "=", "names", "[", "0", "]", ",", "names", "[", "1", "]", ",", "names", "[", "2", ":", "]", "self", ".", "connectAt", "(", "fromName", ",", "toName", ")", "if", "len", "(", "rest", ")", "!=", "0", ":", "self", ".", "connect", "(", "toName", ",", "*", "rest", ")" ]

[ "Connects", "a", "list", "of", "names", "one", "to", "the", "next", "." ]

[ "def", "stop_watching", "(", "self", ",", "cluster", ")", ":", "znode_path", "=", "\"/\"", ".", "join", "(", "[", "self", ".", "base_path", ",", "cluster", ".", "name", "]", ")", "if", "znode_path", "in", "self", ".", "stop_events", ":", "self", ".", "stop_events", "[", "znode_path", "]", ".", "set", "(", ")" ]

[ "Causes", "the", "thread", "that", "launched", "the", "watch", "of", "the", "cluster", "path", "to", "end", "by", "setting", "the", "proper", "stop", "event", "found", "in", "self", ".", "stop_events", "." ]

[ "def", "file_local_list", "(", "self", ",", "saltenv", "=", "'base'", ")", ":", "filesdest", "=", "os", ".", "path", ".", "join", "(", "self", ".", "opts", "[", "'cachedir'", "]", ",", "'files'", ",", "saltenv", ")", "localfilesdest", "=", "os", ".", "path", ".", "join", "(", "self", ".", "opts", "[", "'cachedir'", "]", ",", "'localfiles'", ")", "fdest", "=", "self", ".", "_file_local_list", "(", "filesdest", ")", "ldest", "=", "self", ".", "_file_local_list", "(", "localfilesdest", ")", "return", "sorted", "(", "fdest", ".", "union", "(", "ldest", ")", ")" ]

[ "List", "files", "in", "the", "local", "minion", "files", "and", "localfiles", "caches" ]

[ "def", "end_element", "(", "self", ",", "name", ")", ":", "self", ".", "in_tag", "=", "False", "if", "name", "==", "self", ".", "tag", ":", "self", ".", "add_url", "(", ")" ]

[ "If", "end", "tag", "is", "our", "tag", "call", "add_url", "()", "." ]

[ "def", "plot_polarbar", "(", "scores", ",", "labels", "=", "None", ",", "labels_size", "=", "15", ",", "colors", "=", "\"default\"", ",", "distribution_means", "=", "None", ",", "distribution_sds", "=", "None", ",", "treshold", "=", "1.28", ",", "fig_size", "=", "(", "15", ",", "15", ")", ")", ":", "# Sanity check", "if", "isinstance", "(", "scores", ",", "dict", ")", ":", "if", "labels", "is", "None", ":", "labels", "=", "list", "(", "scores", ".", "keys", "(", ")", ")", "try", ":", "scores", "=", "[", "scores", "[", "key", "]", "for", "key", "in", "labels", "]", "except", "KeyError", ":", "print", "(", "\"NeuroKit Error: plot_polarbar(): labels and scores keys not matching. Recheck them.\"", ")", "# Parameters", "if", "colors", "==", "\"default\"", ":", "if", "len", "(", "scores", ")", "<", "9", ":", "colors", "=", "[", "\"#f44336\"", ",", "\"#9C27B0\"", ",", "\"#3F51B5\"", ",", "\"#03A9F4\"", ",", "\"#009688\"", ",", "\"#8BC34A\"", ",", "\"#FFEB3B\"", ",", "\"#FF9800\"", ",", "\"#795548\"", "]", "else", ":", "colors", "=", "None", "if", "labels", "is", "None", ":", "labels", "=", "range", "(", "len", "(", "scores", ")", ")", "N", "=", "len", "(", "scores", ")", "theta", "=", "np", ".", "linspace", "(", "0.0", ",", "-", "2", "*", "np", ".", "pi", ",", "N", ",", "endpoint", "=", "False", ")", "width", "=", "2", "*", "np", ".", "pi", "/", "N", "# Main", "plot", "=", "plt", ".", "figure", "(", "figsize", "=", "fig_size", ")", "layer1", "=", "plot", ".", "add_subplot", "(", "111", ",", "projection", "=", "\"polar\"", ")", "bars1", "=", "layer1", ".", "bar", "(", "theta", "+", "np", ".", "pi", "/", "len", "(", "scores", ")", ",", "scores", ",", "width", "=", "width", ",", "bottom", "=", "0.0", ")", "layer1", ".", "yaxis", ".", "set_ticks", "(", "range", "(", "11", ")", ")", "layer1", ".", "yaxis", ".", "set_ticklabels", "(", "[", "]", ")", "layer1", ".", "xaxis", ".", "set_ticks", "(", "theta", "+", "np", ".", "pi", "/", "len", "(", "scores", ")", ")", "layer1", ".", "xaxis", ".", "set_ticklabels", "(", "labels", ",", "fontsize", "=", "labels_size", ")", "for", "index", ",", "bar", "in", "enumerate", "(", "bars1", ")", ":", "if", "colors", "is", "not", "None", ":", "bar", ".", "set_facecolor", "(", "colors", "[", "index", "]", ")", "bar", ".", "set_alpha", "(", "1", ")", "# Layer 2", "if", "distribution_means", "is", "not", "None", "and", "distribution_sds", "is", "not", "None", ":", "# Sanity check", "if", "isinstance", "(", "distribution_means", ",", "int", ")", ":", "distribution_means", "=", "[", "distribution_means", "]", "*", "N", "if", "isinstance", "(", "distribution_sds", ",", "int", ")", ":", "distribution_sds", "=", "[", "distribution_sds", "]", "*", "N", "# TODO: add convertion if those parameter are dict", "bottoms", ",", "tops", "=", "normal_range", "(", "np", ".", "array", "(", "distribution_means", ")", ",", "np", ".", "array", "(", "distribution_sds", ")", ",", "treshold", "=", "treshold", ")", "tops", "=", "tops", "-", "bottoms", "layer2", "=", "plot", ".", "add_subplot", "(", "111", ",", "polar", "=", "True", ")", "bars2", "=", "layer2", ".", "bar", "(", "theta", ",", "tops", ",", "width", "=", "width", ",", "bottom", "=", "bottoms", ",", "linewidth", "=", "0", ")", "layer2", ".", "xaxis", ".", "set_ticks", "(", "theta", "+", "np", ".", "pi", "/", "len", "(", "scores", ")", ")", "layer2", ".", "xaxis", ".", "set_ticklabels", "(", "labels", ",", "fontsize", "=", "labels_size", ")", "for", "index", ",", "bar", "in", "enumerate", "(", "bars2", ")", ":", "bar", ".", "set_facecolor", "(", "\"#607D8B\"", ")", "bar", ".", "set_alpha", "(", "0.3", ")", "return", "(", "plot", ")" ]

[ "Polar", "bar", "chart", "." ]

[ "def", "voigt_symmetrized", "(", "self", ")", ":", "if", "not", "(", "self", ".", "rank", "%", "2", "==", "0", "and", "self", ".", "rank", ">=", "2", ")", ":", "raise", "ValueError", "(", "\"V-symmetrization requires rank even and >= 2\"", ")", "v", "=", "self", ".", "voigt", "perms", "=", "list", "(", "itertools", ".", "permutations", "(", "range", "(", "len", "(", "v", ".", "shape", ")", ")", ")", ")", "new_v", "=", "sum", "(", "[", "np", ".", "transpose", "(", "v", ",", "ind", ")", "for", "ind", "in", "perms", "]", ")", "/", "len", "(", "perms", ")", "return", "self", ".", "__class__", ".", "from_voigt", "(", "new_v", ")" ]

[ "Returns", "a", "voigt", "-", "symmetrized", "tensor", "i", ".", "e", ".", "a", "voigt", "-", "notation", "tensor", "such", "that", "it", "is", "invariant", "wrt", "permutation", "of", "indices" ]

[ "def", "snapshot_get", "(", "repository", ",", "snapshot", ",", "ignore_unavailable", "=", "False", ",", "hosts", "=", "None", ",", "profile", "=", "None", ")", ":", "es", "=", "_get_instance", "(", "hosts", ",", "profile", ")", "try", ":", "return", "es", ".", "snapshot", ".", "get", "(", "repository", "=", "repository", ",", "snapshot", "=", "snapshot", ",", "ignore_unavailable", "=", "ignore_unavailable", ")", "except", "elasticsearch", ".", "TransportError", "as", "e", ":", "raise", "CommandExecutionError", "(", "\"Cannot obtain details of snapshot {0} in repository {1}, server returned code {2} with message {3}\"", ".", "format", "(", "snapshot", ",", "repository", ",", "e", ".", "status_code", ",", "e", ".", "error", ")", ")" ]

[ "..", "versionadded", "::", "2017", ".", "7", ".", "0" ]

[ "def", "terminal_cfg_line_exec_timeout", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "terminal_cfg", "=", "ET", ".", "SubElement", "(", "config", ",", "\"terminal-cfg\"", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-terminal\"", ")", "line", "=", "ET", ".", "SubElement", "(", "terminal_cfg", ",", "\"line\"", ")", "sessionid_key", "=", "ET", ".", "SubElement", "(", "line", ",", "\"sessionid\"", ")", "sessionid_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'sessionid'", ")", "exec_timeout", "=", "ET", ".", "SubElement", "(", "line", ",", "\"exec-timeout\"", ")", "exec_timeout", ".", "text", "=", "kwargs", ".", "pop", "(", "'exec_timeout'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "has_code", "(", "state", ",", "text", ",", "incorrect_msg", "=", "\"Check the {ast_path}. The checker expected to find {text}.\"", ",", "fixed", "=", "False", ",", ")", ":", "stu_ast", "=", "state", ".", "student_ast", "stu_code", "=", "state", ".", "student_code", "# fallback on using complete student code if no ast", "ParseError", "=", "state", ".", "ast_dispatcher", ".", "ParseError", "def", "get_text", "(", "ast", ",", "code", ")", ":", "if", "isinstance", "(", "ast", ",", "ParseError", ")", ":", "return", "code", "try", ":", "return", "ast", ".", "get_text", "(", "code", ")", "except", ":", "return", "code", "stu_text", "=", "get_text", "(", "stu_ast", ",", "stu_code", ")", "_msg", "=", "incorrect_msg", ".", "format", "(", "ast_path", "=", "state", ".", "get_ast_path", "(", ")", "or", "\"highlighted code\"", ",", "text", "=", "text", ")", "# either simple text matching or regex test", "res", "=", "text", "in", "stu_text", "if", "fixed", "else", "re", ".", "search", "(", "text", ",", "stu_text", ")", "if", "not", "res", ":", "state", ".", "report", "(", "Feedback", "(", "_msg", ")", ")", "return", "state" ]

[ "Test", "whether", "the", "student", "code", "contains", "text", "." ]

[ "def", "absence_count", "(", "self", ")", ":", "# FIXME: remove recursive dep", "from", ".", ".", "eighth", ".", "models", "import", "EighthSignup", "return", "EighthSignup", ".", "objects", ".", "filter", "(", "user", "=", "self", ",", "was_absent", "=", "True", ",", "scheduled_activity__attendance_taken", "=", "True", ")", ".", "count", "(", ")" ]

[ "Return", "the", "user", "s", "absence", "count", "." ]

[ "def", "add_actor", "(", "self", ",", "uinput", ",", "reset_camera", "=", "False", ",", "name", "=", "None", ",", "loc", "=", "None", ",", "culling", "=", "False", ")", ":", "# add actor to the correct render window", "self", ".", "_active_renderer_index", "=", "self", ".", "loc_to_index", "(", "loc", ")", "renderer", "=", "self", ".", "renderers", "[", "self", ".", "_active_renderer_index", "]", "return", "renderer", ".", "add_actor", "(", "uinput", ",", "reset_camera", ",", "name", ",", "culling", ")" ]

[ "Adds", "an", "actor", "to", "render", "window", ".", "Creates", "an", "actor", "if", "input", "is", "a", "mapper", "." ]

[ "def", "_format_value", "(", "self", ",", "value", ")", ":", "# Use renamed format_name() for Django versions >= 1.10.", "if", "hasattr", "(", "self", ",", "'format_value'", ")", ":", "return", "super", "(", "DateTimePicker", ",", "self", ")", ".", "format_value", "(", "value", ")", "# Use old _format_name() for Django versions < 1.10.", "else", ":", "return", "super", "(", "DateTimePicker", ",", "self", ")", ".", "_format_value", "(", "value", ")" ]

[ "This", "function", "name", "was", "changed", "in", "Django", "1", ".", "10", "and", "removed", "in", "2", ".", "0", "." ]

[ "def", "intersect_range", "(", "self", ",", "start", "=", "None", ",", "stop", "=", "None", ")", ":", "try", ":", "loc", "=", "self", ".", "locate_range", "(", "start", "=", "start", ",", "stop", "=", "stop", ")", "except", "KeyError", ":", "return", "self", ".", "values", "[", "0", ":", "0", "]", "else", ":", "return", "self", "[", "loc", "]" ]

[ "Intersect", "with", "range", "defined", "by", "start", "and", "stop", "values", "**", "inclusive", "**", "." ]

[ "def", "_split_standard_name", "(", "self", ",", "standard_name", ")", ":", "if", "isinstance", "(", "standard_name", ",", "basestring", ")", "and", "' '", "in", "standard_name", ":", "return", "standard_name", ".", "split", "(", "' '", ",", "1", ")", "# if this isn't a string, then it doesn't make sense to split", "# -- treat value as standard name with no modifier", "else", ":", "return", "standard_name", ",", "None" ]

[ "Returns", "a", "tuple", "of", "the", "standard_name", "and", "standard_name", "modifier" ]

[ "def", "update_widget_channels", "(", "self", ")", ":", "sel1", "=", "self", ".", "x_axis_list", ".", "GetSelection", "(", ")", "sel2", "=", "self", ".", "y_axis_list", ".", "GetSelection", "(", ")", "if", "sel1", ">=", "0", "and", "sel2", ">=", "0", ":", "channel_1", "=", "self", ".", "x_axis_list", ".", "GetString", "(", "sel1", ")", "channel_2", "=", "self", ".", "y_axis_list", ".", "GetString", "(", "sel2", ")", "self", ".", "fcgatemanager", ".", "set_axes", "(", "(", "channel_1", ",", "channel_2", ")", ",", "self", ".", "ax", ")" ]

[ "Parameters", "-------------", "axis", ":", "x", "or", "y", "event", ":", "pick", "of", "list", "text" ]

[ "def", "_parse_rs_map_file", "(", "rsfile", ")", ":", "rs_map", "=", "{", "}", "col", "=", "[", "'chromosome'", ",", "'position'", ",", "'rs_id'", ",", "'var_type'", ",", "'alleles'", "]", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ",", "rsfile", ")", ")", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "__file__", ")", ",", "rsfile", ")", ")", "as", "tsvfile", ":", "reader", "=", "csv", ".", "reader", "(", "tsvfile", ",", "delimiter", "=", "\"\\t\"", ")", "for", "row", "in", "reader", ":", "chromosome", "=", "row", "[", "col", ".", "index", "(", "'chromosome'", ")", "]", "position", "=", "row", "[", "col", ".", "index", "(", "'position'", ")", "]", "# rs_id, var_type, alleles) = row", "map_key", "=", "\"chr{0}-{1}\"", ".", "format", "(", "chromosome", ",", "position", ")", "rs_info", "=", "{", "'type'", ":", "row", "[", "col", ".", "index", "(", "'var_type'", ")", "]", ",", "'rs_id'", ":", "row", "[", "col", ".", "index", "(", "'rs_id'", ")", "]", ",", "'alleles'", ":", "row", "[", "col", ".", "index", "(", "'alleles'", ")", "]", "}", "if", "map_key", "in", "rs_map", ":", "rs_map", "[", "map_key", "]", ".", "append", "(", "rs_info", ")", "else", ":", "rs_map", "[", "map_key", "]", "=", "[", "rs_info", "]", "return", "rs_map" ]

[ "Parses", "rsID", "mapping", "file", "from", "dbSNP", "Outputs", "dict", "where", "keys", "are", "coordinates", "in", "the", "format", "{", "chromsome", "}", "-", "{", "position", "}" ]

[ "def", "diffstore", "(", "self", ",", "destination", ",", "*", "others", ")", ":", "others", "=", "self", ".", "_typesafe_others", "(", "others", ")", "destination", "=", "self", ".", "_typesafe", "(", "destination", ")", "return", "self", ".", "_client", ".", "sdiffstore", "(", "destination", ",", "self", ".", "key_prefix", ",", "*", "others", ")" ]

[ "The", "same", "as", ":", "meth", ":", "difference", "but", "stores", "the", "resulting", "set", "@destination" ]

[ "def", "collect_transitive_dependencies", "(", "collected", ":", "Set", "[", "str", "]", ",", "dep_graph", ":", "DepGraph", ",", "from_name", ":", "str", ")", "->", "None", ":", "immediate_deps", "=", "dep_graph", "[", "from_name", "]", "for", "to_name", "in", "immediate_deps", ":", "if", "to_name", "not", "in", "collected", ":", "collected", ".", "add", "(", "to_name", ")", "collect_transitive_dependencies", "(", "collected", ",", "dep_graph", ",", "to_name", ")" ]

[ "Collect", "transitive", "dependencies", "." ]