Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "get_msg_pending", "(", "self", ",", "channel", ",", "flags", ")", ":", "count", "=", "DWORD", "(", "0", ")", "UcanGetMsgPending", "(", "self", ".", "_handle", ",", "channel", ",", "flags", ",", "byref", "(", "count", ")", ")", "return", "count", ".", "value" ]

[ "Returns", "the", "number", "of", "pending", "CAN", "messages", "." ]

[ "def", "profile", "(", "request", ",", "username", ",", "template", "=", "\"accounts/account_profile.html\"", ",", "extra_context", "=", "None", ")", ":", "lookup", "=", "{", "\"username__iexact\"", ":", "username", ",", "\"is_active\"", ":", "True", "}", "context", "=", "{", "\"profile_user\"", ":", "get_object_or_404", "(", "User", ",", "*", "*", "lookup", ")", "}", "context", ".", "update", "(", "extra_context", "or", "{", "}", ")", "return", "TemplateResponse", "(", "request", ",", "template", ",", "context", ")" ]

[ "Display", "a", "profile", "." ]

[ "def", "p_class_declaration_statement", "(", "p", ")", ":", "if", "len", "(", "p", ")", "==", "8", ":", "p", "[", "0", "]", "=", "ast", ".", "Class", "(", "p", "[", "2", "]", ",", "p", "[", "1", "]", ",", "p", "[", "3", "]", ",", "p", "[", "4", "]", ",", "p", "[", "6", "]", ",", "lineno", "=", "p", ".", "lineno", "(", "2", ")", ")", "else", ":", "p", "[", "0", "]", "=", "ast", ".", "Interface", "(", "p", "[", "2", "]", ",", "p", "[", "3", "]", ",", "p", "[", "5", "]", ",", "lineno", "=", "p", ".", "lineno", "(", "1", ")", ")" ]

[ "class_declaration_statement", ":", "class_entry_type", "STRING", "extends_from", "implements_list", "LBRACE", "class_statement_list", "RBRACE", "|", "INTERFACE", "STRING", "interface_extends_list", "LBRACE", "class_statement_list", "RBRACE" ]

[ "def", "delta", "(", "d1", ",", "d2", ",", "opt", "=", "'d'", ")", ":", "delta", "=", "0", "if", "opt", "==", "'m'", ":", "while", "True", ":", "mdays", "=", "monthrange", "(", "d1", ".", "year", ",", "d1", ".", "month", ")", "[", "1", "]", "d1", "+=", "timedelta", "(", "days", "=", "mdays", ")", "if", "d1", "<=", "d2", ":", "delta", "+=", "1", "else", ":", "break", "else", ":", "delta", "=", "(", "d2", "-", "d1", ")", ".", "days", "return", "delta" ]

[ "Compute", "difference", "between", "given", "2", "dates", "in", "month", "/", "day", "." ]

[ "def", "unmarshaller", "(", "self", ",", "typed", "=", "True", ")", ":", "if", "typed", ":", "return", "UmxEncoded", "(", "self", ".", "schema", "(", ")", ")", "else", ":", "return", "RPC", ".", "unmarshaller", "(", "self", ",", "typed", ")" ]

[ "Get", "the", "appropriate", "XML", "decoder", "." ]

[ "def", "__dict_to_pod_spec", "(", "spec", ")", ":", "spec_obj", "=", "kubernetes", ".", "client", ".", "V1PodSpec", "(", ")", "for", "key", ",", "value", "in", "iteritems", "(", "spec", ")", ":", "if", "hasattr", "(", "spec_obj", ",", "key", ")", ":", "setattr", "(", "spec_obj", ",", "key", ",", "value", ")", "return", "spec_obj" ]

[ "Converts", "a", "dictionary", "into", "kubernetes", "V1PodSpec", "instance", "." ]

[ "def", "find_atoms_within_distance", "(", "atoms", ",", "cutoff_distance", ",", "point", ")", ":", "return", "[", "x", "for", "x", "in", "atoms", "if", "distance", "(", "x", ",", "point", ")", "<=", "cutoff_distance", "]" ]

[ "Returns", "atoms", "within", "the", "distance", "from", "the", "point", "." ]

[ "def", "Serialize", "(", "self", ",", "writer", ")", ":", "writer", ".", "WriteUInt256", "(", "self", ".", "AssetId", ")", "writer", ".", "WriteFixed8", "(", "self", ".", "Value", ")", "writer", ".", "WriteUInt160", "(", "self", ".", "ScriptHash", ")" ]

[ "Serialize", "object", "." ]

[ "def", "login", "(", "token", ",", "apikey", ",", "username", ",", "password", ")", ":", "if", "manual_login_success", "(", "token", ",", "username", ",", "password", ")", ":", "return", "if", "not", "apikey", ":", "if", "has_browser", "(", ")", ":", "apikey", "=", "wait_for_apikey", "(", ")", "else", ":", "floyd_logger", ".", "error", "(", "\"No browser found, please login manually by creating login key at %s/settings/apikey.\"", ",", "floyd", ".", "floyd_web_host", ")", "sys", ".", "exit", "(", "1", ")", "if", "apikey", ":", "user", "=", "AuthClient", "(", ")", ".", "get_user", "(", "apikey", ",", "is_apikey", "=", "True", ")", "AuthConfigManager", ".", "set_apikey", "(", "username", "=", "user", ".", "username", ",", "apikey", "=", "apikey", ")", "floyd_logger", ".", "info", "(", "\"Login Successful as %s\"", ",", "user", ".", "username", ")", "else", ":", "floyd_logger", ".", "error", "(", "\"Login failed, please see --help for other login options.\"", ")" ]

[ "Login", "to", "FloydHub", "." ]

[ "def", "get_black_list", "(", "self", ",", "begin_openid", "=", "None", ")", ":", "data", "=", "{", "}", "if", "begin_openid", ":", "data", "[", "'begin_openid'", "]", "=", "begin_openid", "return", "self", ".", "_post", "(", "'tags/members/getblacklist'", ",", "data", "=", "data", ",", ")" ]

[ "获取公众号的黑名单列表", "详情请参考", "https", ":", "//", "mp", ".", "weixin", ".", "qq", ".", "com", "/", "wiki?id", "=", "mp1471422259_pJMWA" ]

[ "def", "build_index", "(", "root", ",", "base_url", ")", ":", "# Find all packages.", "packages", "=", "[", "]", "for", "pkg_xml", ",", "zf", ",", "subdir", "in", "_find_packages", "(", "os", ".", "path", ".", "join", "(", "root", ",", "'packages'", ")", ")", ":", "zipstat", "=", "os", ".", "stat", "(", "zf", ".", "filename", ")", "url", "=", "'%s/%s/%s'", "%", "(", "base_url", ",", "subdir", ",", "os", ".", "path", ".", "split", "(", "zf", ".", "filename", ")", "[", "1", "]", ")", "unzipped_size", "=", "sum", "(", "zf_info", ".", "file_size", "for", "zf_info", "in", "zf", ".", "infolist", "(", ")", ")", "# Fill in several fields of the package xml with calculated values.", "pkg_xml", ".", "set", "(", "'unzipped_size'", ",", "'%s'", "%", "unzipped_size", ")", "pkg_xml", ".", "set", "(", "'size'", ",", "'%s'", "%", "zipstat", ".", "st_size", ")", "pkg_xml", ".", "set", "(", "'subdir'", ",", "subdir", ")", "pkg_xml", ".", "set", "(", "'url'", ",", "url", ")", "# Record the package.", "packages", ".", "append", "(", "pkg_xml", ")", "# Find all collections", "collections", "=", "list", "(", "_find_collections", "(", "os", ".", "path", ".", "join", "(", "root", ",", "'collections'", ")", ")", ")", "# Check that all UIDs are unique", "uids", "=", "set", "(", ")", "for", "item", "in", "packages", "+", "collections", ":", "if", "item", ".", "get", "(", "'id'", ")", "in", "uids", ":", "raise", "ValueError", "(", "'Duplicate UID: %s'", "%", "item", ".", "get", "(", "'id'", ")", ")", "uids", ".", "add", "(", "item", ".", "get", "(", "'id'", ")", ")", "# Put it all together", "top_elt", "=", "ElementTree", ".", "Element", "(", "'polyglot_data'", ")", "top_elt", ".", "append", "(", "ElementTree", ".", "Element", "(", "'packages'", ")", ")", "for", "package", "in", "packages", ":", "top_elt", "[", "0", "]", ".", "append", "(", "package", ")", "top_elt", ".", "append", "(", "ElementTree", ".", "Element", "(", "'collections'", ")", ")", "for", "collection", "in", "collections", ":", "top_elt", "[", "1", "]", ".", "append", "(", "collection", ")", "_indent_xml", "(", "top_elt", ")", "return", "top_elt" ]

[ "Create", "a", "new", "data", ".", "xml", "index", "file", "by", "combining", "the", "xml", "description", "files", "for", "various", "packages", "and", "collections", ".", "root", "should", "be", "the", "path", "to", "a", "directory", "containing", "the", "package", "xml", "and", "zip", "files", ";", "and", "the", "collection", "xml", "files", ".", "The", "root", "directory", "is", "expected", "to", "have", "the", "following", "subdirectories", "::" ]

[ "def", "_update_settings", "(", "self", ",", "X", ")", ":", "self", ".", "logger", ".", "info", "(", "\"Loading default parameters for Sparse Logistic Regression\"", ")", "config", "=", "get_config", "(", ")", "[", "\"learning\"", "]", "[", "\"SparseLogisticRegression\"", "]", "for", "key", "in", "config", ".", "keys", "(", ")", ":", "if", "key", "not", "in", "self", ".", "settings", ":", "self", ".", "settings", "[", "key", "]", "=", "config", "[", "key", "]", "# Add one feature for padding vector (all 0s)", "self", ".", "settings", "[", "\"input_dim\"", "]", "=", "X", "[", "1", "]", ".", "shape", "[", "1", "]", "+", "1" ]

[ "Update", "the", "model", "argument", "." ]

[ "def", "visitConcatenation", "(", "self", ",", "ctx", ")", ":", "arg1", "=", "conversions", ".", "to_string", "(", "self", ".", "visit", "(", "ctx", ".", "expression", "(", "0", ")", ")", ",", "self", ".", "_eval_context", ")", "arg2", "=", "conversions", ".", "to_string", "(", "self", ".", "visit", "(", "ctx", ".", "expression", "(", "1", ")", ")", ",", "self", ".", "_eval_context", ")", "return", "arg1", "+", "arg2" ]

[ "expression", ":", "expression", "AMPERSAND", "expression" ]

[ "def", "createFileList", "(", "self", ")", ":", "global", "childFileListDownload", "global", "filelistDownloadActive", "mypid", "=", "os", ".", "getpid", "(", ")", "if", "mypid", "not", "in", "childFileListDownload", "or", "not", "childFileListDownload", "[", "mypid", "]", ".", "is_alive", "(", ")", ":", "childFileListDownload", "[", "mypid", "]", "=", "multiproc", ".", "Process", "(", "target", "=", "self", ".", "createFileListHTTP", ")", "filelistDownloadActive", "=", "1", "childFileListDownload", "[", "mypid", "]", ".", "start", "(", ")", "filelistDownloadActive", "=", "0" ]

[ "SRTM", "data", "is", "split", "into", "different", "directories", "get", "a", "list", "of", "all", "of", "them", "and", "create", "a", "dictionary", "for", "easy", "lookup", "." ]

[ "def", "_normalize_vc_input", "(", "data", ")", ":", "if", "data", ".", "get", "(", "\"ensemble\"", ")", ":", "for", "k", "in", "[", "\"batch_samples\"", ",", "\"validate\"", ",", "\"vrn_file\"", "]", ":", "data", "[", "k", "]", "=", "data", "[", "\"ensemble\"", "]", "[", "k", "]", "data", "[", "\"config\"", "]", "[", "\"algorithm\"", "]", "[", "\"variantcaller\"", "]", "=", "\"ensemble\"", "data", "[", "\"metadata\"", "]", "=", "{", "\"batch\"", ":", "data", "[", "\"ensemble\"", "]", "[", "\"batch_id\"", "]", "}", "return", "data" ]

[ "Normalize", "different", "types", "of", "variant", "calling", "inputs", "." ]

[ "def", "get_subtask_fields", "(", "config_class", ")", ":", "from", "lsst", ".", "pex", ".", "config", "import", "ConfigurableField", ",", "RegistryField", "def", "is_subtask_field", "(", "obj", ")", ":", "return", "isinstance", "(", "obj", ",", "(", "ConfigurableField", ",", "RegistryField", ")", ")", "return", "_get_alphabetical_members", "(", "config_class", ",", "is_subtask_field", ")" ]

[ "Get", "all", "configurable", "subtask", "fields", "from", "a", "Config", "class", "." ]

[ "def", "self_sign_jwks", "(", "keyjar", ",", "iss", ",", "kid", "=", "''", ",", "lifetime", "=", "3600", ")", ":", "# _json = json.dumps(jwks)", "_jwt", "=", "JWT", "(", "keyjar", ",", "iss", "=", "iss", ",", "lifetime", "=", "lifetime", ")", "jwks", "=", "keyjar", ".", "export_jwks", "(", "issuer", "=", "iss", ")", "return", "_jwt", ".", "pack", "(", "payload", "=", "{", "'jwks'", ":", "jwks", "}", ",", "owner", "=", "iss", ",", "kid", "=", "kid", ")" ]

[ "Create", "a", "signed", "JWT", "containing", "a", "JWKS", ".", "The", "JWT", "is", "signed", "by", "one", "of", "the", "keys", "in", "the", "JWKS", "." ]

[ "def", "population_fraction", "(", "self", ")", ":", "numerator", "=", "self", ".", "_cube_dict", "[", "\"result\"", "]", ".", "get", "(", "\"filtered\"", ",", "{", "}", ")", ".", "get", "(", "\"weighted_n\"", ")", "denominator", "=", "self", ".", "_cube_dict", "[", "\"result\"", "]", ".", "get", "(", "\"unfiltered\"", ",", "{", "}", ")", ".", "get", "(", "\"weighted_n\"", ")", "try", ":", "return", "numerator", "/", "denominator", "except", "ZeroDivisionError", ":", "return", "np", ".", "nan", "except", "Exception", ":", "return", "1.0" ]

[ "The", "filtered", "/", "unfiltered", "ratio", "for", "cube", "response", "." ]

[ "def", "remove_file", "(", "self", ",", "filepath", ")", ":", "self", ".", "_models", ".", "pop", "(", "filepath", ")", "self", ".", "_updates", ".", "pop", "(", "filepath", ",", "default", "=", "None", ")", "self", ".", "signalModelDestroyed", ".", "emit", "(", "filepath", ")" ]

[ "Removes", "the", "DataFrameModel", "from", "being", "registered", ".", ":", "param", "filepath", ":", "(", "str", ")", "The", "filepath", "to", "delete", "from", "the", "DataFrameModelManager", ".", ":", "return", ":", "None" ]

[ "def", "nonzero", "(", "self", ")", ":", "msg", "=", "(", "\"Series.nonzero() is deprecated \"", "\"and will be removed in a future version.\"", "\"Use Series.to_numpy().nonzero() instead\"", ")", "warnings", ".", "warn", "(", "msg", ",", "FutureWarning", ",", "stacklevel", "=", "2", ")", "return", "self", ".", "_values", ".", "nonzero", "(", ")" ]

[ "Return", "the", "*", "integer", "*", "indices", "of", "the", "elements", "that", "are", "non", "-", "zero", "." ]

[ "def", "prompt_auth", "(", "self", ")", ":", "if", "self", ".", "username", "and", "self", ".", "password", ":", "return", "sys", ".", "stdout", ".", "write", "(", "\"Please insert your credentials for %s\\n\"", "%", "self", ".", "url", ".", "base_url", ")", "while", "not", "self", ".", "username", ":", "self", ".", "username", "=", "raw_input", "(", "\"Username [%s]: \"", "%", "getpass", ".", "getuser", "(", ")", ")", "while", "not", "self", ".", "password", ":", "self", ".", "password", "=", "getpass", ".", "getpass", "(", "\"Password: \"", ")" ]

[ "Prompt", "the", "user", "for", "login", "/", "pass", "if", "needed", "." ]

[ "def", "render", "(", "self", ",", "form", ",", "form_style", ",", "context", ")", ":", "return", "render_to_string", "(", "self", ".", "template", ",", "Context", "(", "{", "'input'", ":", "self", "}", ")", ")" ]

[ "Renders", "an", "<input", "/", ">", "if", "container", "is", "used", "as", "a", "Layout", "object" ]

[ "def", "rename_dont_move", "(", "self", ",", "path", ",", "dest", ")", ":", "from", "snakebite", ".", "errors", "import", "FileAlreadyExistsException", "try", ":", "self", ".", "get_bite", "(", ")", ".", "rename2", "(", "path", ",", "dest", ",", "overwriteDest", "=", "False", ")", "except", "FileAlreadyExistsException", ":", "# Unfortunately python2 don't allow exception chaining.", "raise", "luigi", ".", "target", ".", "FileAlreadyExists", "(", ")" ]

[ "Use", "snakebite", ".", "rename_dont_move", "if", "available", "." ]

[ "def", "getParser", "(", "self", ",", "doc", "=", "None", ")", ":", "if", "self", ".", "parser", ":", "return", "self", ".", "parser", "env", "=", "self", ".", "env", "parser", "=", "self", ".", "parserClass", "(", "doc", ")", "parser", ".", "add_option", "(", "\"-V\"", ",", "\"--version\"", ",", "action", "=", "\"store_true\"", ",", "dest", "=", "\"version\"", ",", "default", "=", "False", ",", "help", "=", "\"Output nose version and exit\"", ")", "parser", ".", "add_option", "(", "\"-p\"", ",", "\"--plugins\"", ",", "action", "=", "\"store_true\"", ",", "dest", "=", "\"showPlugins\"", ",", "default", "=", "False", ",", "help", "=", "\"Output list of available plugins and exit. Combine with \"", "\"higher verbosity for greater detail\"", ")", "parser", ".", "add_option", "(", "\"-v\"", ",", "\"--verbose\"", ",", "action", "=", "\"count\"", ",", "dest", "=", "\"verbosity\"", ",", "default", "=", "self", ".", "verbosity", ",", "help", "=", "\"Be more verbose. [NOSE_VERBOSE]\"", ")", "parser", ".", "add_option", "(", "\"--verbosity\"", ",", "action", "=", "\"store\"", ",", "dest", "=", "\"verbosity\"", ",", "metavar", "=", "'VERBOSITY'", ",", "type", "=", "\"int\"", ",", "help", "=", "\"Set verbosity; --verbosity=2 is \"", "\"the same as -v\"", ")", "parser", ".", "add_option", "(", "\"-q\"", ",", "\"--quiet\"", ",", "action", "=", "\"store_const\"", ",", "const", "=", "0", ",", "dest", "=", "\"verbosity\"", ",", "help", "=", "\"Be less verbose\"", ")", "parser", ".", "add_option", "(", "\"-c\"", ",", "\"--config\"", ",", "action", "=", "\"append\"", ",", "dest", "=", "\"files\"", ",", "metavar", "=", "\"FILES\"", ",", "help", "=", "\"Load configuration from config file(s). May be specified \"", "\"multiple times; in that case, all config files will be \"", "\"loaded and combined\"", ")", "parser", ".", "add_option", "(", "\"-w\"", ",", "\"--where\"", ",", "action", "=", "\"append\"", ",", "dest", "=", "\"where\"", ",", "metavar", "=", "\"WHERE\"", ",", "help", "=", "\"Look for tests in this directory. \"", "\"May be specified multiple times. The first directory passed \"", "\"will be used as the working directory, in place of the current \"", "\"working directory, which is the default. Others will be added \"", "\"to the list of tests to execute. [NOSE_WHERE]\"", ")", "parser", ".", "add_option", "(", "\"--py3where\"", ",", "action", "=", "\"append\"", ",", "dest", "=", "\"py3where\"", ",", "metavar", "=", "\"PY3WHERE\"", ",", "help", "=", "\"Look for tests in this directory under Python 3.x. \"", "\"Functions the same as 'where', but only applies if running under \"", "\"Python 3.x or above. Note that, if present under 3.x, this \"", "\"option completely replaces any directories specified with \"", "\"'where', so the 'where' option becomes ineffective. \"", "\"[NOSE_PY3WHERE]\"", ")", "parser", ".", "add_option", "(", "\"-m\"", ",", "\"--match\"", ",", "\"--testmatch\"", ",", "action", "=", "\"store\"", ",", "dest", "=", "\"testMatch\"", ",", "metavar", "=", "\"REGEX\"", ",", "help", "=", "\"Files, directories, function names, and class names \"", "\"that match this regular expression are considered tests. \"", "\"Default: %s [NOSE_TESTMATCH]\"", "%", "self", ".", "testMatchPat", ",", "default", "=", "self", ".", "testMatchPat", ")", "parser", ".", "add_option", "(", "\"--tests\"", ",", "action", "=", "\"store\"", ",", "dest", "=", "\"testNames\"", ",", "default", "=", "None", ",", "metavar", "=", "'NAMES'", ",", "help", "=", "\"Run these tests (comma-separated list). This argument is \"", "\"useful mainly from configuration files; on the command line, \"", "\"just pass the tests to run as additional arguments with no \"", "\"switch.\"", ")", "parser", ".", "add_option", "(", "\"-l\"", ",", "\"--debug\"", ",", "action", "=", "\"store\"", ",", "dest", "=", "\"debug\"", ",", "default", "=", "self", ".", "debug", ",", "help", "=", "\"Activate debug logging for one or more systems. \"", "\"Available debug loggers: nose, nose.importer, \"", "\"nose.inspector, nose.plugins, nose.result and \"", "\"nose.selector. Separate multiple names with a comma.\"", ")", "parser", ".", "add_option", "(", "\"--debug-log\"", ",", "dest", "=", "\"debugLog\"", ",", "action", "=", "\"store\"", ",", "default", "=", "self", ".", "debugLog", ",", "metavar", "=", "\"FILE\"", ",", "help", "=", "\"Log debug messages to this file \"", "\"(default: sys.stderr)\"", ")", "parser", ".", "add_option", "(", "\"--logging-config\"", ",", "\"--log-config\"", ",", "dest", "=", "\"loggingConfig\"", ",", "action", "=", "\"store\"", ",", "default", "=", "self", ".", "loggingConfig", ",", "metavar", "=", "\"FILE\"", ",", "help", "=", "\"Load logging config from this file -- bypasses all other\"", "\" logging config settings.\"", ")", "parser", ".", "add_option", "(", "\"-I\"", ",", "\"--ignore-files\"", ",", "action", "=", "\"append\"", ",", "dest", "=", "\"ignoreFiles\"", ",", "metavar", "=", "\"REGEX\"", ",", "help", "=", "\"Completely ignore any file that matches this regular \"", "\"expression. Takes precedence over any other settings or \"", "\"plugins. \"", "\"Specifying this option will replace the default setting. \"", "\"Specify this option multiple times \"", "\"to add more regular expressions [NOSE_IGNORE_FILES]\"", ")", "parser", ".", "add_option", "(", "\"-e\"", ",", "\"--exclude\"", ",", "action", "=", "\"append\"", ",", "dest", "=", "\"exclude\"", ",", "metavar", "=", "\"REGEX\"", ",", "help", "=", "\"Don't run tests that match regular \"", "\"expression [NOSE_EXCLUDE]\"", ")", "parser", ".", "add_option", "(", "\"-i\"", ",", "\"--include\"", ",", "action", "=", "\"append\"", ",", "dest", "=", "\"include\"", ",", "metavar", "=", "\"REGEX\"", ",", "help", "=", "\"This regular expression will be applied to files, \"", "\"directories, function names, and class names for a chance \"", "\"to include additional tests that do not match TESTMATCH. \"", "\"Specify this option multiple times \"", "\"to add more regular expressions [NOSE_INCLUDE]\"", ")", "parser", ".", "add_option", "(", "\"-x\"", ",", "\"--stop\"", ",", "action", "=", "\"store_true\"", ",", "dest", "=", "\"stopOnError\"", ",", "default", "=", "self", ".", "stopOnError", ",", "help", "=", "\"Stop running tests after the first error or failure\"", ")", "parser", ".", "add_option", "(", "\"-P\"", ",", "\"--no-path-adjustment\"", ",", "action", "=", "\"store_false\"", ",", "dest", "=", "\"addPaths\"", ",", "default", "=", "self", ".", "addPaths", ",", "help", "=", "\"Don't make any changes to sys.path when \"", "\"loading tests [NOSE_NOPATH]\"", ")", "parser", ".", "add_option", "(", "\"--exe\"", ",", "action", "=", "\"store_true\"", ",", "dest", "=", "\"includeExe\"", ",", "default", "=", "self", ".", "includeExe", ",", "help", "=", "\"Look for tests in python modules that are \"", "\"executable. Normal behavior is to exclude executable \"", "\"modules, since they may not be import-safe \"", "\"[NOSE_INCLUDE_EXE]\"", ")", "parser", ".", "add_option", "(", "\"--noexe\"", ",", "action", "=", "\"store_false\"", ",", "dest", "=", "\"includeExe\"", ",", "help", "=", "\"DO NOT look for tests in python modules that are \"", "\"executable. (The default on the windows platform is to \"", "\"do so.)\"", ")", "parser", ".", "add_option", "(", "\"--traverse-namespace\"", ",", "action", "=", "\"store_true\"", ",", "default", "=", "self", ".", "traverseNamespace", ",", "dest", "=", "\"traverseNamespace\"", ",", "help", "=", "\"Traverse through all path entries of a namespace package\"", ")", "parser", ".", "add_option", "(", "\"--first-package-wins\"", ",", "\"--first-pkg-wins\"", ",", "\"--1st-pkg-wins\"", ",", "action", "=", "\"store_true\"", ",", "default", "=", "False", ",", "dest", "=", "\"firstPackageWins\"", ",", "help", "=", "\"nose's importer will normally evict a package from sys.\"", "\"modules if it sees a package with the same name in a different \"", "\"location. Set this option to disable that behavior.\"", ")", "self", ".", "plugins", ".", "loadPlugins", "(", ")", "self", ".", "pluginOpts", "(", "parser", ")", "self", ".", "parser", "=", "parser", "return", "parser" ]

[ "Get", "the", "command", "line", "option", "parser", "." ]

[ "def", "get_time", "(", "self", ")", "->", "float", ":", "if", "self", ".", "pause_time", "is", "not", "None", ":", "curr_time", "=", "self", ".", "pause_time", "-", "self", ".", "offset", "-", "self", ".", "start_time", "return", "curr_time", "curr_time", "=", "time", ".", "time", "(", ")", "return", "curr_time", "-", "self", ".", "start_time", "-", "self", ".", "offset" ]

[ "Get", "the", "current", "time", "in", "seconds" ]

[ "def", "setConfigurable", "(", "self", ",", "state", ")", ":", "self", ".", "_configurable", "=", "state", "self", ".", "_configButton", ".", "setVisible", "(", "state", ")" ]

[ "Sets", "whether", "or", "not", "this", "logger", "widget", "is", "configurable", ".", ":", "param", "state", "|", "<bool", ">" ]

[ "def", "_get_dbt_columns_from_bq_table", "(", "self", ",", "table", ")", ":", "columns", "=", "[", "]", "for", "col", "in", "table", ".", "schema", ":", "# BigQuery returns type labels that are not valid type specifiers", "dtype", "=", "self", ".", "Column", ".", "translate_type", "(", "col", ".", "field_type", ")", "column", "=", "self", ".", "Column", "(", "col", ".", "name", ",", "dtype", ",", "col", ".", "fields", ",", "col", ".", "mode", ")", "columns", ".", "append", "(", "column", ")", "return", "columns" ]

[ "Translates", "BQ", "SchemaField", "dicts", "into", "dbt", "BigQueryColumn", "objects" ]

[ "def", "press_pwr_btn", "(", "self", ")", ":", "sushy_system", "=", "self", ".", "_get_sushy_system", "(", "PROLIANT_SYSTEM_ID", ")", "try", ":", "sushy_system", ".", "push_power_button", "(", "sys_cons", ".", "PUSH_POWER_BUTTON_PRESS", ")", "except", "sushy", ".", "exceptions", ".", "SushyError", "as", "e", ":", "msg", "=", "(", "self", ".", "_", "(", "'The Redfish controller failed to press power button'", "' of server. Error %(error)s'", ")", "%", "{", "'error'", ":", "str", "(", "e", ")", "}", ")", "LOG", ".", "debug", "(", "msg", ")", "raise", "exception", ".", "IloError", "(", "msg", ")" ]

[ "Simulates", "a", "physical", "press", "of", "the", "server", "power", "button", "." ]

[ "def", "aryule", "(", "X", ",", "order", ",", "norm", "=", "'biased'", ",", "allow_singularity", "=", "True", ")", ":", "assert", "norm", "in", "[", "'biased'", ",", "'unbiased'", "]", "r", "=", "CORRELATION", "(", "X", ",", "maxlags", "=", "order", ",", "norm", "=", "norm", ")", "A", ",", "P", ",", "k", "=", "LEVINSON", "(", "r", ",", "allow_singularity", "=", "allow_singularity", ")", "return", "A", ",", "P", ",", "k" ]

[ "r", "Compute", "AR", "coefficients", "using", "Yule", "-", "Walker", "method" ]

[ "def", "match", "(", "vec1", ",", "vec2", ",", "psd", "=", "None", ",", "low_frequency_cutoff", "=", "None", ",", "high_frequency_cutoff", "=", "None", ",", "v1_norm", "=", "None", ",", "v2_norm", "=", "None", ")", ":", "htilde", "=", "make_frequency_series", "(", "vec1", ")", "stilde", "=", "make_frequency_series", "(", "vec2", ")", "N", "=", "(", "len", "(", "htilde", ")", "-", "1", ")", "*", "2", "global", "_snr", "if", "_snr", "is", "None", "or", "_snr", ".", "dtype", "!=", "htilde", ".", "dtype", "or", "len", "(", "_snr", ")", "!=", "N", ":", "_snr", "=", "zeros", "(", "N", ",", "dtype", "=", "complex_same_precision_as", "(", "vec1", ")", ")", "snr", ",", "_", ",", "snr_norm", "=", "matched_filter_core", "(", "htilde", ",", "stilde", ",", "psd", ",", "low_frequency_cutoff", ",", "high_frequency_cutoff", ",", "v1_norm", ",", "out", "=", "_snr", ")", "maxsnr", ",", "max_id", "=", "snr", ".", "abs_max_loc", "(", ")", "if", "v2_norm", "is", "None", ":", "v2_norm", "=", "sigmasq", "(", "stilde", ",", "psd", ",", "low_frequency_cutoff", ",", "high_frequency_cutoff", ")", "return", "maxsnr", "*", "snr_norm", "/", "sqrt", "(", "v2_norm", ")", ",", "max_id" ]

[ "Return", "the", "match", "between", "the", "two", "TimeSeries", "or", "FrequencySeries", "." ]

[ "def", "unwatch_from_file", "(", "connection", ",", "file_name", ")", ":", "with", "open", "(", "file_name", ",", "'r'", ")", "as", "filehandle", ":", "for", "line", "in", "filehandle", ".", "xreadlines", "(", ")", ":", "volume", ",", "interval", ",", "retention", "=", "line", ".", "rstrip", "(", ")", ".", "split", "(", "','", ")", "unwatch", "(", "connection", ",", "get_volume_id", "(", "connection", ",", "volume", ")", ")" ]

[ "Start", "watching", "a", "new", "volume" ]

[ "def", "get_account_certificate", "(", "self", ",", "account_id", ",", "cert_id", ",", "*", "*", "kwargs", ")", ":", "# noqa: E501", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'asynchronous'", ")", ":", "return", "self", ".", "get_account_certificate_with_http_info", "(", "account_id", ",", "cert_id", ",", "*", "*", "kwargs", ")", "# noqa: E501", "else", ":", "(", "data", ")", "=", "self", ".", "get_account_certificate_with_http_info", "(", "account_id", ",", "cert_id", ",", "*", "*", "kwargs", ")", "# noqa: E501", "return", "data" ]

[ "Get", "trusted", "certificate", "by", "ID", ".", "#", "noqa", ":", "E501" ]

[ "def", "clonemedium", "(", "medium", ",", "uuid_in", "=", "None", ",", "file_in", "=", "None", ",", "uuid_out", "=", "None", ",", "file_out", "=", "None", ",", "mformat", "=", "None", ",", "variant", "=", "None", ",", "existing", "=", "False", ",", "*", "*", "kwargs", ")", ":", "params", "=", "''", "valid_mediums", "=", "(", "'disk'", ",", "'dvd'", ",", "'floppy'", ")", "if", "medium", "in", "valid_mediums", ":", "params", "+=", "medium", "else", ":", "raise", "CommandExecutionError", "(", "'Medium must be one of: {0}.'", ".", "format", "(", "', '", ".", "join", "(", "valid_mediums", ")", ")", ")", "if", "(", "uuid_in", "and", "file_in", ")", "or", "(", "not", "uuid_in", "and", "not", "file_in", ")", ":", "raise", "CommandExecutionError", "(", "'Either uuid_in or file_in must be used, but not both.'", ")", "if", "uuid_in", ":", "if", "medium", "==", "'disk'", ":", "item", "=", "'hdds'", "elif", "medium", "==", "'dvd'", ":", "item", "=", "'dvds'", "elif", "medium", "==", "'floppy'", ":", "item", "=", "'floppies'", "items", "=", "list_items", "(", "item", ")", "if", "uuid_in", "not", "in", "items", ":", "raise", "CommandExecutionError", "(", "'UUID {0} was not found'", ".", "format", "(", "uuid_in", ")", ")", "params", "+=", "' '", "+", "uuid_in", "elif", "file_in", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "file_in", ")", ":", "raise", "CommandExecutionError", "(", "'File {0} was not found'", ".", "format", "(", "file_in", ")", ")", "params", "+=", "' '", "+", "file_in", "if", "(", "uuid_out", "and", "file_out", ")", "or", "(", "not", "uuid_out", "and", "not", "file_out", ")", ":", "raise", "CommandExecutionError", "(", "'Either uuid_out or file_out must be used, but not both.'", ")", "if", "uuid_out", ":", "params", "+=", "' '", "+", "uuid_out", "elif", "file_out", ":", "try", ":", "salt", ".", "utils", ".", "files", ".", "fopen", "(", "file_out", ",", "'w'", ")", ".", "close", "(", ")", "# pylint: disable=resource-leakage", "os", ".", "unlink", "(", "file_out", ")", "params", "+=", "' '", "+", "file_out", "except", "OSError", ":", "raise", "CommandExecutionError", "(", "'{0} is not a valid filename'", ".", "format", "(", "file_out", ")", ")", "if", "mformat", ":", "valid_mformat", "=", "(", "'VDI'", ",", "'VMDK'", ",", "'VHD'", ",", "'RAW'", ")", "if", "mformat", "not", "in", "valid_mformat", ":", "raise", "CommandExecutionError", "(", "'If specified, mformat must be one of: {0}'", ".", "format", "(", "', '", ".", "join", "(", "valid_mformat", ")", ")", ")", "else", ":", "params", "+=", "' --format '", "+", "mformat", "valid_variant", "=", "(", "'Standard'", ",", "'Fixed'", ",", "'Split2G'", ",", "'Stream'", ",", "'ESX'", ")", "if", "variant", "and", "variant", "not", "in", "valid_variant", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "file_in", ")", ":", "raise", "CommandExecutionError", "(", "'If specified, variant must be one of: {0}'", ".", "format", "(", "', '", ".", "join", "(", "valid_variant", ")", ")", ")", "else", ":", "params", "+=", "' --variant '", "+", "variant", "if", "existing", ":", "params", "+=", "' --existing'", "cmd", "=", "'{0} clonemedium {1}'", ".", "format", "(", "vboxcmd", "(", ")", ",", "params", ")", "ret", "=", "salt", ".", "modules", ".", "cmdmod", ".", "run_all", "(", "cmd", ")", "if", "ret", "[", "'retcode'", "]", "==", "0", ":", "return", "True", "return", "ret", "[", "'stderr'", "]" ]

[ "Clone", "a", "new", "VM", "from", "an", "existing", "VM" ]

[ "def", "cget", "(", "self", ",", "key", ")", ":", "if", "key", "is", "\"canvaswidth\"", ":", "return", "self", ".", "_canvaswidth", "elif", "key", "is", "\"canvasheight\"", ":", "return", "self", ".", "_canvasheight", "elif", "key", "is", "\"function_new\"", ":", "return", "self", ".", "_function_new", "elif", "key", "is", "\"callback_add\"", ":", "return", "self", ".", "_callback_add", "elif", "key", "is", "\"callback_del\"", ":", "return", "self", ".", "_callback_del", "elif", "key", "is", "\"callback_move\"", ":", "return", "self", ".", "_callback_move", "else", ":", "ttk", ".", "Frame", ".", "cget", "(", "self", ",", "key", ")" ]

[ "Query", "widget", "option", "." ]

[ "def", "search_rna_quantifications", "(", "self", ",", "rna_quantification_set_id", "=", "\"\"", ")", ":", "request", "=", "protocol", ".", "SearchRnaQuantificationsRequest", "(", ")", "request", ".", "rna_quantification_set_id", "=", "rna_quantification_set_id", "request", ".", "page_size", "=", "pb", ".", "int", "(", "self", ".", "_page_size", ")", "return", "self", ".", "_run_search_request", "(", "request", ",", "\"rnaquantifications\"", ",", "protocol", ".", "SearchRnaQuantificationsResponse", ")" ]

[ "Returns", "an", "iterator", "over", "the", "RnaQuantification", "objects", "from", "the", "server" ]

[ "def", "aracne", "(", "m", ",", "*", "*", "kwargs", ")", ":", "I0", "=", "kwargs", ".", "get", "(", "'I0'", ",", "0.0", ")", "# No default thresholding", "W0", "=", "kwargs", ".", "get", "(", "'W0'", ",", "0.05", ")", "# thresholding", "m", "=", "np", ".", "where", "(", "m", ">", "I0", ",", "m", ",", "0", ")", "# Finding triplets and filtering them", "for", "i", "in", "range", "(", "m", ".", "shape", "[", "0", "]", "-", "2", ")", ":", "for", "j", "in", "range", "(", "i", "+", "1", ",", "m", ".", "shape", "[", "0", "]", "-", "1", ")", ":", "for", "k", "in", "range", "(", "j", "+", "1", ",", "m", ".", "shape", "[", "0", "]", ")", ":", "triplet", "=", "[", "m", "[", "i", ",", "j", "]", ",", "m", "[", "j", ",", "k", "]", ",", "m", "[", "i", ",", "k", "]", "]", "min_index", ",", "min_value", "=", "min", "(", "enumerate", "(", "triplet", ")", ",", "key", "=", "operator", ".", "itemgetter", "(", "1", ")", ")", "if", "0", "<", "min_value", "<", "W0", ":", "if", "min_index", "==", "0", ":", "m", "[", "i", ",", "j", "]", "=", "m", "[", "j", ",", "i", "]", "=", "0.", "elif", "min_index", "==", "1", ":", "m", "[", "j", ",", "k", "]", "=", "m", "[", "k", ",", "j", "]", "=", "0.", "else", ":", "m", "[", "i", ",", "k", "]", "=", "m", "[", "k", ",", "i", "]", "=", "0.", "return", "m" ]

[ "Implementation", "of", "the", "ARACNE", "algorithm", "." ]

[ "def", "main", "(", "args", "=", "None", ")", ":", "api", ".", "config", ".", "init", "(", ")", "zxbpp", ".", "init", "(", ")", "zxbparser", ".", "init", "(", ")", "arch", ".", "zx48k", ".", "backend", ".", "init", "(", ")", "arch", ".", "zx48k", ".", "Translator", ".", "reset", "(", ")", "asmparse", ".", "init", "(", ")", "# ------------------------------------------------------------", "# Command line parsing", "# ------------------------------------------------------------", "parser", "=", "argparse", ".", "ArgumentParser", "(", "prog", "=", "'zxb'", ")", "parser", ".", "add_argument", "(", "'PROGRAM'", ",", "type", "=", "str", ",", "help", "=", "'BASIC program file'", ")", "parser", ".", "add_argument", "(", "'-d'", ",", "'--debug'", ",", "dest", "=", "'debug'", ",", "default", "=", "OPTIONS", ".", "Debug", ".", "value", ",", "action", "=", "'count'", ",", "help", "=", "'Enable verbosity/debugging output. Additional -d increase verbosity/debug level'", ")", "parser", ".", "add_argument", "(", "'-O'", ",", "'--optimize'", ",", "type", "=", "int", ",", "default", "=", "OPTIONS", ".", "optimization", ".", "value", ",", "help", "=", "'Sets optimization level. '", "'0 = None (default level is {0})'", ".", "format", "(", "OPTIONS", ".", "optimization", ".", "value", ")", ")", "parser", ".", "add_argument", "(", "'-o'", ",", "'--output'", ",", "type", "=", "str", ",", "dest", "=", "'output_file'", ",", "default", "=", "None", ",", "help", "=", "'Sets output file. Default is input filename with .bin extension'", ")", "parser", ".", "add_argument", "(", "'-T'", ",", "'--tzx'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Sets output format to tzx (default is .bin)\"", ")", "parser", ".", "add_argument", "(", "'-t'", ",", "'--tap'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Sets output format to tap (default is .bin)\"", ")", "parser", ".", "add_argument", "(", "'-B'", ",", "'--BASIC'", ",", "action", "=", "'store_true'", ",", "dest", "=", "'basic'", ",", "help", "=", "\"Creates a BASIC loader which loads the rest of the CODE. Requires -T ot -t\"", ")", "parser", ".", "add_argument", "(", "'-a'", ",", "'--autorun'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Sets the program to be run once loaded\"", ")", "parser", ".", "add_argument", "(", "'-A'", ",", "'--asm'", ",", "action", "=", "'store_true'", ",", "help", "=", "\"Sets output format to asm\"", ")", "parser", ".", "add_argument", "(", "'-S'", ",", "'--org'", ",", "type", "=", "str", ",", "default", "=", "str", "(", "OPTIONS", ".", "org", ".", "value", ")", ",", "help", "=", "\"Start of machine code. By default %i\"", "%", "OPTIONS", ".", "org", ".", "value", ")", "parser", ".", "add_argument", "(", "'-e'", ",", "'--errmsg'", ",", "type", "=", "str", ",", "dest", "=", "'stderr'", ",", "default", "=", "OPTIONS", ".", "StdErrFileName", ".", "value", ",", "help", "=", "'Error messages file (standard error console by default)'", ")", "parser", ".", "add_argument", "(", "'--array-base'", ",", "type", "=", "int", ",", "default", "=", "OPTIONS", ".", "array_base", ".", "value", ",", "help", "=", "'Default lower index for arrays ({0} by default)'", ".", "format", "(", "OPTIONS", ".", "array_base", ".", "value", ")", ")", "parser", ".", "add_argument", "(", "'--string-base'", ",", "type", "=", "int", ",", "default", "=", "OPTIONS", ".", "string_base", ".", "value", ",", "help", "=", "'Default lower index for strings ({0} by default)'", ".", "format", "(", "OPTIONS", ".", "array_base", ".", "value", ")", ")", "parser", ".", "add_argument", "(", "'-Z'", ",", "'--sinclair'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Enable by default some more original ZX Spectrum Sinclair BASIC features: ATTR, SCREEN$, '", "'POINT'", ")", "parser", ".", "add_argument", "(", "'-H'", ",", "'--heap-size'", ",", "type", "=", "int", ",", "default", "=", "OPTIONS", ".", "heap_size", ".", "value", ",", "help", "=", "'Sets heap size in bytes (default {0} bytes)'", ".", "format", "(", "OPTIONS", ".", "heap_size", ".", "value", ")", ")", "parser", ".", "add_argument", "(", "'--debug-memory'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Enables out-of-memory debug'", ")", "parser", ".", "add_argument", "(", "'--debug-array'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Enables array boundary checking'", ")", "parser", ".", "add_argument", "(", "'--strict-bool'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Enforce boolean values to be 0 or 1'", ")", "parser", ".", "add_argument", "(", "'--enable-break'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Enables program execution BREAK detection'", ")", "parser", ".", "add_argument", "(", "'-E'", ",", "'--emit-backend'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Emits backend code instead of ASM or binary'", ")", "parser", ".", "add_argument", "(", "'--explicit'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Requires all variables and functions to be declared before used'", ")", "parser", ".", "add_argument", "(", "'-D'", ",", "'--define'", ",", "type", "=", "str", ",", "dest", "=", "'defines'", ",", "action", "=", "'append'", ",", "help", "=", "'Defines de given macro. Eg. -D MYDEBUG or -D NAME=Value'", ")", "parser", ".", "add_argument", "(", "'-M'", ",", "'--mmap'", ",", "type", "=", "str", ",", "dest", "=", "'memory_map'", ",", "default", "=", "None", ",", "help", "=", "'Generate label memory map'", ")", "parser", ".", "add_argument", "(", "'-i'", ",", "'--ignore-case'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Ignore case. Makes variable names are case insensitive'", ")", "parser", ".", "add_argument", "(", "'-I'", ",", "'--include-path'", ",", "type", "=", "str", ",", "default", "=", "''", ",", "help", "=", "'Add colon separated list of directories to add to include path. e.g. -I dir1:dir2'", ")", "parser", ".", "add_argument", "(", "'--strict'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Enables strict mode. Force explicit type declaration'", ")", "parser", ".", "add_argument", "(", "'--headerless'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Header-less mode: omit asm prologue and epilogue'", ")", "parser", ".", "add_argument", "(", "'--version'", ",", "action", "=", "'version'", ",", "version", "=", "'%(prog)s {0}'", ".", "format", "(", "VERSION", ")", ")", "parser", ".", "add_argument", "(", "'--parse-only'", ",", "action", "=", "'store_true'", ",", "help", "=", "'Only parses to check for syntax and semantic errors'", ")", "parser", ".", "add_argument", "(", "'--append-binary'", ",", "default", "=", "[", "]", ",", "action", "=", "'append'", ",", "help", "=", "'Appends binary to tape file (only works with -t or -T)'", ")", "parser", ".", "add_argument", "(", "'--append-headless-binary'", ",", "default", "=", "[", "]", ",", "action", "=", "'append'", ",", "help", "=", "'Appends binary to tape file (only works with -t or -T)'", ")", "options", "=", "parser", ".", "parse_args", "(", "args", "=", "args", ")", "# ------------------------------------------------------------", "# Setting of internal parameters according to command line", "# ------------------------------------------------------------", "OPTIONS", ".", "Debug", ".", "value", "=", "options", ".", "debug", "OPTIONS", ".", "optimization", ".", "value", "=", "options", ".", "optimize", "OPTIONS", ".", "outputFileName", ".", "value", "=", "options", ".", "output_file", "OPTIONS", ".", "StdErrFileName", ".", "value", "=", "options", ".", "stderr", "OPTIONS", ".", "array_base", ".", "value", "=", "options", ".", "array_base", "OPTIONS", ".", "string_base", ".", "value", "=", "options", ".", "string_base", "OPTIONS", ".", "Sinclair", ".", "value", "=", "options", ".", "sinclair", "OPTIONS", ".", "heap_size", ".", "value", "=", "options", ".", "heap_size", "OPTIONS", ".", "memoryCheck", ".", "value", "=", "options", ".", "debug_memory", "OPTIONS", ".", "strictBool", ".", "value", "=", "options", ".", "strict_bool", "or", "OPTIONS", ".", "Sinclair", ".", "value", "OPTIONS", ".", "arrayCheck", ".", "value", "=", "options", ".", "debug_array", "OPTIONS", ".", "emitBackend", ".", "value", "=", "options", ".", "emit_backend", "OPTIONS", ".", "enableBreak", ".", "value", "=", "options", ".", "enable_break", "OPTIONS", ".", "explicit", ".", "value", "=", "options", ".", "explicit", "OPTIONS", ".", "memory_map", ".", "value", "=", "options", ".", "memory_map", "OPTIONS", ".", "strict", ".", "value", "=", "options", ".", "strict", "OPTIONS", ".", "headerless", ".", "value", "=", "options", ".", "headerless", "OPTIONS", ".", "org", ".", "value", "=", "api", ".", "utils", ".", "parse_int", "(", "options", ".", "org", ")", "if", "OPTIONS", ".", "org", ".", "value", "is", "None", ":", "parser", ".", "error", "(", "\"Invalid --org option '{}'\"", ".", "format", "(", "options", ".", "org", ")", ")", "if", "options", ".", "defines", ":", "for", "i", "in", "options", ".", "defines", ":", "name", ",", "val", "=", "tuple", "(", "i", ".", "split", "(", "'='", ",", "1", ")", ")", "OPTIONS", ".", "__DEFINES", ".", "value", "[", "name", "]", "=", "val", "zxbpp", ".", "ID_TABLE", ".", "define", "(", "name", ",", "lineno", "=", "0", ")", "if", "OPTIONS", ".", "Sinclair", ".", "value", ":", "OPTIONS", ".", "array_base", ".", "value", "=", "1", "OPTIONS", ".", "string_base", ".", "value", "=", "1", "OPTIONS", ".", "strictBool", ".", "value", "=", "True", "OPTIONS", ".", "case_insensitive", ".", "value", "=", "True", "if", "options", ".", "ignore_case", ":", "OPTIONS", ".", "case_insensitive", ".", "value", "=", "True", "debug", ".", "ENABLED", "=", "OPTIONS", ".", "Debug", ".", "value", "if", "int", "(", "options", ".", "tzx", ")", "+", "int", "(", "options", ".", "tap", ")", "+", "int", "(", "options", ".", "asm", ")", "+", "int", "(", "options", ".", "emit_backend", ")", "+", "int", "(", "options", ".", "parse_only", ")", ">", "1", ":", "parser", ".", "error", "(", "\"Options --tap, --tzx, --emit-backend, --parse-only and --asm are mutually exclusive\"", ")", "return", "3", "if", "options", ".", "basic", "and", "not", "options", ".", "tzx", "and", "not", "options", ".", "tap", ":", "parser", ".", "error", "(", "'Option --BASIC and --autorun requires --tzx or tap format'", ")", "return", "4", "if", "options", ".", "append_binary", "and", "not", "options", ".", "tzx", "and", "not", "options", ".", "tap", ":", "parser", ".", "error", "(", "'Option --append-binary needs either --tap or --tzx'", ")", "return", "5", "OPTIONS", ".", "use_loader", ".", "value", "=", "options", ".", "basic", "OPTIONS", ".", "autorun", ".", "value", "=", "options", ".", "autorun", "if", "options", ".", "tzx", ":", "OPTIONS", ".", "output_file_type", ".", "value", "=", "'tzx'", "elif", "options", ".", "tap", ":", "OPTIONS", ".", "output_file_type", ".", "value", "=", "'tap'", "elif", "options", ".", "asm", ":", "OPTIONS", ".", "output_file_type", ".", "value", "=", "'asm'", "elif", "options", ".", "emit_backend", ":", "OPTIONS", ".", "output_file_type", ".", "value", "=", "'ic'", "args", "=", "[", "options", ".", "PROGRAM", "]", "if", "not", "os", ".", "path", ".", "exists", "(", "options", ".", "PROGRAM", ")", ":", "parser", ".", "error", "(", "\"No such file or directory: '%s'\"", "%", "args", "[", "0", "]", ")", "return", "2", "if", "OPTIONS", ".", "memoryCheck", ".", "value", ":", "OPTIONS", ".", "__DEFINES", ".", "value", "[", "'__MEMORY_CHECK__'", "]", "=", "''", "zxbpp", ".", "ID_TABLE", ".", "define", "(", "'__MEMORY_CHECK__'", ",", "lineno", "=", "0", ")", "if", "OPTIONS", ".", "arrayCheck", ".", "value", ":", "OPTIONS", ".", "__DEFINES", ".", "value", "[", "'__CHECK_ARRAY_BOUNDARY__'", "]", "=", "''", "zxbpp", ".", "ID_TABLE", ".", "define", "(", "'__CHECK_ARRAY_BOUNDARY__'", ",", "lineno", "=", "0", ")", "OPTIONS", ".", "include_path", ".", "value", "=", "options", ".", "include_path", "OPTIONS", ".", "inputFileName", ".", "value", "=", "zxbparser", ".", "FILENAME", "=", "os", ".", "path", ".", "basename", "(", "args", "[", "0", "]", ")", "if", "not", "OPTIONS", ".", "outputFileName", ".", "value", ":", "OPTIONS", ".", "outputFileName", ".", "value", "=", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "OPTIONS", ".", "inputFileName", ".", "value", ")", ")", "[", "0", "]", "+", "os", ".", "path", ".", "extsep", "+", "OPTIONS", ".", "output_file_type", ".", "value", "if", "OPTIONS", ".", "StdErrFileName", ".", "value", ":", "OPTIONS", ".", "stderr", ".", "value", "=", "open_file", "(", "OPTIONS", ".", "StdErrFileName", ".", "value", ",", "'wt'", ",", "'utf-8'", ")", "zxbpp", ".", "setMode", "(", "'basic'", ")", "zxbpp", ".", "main", "(", "args", ")", "if", "gl", ".", "has_errors", ":", "debug", ".", "__DEBUG__", "(", "\"exiting due to errors.\"", ")", "return", "1", "# Exit with errors", "input_", "=", "zxbpp", ".", "OUTPUT", "zxbparser", ".", "parser", ".", "parse", "(", "input_", ",", "lexer", "=", "zxblex", ".", "lexer", ",", "tracking", "=", "True", ",", "debug", "=", "(", "OPTIONS", ".", "Debug", ".", "value", ">", "2", ")", ")", "if", "gl", ".", "has_errors", ":", "debug", ".", "__DEBUG__", "(", "\"exiting due to errors.\"", ")", "return", "1", "# Exit with errors", "# Optimizations", "optimizer", "=", "api", ".", "optimize", ".", "OptimizerVisitor", "(", ")", "optimizer", ".", "visit", "(", "zxbparser", ".", "ast", ")", "# Emits intermediate code", "translator", "=", "arch", ".", "zx48k", ".", "Translator", "(", ")", "translator", ".", "visit", "(", "zxbparser", ".", "ast", ")", "if", "gl", ".", "DATA_IS_USED", ":", "gl", ".", "FUNCTIONS", ".", "extend", "(", "gl", ".", "DATA_FUNCTIONS", ")", "# This will fill MEMORY with pending functions", "func_visitor", "=", "arch", ".", "zx48k", ".", "FunctionTranslator", "(", "gl", ".", "FUNCTIONS", ")", "func_visitor", ".", "start", "(", ")", "# Emits data lines", "translator", ".", "emit_data_blocks", "(", ")", "# Emits default constant strings", "translator", ".", "emit_strings", "(", ")", "# Emits jump tables", "translator", ".", "emit_jump_tables", "(", ")", "if", "OPTIONS", ".", "emitBackend", ".", "value", ":", "with", "open_file", "(", "OPTIONS", ".", "outputFileName", ".", "value", ",", "'wt'", ",", "'utf-8'", ")", "as", "output_file", ":", "for", "quad", "in", "translator", ".", "dumpMemory", "(", "backend", ".", "MEMORY", ")", ":", "output_file", ".", "write", "(", "str", "(", "quad", ")", "+", "'\\n'", ")", "backend", ".", "MEMORY", "[", ":", "]", "=", "[", "]", "# Empties memory", "# This will fill MEMORY with global declared variables", "translator", "=", "arch", ".", "zx48k", ".", "VarTranslator", "(", ")", "translator", ".", "visit", "(", "zxbparser", ".", "data_ast", ")", "for", "quad", "in", "translator", ".", "dumpMemory", "(", "backend", ".", "MEMORY", ")", ":", "output_file", ".", "write", "(", "str", "(", "quad", ")", "+", "'\\n'", ")", "return", "0", "# Exit success", "# Join all lines into a single string and ensures an INTRO at end of file", "asm_output", "=", "backend", ".", "emit", "(", "backend", ".", "MEMORY", ")", "asm_output", "=", "optimize", "(", "asm_output", ")", "+", "'\\n'", "asm_output", "=", "asm_output", ".", "split", "(", "'\\n'", ")", "for", "i", "in", "range", "(", "len", "(", "asm_output", ")", ")", ":", "tmp", "=", "backend", ".", "ASMS", ".", "get", "(", "asm_output", "[", "i", "]", ",", "None", ")", "if", "tmp", "is", "not", "None", ":", "asm_output", "[", "i", "]", "=", "'\\n'", ".", "join", "(", "tmp", ")", "asm_output", "=", "'\\n'", ".", "join", "(", "asm_output", ")", "# Now filter them against the preprocessor again", "zxbpp", ".", "setMode", "(", "'asm'", ")", "zxbpp", ".", "OUTPUT", "=", "''", "zxbpp", ".", "filter_", "(", "asm_output", ",", "args", "[", "0", "]", ")", "# Now output the result", "asm_output", "=", "zxbpp", ".", "OUTPUT", ".", "split", "(", "'\\n'", ")", "get_inits", "(", "asm_output", ")", "# Find out remaining inits", "backend", ".", "MEMORY", "[", ":", "]", "=", "[", "]", "# This will fill MEMORY with global declared variables", "translator", "=", "arch", ".", "zx48k", ".", "VarTranslator", "(", ")", "translator", ".", "visit", "(", "zxbparser", ".", "data_ast", ")", "if", "gl", ".", "has_errors", ":", "debug", ".", "__DEBUG__", "(", "\"exiting due to errors.\"", ")", "return", "1", "# Exit with errors", "tmp", "=", "[", "x", "for", "x", "in", "backend", ".", "emit", "(", "backend", ".", "MEMORY", ")", "if", "x", ".", "strip", "(", ")", "[", "0", "]", "!=", "'#'", "]", "asm_output", "+=", "tmp", "asm_output", "=", "backend", ".", "emit_start", "(", ")", "+", "asm_output", "asm_output", "+=", "backend", ".", "emit_end", "(", "asm_output", ")", "if", "options", ".", "asm", ":", "# Only output assembler file", "with", "open_file", "(", "OPTIONS", ".", "outputFileName", ".", "value", ",", "'wt'", ",", "'utf-8'", ")", "as", "output_file", ":", "output", "(", "asm_output", ",", "output_file", ")", "elif", "not", "options", ".", "parse_only", ":", "fout", "=", "StringIO", "(", ")", "output", "(", "asm_output", ",", "fout", ")", "asmparse", ".", "assemble", "(", "fout", ".", "getvalue", "(", ")", ")", "fout", ".", "close", "(", ")", "asmparse", ".", "generate_binary", "(", "OPTIONS", ".", "outputFileName", ".", "value", ",", "OPTIONS", ".", "output_file_type", ".", "value", ",", "binary_files", "=", "options", ".", "append_binary", ",", "headless_binary_files", "=", "options", ".", "append_headless_binary", ")", "if", "gl", ".", "has_errors", ":", "return", "5", "# Error in assembly", "if", "OPTIONS", ".", "memory_map", ".", "value", ":", "with", "open_file", "(", "OPTIONS", ".", "memory_map", ".", "value", ",", "'wt'", ",", "'utf-8'", ")", "as", "f", ":", "f", ".", "write", "(", "asmparse", ".", "MEMORY", ".", "memory_map", ")", "return", "gl", ".", "has_errors" ]

[ "Entry", "point", "when", "executed", "from", "command", "line", ".", "You", "can", "use", "zxb", ".", "py", "as", "a", "module", "with", "import", "and", "this", "function", "won", "t", "be", "executed", "." ]

[ "def", "squad_v2_f1", "(", "y_true", ":", "List", "[", "List", "[", "str", "]", "]", ",", "y_predicted", ":", "List", "[", "str", "]", ")", "->", "float", ":", "f1_total", "=", "0.0", "for", "ground_truth", ",", "prediction", "in", "zip", "(", "y_true", ",", "y_predicted", ")", ":", "prediction_tokens", "=", "normalize_answer", "(", "prediction", ")", ".", "split", "(", ")", "f1s", "=", "[", "]", "for", "gt", "in", "ground_truth", ":", "gt_tokens", "=", "normalize_answer", "(", "gt", ")", ".", "split", "(", ")", "if", "len", "(", "gt_tokens", ")", "==", "0", "or", "len", "(", "prediction_tokens", ")", "==", "0", ":", "f1s", ".", "append", "(", "float", "(", "gt_tokens", "==", "prediction_tokens", ")", ")", "continue", "common", "=", "Counter", "(", "prediction_tokens", ")", "&", "Counter", "(", "gt_tokens", ")", "num_same", "=", "sum", "(", "common", ".", "values", "(", ")", ")", "if", "num_same", "==", "0", ":", "f1s", ".", "append", "(", "0.0", ")", "continue", "precision", "=", "1.0", "*", "num_same", "/", "len", "(", "prediction_tokens", ")", "recall", "=", "1.0", "*", "num_same", "/", "len", "(", "gt_tokens", ")", "f1", "=", "(", "2", "*", "precision", "*", "recall", ")", "/", "(", "precision", "+", "recall", ")", "f1s", ".", "append", "(", "f1", ")", "f1_total", "+=", "max", "(", "f1s", ")", "return", "100", "*", "f1_total", "/", "len", "(", "y_true", ")", "if", "len", "(", "y_true", ")", ">", "0", "else", "0" ]

[ "Calculates", "F", "-", "1", "score", "between", "y_true", "and", "y_predicted", "F", "-", "1", "score", "uses", "the", "best", "matching", "y_true", "answer" ]

[ "def", "listen_for_events", "(", ")", ":", "import_event_modules", "(", ")", "conn", "=", "redis_connection", ".", "get_connection", "(", ")", "pubsub", "=", "conn", ".", "pubsub", "(", ")", "pubsub", ".", "subscribe", "(", "\"eventlib\"", ")", "for", "message", "in", "pubsub", ".", "listen", "(", ")", ":", "if", "message", "[", "'type'", "]", "!=", "'message'", ":", "continue", "data", "=", "loads", "(", "message", "[", "\"data\"", "]", ")", "if", "'name'", "in", "data", ":", "event_name", "=", "data", ".", "pop", "(", "'name'", ")", "process_external", "(", "event_name", ",", "data", ")" ]

[ "Pubsub", "event", "listener" ]

[ "def", "image_neighbor_smooth", "(", "xlevel", "=", "0.2", ",", "ylevel", "=", "0.2", ",", "image", "=", "\"auto\"", ")", ":", "if", "image", "==", "\"auto\"", ":", "image", "=", "_pylab", ".", "gca", "(", ")", ".", "images", "[", "0", "]", "Z", "=", "_n", ".", "array", "(", "image", ".", "get_array", "(", ")", ")", "# store this image in the undo list", "global", "image_undo_list", "image_undo_list", ".", "append", "(", "[", "image", ",", "Z", "]", ")", "if", "len", "(", "image_undo_list", ")", ">", "10", ":", "image_undo_list", ".", "pop", "(", "0", ")", "# get the diagonal smoothing level (eliptical, and scaled down by distance)", "dlevel", "=", "(", "(", "xlevel", "**", "2", "+", "ylevel", "**", "2", ")", "/", "2.0", ")", "**", "(", "0.5", ")", "# don't touch the first column", "new_Z", "=", "[", "Z", "[", "0", "]", "*", "1.0", "]", "for", "m", "in", "range", "(", "1", ",", "len", "(", "Z", ")", "-", "1", ")", ":", "new_Z", ".", "append", "(", "Z", "[", "m", "]", "*", "1.0", ")", "for", "n", "in", "range", "(", "1", ",", "len", "(", "Z", "[", "0", "]", ")", "-", "1", ")", ":", "new_Z", "[", "-", "1", "]", "[", "n", "]", "=", "(", "Z", "[", "m", ",", "n", "]", "+", "xlevel", "*", "(", "Z", "[", "m", "+", "1", ",", "n", "]", "+", "Z", "[", "m", "-", "1", ",", "n", "]", ")", "+", "ylevel", "*", "(", "Z", "[", "m", ",", "n", "+", "1", "]", "+", "Z", "[", "m", ",", "n", "-", "1", "]", ")", "+", "dlevel", "*", "(", "Z", "[", "m", "+", "1", ",", "n", "+", "1", "]", "+", "Z", "[", "m", "-", "1", ",", "n", "+", "1", "]", "+", "Z", "[", "m", "+", "1", ",", "n", "-", "1", "]", "+", "Z", "[", "m", "-", "1", ",", "n", "-", "1", "]", ")", ")", "/", "(", "1.0", "+", "xlevel", "*", "2", "+", "ylevel", "*", "2", "+", "dlevel", "*", "4", ")", "# don't touch the last column", "new_Z", ".", "append", "(", "Z", "[", "-", "1", "]", "*", "1.0", ")", "# images have transposed data", "image", ".", "set_array", "(", "_n", ".", "array", "(", "new_Z", ")", ")", "# update the plot", "_pylab", ".", "draw", "(", ")" ]

[ "This", "will", "bleed", "nearest", "neighbor", "pixels", "into", "each", "other", "with", "the", "specified", "weight", "factors", "." ]

[ "def", "any_file_field", "(", "field", ",", "*", "*", "kwargs", ")", ":", "def", "get_some_file", "(", "path", ")", ":", "subdirs", ",", "files", "=", "field", ".", "storage", ".", "listdir", "(", "path", ")", "if", "files", ":", "result_file", "=", "random", ".", "choice", "(", "files", ")", "instance", "=", "field", ".", "storage", ".", "open", "(", "\"%s/%s\"", "%", "(", "path", ",", "result_file", ")", ")", ".", "file", "return", "FieldFile", "(", "instance", ",", "field", ",", "result_file", ")", "for", "subdir", "in", "subdirs", ":", "result", "=", "get_some_file", "(", "\"%s/%s\"", "%", "(", "path", ",", "subdir", ")", ")", "if", "result", ":", "return", "result", "result", "=", "get_some_file", "(", "field", ".", "upload_to", ")", "if", "result", "is", "None", "and", "not", "field", ".", "null", ":", "raise", "TypeError", "(", "\"Can't found file in %s for non nullable FileField\"", "%", "field", ".", "upload_to", ")", "return", "result" ]

[ "Lookup", "for", "nearest", "existing", "file" ]

[ "def", "get_by", "(", "self", ",", "prop", ",", "val", ",", "raise_exc", "=", "False", ")", ":", "try", ":", "val", "=", "self", ".", "serialize", "(", "val", ")", "return", "self", ".", "_meta", "[", "prop", "]", "[", "val", "]", "[", "0", "]", "except", "(", "KeyError", ",", "IndexError", ")", ":", "if", "raise_exc", ":", "raise", "else", ":", "return", "None" ]

[ "Retrieve", "an", "item", "from", "the", "dictionary", "with", "the", "given", "metadata", "properties", ".", "If", "there", "is", "no", "such", "item", "None", "will", "be", "returned", "if", "there", "are", "multiple", "such", "items", "the", "first", "will", "be", "returned", "." ]

[ "def", "get_assessment_taken", "(", "self", ")", ":", "# Implemented from template for osid.learning.Activity.get_objective", "if", "not", "bool", "(", "self", ".", "_my_map", "[", "'assessmentTakenId'", "]", ")", ":", "raise", "errors", ".", "IllegalState", "(", "'assessment_taken empty'", ")", "mgr", "=", "self", ".", "_get_provider_manager", "(", "'ASSESSMENT'", ")", "if", "not", "mgr", ".", "supports_assessment_taken_lookup", "(", ")", ":", "raise", "errors", ".", "OperationFailed", "(", "'Assessment does not support AssessmentTaken lookup'", ")", "lookup_session", "=", "mgr", ".", "get_assessment_taken_lookup_session", "(", "proxy", "=", "getattr", "(", "self", ",", "\"_proxy\"", ",", "None", ")", ")", "lookup_session", ".", "use_federated_bank_view", "(", ")", "return", "lookup_session", ".", "get_assessment_taken", "(", "self", ".", "get_assessment_taken_id", "(", ")", ")" ]

[ "Gets", "the", "AssessmentTakeb", "." ]

[ "def", "_make_property_from_dict", "(", "self", ",", "property_def", ":", "Dict", ")", "->", "Property", ":", "property_hash", "=", "hash_dump", "(", "property_def", ")", "edge_property_model", "=", "self", ".", "object_cache_property", ".", "get", "(", "property_hash", ")", "if", "edge_property_model", "is", "None", ":", "edge_property_model", "=", "self", ".", "get_property_by_hash", "(", "property_hash", ")", "if", "not", "edge_property_model", ":", "property_def", "[", "'sha512'", "]", "=", "property_hash", "edge_property_model", "=", "Property", "(", "*", "*", "property_def", ")", "self", ".", "object_cache_property", "[", "property_hash", "]", "=", "edge_property_model", "return", "edge_property_model" ]

[ "Build", "an", "edge", "property", "from", "a", "dictionary", "." ]

[ "def", "edit_ipython_profile", "(", "spark_home", ",", "spark_python", ",", "py4j", ")", ":", "from", "IPython", "import", "get_ipython", "ip", "=", "get_ipython", "(", ")", "if", "ip", ":", "profile_dir", "=", "ip", ".", "profile_dir", ".", "location", "else", ":", "from", "IPython", ".", "utils", ".", "path", "import", "locate_profile", "profile_dir", "=", "locate_profile", "(", ")", "startup_file_loc", "=", "os", ".", "path", ".", "join", "(", "profile_dir", ",", "\"startup\"", ",", "\"findspark.py\"", ")", "with", "open", "(", "startup_file_loc", ",", "'w'", ")", "as", "startup_file", ":", "#Lines of code to be run when IPython starts", "startup_file", ".", "write", "(", "\"import sys, os\\n\"", ")", "startup_file", ".", "write", "(", "\"os.environ['SPARK_HOME'] = '\"", "+", "spark_home", "+", "\"'\\n\"", ")", "startup_file", ".", "write", "(", "\"sys.path[:0] = \"", "+", "str", "(", "[", "spark_python", ",", "py4j", "]", ")", "+", "\"\\n\"", ")", "startup_file", ".", "write", "(", "\"import pyspark\\n\"", ")" ]

[ "Adds", "a", "startup", "file", "to", "the", "current", "IPython", "profile", "to", "import", "pyspark", "." ]

[ "def", "tokentype", "(", "self", ",", "s", ")", ":", "a", "=", "s", "[", "0", "]", "if", "len", "(", "s", ")", ">", "0", "else", "\"\"", "b", "=", "s", "[", "1", "]", "if", "len", "(", "s", ")", ">", "1", "else", "\"\"", "if", "a", ".", "isdigit", "(", ")", "or", "(", "a", "in", "[", "\"+\"", ",", "\"-\"", "]", "and", "b", ".", "isdigit", "(", ")", ")", ":", "return", "self", ".", "parse_number", "(", "s", ")", "elif", "a", "==", "'\"'", ":", "return", "self", ".", "parse_string", "(", "s", ")", "elif", "a", "==", "':'", ":", "return", "self", ".", "parse_colon", "(", "s", ")", "elif", "a", "==", "';'", ":", "return", "self", ".", "parse_semicolon", "(", "s", ")", "else", ":", "return", "self", ".", "parse_word", "(", "s", ")" ]

[ "Parses", "string", "and", "returns", "a", "(", "Tokenizer", ".", "TYPE", "value", ")", "tuple", "." ]

[ "def", "ndarray_to_instances", "(", "array", ",", "relation", ",", "att_template", "=", "\"Att-#\"", ",", "att_list", "=", "None", ")", ":", "if", "len", "(", "numpy", ".", "shape", "(", "array", ")", ")", "!=", "2", ":", "raise", "Exception", "(", "\"Number of array dimensions must be 2!\"", ")", "rows", ",", "cols", "=", "numpy", ".", "shape", "(", "array", ")", "# header", "atts", "=", "[", "]", "if", "att_list", "is", "not", "None", ":", "if", "len", "(", "att_list", ")", "!=", "cols", ":", "raise", "Exception", "(", "\"Number columns and provided attribute names differ: \"", "+", "str", "(", "cols", ")", "+", "\" != \"", "+", "len", "(", "att_list", ")", ")", "for", "name", "in", "att_list", ":", "att", "=", "Attribute", ".", "create_numeric", "(", "name", ")", "atts", ".", "append", "(", "att", ")", "else", ":", "for", "i", "in", "range", "(", "cols", ")", ":", "name", "=", "att_template", ".", "replace", "(", "\"#\"", ",", "str", "(", "i", "+", "1", ")", ")", ".", "replace", "(", "\"!\"", ",", "str", "(", "i", ")", ")", ".", "replace", "(", "\"@\"", ",", "relation", ")", "att", "=", "Attribute", ".", "create_numeric", "(", "name", ")", "atts", ".", "append", "(", "att", ")", "result", "=", "Instances", ".", "create_instances", "(", "relation", ",", "atts", ",", "rows", ")", "# data", "for", "i", "in", "range", "(", "rows", ")", ":", "inst", "=", "Instance", ".", "create_instance", "(", "array", "[", "i", "]", ")", "result", ".", "add_instance", "(", "inst", ")", "return", "result" ]

[ "Converts", "the", "numpy", "matrix", "into", "an", "Instances", "object", "and", "returns", "it", "." ]

[ "def", "get_related_entry_admin_url", "(", "entry", ")", ":", "namespaces", "=", "{", "Document", ":", "'wagtaildocs:edit'", ",", "Link", ":", "'wagtaillinks:edit'", ",", "Page", ":", "'wagtailadmin_pages:edit'", ",", "}", "for", "cls", ",", "url", "in", "namespaces", ".", "iteritems", "(", ")", ":", "if", "issubclass", "(", "entry", ".", "content_type", ".", "model_class", "(", ")", ",", "cls", ")", ":", "return", "urlresolvers", ".", "reverse", "(", "url", ",", "args", "=", "(", "entry", ".", "object_id", ",", ")", ")", "return", "''" ]

[ "Returns", "admin", "URL", "for", "specified", "entry", "instance", "." ]

[ "def", "pyxb_is_v1", "(", "pyxb_obj", ")", ":", "# TODO: Will not detect v1.2 as v1.", "return", "(", "pyxb_obj", ".", "_element", "(", ")", ".", "name", "(", ")", ".", "namespace", "(", ")", "==", "d1_common", ".", "types", ".", "dataoneTypes_v1", ".", "Namespace", ")" ]

[ "Args", ":", "pyxb_obj", ":", "PyXB", "object", "PyXB", "object", "holding", "an", "unknown", "type", "." ]

[ "def", "arrays", "(", "self", ",", "field_name", "=", "None", ")", ":", "fieldname", "=", "field_name", "or", "self", ".", "raster_field", ".", "name", "arrays", "=", "[", "]", "for", "obj", "in", "self", ":", "arr", "=", "getattr", "(", "obj", ",", "fieldname", ")", "if", "isinstance", "(", "arr", ",", "np", ".", "ndarray", ")", ":", "arrays", ".", "append", "(", "arr", ")", "else", ":", "arrays", ".", "append", "(", "obj", ".", "array", "(", ")", ")", "return", "arrays" ]

[ "Returns", "a", "list", "of", "ndarrays", "." ]

[ "def", "temp_url", "(", "self", ",", "duration", "=", "120", ")", ":", "return", "self", ".", "bucket", ".", "_boto_s3", ".", "meta", ".", "client", ".", "generate_presigned_url", "(", "'get_object'", ",", "Params", "=", "{", "'Bucket'", ":", "self", ".", "bucket", ".", "name", ",", "'Key'", ":", "self", ".", "name", "}", ",", "ExpiresIn", "=", "duration", ")" ]

[ "Returns", "a", "temporary", "URL", "for", "the", "given", "key", "." ]

[ "def", "get_file_ids", "(", "object", ")", ":", "import", "MOPdbaccess", "mysql", "=", "MOPdbaccess", ".", "connect", "(", "'cfeps'", ",", "'cfhls'", ",", "dbSystem", "=", "'MYSQL'", ")", "cfeps", "=", "mysql", ".", "cursor", "(", ")", "sql", "=", "\"SELECT file_id FROM measure WHERE provisional LIKE %s\"", "cfeps", ".", "execute", "(", "sql", ",", "(", "object", ",", ")", ")", "file_ids", "=", "cfeps", ".", "fetchall", "(", ")", "return", "(", "file_ids", ")" ]

[ "Get", "the", "exposure", "for", "a", "particular", "line", "in", "the", "meausre", "table" ]

[ "def", "bisect", "(", "f", ",", "a", ",", "b", ",", "args", "=", "(", ")", ",", "xtol", "=", "_xtol", ",", "rtol", "=", "_rtol", ",", "maxiter", "=", "_iter", ",", "disp", "=", "True", ")", ":", "if", "xtol", "<=", "0", ":", "raise", "ValueError", "(", "\"xtol is too small (<= 0)\"", ")", "if", "maxiter", "<", "1", ":", "raise", "ValueError", "(", "\"maxiter must be greater than 0\"", ")", "# Convert to float", "xa", "=", "a", "*", "1.0", "xb", "=", "b", "*", "1.0", "fa", "=", "f", "(", "xa", ",", "*", "args", ")", "fb", "=", "f", "(", "xb", ",", "*", "args", ")", "funcalls", "=", "2", "root", ",", "status", "=", "_bisect_interval", "(", "xa", ",", "xb", ",", "fa", ",", "fb", ")", "# Check for sign error and early termination", "if", "status", "==", "_ECONVERGED", ":", "itr", "=", "0", "else", ":", "# Perform bisection", "dm", "=", "xb", "-", "xa", "for", "itr", "in", "range", "(", "maxiter", ")", ":", "dm", "*=", "0.5", "xm", "=", "xa", "+", "dm", "fm", "=", "f", "(", "xm", ",", "*", "args", ")", "funcalls", "+=", "1", "if", "fm", "*", "fa", ">=", "0", ":", "xa", "=", "xm", "if", "fm", "==", "0", "or", "abs", "(", "dm", ")", "<", "xtol", "+", "rtol", "*", "abs", "(", "xm", ")", ":", "root", "=", "xm", "status", "=", "_ECONVERGED", "itr", "+=", "1", "break", "if", "disp", "and", "status", "==", "_ECONVERR", ":", "raise", "RuntimeError", "(", "\"Failed to converge\"", ")", "return", "_results", "(", "(", "root", ",", "funcalls", ",", "itr", ",", "status", ")", ")" ]

[ "Find", "root", "of", "a", "function", "within", "an", "interval", "adapted", "from", "Scipy", "s", "bisect", "." ]

[ "def", "set_client_key", "(", "self", ",", "zmq_socket", ",", "client_secret_key_path", ",", "server_public_key_path", ")", ":", "load_and_set_key", "(", "zmq_socket", ",", "client_secret_key_path", ")", "server_public", ",", "_", "=", "zmq", ".", "auth", ".", "load_certificate", "(", "server_public_key_path", ")", "zmq_socket", ".", "curve_serverkey", "=", "server_public" ]

[ "must", "call", "before", "bind" ]

[ "def", "_import", "(", "module", ",", "cls", ")", ":", "global", "Scanner", "try", ":", "cls", "=", "str", "(", "cls", ")", "mod", "=", "__import__", "(", "str", "(", "module", ")", ",", "globals", "(", ")", ",", "locals", "(", ")", ",", "[", "cls", "]", ",", "1", ")", "Scanner", "=", "getattr", "(", "mod", ",", "cls", ")", "except", "ImportError", ":", "pass" ]

[ "A", "messy", "way", "to", "import", "library", "-", "specific", "classes", ".", "TODO", ":", "I", "should", "really", "make", "a", "factory", "class", "or", "something", "but", "I", "m", "lazy", ".", "Plus", "factories", "remind", "me", "a", "lot", "of", "java", "..." ]

[ "def", "wait_for_host", "(", "self", ",", "host", ")", ":", "t", "=", "time", ".", "time", "(", ")", "if", "host", "in", "self", ".", "times", ":", "due_time", "=", "self", ".", "times", "[", "host", "]", "if", "due_time", ">", "t", ":", "wait", "=", "due_time", "-", "t", "time", ".", "sleep", "(", "wait", ")", "t", "=", "time", ".", "time", "(", ")", "wait_time", "=", "random", ".", "uniform", "(", "self", ".", "wait_time_min", ",", "self", ".", "wait_time_max", ")", "self", ".", "times", "[", "host", "]", "=", "t", "+", "wait_time" ]

[ "Throttle", "requests", "to", "one", "host", "." ]

[ "def", "_run_command", "(", "self", ",", "command", ")", ":", "try", ":", "my_result", "=", "call", "(", "command", ",", "shell", "=", "True", ")", "del", "my_result", "except", "CalledProcessError", "as", "e", ":", "LOGGER", ".", "exception", "(", "'Running command failed %s'", "%", "command", ")", "message", "=", "(", "'Error while executing the following shell '", "'command: %s\\nError message: %s'", "%", "(", "command", ",", "str", "(", "e", ")", ")", ")", "# shameless hack - see https://github.com/AIFDR/inasafe/issues/141", "if", "sys", ".", "platform", "==", "'darwin'", ":", "# Mac OS X", "if", "'Errno 4'", "in", "str", "(", "e", ")", ":", "# continue as the error seems to be non critical", "pass", "else", ":", "raise", "Exception", "(", "message", ")", "else", ":", "raise", "Exception", "(", "message", ")" ]

[ "Run", "a", "command", "and", "raise", "any", "error", "as", "needed", "." ]

[ "def", "copy", "(", "self", ")", ":", "copy_distribution", "=", "GaussianDistribution", "(", "variables", "=", "self", ".", "variables", ",", "mean", "=", "self", ".", "mean", ".", "copy", "(", ")", ",", "cov", "=", "self", ".", "covariance", ".", "copy", "(", ")", ")", "if", "self", ".", "_precision_matrix", "is", "not", "None", ":", "copy_distribution", ".", "_precision_matrix", "=", "self", ".", "_precision_matrix", ".", "copy", "(", ")", "return", "copy_distribution" ]

[ "Return", "a", "copy", "of", "the", "distribution", "." ]

[ "def", "_package_and_submit", "(", "args", ")", ":", "args", "=", "_parse_and_validate_args", "(", "args", ")", "logging", ".", "debug", "(", "args", ")", "dist", "=", "__make_tmp_dir", "(", ")", "try", ":", "__package_dependencies", "(", "dist_dir", "=", "dist", ",", "additional_reqs", "=", "args", "[", "'requirements'", "]", ",", "silent", "=", "args", "[", "'silent'", "]", ")", "__package_app", "(", "tasks_pkg", "=", "args", "[", "'package'", "]", ",", "dist_dir", "=", "dist", ",", "custom_main", "=", "args", "[", "'main'", "]", ",", "extra_data", "=", "args", "[", "'extra_data'", "]", ")", "__run_spark_submit", "(", "lane_yaml", "=", "args", "[", "'yaml'", "]", ",", "dist_dir", "=", "dist", ",", "spark_home", "=", "args", "[", "'spark_home'", "]", ",", "spark_args", "=", "args", "[", "'spark_args'", "]", ",", "silent", "=", "args", "[", "'silent'", "]", ")", "except", "Exception", "as", "exc", ":", "__clean_up", "(", "dist", ")", "raise", "exc", "__clean_up", "(", "dist", ")" ]

[ "Packages", "and", "submits", "a", "job", "which", "is", "defined", "in", "a", "YAML", "file", "to", "Spark", "." ]

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

[ "|coro|" ]

[ "def", "__argument", "(", "self", ",", "ttype", ",", "tvalue", ")", ":", "if", "ttype", "in", "[", "\"multiline\"", ",", "\"string\"", "]", ":", "return", "self", ".", "__curcommand", ".", "check_next_arg", "(", "\"string\"", ",", "tvalue", ".", "decode", "(", "\"utf-8\"", ")", ")", "if", "ttype", "in", "[", "\"number\"", ",", "\"tag\"", "]", ":", "return", "self", ".", "__curcommand", ".", "check_next_arg", "(", "ttype", ",", "tvalue", ".", "decode", "(", "\"ascii\"", ")", ")", "if", "ttype", "==", "\"left_bracket\"", ":", "self", ".", "__cstate", "=", "self", ".", "__stringlist", "self", ".", "__curstringlist", "=", "[", "]", "self", ".", "__set_expected", "(", "\"string\"", ")", "return", "True", "condition", "=", "(", "ttype", "in", "[", "\"left_cbracket\"", ",", "\"comma\"", "]", "and", "self", ".", "__curcommand", ".", "non_deterministic_args", ")", "if", "condition", ":", "self", ".", "__curcommand", ".", "reassign_arguments", "(", ")", "# rewind lexer", "self", ".", "lexer", ".", "pos", "-=", "1", "return", "True", "return", "False" ]

[ "Argument", "parsing", "method" ]

[ "def", "get_go2nt", "(", "self", ",", "usr_go2nt", ")", ":", "gos_all", "=", "self", ".", "get_gos_all", "(", ")", "# Minimum set of namedtuple fields available for use with Sorter on grouped GO IDs", "prt_flds_all", "=", "get_hdridx_flds", "(", ")", "+", "self", ".", "gosubdag", ".", "prt_attr", "[", "'flds'", "]", "if", "not", "usr_go2nt", ":", "return", "self", ".", "__init_go2nt_dflt", "(", "gos_all", ",", "prt_flds_all", ")", "usr_nt_flds", "=", "next", "(", "iter", "(", "usr_go2nt", ".", "values", "(", ")", ")", ")", ".", "_fields", "# If user namedtuple already contains all fields available, then return usr_go2nt", "if", "len", "(", "set", "(", "prt_flds_all", ")", ".", "difference", "(", "usr_nt_flds", ")", ")", "==", "0", ":", "return", "self", ".", "_init_go2nt_aug", "(", "usr_go2nt", ")", "# Otherwise, combine user fields and default Sorter fields", "return", "self", ".", "__init_go2nt_w_usr", "(", "gos_all", ",", "usr_go2nt", ",", "prt_flds_all", ")" ]

[ "Combine", "user", "namedtuple", "fields", "GO", "object", "fields", "and", "format_txt", "." ]

[ "def", "append", "(", "self", ",", "path", ",", "data", ",", "*", "*", "kwargs", ")", ":", "metadata_response", "=", "self", ".", "_post", "(", "path", ",", "'APPEND'", ",", "expected_status", "=", "httplib", ".", "TEMPORARY_REDIRECT", ",", "*", "*", "kwargs", ")", "data_response", "=", "self", ".", "_requests_session", ".", "post", "(", "metadata_response", ".", "headers", "[", "'location'", "]", ",", "data", "=", "data", ",", "*", "*", "self", ".", "_requests_kwargs", ")", "_check_response", "(", "data_response", ")", "assert", "not", "data_response", ".", "content" ]

[ "Append", "to", "the", "given", "file", "." ]

[ "def", "draw_court", "(", "ax", "=", "None", ",", "color", "=", "'gray'", ",", "lw", "=", "1", ",", "outer_lines", "=", "False", ")", ":", "if", "ax", "is", "None", ":", "ax", "=", "plt", ".", "gca", "(", ")", "# Create the various parts of an NBA basketball court", "# Create the basketball hoop", "hoop", "=", "Circle", "(", "(", "0", ",", "0", ")", ",", "radius", "=", "7.5", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ",", "fill", "=", "False", ")", "# Create backboard", "backboard", "=", "Rectangle", "(", "(", "-", "30", ",", "-", "12.5", ")", ",", "60", ",", "0", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "# The paint", "# Create the outer box 0f the paint, width=16ft, height=19ft", "outer_box", "=", "Rectangle", "(", "(", "-", "80", ",", "-", "47.5", ")", ",", "160", ",", "190", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ",", "fill", "=", "False", ")", "# Create the inner box of the paint, widt=12ft, height=19ft", "inner_box", "=", "Rectangle", "(", "(", "-", "60", ",", "-", "47.5", ")", ",", "120", ",", "190", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ",", "fill", "=", "False", ")", "# Create free throw top arc", "top_free_throw", "=", "Arc", "(", "(", "0", ",", "142.5", ")", ",", "120", ",", "120", ",", "theta1", "=", "0", ",", "theta2", "=", "180", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ",", "fill", "=", "False", ")", "# Create free throw bottom arc", "bottom_free_throw", "=", "Arc", "(", "(", "0", ",", "142.5", ")", ",", "120", ",", "120", ",", "theta1", "=", "180", ",", "theta2", "=", "0", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ",", "linestyle", "=", "'dashed'", ")", "# Restricted Zone, it is an arc with 4ft radius from center of the hoop", "restricted", "=", "Arc", "(", "(", "0", ",", "0", ")", ",", "80", ",", "80", ",", "theta1", "=", "0", ",", "theta2", "=", "180", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "# Three point line", "# Create the right side 3pt lines, it's 14ft long before it arcs", "corner_three_a", "=", "Rectangle", "(", "(", "-", "220", ",", "-", "47.5", ")", ",", "0", ",", "140", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "# Create the right side 3pt lines, it's 14ft long before it arcs", "corner_three_b", "=", "Rectangle", "(", "(", "220", ",", "-", "47.5", ")", ",", "0", ",", "140", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "# 3pt arc - center of arc will be the hoop, arc is 23'9\" away from hoop", "three_arc", "=", "Arc", "(", "(", "0", ",", "0", ")", ",", "475", ",", "475", ",", "theta1", "=", "22", ",", "theta2", "=", "158", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "# Center Court", "center_outer_arc", "=", "Arc", "(", "(", "0", ",", "422.5", ")", ",", "120", ",", "120", ",", "theta1", "=", "180", ",", "theta2", "=", "0", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "center_inner_arc", "=", "Arc", "(", "(", "0", ",", "422.5", ")", ",", "40", ",", "40", ",", "theta1", "=", "180", ",", "theta2", "=", "0", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ")", "# List of the court elements to be plotted onto the axes", "court_elements", "=", "[", "hoop", ",", "backboard", ",", "outer_box", ",", "inner_box", ",", "top_free_throw", ",", "bottom_free_throw", ",", "restricted", ",", "corner_three_a", ",", "corner_three_b", ",", "three_arc", ",", "center_outer_arc", ",", "center_inner_arc", "]", "if", "outer_lines", ":", "# Draw the half court line, baseline and side out bound lines", "outer_lines", "=", "Rectangle", "(", "(", "-", "250", ",", "-", "47.5", ")", ",", "500", ",", "470", ",", "linewidth", "=", "lw", ",", "color", "=", "color", ",", "fill", "=", "False", ")", "court_elements", ".", "append", "(", "outer_lines", ")", "# Add the court elements onto the axes", "for", "element", "in", "court_elements", ":", "ax", ".", "add_patch", "(", "element", ")", "return", "ax" ]

[ "Returns", "an", "axes", "with", "a", "basketball", "court", "drawn", "onto", "to", "it", "." ]

[ "def", "average", "(", "self", ",", "rows", ":", "List", "[", "Row", "]", ",", "column", ":", "NumberColumn", ")", "->", "Number", ":", "cell_values", "=", "[", "row", ".", "values", "[", "column", ".", "name", "]", "for", "row", "in", "rows", "]", "if", "not", "cell_values", ":", "return", "0.0", "# type: ignore", "return", "sum", "(", "cell_values", ")", "/", "len", "(", "cell_values", ")" ]

[ "Takes", "a", "list", "of", "rows", "and", "a", "column", "and", "returns", "the", "mean", "of", "the", "values", "under", "that", "column", "in", "those", "rows", "." ]

[ "def", "get_wwpns", "(", "self", ",", "partitions", ")", ":", "body", "=", "{", "'partitions'", ":", "[", "p", ".", "uri", "for", "p", "in", "partitions", "]", "}", "result", "=", "self", ".", "manager", ".", "session", ".", "post", "(", "self", ".", "_uri", "+", "'/operations/'", "'export-port-names-list'", ",", "body", "=", "body", ")", "# Parse the returned comma-separated string for each WWPN into a dict:", "wwpn_list", "=", "[", "]", "dict_keys", "=", "(", "'partition-name'", ",", "'adapter-id'", ",", "'device-number'", ",", "'wwpn'", ")", "for", "wwpn_item", "in", "result", "[", "'wwpn-list'", "]", ":", "dict_values", "=", "wwpn_item", ".", "split", "(", "','", ")", "wwpn_list", ".", "append", "(", "dict", "(", "zip", "(", "dict_keys", ",", "dict_values", ")", ")", ")", "return", "wwpn_list" ]

[ "Return", "the", "WWPNs", "of", "the", "host", "ports", "(", "of", "the", ":", "term", ":", "HBAs", "<HBA", ">", ")", "of", "the", "specified", ":", "term", ":", "Partitions", "<Partition", ">", "of", "this", "CPC", "." ]

[ "def", "entity_data", "(", "self", ",", "entity_type", ",", "entity_id", ",", "history_index", ")", ":", "return", "self", ".", "entity_history", "(", "entity_type", ",", "entity_id", ")", "[", "history_index", "]" ]

[ "Return", "the", "data", "dict", "for", "an", "entity", "at", "a", "specific", "index", "of", "its", "history", "." ]

[ "def", "read_identifiables", "(", "self", ",", "cls", ",", "sdmxobj", ",", "offset", "=", "None", ")", ":", "path", "=", "self", ".", "_paths", "[", "cls", "]", "if", "offset", ":", "try", ":", "base", "=", "self", ".", "_paths", "[", "offset", "]", "(", "sdmxobj", ".", "_elem", ")", "[", "0", "]", "except", "IndexError", ":", "return", "None", "else", ":", "base", "=", "sdmxobj", ".", "_elem", "result", "=", "{", "e", ".", "get", "(", "'id'", ")", ":", "cls", "(", "self", ",", "e", ")", "for", "e", "in", "path", "(", "base", ")", "}", "if", "isinstance", "(", "sdmxobj", ",", "dict", ")", ":", "sdmxobj", ".", "update", "(", "result", ")", "else", ":", "return", "DictLike", "(", "result", ")" ]

[ "If", "sdmxobj", "inherits", "from", "dict", ":", "update", "it", "with", "modelized", "elements", ".", "These", "must", "be", "instances", "of", "model", ".", "IdentifiableArtefact", "i", ".", "e", ".", "have", "an", "id", "attribute", ".", "This", "will", "be", "used", "as", "dict", "keys", ".", "If", "sdmxobj", "does", "not", "inherit", "from", "dict", ":", "return", "a", "new", "DictLike", "." ]

[ "def", "list_policies", "(", ")", ":", "ret", "=", "{", "}", "cmd", "=", "__execute_kadmin", "(", "'list_policies'", ")", "if", "cmd", "[", "'retcode'", "]", "!=", "0", "or", "cmd", "[", "'stderr'", "]", ":", "ret", "[", "'comment'", "]", "=", "cmd", "[", "'stderr'", "]", ".", "splitlines", "(", ")", "[", "-", "1", "]", "ret", "[", "'result'", "]", "=", "False", "return", "ret", "ret", "=", "{", "'policies'", ":", "[", "]", "}", "for", "i", "in", "cmd", "[", "'stdout'", "]", ".", "splitlines", "(", ")", "[", "1", ":", "]", ":", "ret", "[", "'policies'", "]", ".", "append", "(", "i", ")", "return", "ret" ]

[ "List", "policies" ]

[ "def", "get_user_participants", "(", "self", ",", "appointment_group", ",", "*", "*", "kwargs", ")", ":", "from", "canvasapi", ".", "appointment_group", "import", "AppointmentGroup", "from", "canvasapi", ".", "user", "import", "User", "appointment_group_id", "=", "obj_or_id", "(", "appointment_group", ",", "\"appointment_group\"", ",", "(", "AppointmentGroup", ",", ")", ")", "return", "PaginatedList", "(", "User", ",", "self", ".", "__requester", ",", "'GET'", ",", "'appointment_groups/{}/users'", ".", "format", "(", "appointment_group_id", ")", ",", "_kwargs", "=", "combine_kwargs", "(", "*", "*", "kwargs", ")", ")" ]

[ "List", "user", "participants", "in", "this", "appointment", "group", "." ]

[ "def", "replaceelement", "(", "oldelem", ",", "newelem", ")", ":", "parent", "=", "oldelem", ".", "getparent", "(", ")", "if", "parent", "is", "not", "None", ":", "size", "=", "len", "(", "parent", ".", "getchildren", "(", ")", ")", "for", "x", "in", "range", "(", "0", ",", "size", ")", ":", "if", "parent", ".", "getchildren", "(", ")", "[", "x", "]", "==", "oldelem", ":", "parent", ".", "remove", "(", "oldelem", ")", "parent", ".", "insert", "(", "x", ",", "newelem", ")" ]

[ "Given", "a", "parent", "element", "replace", "oldelem", "with", "newelem", "." ]

[ "def", "clean", "(", "self", ")", ":", "with", "self", ".", "mutex", ":", "now", "=", "time", ".", "time", "(", ")", "if", "self", ".", "last_clean_time", "+", "self", ".", "CLEAN_INTERVAL", "<", "now", ":", "to_remove", "=", "[", "]", "for", "(", "host", ",", "pool", ")", "in", "self", ".", "host_to_pool", ".", "items", "(", ")", ":", "pool", ".", "clean", "(", ")", "if", "pool", ".", "size", "(", ")", "==", "0", ":", "to_remove", ".", "append", "(", "host", ")", "for", "host", "in", "to_remove", ":", "del", "self", ".", "host_to_pool", "[", "host", "]", "self", ".", "last_clean_time", "=", "now" ]

[ "Clean", "up", "the", "stale", "connections", "in", "all", "of", "the", "pools", "and", "then", "get", "rid", "of", "empty", "pools", ".", "Pools", "clean", "themselves", "every", "time", "a", "connection", "is", "fetched", ";", "this", "cleaning", "takes", "care", "of", "pools", "that", "aren", "t", "being", "used", "any", "more", "so", "nothing", "is", "being", "gotten", "from", "them", "." ]

[ "def", "render", "(", "self", ",", "context", ")", ":", "module_path", "=", "self", ".", "path", ".", "resolve", "(", "context", ")", "if", "not", "settings", ".", "SYSTEMJS_ENABLED", ":", "if", "settings", ".", "SYSTEMJS_DEFAULT_JS_EXTENSIONS", ":", "name", ",", "ext", "=", "posixpath", ".", "splitext", "(", "module_path", ")", "if", "not", "ext", ":", "module_path", "=", "'{}.js'", ".", "format", "(", "module_path", ")", "if", "settings", ".", "SYSTEMJS_SERVER_URL", ":", "tpl", "=", "\"\"\"<script src=\"{url}{app}\" type=\"text/javascript\"></script>\"\"\"", "else", ":", "tpl", "=", "\"\"\"<script type=\"text/javascript\">System.import('{app}');</script>\"\"\"", "return", "tpl", ".", "format", "(", "app", "=", "module_path", ",", "url", "=", "settings", ".", "SYSTEMJS_SERVER_URL", ")", "# else: create a bundle", "rel_path", "=", "System", ".", "get_bundle_path", "(", "module_path", ")", "url", "=", "staticfiles_storage", ".", "url", "(", "rel_path", ")", "tag_attrs", "=", "{", "'type'", ":", "'text/javascript'", "}", "for", "key", ",", "value", "in", "self", ".", "tag_attrs", ".", "items", "(", ")", ":", "if", "not", "isinstance", "(", "value", ",", "bool", ")", ":", "value", "=", "value", ".", "resolve", "(", "context", ")", "tag_attrs", "[", "key", "]", "=", "value", "return", "\"\"\"<script{attrs} src=\"{url}\"></script>\"\"\"", ".", "format", "(", "url", "=", "url", ",", "attrs", "=", "flatatt", "(", "tag_attrs", ")", ")" ]

[ "Build", "the", "filepath", "by", "appending", "the", "extension", "." ]

[ "def", "distance", "(", "self", ",", "loc", ")", ":", "assert", "type", "(", "loc", ")", "==", "type", "(", "self", ")", "# convert decimal degrees to radians", "lon1", ",", "lat1", ",", "lon2", ",", "lat2", "=", "map", "(", "radians", ",", "[", "self", ".", "lon", ",", "self", ".", "lat", ",", "loc", ".", "lon", ",", "loc", ".", "lat", ",", "]", ")", "# haversine formula", "dlon", "=", "lon2", "-", "lon1", "dlat", "=", "lat2", "-", "lat1", "a", "=", "sin", "(", "dlat", "/", "2", ")", "**", "2", "+", "cos", "(", "lat1", ")", "*", "cos", "(", "lat2", ")", "*", "sin", "(", "dlon", "/", "2", ")", "**", "2", "c", "=", "2", "*", "asin", "(", "sqrt", "(", "a", ")", ")", "r", "=", "6371000", "# Radius of earth in meters.", "return", "c", "*", "r" ]

[ "Calculate", "the", "great", "circle", "distance", "between", "two", "points", "on", "the", "earth", "(", "specified", "in", "decimal", "degrees", ")" ]

[ "def", "export", "(", "_", ")", ":", "FLAGS", "=", "tf", ".", "app", ".", "flags", ".", "FLAGS", "#with tf.Graph().as_default():", "tf", ".", "reset_default_graph", "(", ")", "def", "preprocess_image", "(", "image_buffer", ")", ":", "\"\"\"Preprocess JPEG encoded bytes to 3D float Tensor.\"\"\"", "# Decode the string as an RGB JPEG.", "# Note that the resulting image contains an unknown height and width", "# that is set dynamically by decode_jpeg. In other words, the height", "# and width of image is unknown at compile-time.", "image", "=", "tf", ".", "image", ".", "decode_jpeg", "(", "image_buffer", ",", "channels", "=", "3", ")", "# After this point, all image pixels reside in [0,1)", "# until the very end, when they're rescaled to (-1, 1). The various", "# adjust_* ops all require this range for dtype float.", "image", "=", "tf", ".", "image", ".", "convert_image_dtype", "(", "image", ",", "dtype", "=", "tf", ".", "float32", ")", "# Crop the central region of the image with an area containing 87.5% of", "# the original image.", "image", "=", "tf", ".", "image", ".", "central_crop", "(", "image", ",", "central_fraction", "=", "0.875", ")", "# Resize the image to the original height and width.", "image", "=", "tf", ".", "expand_dims", "(", "image", ",", "0", ")", "image", "=", "tf", ".", "image", ".", "resize_bilinear", "(", "image", ",", "[", "FLAGS", ".", "image_size", ",", "FLAGS", ".", "image_size", "]", ",", "align_corners", "=", "False", ")", "image", "=", "tf", ".", "squeeze", "(", "image", ",", "[", "0", "]", ")", "# Finally, rescale to [-1,1] instead of [0, 1)", "image", "=", "tf", ".", "subtract", "(", "image", ",", "0.5", ")", "image", "=", "tf", ".", "multiply", "(", "image", ",", "2.0", ")", "return", "image", "# Get images and labels from the dataset.", "jpegs", "=", "tf", ".", "placeholder", "(", "tf", ".", "string", ",", "[", "None", "]", ",", "name", "=", "'jpegs'", ")", "images", "=", "tf", ".", "map_fn", "(", "preprocess_image", ",", "jpegs", ",", "dtype", "=", "tf", ".", "float32", ")", "labels", "=", "tf", ".", "placeholder", "(", "tf", ".", "int32", ",", "[", "None", "]", ",", "name", "=", "'labels'", ")", "# Number of classes in the Dataset label set plus 1.", "# Label 0 is reserved for an (unused) background class.", "dataset", "=", "ImagenetData", "(", "subset", "=", "FLAGS", ".", "subset", ")", "num_classes", "=", "dataset", ".", "num_classes", "(", ")", "+", "1", "# Build a Graph that computes the logits predictions from the", "# inference model.", "logits", ",", "_", "=", "inception", ".", "inference", "(", "images", ",", "num_classes", ")", "# Calculate predictions.", "top_1_op", "=", "tf", ".", "nn", ".", "in_top_k", "(", "logits", ",", "labels", ",", "1", ")", "top_5_op", "=", "tf", ".", "nn", ".", "in_top_k", "(", "logits", ",", "labels", ",", "5", ")", "# Restore the moving average version of the learned variables for eval.", "variable_averages", "=", "tf", ".", "train", ".", "ExponentialMovingAverage", "(", "inception", ".", "MOVING_AVERAGE_DECAY", ")", "variables_to_restore", "=", "variable_averages", ".", "variables_to_restore", "(", ")", "saver", "=", "tf", ".", "train", ".", "Saver", "(", "variables_to_restore", ")", "with", "tf", ".", "Session", "(", ")", "as", "sess", ":", "ckpt", "=", "tf", ".", "train", ".", "get_checkpoint_state", "(", "FLAGS", ".", "train_dir", ")", "if", "not", "ckpt", "or", "not", "ckpt", ".", "model_checkpoint_path", ":", "raise", "Exception", "(", "\"No checkpoint file found at: {}\"", ".", "format", "(", "FLAGS", ".", "train_dir", ")", ")", "print", "(", "\"ckpt.model_checkpoint_path: {0}\"", ".", "format", "(", "ckpt", ".", "model_checkpoint_path", ")", ")", "saver", ".", "restore", "(", "sess", ",", "ckpt", ".", "model_checkpoint_path", ")", "# Assuming model_checkpoint_path looks something like:", "# /my-favorite-path/imagenet_train/model.ckpt-0,", "# extract global_step from it.", "global_step", "=", "ckpt", ".", "model_checkpoint_path", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", ".", "split", "(", "'-'", ")", "[", "-", "1", "]", "print", "(", "'Successfully loaded model from %s at step=%s.'", "%", "(", "ckpt", ".", "model_checkpoint_path", ",", "global_step", ")", ")", "print", "(", "\"Exporting saved_model to: {}\"", ".", "format", "(", "FLAGS", ".", "export_dir", ")", ")", "# exported signatures defined in code", "signatures", "=", "{", "tf", ".", "saved_model", ".", "signature_constants", ".", "DEFAULT_SERVING_SIGNATURE_DEF_KEY", ":", "{", "'inputs'", ":", "{", "'jpegs'", ":", "jpegs", ",", "'labels'", ":", "labels", "}", ",", "'outputs'", ":", "{", "'top_5_acc'", ":", "top_5_op", "}", ",", "'method_name'", ":", "tf", ".", "saved_model", ".", "signature_constants", ".", "PREDICT_METHOD_NAME", "}", "}", "TFNode", ".", "export_saved_model", "(", "sess", ",", "FLAGS", ".", "export_dir", ",", "tf", ".", "saved_model", ".", "tag_constants", ".", "SERVING", ",", "signatures", ")", "print", "(", "\"Exported saved_model\"", ")" ]

[ "Evaluate", "model", "on", "Dataset", "for", "a", "number", "of", "steps", "." ]

[ "def", "OnInit", "(", "self", ")", ":", "project", "=", "compass", ".", "CompassProjectParser", "(", "sys", ".", "argv", "[", "1", "]", ")", ".", "parse", "(", ")", "frame", "=", "MyFrame", "(", "None", ",", "-", "1", ",", "'wxCompass'", ",", "project", ")", "frame", ".", "Show", "(", "True", ")", "self", ".", "SetTopWindow", "(", "frame", ")", "return", "True" ]

[ "Initialize", "by", "creating", "the", "split", "window", "with", "the", "tree" ]

[ "def", "vms", "(", "message", ",", "level", "=", "1", ")", ":", "if", "verbose", "is", "not", "None", "and", "verbose", "!=", "False", ":", "if", "isinstance", "(", "verbose", ",", "bool", ")", "or", "(", "isinstance", "(", "verbose", ",", "int", ")", "and", "level", "<=", "verbose", ")", ":", "std", "(", "message", ")" ]

[ "Writes", "the", "specified", "message", "*", "only", "*", "if", "verbose", "output", "is", "enabled", "." ]

[ "def", "split_marker", "(", "marker", ",", "fg_id", "=", "1", ",", "bg_id", "=", "2", ")", ":", "img_marker", "=", "scipy", ".", "asarray", "(", "marker", ")", "img_fgmarker", "=", "scipy", ".", "zeros", "(", "img_marker", ".", "shape", ",", "scipy", ".", "bool_", ")", "img_fgmarker", "[", "img_marker", "==", "fg_id", "]", "=", "True", "img_bgmarker", "=", "scipy", ".", "zeros", "(", "img_marker", ".", "shape", ",", "scipy", ".", "bool_", ")", "img_bgmarker", "[", "img_marker", "==", "bg_id", "]", "=", "True", "return", "img_fgmarker", ",", "img_bgmarker" ]

[ "Splits", "an", "integer", "marker", "image", "into", "two", "binary", "image", "containing", "the", "foreground", "and", "background", "markers", "respectively", ".", "All", "encountered", "1", "s", "are", "hereby", "treated", "as", "foreground", "all", "2", "s", "as", "background", "all", "0", "s", "as", "neutral", "marker", "and", "all", "others", "are", "ignored", ".", "This", "behaviour", "can", "be", "changed", "by", "supplying", "the", "fg_id", "and", "/", "or", "bg_id", "parameters", ".", "Parameters", "----------", "marker", ":", "ndarray", "The", "marker", "image", ".", "fg_id", ":", "integer", "The", "value", "that", "should", "be", "treated", "as", "foreground", ".", "bg_id", ":", "integer", "The", "value", "that", "should", "be", "treated", "as", "background", ".", "Returns", "-------", "fgmarkers", "bgmarkers", ":", "nadarray", "The", "fore", "-", "and", "background", "markers", "as", "boolean", "images", "." ]

[ "async", "def", "leave", "(", "self", ")", ":", "is_group_conversation", "=", "(", "self", ".", "_conversation", ".", "type", "==", "hangouts_pb2", ".", "CONVERSATION_TYPE_GROUP", ")", "try", ":", "if", "is_group_conversation", ":", "await", "self", ".", "_client", ".", "remove_user", "(", "hangouts_pb2", ".", "RemoveUserRequest", "(", "request_header", "=", "self", ".", "_client", ".", "get_request_header", "(", ")", ",", "event_request_header", "=", "self", ".", "_get_event_request_header", "(", ")", ",", ")", ")", "else", ":", "await", "self", ".", "_client", ".", "delete_conversation", "(", "hangouts_pb2", ".", "DeleteConversationRequest", "(", "request_header", "=", "self", ".", "_client", ".", "get_request_header", "(", ")", ",", "conversation_id", "=", "hangouts_pb2", ".", "ConversationId", "(", "id", "=", "self", ".", "id_", ")", ",", "delete_upper_bound_timestamp", "=", "parsers", ".", "to_timestamp", "(", "datetime", ".", "datetime", ".", "now", "(", "tz", "=", "datetime", ".", "timezone", ".", "utc", ")", ")", ")", ")", "except", "exceptions", ".", "NetworkError", "as", "e", ":", "logger", ".", "warning", "(", "'Failed to leave conversation: {}'", ".", "format", "(", "e", ")", ")", "raise" ]

[ "Leave", "this", "conversation", "." ]

[ "def", "backends_to_mutate", "(", "self", ",", "namespace", ",", "stream", ")", ":", "if", "namespace", "not", "in", "self", ".", "namespaces", ":", "raise", "NamespaceMissing", "(", "'`{}` namespace is not configured'", ".", "format", "(", "namespace", ")", ")", "return", "self", ".", "prefix_confs", "[", "namespace", "]", "[", "self", ".", "get_matching_prefix", "(", "namespace", ",", "stream", ")", "]" ]

[ "Return", "all", "the", "backends", "enabled", "for", "writing", "for", "stream", "." ]

[ "def", "page", "(", "self", ",", "enabled", "=", "values", ".", "unset", ",", "date_created_after", "=", "values", ".", "unset", ",", "date_created_before", "=", "values", ".", "unset", ",", "friendly_name", "=", "values", ".", "unset", ",", "page_token", "=", "values", ".", "unset", ",", "page_number", "=", "values", ".", "unset", ",", "page_size", "=", "values", ".", "unset", ")", ":", "params", "=", "values", ".", "of", "(", "{", "'Enabled'", ":", "enabled", ",", "'DateCreatedAfter'", ":", "serialize", ".", "iso8601_datetime", "(", "date_created_after", ")", ",", "'DateCreatedBefore'", ":", "serialize", ".", "iso8601_datetime", "(", "date_created_before", ")", ",", "'FriendlyName'", ":", "friendly_name", ",", "'PageToken'", ":", "page_token", ",", "'Page'", ":", "page_number", ",", "'PageSize'", ":", "page_size", ",", "}", ")", "response", "=", "self", ".", "_version", ".", "page", "(", "'GET'", ",", "self", ".", "_uri", ",", "params", "=", "params", ",", ")", "return", "CompositionHookPage", "(", "self", ".", "_version", ",", "response", ",", "self", ".", "_solution", ")" ]

[ "Retrieve", "a", "single", "page", "of", "CompositionHookInstance", "records", "from", "the", "API", ".", "Request", "is", "executed", "immediately" ]

[ "def", "create_derived_metric", "(", "self", ",", "*", "*", "kwargs", ")", ":", "# noqa: E501", "kwargs", "[", "'_return_http_data_only'", "]", "=", "True", "if", "kwargs", ".", "get", "(", "'async_req'", ")", ":", "return", "self", ".", "create_derived_metric_with_http_info", "(", "*", "*", "kwargs", ")", "# noqa: E501", "else", ":", "(", "data", ")", "=", "self", ".", "create_derived_metric_with_http_info", "(", "*", "*", "kwargs", ")", "# noqa: E501", "return", "data" ]

[ "Create", "a", "specific", "derived", "metric", "definition", "#", "noqa", ":", "E501" ]

[ "def", "propagate_measurement_info", "(", "self", ")", ":", "meas_df", "=", "self", ".", "tables", "[", "'measurements'", "]", ".", "df", "names_list", "=", "[", "'specimen'", ",", "'sample'", ",", "'site'", ",", "'location'", "]", "# add in any tables that you can", "for", "num", ",", "name", "in", "enumerate", "(", "names_list", ")", ":", "# don't replace tables that already exist", "if", "(", "name", "+", "\"s\"", ")", "in", "self", ".", "tables", ":", "continue", "elif", "name", "in", "meas_df", ".", "columns", ":", "items", "=", "meas_df", "[", "name", "]", ".", "unique", "(", ")", "df", "=", "pd", ".", "DataFrame", "(", "columns", "=", "[", "name", "]", ",", "index", "=", "items", ")", "df", "[", "name", "]", "=", "df", ".", "index", "# add in parent name if possible", "# (i.e., sample name to specimens table)", "if", "num", "<", "(", "len", "(", "names_list", ")", "-", "1", ")", ":", "parent", "=", "names_list", "[", "num", "+", "1", "]", "if", "parent", "in", "meas_df", ".", "columns", ":", "meas_df", "=", "meas_df", ".", "where", "(", "meas_df", ".", "notnull", "(", ")", ",", "\"\"", ")", "df", "[", "parent", "]", "=", "meas_df", ".", "drop_duplicates", "(", "subset", "=", "[", "name", "]", ")", "[", "parent", "]", ".", "values", ".", "astype", "(", "str", ")", "df", "=", "df", ".", "where", "(", "df", "!=", "\"\"", ",", "np", ".", "nan", ")", "df", "=", "df", ".", "dropna", "(", "how", "=", "'all'", ",", "axis", "=", "'rows'", ")", "if", "len", "(", "df", ")", ":", "self", ".", "tables", "[", "name", "+", "\"s\"", "]", "=", "MagicDataFrame", "(", "dtype", "=", "name", "+", "\"s\"", ",", "df", "=", "df", ")", "self", ".", "write_table_to_file", "(", "name", "+", "\"s\"", ")" ]

[ "Take", "a", "contribution", "with", "a", "measurement", "table", ".", "Create", "specimen", "sample", "site", "and", "location", "tables", "using", "the", "unique", "names", "in", "the", "measurement", "table", "to", "fill", "in", "the", "index", "." ]

[ "def", "ramp_array", "(", "rampdata", ",", "ti", ",", "gain", "=", "1.0", ",", "ron", "=", "1.0", ",", "badpixels", "=", "None", ",", "dtype", "=", "'float64'", ",", "saturation", "=", "65631", ",", "blank", "=", "0", ",", "nsig", "=", "None", ",", "normalize", "=", "False", ")", ":", "import", "numina", ".", "array", ".", "_nirproc", "as", "_nirproc", "if", "ti", "<=", "0", ":", "raise", "ValueError", "(", "\"invalid parameter, ti <= 0.0\"", ")", "if", "gain", "<=", "0", ":", "raise", "ValueError", "(", "\"invalid parameter, gain <= 0.0\"", ")", "if", "ron", "<=", "0", ":", "raise", "ValueError", "(", "\"invalid parameter, ron < 0.0\"", ")", "if", "saturation", "<=", "0", ":", "raise", "ValueError", "(", "\"invalid parameter, saturation <= 0\"", ")", "rampdata", "=", "numpy", ".", "asarray", "(", "rampdata", ")", "if", "rampdata", ".", "ndim", "!=", "3", ":", "raise", "ValueError", "(", "'rampdata must be 3D'", ")", "# change byteorder", "ndtype", "=", "rampdata", ".", "dtype", ".", "newbyteorder", "(", "'='", ")", "rampdata", "=", "numpy", ".", "asarray", "(", "rampdata", ",", "dtype", "=", "ndtype", ")", "# type of the output", "fdtype", "=", "numpy", ".", "result_type", "(", "rampdata", ".", "dtype", ",", "dtype", ")", "# Type of the mask", "mdtype", "=", "numpy", ".", "dtype", "(", "'uint8'", ")", "fshape", "=", "(", "rampdata", ".", "shape", "[", "1", "]", ",", "rampdata", ".", "shape", "[", "2", "]", ")", "if", "badpixels", "is", "None", ":", "badpixels", "=", "numpy", ".", "zeros", "(", "fshape", ",", "dtype", "=", "mdtype", ")", "else", ":", "if", "badpixels", ".", "shape", "!=", "fshape", ":", "msg", "=", "'shape of badpixels is not compatible with shape of rampdata'", "raise", "ValueError", "(", "msg", ")", "if", "badpixels", ".", "dtype", "!=", "mdtype", ":", "raise", "ValueError", "(", "'dtype of badpixels must be uint8'", ")", "result", "=", "numpy", ".", "empty", "(", "fshape", ",", "dtype", "=", "fdtype", ")", "var", "=", "numpy", ".", "empty_like", "(", "result", ")", "npix", "=", "numpy", ".", "empty", "(", "fshape", ",", "dtype", "=", "mdtype", ")", "mask", "=", "badpixels", ".", "copy", "(", ")", "_nirproc", ".", "_process_ramp_intl", "(", "rampdata", ",", "ti", ",", "gain", ",", "ron", ",", "badpixels", ",", "saturation", ",", "blank", ",", "result", ",", "var", ",", "npix", ",", "mask", ")", "return", "result", ",", "var", ",", "npix", ",", "mask" ]

[ "Loop", "over", "the", "first", "axis", "applying", "ramp", "processing", "." ]

[ "def", "check_archive_format", "(", "format", ",", "compression", ")", ":", "if", "format", "not", "in", "ArchiveFormats", ":", "raise", "util", ".", "PatoolError", "(", "\"unknown archive format `%s'\"", "%", "format", ")", "if", "compression", "is", "not", "None", "and", "compression", "not", "in", "ArchiveCompressions", ":", "raise", "util", ".", "PatoolError", "(", "\"unkonwn archive compression `%s'\"", "%", "compression", ")" ]

[ "Make", "sure", "format", "and", "compression", "is", "known", "." ]

[ "def", "send", "(", "self", ",", "conn", ")", ":", "if", "conn", "is", "None", ":", "raise", "ValueError", "(", "\"Cannot send to connection None\"", ")", "with", "(", "yield", "conn", ".", "write_lock", ".", "acquire", "(", ")", ")", ":", "sent", "=", "0", "yield", "conn", ".", "write_message", "(", "self", ".", "header_json", ",", "locked", "=", "False", ")", "sent", "+=", "len", "(", "self", ".", "header_json", ")", "# uncomment this to make it a lot easier to reproduce lock-related bugs", "#yield gen.sleep(0.1)", "yield", "conn", ".", "write_message", "(", "self", ".", "metadata_json", ",", "locked", "=", "False", ")", "sent", "+=", "len", "(", "self", ".", "metadata_json", ")", "# uncomment this to make it a lot easier to reproduce lock-related bugs", "#yield gen.sleep(0.1)", "yield", "conn", ".", "write_message", "(", "self", ".", "content_json", ",", "locked", "=", "False", ")", "sent", "+=", "len", "(", "self", ".", "content_json", ")", "sent", "+=", "yield", "self", ".", "write_buffers", "(", "conn", ",", "locked", "=", "False", ")", "raise", "gen", ".", "Return", "(", "sent", ")" ]

[ "Send", "the", "message", "on", "the", "given", "connection", "." ]

[ "def", "generate", "(", "self", ")", ":", "exp_name", "=", "self", ".", "exp_name", "(", ")", "fname", "=", "os", ".", "path", ".", "basename", "(", "self", ".", "out_path", ")", "fname", "=", "\"{exp}_{prefix}_{name}{ending}\"", ".", "format", "(", "exp", "=", "exp_name", ",", "prefix", "=", "os", ".", "path", ".", "splitext", "(", "fname", ")", "[", "0", "]", ",", "ending", "=", "os", ".", "path", ".", "splitext", "(", "fname", ")", "[", "-", "1", "]", ",", "name", "=", "\"full\"", ")", "first", "=", "True", "for", "chunk", "in", "self", ".", "report", "(", ")", ":", "print", "(", "\"Writing chunk to :'{0}'\"", ".", "format", "(", "fname", ")", ")", "chunk", ".", "to_csv", "(", "fname", ",", "header", "=", "first", ",", "mode", "=", "'a'", ")", "first", "=", "False" ]

[ "Fetch", "all", "rows", "associated", "with", "this", "experiment", "." ]

[ "def", "_set_action_memory", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "RestrictedClassType", "(", "base_type", "=", "unicode", ",", "restriction_type", "=", "\"dict_key\"", ",", "restriction_arg", "=", "{", "u'raslog'", ":", "{", "'value'", ":", "1", "}", "}", ",", ")", ",", "is_leaf", "=", "True", ",", "yang_name", "=", "\"action-memory\"", ",", "rest_name", "=", "\"action\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'Action to take when memory usage exceeds threshold'", ",", "u'alt-name'", ":", "u'action'", ",", "u'cli-suppress-no'", ":", "None", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-resource-monitor'", ",", "defining_module", "=", "'brocade-resource-monitor'", ",", "yang_type", "=", "'resource-monitor-actiontype'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"action_memory must be of a type compatible with resource-monitor-actiontype\"\"\"", ",", "'defined-type'", ":", "\"brocade-resource-monitor:resource-monitor-actiontype\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_type=\"dict_key\", restriction_arg={u'raslog': {'value': 1}},), is_leaf=True, yang_name=\"action-memory\", rest_name=\"action\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Action to take when memory usage exceeds threshold', u'alt-name': u'action', u'cli-suppress-no': None}}, namespace='urn:brocade.com:mgmt:brocade-resource-monitor', defining_module='brocade-resource-monitor', yang_type='resource-monitor-actiontype', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__action_memory", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "Setter", "method", "for", "action_memory", "mapped", "from", "YANG", "variable", "/", "rbridge_id", "/", "resource_monitor", "/", "memory", "/", "action_memory", "(", "resource", "-", "monitor", "-", "actiontype", ")", "If", "this", "variable", "is", "read", "-", "only", "(", "config", ":", "false", ")", "in", "the", "source", "YANG", "file", "then", "_set_action_memory", "is", "considered", "as", "a", "private", "method", ".", "Backends", "looking", "to", "populate", "this", "variable", "should", "do", "so", "via", "calling", "thisObj", ".", "_set_action_memory", "()", "directly", "." ]

[ "def", "generate", "(", "self", ",", "*", "*", "kwargs", ")", ":", "self", ".", "current_params", ".", "update", "(", "kwargs", ")", "rfparams", "=", "{", "param", ":", "self", ".", "current_params", "[", "param", "]", "for", "param", "in", "kwargs", "if", "param", "not", "in", "self", ".", "location_args", "}", "hp", ",", "hc", "=", "self", ".", "rframe_generator", ".", "generate", "(", "*", "*", "rfparams", ")", "if", "isinstance", "(", "hp", ",", "TimeSeries", ")", ":", "df", "=", "self", ".", "current_params", "[", "'delta_f'", "]", "hp", "=", "hp", ".", "to_frequencyseries", "(", "delta_f", "=", "df", ")", "hc", "=", "hc", ".", "to_frequencyseries", "(", "delta_f", "=", "df", ")", "# time-domain waveforms will not be shifted so that the peak amp", "# happens at the end of the time series (as they are for f-domain),", "# so we add an additional shift to account for it", "tshift", "=", "1.", "/", "df", "-", "abs", "(", "hp", ".", "_epoch", ")", "else", ":", "tshift", "=", "0.", "hp", ".", "_epoch", "=", "hc", ".", "_epoch", "=", "self", ".", "_epoch", "h", "=", "{", "}", "if", "self", ".", "detector_names", "!=", "[", "'RF'", "]", ":", "for", "detname", ",", "det", "in", "self", ".", "detectors", ".", "items", "(", ")", ":", "# apply detector response function", "fp", ",", "fc", "=", "det", ".", "antenna_pattern", "(", "self", ".", "current_params", "[", "'ra'", "]", ",", "self", ".", "current_params", "[", "'dec'", "]", ",", "self", ".", "current_params", "[", "'polarization'", "]", ",", "self", ".", "current_params", "[", "'tc'", "]", ")", "thish", "=", "fp", "*", "hp", "+", "fc", "*", "hc", "# apply the time shift", "tc", "=", "self", ".", "current_params", "[", "'tc'", "]", "+", "det", ".", "time_delay_from_earth_center", "(", "self", ".", "current_params", "[", "'ra'", "]", ",", "self", ".", "current_params", "[", "'dec'", "]", ",", "self", ".", "current_params", "[", "'tc'", "]", ")", "h", "[", "detname", "]", "=", "apply_fd_time_shift", "(", "thish", ",", "tc", "+", "tshift", ",", "copy", "=", "False", ")", "if", "self", ".", "recalib", ":", "# recalibrate with given calibration model", "h", "[", "detname", "]", "=", "self", ".", "recalib", "[", "detname", "]", ".", "map_to_adjust", "(", "h", "[", "detname", "]", ",", "*", "*", "self", ".", "current_params", ")", "else", ":", "# no detector response, just use the + polarization", "if", "'tc'", "in", "self", ".", "current_params", ":", "hp", "=", "apply_fd_time_shift", "(", "hp", ",", "self", ".", "current_params", "[", "'tc'", "]", "+", "tshift", ",", "copy", "=", "False", ")", "h", "[", "'RF'", "]", "=", "hp", "if", "self", ".", "gates", "is", "not", "None", ":", "# resize all to nearest power of 2", "for", "d", "in", "h", ".", "values", "(", ")", ":", "d", ".", "resize", "(", "ceilpow2", "(", "len", "(", "d", ")", "-", "1", ")", "+", "1", ")", "h", "=", "strain", ".", "apply_gates_to_fd", "(", "h", ",", "self", ".", "gates", ")", "return", "h" ]

[ "Generates", "a", "waveform", "applies", "a", "time", "shift", "and", "the", "detector", "response", "function", "from", "the", "given", "kwargs", "." ]

[ "def", "_login", "(", "self", ",", "username", ",", "password", ")", ":", "self", ".", "logger", ".", "debug", "(", "'login ...'", ")", "res", "=", "self", ".", "session", ".", "http", ".", "get", "(", "self", ".", "login_url", ")", "input_list", "=", "self", ".", "_input_re", ".", "findall", "(", "res", ".", "text", ")", "if", "not", "input_list", ":", "raise", "PluginError", "(", "'Missing input data on login website.'", ")", "data", "=", "{", "}", "for", "_input_data", "in", "input_list", ":", "try", ":", "_input_name", "=", "self", ".", "_name_re", ".", "search", "(", "_input_data", ")", ".", "group", "(", "1", ")", "except", "AttributeError", ":", "continue", "try", ":", "_input_value", "=", "self", ".", "_value_re", ".", "search", "(", "_input_data", ")", ".", "group", "(", "1", ")", "except", "AttributeError", ":", "_input_value", "=", "''", "data", "[", "_input_name", "]", "=", "_input_value", "login_data", "=", "{", "'ctl00$Login1$UserName'", ":", "username", ",", "'ctl00$Login1$Password'", ":", "password", ",", "'ctl00$Login1$LoginButton.x'", ":", "'0'", ",", "'ctl00$Login1$LoginButton.y'", ":", "'0'", "}", "data", ".", "update", "(", "login_data", ")", "res", "=", "self", ".", "session", ".", "http", ".", "post", "(", "self", ".", "login_url", ",", "data", "=", "data", ")", "for", "cookie", "in", "self", ".", "session", ".", "http", ".", "cookies", ":", "self", ".", "_session_attributes", ".", "set", "(", "cookie", ".", "name", ",", "cookie", ".", "value", ",", "expires", "=", "3600", "*", "24", ")", "if", "self", ".", "_session_attributes", ".", "get", "(", "'ASP.NET_SessionId'", ")", "and", "self", ".", "_session_attributes", ".", "get", "(", "'.abportail1'", ")", ":", "self", ".", "logger", ".", "debug", "(", "'New session data'", ")", "self", ".", "set_expires_time_cache", "(", ")", "return", "True", "else", ":", "self", ".", "logger", ".", "error", "(", "'Failed to login, check your username/password'", ")", "return", "False" ]

[ "login", "and", "update", "cached", "cookies" ]

[ "def", "complete_contexts", "(", "self", ")", ":", "if", "self", ".", "_complete_contexts", ":", "return", "self", ".", "_complete_contexts", "self", ".", "context", "(", ")", "return", "self", ".", "_complete_contexts" ]

[ "Return", "a", "list", "of", "interfaces", "that", "have", "satisfied", "contexts", "." ]

[ "def", "encrypt_to_file", "(", "contents", ",", "filename", ")", ":", "if", "not", "filename", ".", "endswith", "(", "'.enc'", ")", ":", "raise", "ValueError", "(", "\"%s does not end with .enc\"", "%", "filename", ")", "key", "=", "Fernet", ".", "generate_key", "(", ")", "fer", "=", "Fernet", "(", "key", ")", "encrypted_file", "=", "fer", ".", "encrypt", "(", "contents", ")", "with", "open", "(", "filename", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "encrypted_file", ")", "return", "key" ]

[ "Encrypts", "contents", "and", "writes", "it", "to", "filename", "." ]

[ "def", "_set_rpc", "(", "self", ",", "rpc_type", ":", "str", ")", "->", "None", ":", "if", "rpc_type", "==", "\"infura\"", ":", "self", ".", "set_api_rpc_infura", "(", ")", "elif", "rpc_type", "==", "\"localhost\"", ":", "self", ".", "set_api_rpc_localhost", "(", ")", "else", ":", "self", ".", "set_api_rpc", "(", "rpc_type", ")" ]

[ "Sets", "rpc", "based", "on", "the", "type", ":", "param", "rpc_type", ":", "The", "type", "of", "connection", ":", "like", "infura", "ganache", "localhost", ":", "return", ":" ]

[ "def", "sample_callable_bed", "(", "bam_file", ",", "ref_file", ",", "data", ")", ":", "from", "bcbio", ".", "heterogeneity", "import", "chromhacks", "CovInfo", "=", "collections", ".", "namedtuple", "(", "\"CovInfo\"", ",", "\"callable, raw_callable, depth_files\"", ")", "noalt_calling", "=", "\"noalt_calling\"", "in", "dd", ".", "get_tools_on", "(", "data", ")", "or", "\"altcontigs\"", "in", "dd", ".", "get_exclude_regions", "(", "data", ")", "def", "callable_chrom_filter", "(", "r", ")", ":", "\"\"\"Filter to callable region, potentially limiting by chromosomes.\n \"\"\"", "return", "r", ".", "name", "==", "\"CALLABLE\"", "and", "(", "not", "noalt_calling", "or", "chromhacks", ".", "is_nonalt", "(", "r", ".", "chrom", ")", ")", "out_file", "=", "\"%s-callable_sample.bed\"", "%", "os", ".", "path", ".", "splitext", "(", "bam_file", ")", "[", "0", "]", "with", "shared", ".", "bedtools_tmpdir", "(", "data", ")", ":", "sv_bed", "=", "regions", ".", "get_sv_bed", "(", "data", ")", "callable_bed", ",", "depth_files", "=", "coverage", ".", "calculate", "(", "bam_file", ",", "data", ",", "sv_bed", ")", "input_regions_bed", "=", "dd", ".", "get_variant_regions", "(", "data", ")", "if", "not", "utils", ".", "file_uptodate", "(", "out_file", ",", "callable_bed", ")", ":", "with", "file_transaction", "(", "data", ",", "out_file", ")", "as", "tx_out_file", ":", "callable_regions", "=", "pybedtools", ".", "BedTool", "(", "callable_bed", ")", "filter_regions", "=", "callable_regions", ".", "filter", "(", "callable_chrom_filter", ")", "if", "input_regions_bed", ":", "if", "not", "utils", ".", "file_uptodate", "(", "out_file", ",", "input_regions_bed", ")", ":", "input_regions", "=", "pybedtools", ".", "BedTool", "(", "input_regions_bed", ")", "filter_regions", ".", "intersect", "(", "input_regions", ",", "nonamecheck", "=", "True", ")", ".", "saveas", "(", "tx_out_file", ")", "else", ":", "filter_regions", ".", "saveas", "(", "tx_out_file", ")", "return", "CovInfo", "(", "out_file", ",", "callable_bed", ",", "depth_files", ")" ]

[ "Retrieve", "callable", "regions", "for", "a", "sample", "subset", "by", "defined", "analysis", "regions", "." ]

[ "def", "random_draw", "(", "self", ",", "size", "=", "None", ")", ":", "return", "scipy", ".", "asarray", "(", "[", "scipy", ".", "stats", ".", "gamma", ".", "rvs", "(", "a", ",", "loc", "=", "0", ",", "scale", "=", "1.0", "/", "b", ",", "size", "=", "size", ")", "for", "a", ",", "b", "in", "zip", "(", "self", ".", "a", ",", "self", ".", "b", ")", "]", ")" ]

[ "Draw", "random", "samples", "of", "the", "hyperparameters", ".", "Parameters", "----------", "size", ":", "None", "int", "or", "array", "-", "like", "optional", "The", "number", "/", "shape", "of", "samples", "to", "draw", ".", "If", "None", "only", "one", "sample", "is", "returned", ".", "Default", "is", "None", "." ]

[ "def", "_signal_load", "(", "self", ")", ":", "# set our name", "self", ".", "set_name", "(", "str", "(", "self", ".", "_combobox_cmaps", ".", "currentText", "(", ")", ")", ")", "# load the colormap", "self", ".", "load_colormap", "(", ")", "# rebuild the interface", "self", ".", "_build_gui", "(", ")", "self", ".", "_button_save", ".", "setEnabled", "(", "False", ")" ]

[ "Load", "the", "selected", "cmap", "." ]

[ "def", "logout", "(", "config", ")", ":", "state", "=", "read", "(", "config", ".", "configfile", ")", "if", "state", ".", "get", "(", "\"BUGZILLA\"", ")", ":", "remove", "(", "config", ".", "configfile", ",", "\"BUGZILLA\"", ")", "success_out", "(", "\"Forgotten\"", ")", "else", ":", "error_out", "(", "\"No stored Bugzilla credentials\"", ")" ]

[ "Remove", "and", "forget", "your", "Bugzilla", "credentials" ]

[ "def", "setupTable_vmtx", "(", "self", ")", ":", "if", "\"vmtx\"", "not", "in", "self", ".", "tables", ":", "return", "self", ".", "otf", "[", "\"vmtx\"", "]", "=", "vmtx", "=", "newTable", "(", "\"vmtx\"", ")", "vmtx", ".", "metrics", "=", "{", "}", "for", "glyphName", ",", "glyph", "in", "self", ".", "allGlyphs", ".", "items", "(", ")", ":", "height", "=", "otRound", "(", "glyph", ".", "height", ")", "if", "height", "<", "0", ":", "raise", "ValueError", "(", "\"The height should not be negative: '%s'\"", "%", "(", "glyphName", ")", ")", "verticalOrigin", "=", "_getVerticalOrigin", "(", "self", ".", "otf", ",", "glyph", ")", "bounds", "=", "self", ".", "glyphBoundingBoxes", "[", "glyphName", "]", "top", "=", "bounds", ".", "yMax", "if", "bounds", "else", "0", "vmtx", "[", "glyphName", "]", "=", "(", "height", ",", "verticalOrigin", "-", "top", ")" ]

[ "Make", "the", "vmtx", "table", "." ]

[ "def", "map2cube", "(", "data_map", ",", "layout", ")", ":", "if", "np", ".", "all", "(", "np", ".", "array", "(", "data_map", ".", "shape", ")", "%", "np", ".", "array", "(", "layout", ")", ")", ":", "raise", "ValueError", "(", "'The desired layout must be a multiple of the number '", "'pixels in the data map.'", ")", "d_shape", "=", "np", ".", "array", "(", "data_map", ".", "shape", ")", "//", "np", ".", "array", "(", "layout", ")", "return", "np", ".", "array", "(", "[", "data_map", "[", "(", "slice", "(", "i", "*", "d_shape", "[", "0", "]", ",", "(", "i", "+", "1", ")", "*", "d_shape", "[", "0", "]", ")", ",", "slice", "(", "j", "*", "d_shape", "[", "1", "]", ",", "(", "j", "+", "1", ")", "*", "d_shape", "[", "1", "]", ")", ")", "]", "for", "i", "in", "range", "(", "layout", "[", "0", "]", ")", "for", "j", "in", "range", "(", "layout", "[", "1", "]", ")", "]", ")" ]

[ "r", "Map", "to", "cube" ]

[ "def", "call_in_executor", "(", "self", ",", "func", ":", "Callable", ",", "*", "args", ",", "executor", ":", "Union", "[", "Executor", ",", "str", "]", "=", "None", ",", "*", "*", "kwargs", ")", "->", "Awaitable", ":", "assert", "check_argument_types", "(", ")", "if", "isinstance", "(", "executor", ",", "str", ")", ":", "executor", "=", "self", ".", "require_resource", "(", "Executor", ",", "executor", ")", "return", "asyncio_extras", ".", "call_in_executor", "(", "func", ",", "*", "args", ",", "executor", "=", "executor", ",", "*", "*", "kwargs", ")" ]

[ "Call", "the", "given", "callable", "in", "an", "executor", "." ]