Datasets:

kejian

/

codesearchnet-py-linelen40-rebalanced200k-v1

like 0

[ "def", "setup", "(", "self", ")", ":", "if", "not", "isinstance", "(", "self", ".", "filePath", ",", "str", ")", ":", "raise", "TypeError", "(", "\"File path is not a string!\"", ")", "if", "self", ".", "controller", "is", "None", ":", "raise", "ValueError", "(", "\"Command controller hasn't been specified!\"", ")" ]

[ "def", "listfolder", "(", "p", ")", ":", "for", "entry", "in", "scandir", ".", "scandir", "(", "p", ")", ":", "if", "entry", ".", "is_dir", "(", ")", ":", "yield", "entry", ".", "name" ]

[ "def", "drop_matching_records", "(", "self", ",", "check", ")", ":", "matches", "=", "self", ".", "_match", "(", "check", ")", "for", "m", "in", "matches", ":", "del", "self", ".", "_records", "[", "m", "[", "'msg_id'", "]", "]" ]

[ "def", "__get_user_env_vars", "(", "self", ")", ":", "return", "(", "os", ".", "environ", ".", "get", "(", "self", ".", "GP_URL_ENV_VAR", ")", ",", "os", ".", "environ", ".", "get", "(", "self", ".", "GP_INSTANCE_ID_ENV_VAR", ")", ",", "os", ".", "environ", ".", "get", "(", "self", ".", "GP_USER_ID_ENV_VAR", ")", ",", "os", ".", "environ", ".", "get", "(", "self", ".", "GP_PASSWORD_ENV_VAR", ")", ",", "os", ".", "environ", ".", "get", "(", "self", ".", "GP_IAM_API_KEY_ENV_VAR", ")", ")" ]

[ "def", "reset_all", "(", "self", ",", "suppress_logging", "=", "False", ")", ":", "pool_names", "=", "list", "(", "self", ".", "pools", ")", "for", "name", "in", "pool_names", ":", "self", ".", "reset", "(", "name", ",", "suppress_logging", ")" ]

[ "def", "get_file_info", "(", "self", ",", "relativePath", ")", ":", "relativePath", "=", "self", ".", "to_repo_relative_path", "(", "path", "=", "relativePath", ",", "split", "=", "False", ")", "fileName", "=", "os", ".", "path", ".", "basename", "(", "relativePath", ")", "isRepoFile", ",", "fileOnDisk", ",", "infoOnDisk", ",", "classOnDisk", "=", "self", ".", "is_repository_file", "(", "relativePath", ")", "if", "not", "isRepoFile", ":", "return", "None", ",", "\"file is not a registered repository file.\"", "if", "not", "infoOnDisk", ":", "return", "None", ",", "\"file is a registered repository file but info file missing\"", "fileInfoPath", "=", "os", ".", "path", ".", "join", "(", "self", ".", "__path", ",", "os", ".", "path", ".", "dirname", "(", "relativePath", ")", ",", "self", ".", "__fileInfo", "%", "fileName", ")", "try", ":", "with", "open", "(", "fileInfoPath", ",", "'rb'", ")", "as", "fd", ":", "info", "=", "pickle", ".", "load", "(", "fd", ")", "except", "Exception", "as", "err", ":", "return", "None", ",", "\"Unable to read file info from disk (%s)\"", "%", "str", "(", "err", ")", "return", "info", ",", "''" ]

[ "def", "setup", "(", "self", ",", "pin", ",", "value", ")", ":", "self", ".", "_validate_pin", "(", "pin", ")", "# Set bit to 1 for input or 0 for output.", "if", "value", "==", "GPIO", ".", "IN", ":", "self", ".", "iodir", "[", "int", "(", "pin", "/", "8", ")", "]", "|=", "1", "<<", "(", "int", "(", "pin", "%", "8", ")", ")", "elif", "value", "==", "GPIO", ".", "OUT", ":", "self", ".", "iodir", "[", "int", "(", "pin", "/", "8", ")", "]", "&=", "~", "(", "1", "<<", "(", "int", "(", "pin", "%", "8", ")", ")", ")", "else", ":", "raise", "ValueError", "(", "'Unexpected value. Must be GPIO.IN or GPIO.OUT.'", ")", "self", ".", "write_iodir", "(", ")" ]

[ "def", "sample", "(", "self", ",", "num_rows", "=", "1", ")", ":", "self", ".", "check_fit", "(", ")", "res", "=", "{", "}", "means", "=", "np", ".", "zeros", "(", "self", ".", "covariance", ".", "shape", "[", "0", "]", ")", "size", "=", "(", "num_rows", ",", ")", "clean_cov", "=", "np", ".", "nan_to_num", "(", "self", ".", "covariance", ")", "samples", "=", "np", ".", "random", ".", "multivariate_normal", "(", "means", ",", "clean_cov", ",", "size", "=", "size", ")", "for", "i", ",", "(", "label", ",", "distrib", ")", "in", "enumerate", "(", "self", ".", "distribs", ".", "items", "(", ")", ")", ":", "cdf", "=", "stats", ".", "norm", ".", "cdf", "(", "samples", "[", ":", ",", "i", "]", ")", "res", "[", "label", "]", "=", "distrib", ".", "percent_point", "(", "cdf", ")", "return", "pd", ".", "DataFrame", "(", "data", "=", "res", ")" ]

[ "def", "can_read", "(", "self", ")", ":", "sm", "=", "getSecurityManager", "(", ")", "if", "not", "sm", ".", "checkPermission", "(", "permissions", ".", "View", ",", "self", ".", "context", ")", ":", "return", "False", "return", "True" ]

[ "def", "save", "(", "self", ",", "path", ")", ":", "path", "=", "os", ".", "path", ".", "expandvars", "(", "os", ".", "path", ".", "expanduser", "(", "path", ")", ")", "with", "open", "(", "path", ",", "\"wb\"", ")", "as", "f", ":", "pickle", ".", "dump", "(", "self", ".", "roots", ",", "f", ")" ]

[ "def", "update_history_log", "(", "history_log", ",", "clear", "=", "False", ",", "description", "=", "None", ",", "test_log", "=", "None", ")", ":", "if", "not", "test_log", "and", "not", "clear", ":", "raise", "IpaUtilsException", "(", "'A test log or clear flag must be provided.'", ")", "if", "clear", ":", "with", "ignored", "(", "OSError", ")", ":", "os", ".", "remove", "(", "history_log", ")", "else", ":", "history_dir", "=", "os", ".", "path", ".", "dirname", "(", "history_log", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "history_dir", ")", ":", "try", ":", "os", ".", "makedirs", "(", "history_dir", ")", "except", "OSError", "as", "error", ":", "raise", "IpaUtilsException", "(", "'Unable to create directory: %s'", "%", "error", ")", "with", "open", "(", "history_log", ",", "'a+'", ")", "as", "f", ":", "# Using append mode creates file if it does not exist", "if", "description", ":", "description", "=", "'\"%s\"'", "%", "description", "out", "=", "'{} {}'", ".", "format", "(", "test_log", ",", "description", "or", "''", ")", "f", ".", "write", "(", "out", ".", "strip", "(", ")", "+", "'\\n'", ")" ]

[ "def", "_ExtractRequestSummaryFields", "(", "document", ")", ":", "headers", "=", "document", ".", "childAtPath", "(", "'Header/RequestHeader'", ")", "body", "=", "document", ".", "childAtPath", "(", "'Body'", ")", "summary_fields", "=", "{", "'methodName'", ":", "body", ".", "getChildren", "(", ")", "[", "0", "]", ".", "name", "}", "# Extract AdWords-specific fields if they exist.", "# Note: We need to check if None because this will always evaluate False.", "client_customer_id", "=", "headers", ".", "getChild", "(", "'clientCustomerId'", ")", "if", "client_customer_id", "is", "not", "None", ":", "summary_fields", "[", "'clientCustomerId'", "]", "=", "client_customer_id", ".", "text", "# Extract Ad Manager-specific fields if they exist.", "# Note: We need to check if None because this will always evaluate False.", "network_code", "=", "headers", ".", "getChild", "(", "'networkCode'", ")", "if", "network_code", "is", "not", "None", ":", "summary_fields", "[", "'networkCode'", "]", "=", "network_code", ".", "text", "return", "summary_fields" ]

[ "def", "k_nearest_approx", "(", "self", ",", "vec", ",", "k", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'lshf'", ")", ":", "self", ".", "lshf", "=", "self", ".", "_init_lsh_forest", "(", ")", "# TODO(kelvin): make this inner product score, to be consistent with k_nearest", "distances", ",", "neighbors", "=", "self", ".", "lshf", ".", "kneighbors", "(", "[", "vec", "]", ",", "n_neighbors", "=", "k", ",", "return_distance", "=", "True", ")", "scores", "=", "np", ".", "subtract", "(", "1", ",", "distances", ")", "nbr_score_pairs", "=", "self", ".", "_word_to_score", "(", "np", ".", "squeeze", "(", "neighbors", ")", ",", "np", ".", "squeeze", "(", "scores", ")", ")", "return", "sorted", "(", "nbr_score_pairs", ".", "items", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", ",", "reverse", "=", "True", ")" ]

[ "def", "esinw", "(", "b", ",", "orbit", ",", "solve_for", "=", "None", ",", "*", "*", "kwargs", ")", ":", "orbit_ps", "=", "_get_system_ps", "(", "b", ",", "orbit", ")", "metawargs", "=", "orbit_ps", ".", "meta", "metawargs", ".", "pop", "(", "'qualifier'", ")", "esinw_def", "=", "FloatParameter", "(", "qualifier", "=", "'esinw'", ",", "value", "=", "0.0", ",", "default_unit", "=", "u", ".", "dimensionless_unscaled", ",", "limits", "=", "(", "-", "1.0", ",", "1.0", ")", ",", "description", "=", "'Eccentricity times sin of argument of periastron'", ")", "esinw", ",", "created", "=", "b", ".", "get_or_create", "(", "'esinw'", ",", "esinw_def", ",", "*", "*", "metawargs", ")", "ecc", "=", "b", ".", "get_parameter", "(", "qualifier", "=", "'ecc'", ",", "*", "*", "metawargs", ")", "per0", "=", "b", ".", "get_parameter", "(", "qualifier", "=", "'per0'", ",", "*", "*", "metawargs", ")", "if", "solve_for", "in", "[", "None", ",", "esinw", "]", ":", "lhs", "=", "esinw", "rhs", "=", "ecc", "*", "sin", "(", "per0", ")", "elif", "solve_for", "==", "ecc", ":", "lhs", "=", "ecc", "rhs", "=", "esinw", "/", "sin", "(", "per0", ")", "elif", "solve_for", "==", "per0", ":", "lhs", "=", "per0", "#rhs = arcsin(esinw/ecc)", "rhs", "=", "esinw2per0", "(", "ecc", ",", "esinw", ")", "else", ":", "raise", "NotImplementedError", "return", "lhs", ",", "rhs", ",", "{", "'orbit'", ":", "orbit", "}" ]

[ "def", "get", "(", "name", ",", "defval", "=", "None", ")", ":", "with", "s_datfile", ".", "openDatFile", "(", "'synapse.data/%s.mpk'", "%", "name", ")", "as", "fd", ":", "return", "s_msgpack", ".", "un", "(", "fd", ".", "read", "(", ")", ")" ]

[ "def", "get_train_eval_files", "(", "input_dir", ")", ":", "data_dir", "=", "_get_latest_data_dir", "(", "input_dir", ")", "train_pattern", "=", "os", ".", "path", ".", "join", "(", "data_dir", ",", "'train*.tfrecord.gz'", ")", "eval_pattern", "=", "os", ".", "path", ".", "join", "(", "data_dir", ",", "'eval*.tfrecord.gz'", ")", "train_files", "=", "file_io", ".", "get_matching_files", "(", "train_pattern", ")", "eval_files", "=", "file_io", ".", "get_matching_files", "(", "eval_pattern", ")", "return", "train_files", ",", "eval_files" ]

[ "def", "gallery_images", "(", "self", ")", ":", "api_version", "=", "self", ".", "_get_api_version", "(", "'gallery_images'", ")", "if", "api_version", "==", "'2018-06-01'", ":", "from", ".", "v2018_06_01", ".", "operations", "import", "GalleryImagesOperations", "as", "OperationClass", "elif", "api_version", "==", "'2019-03-01'", ":", "from", ".", "v2019_03_01", ".", "operations", "import", "GalleryImagesOperations", "as", "OperationClass", "else", ":", "raise", "NotImplementedError", "(", "\"APIVersion {} is not available\"", ".", "format", "(", "api_version", ")", ")", "return", "OperationClass", "(", "self", ".", "_client", ",", "self", ".", "config", ",", "Serializer", "(", "self", ".", "_models_dict", "(", "api_version", ")", ")", ",", "Deserializer", "(", "self", ".", "_models_dict", "(", "api_version", ")", ")", ")" ]

[ "def", "get_path", "(", "self", ",", "name", ",", "default", "=", "None", ")", ":", "if", "name", "not", "in", "self", ":", "if", "default", "is", "not", "None", ":", "return", "default", "raise", "EnvironmentError", ".", "not_found", "(", "self", ".", "_prefix", ",", "name", ")", "return", "pathlib", ".", "Path", "(", "self", "[", "name", "]", ")" ]

[ "def", "ADR", "(", "cpu", ",", "dest", ",", "src", ")", ":", "aligned_pc", "=", "(", "cpu", ".", "instruction", ".", "address", "+", "4", ")", "&", "0xfffffffc", "dest", ".", "write", "(", "aligned_pc", "+", "src", ".", "read", "(", ")", ")" ]

[ "def", "gen_opf", "(", "self", ",", "book_idx", ")", ":", "if", "self", ".", "_chapterization", ":", "title", "=", "'{title}-{book_idx}'", ".", "format", "(", "title", "=", "self", ".", "_title", ",", "book_idx", "=", "book_idx", ")", "book", "=", "'book-{book_idx}'", ".", "format", "(", "book_idx", "=", "book_idx", ")", "toc", "=", "'toc-{book_idx}'", ".", "format", "(", "book_idx", "=", "book_idx", ")", "else", ":", "title", "=", "'{title}'", ".", "format", "(", "title", "=", "self", ".", "_title", ")", "book", "=", "'book'", "toc", "=", "'toc'", "opf_file", "=", "\"\"\"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<package unique-identifier=\"uid\" xmlns:opf=\"http://www.idpf.org/2007/opf\" xmlns:asd=\"http://www.idpf.org/asdfaf\">\n <metadata>\n <dc-metadata xmlns:dc=\"http://purl.org/metadata/dublin_core\" xmlns:oebpackage=\"http://openebook.org/namespaces/oeb-package/1.0/\">\n <dc:Title>{title}</dc:Title>\n <dc:Language>zh-cn</dc:Language>\n <dc:Creator>{author}</dc:Creator>\n <dc:Copyrights>{author}</dc:Copyrights>\n <dc:Publisher>Alexander.Li</dc:Publisher>\n <x-metadata>\n <EmbeddedCover>{cover}</EmbeddedCover>\n </x-metadata>\n </dc-metadata>\n </metadata>\n <manifest>\n <item id=\"toc\" properties=\"nav\" href=\"{book}.html\" media-type=\"application/xhtml+xml\"/>\n <item id=\"content\" media-type=\"application/xhtml+xml\" href=\"{book}.html\"></item>\n <item id=\"cover-image\" media-type=\"image/png\" href=\"{cover}\"/>\n <item id=\"ncx\" media-type=\"application/x-dtbncx+xml\" href=\"{toc}.ncx\"/>\n </manifest>\n <spine toc=\"ncx\">\n <itemref idref=\"cover-image\"/>\n <itemref idref=\"toc\"/>\n <itemref idref=\"content\"/>\n </spine>\n <guide>\n <reference type=\"toc\" title=\"{title_name}\" href=\"{book}.html#toc\"/>\n <reference type=\"content\" title=\"Book\" href=\"{book}.html\"/>\n </guide>\n</package>\n \"\"\"", ".", "format", "(", "title_name", "=", "'目录',", "", "author", "=", "self", ".", "_author", ",", "title", "=", "title", ",", "cover", "=", "self", ".", "_cover_img", ",", "book", "=", "book", ",", "toc", "=", "toc", ")", "return", "opf_file" ]

[ "def", "get_mouse_location2", "(", "self", ")", ":", "x", "=", "ctypes", ".", "c_int", "(", "0", ")", "y", "=", "ctypes", ".", "c_int", "(", "0", ")", "screen_num_ret", "=", "ctypes", ".", "c_ulong", "(", "0", ")", "window_ret", "=", "ctypes", ".", "c_ulong", "(", "0", ")", "_libxdo", ".", "xdo_get_mouse_location2", "(", "self", ".", "_xdo", ",", "ctypes", ".", "byref", "(", "x", ")", ",", "ctypes", ".", "byref", "(", "y", ")", ",", "ctypes", ".", "byref", "(", "screen_num_ret", ")", ",", "ctypes", ".", "byref", "(", "window_ret", ")", ")", "return", "mouse_location2", "(", "x", ".", "value", ",", "y", ".", "value", ",", "screen_num_ret", ".", "value", ",", "window_ret", ".", "value", ")" ]

[ "def", "get_optional", "(", "self", ",", "key", ":", "str", ",", "default", ":", "Optional", "[", "Any", "]", "=", "None", ")", "->", "Optional", "[", "Any", "]", ":", "return", "self", ".", "state", ".", "get", "(", "key", ",", "default", ")" ]

[ "def", "human_readable_size", "(", "num", ",", "suffix", "=", "'B'", ")", ":", "for", "unit", "in", "[", "''", ",", "'Ki'", ",", "'Mi'", ",", "'Gi'", ",", "'Ti'", ",", "'Pi'", ",", "'Ei'", ",", "'Zi'", "]", ":", "if", "abs", "(", "num", ")", "<", "1024.0", ":", "return", "\"%3.1f%s%s\"", "%", "(", "num", ",", "unit", ",", "suffix", ")", "num", "/=", "1024.0", "return", "\"%.1f%s%s\"", "%", "(", "num", ",", "'Yi'", ",", "suffix", ")" ]

[ "def", "get_predicates", "(", "self", ",", "class_", ")", ":", "return", "self", ".", "client", ".", "get_predicates", "(", "class_", "=", "class_", ",", "controller", "=", "self", ".", "controller", ")" ]

[ "def", "init_log_file", "(", "self", ")", ":", "# redirect terminal output", "self", ".", "old_stdout", "=", "sys", ".", "stdout", "sys", ".", "stdout", "=", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "WD", ",", "\"demag_gui.log\"", ")", ",", "'w+'", ")" ]

[ "def", "make_sentence_with_start", "(", "self", ",", "beginning", ",", "strict", "=", "True", ",", "*", "*", "kwargs", ")", ":", "split", "=", "tuple", "(", "self", ".", "word_split", "(", "beginning", ")", ")", "word_count", "=", "len", "(", "split", ")", "if", "word_count", "==", "self", ".", "state_size", ":", "init_states", "=", "[", "split", "]", "elif", "word_count", ">", "0", "and", "word_count", "<", "self", ".", "state_size", ":", "if", "strict", ":", "init_states", "=", "[", "(", "BEGIN", ",", ")", "*", "(", "self", ".", "state_size", "-", "word_count", ")", "+", "split", "]", "else", ":", "init_states", "=", "[", "key", "for", "key", "in", "self", ".", "chain", ".", "model", ".", "keys", "(", ")", "# check for starting with begin as well ordered lists", "if", "tuple", "(", "filter", "(", "lambda", "x", ":", "x", "!=", "BEGIN", ",", "key", ")", ")", "[", ":", "word_count", "]", "==", "split", "]", "random", ".", "shuffle", "(", "init_states", ")", "else", ":", "err_msg", "=", "\"`make_sentence_with_start` for this model requires a string containing 1 to {0} words. Yours has {1}: {2}\"", ".", "format", "(", "self", ".", "state_size", ",", "word_count", ",", "str", "(", "split", ")", ")", "raise", "ParamError", "(", "err_msg", ")", "for", "init_state", "in", "init_states", ":", "output", "=", "self", ".", "make_sentence", "(", "init_state", ",", "*", "*", "kwargs", ")", "if", "output", "is", "not", "None", ":", "return", "output", "return", "None" ]

[ "def", "is_valid_url", "(", "url", ")", ":", "regex", "=", "re", ".", "compile", "(", "r'^(?:http|ftp)s?://'", "# http:// or https://", "r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\\.)+(?:[A-Z]{2,6}\\.?|[A-Z0-9-]{2,}\\.?)|'", "#domain...", "#r'localhost|' #localhost...", "r'\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})'", "# ...or ip", "r'(?::\\d+)?'", "# optional port", "r'(?:/?|[/?]\\S+)$'", ",", "re", ".", "IGNORECASE", ")", "return", "bool", "(", "regex", ".", "match", "(", "url", ")", ")" ]

[ "def", "joinpath", "(", "cls", ",", "first", ",", "*", "others", ")", ":", "if", "not", "isinstance", "(", "first", ",", "cls", ")", ":", "first", "=", "cls", "(", "first", ")", "return", "first", ".", "_next_class", "(", "first", ".", "module", ".", "join", "(", "first", ",", "*", "others", ")", ")" ]

[ "def", "guessoffset", "(", "args", ")", ":", "p", "=", "OptionParser", "(", "guessoffset", ".", "__doc__", ")", "opts", ",", "args", "=", "p", ".", "parse_args", "(", "args", ")", "if", "len", "(", "args", ")", "!=", "1", ":", "sys", ".", "exit", "(", "not", "p", ".", "print_help", "(", ")", ")", "fastqfile", ",", "=", "args", "ai", "=", "iter_fastq", "(", "fastqfile", ")", "rec", "=", "next", "(", "ai", ")", "offset", "=", "64", "while", "rec", ":", "quality", "=", "rec", ".", "quality", "lowcounts", "=", "len", "(", "[", "x", "for", "x", "in", "quality", "if", "x", "<", "59", "]", ")", "highcounts", "=", "len", "(", "[", "x", "for", "x", "in", "quality", "if", "x", ">", "74", "]", ")", "diff", "=", "highcounts", "-", "lowcounts", "if", "diff", ">", "10", ":", "break", "elif", "diff", "<", "-", "10", ":", "offset", "=", "33", "break", "rec", "=", "next", "(", "ai", ")", "if", "offset", "==", "33", ":", "print", "(", "\"Sanger encoding (offset=33)\"", ",", "file", "=", "sys", ".", "stderr", ")", "elif", "offset", "==", "64", ":", "print", "(", "\"Illumina encoding (offset=64)\"", ",", "file", "=", "sys", ".", "stderr", ")", "return", "offset" ]

[ "def", "set_file_license_comment", "(", "self", ",", "doc", ",", "text", ")", ":", "if", "self", ".", "has_package", "(", "doc", ")", "and", "self", ".", "has_file", "(", "doc", ")", ":", "if", "not", "self", ".", "file_license_comment_set", ":", "self", ".", "file_license_comment_set", "=", "True", "self", ".", "file", "(", "doc", ")", ".", "license_comment", "=", "text", "return", "True", "else", ":", "raise", "CardinalityError", "(", "'File::LicenseComment'", ")", "else", ":", "raise", "OrderError", "(", "'File::LicenseComment'", ")" ]

[ "def", "p_pragma", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "Pragma", "(", "PragmaEntry", "(", "p", "[", "3", "]", ",", "lineno", "=", "p", ".", "lineno", "(", "1", ")", ")", ",", "lineno", "=", "p", ".", "lineno", "(", "1", ")", ")", "p", ".", "set_lineno", "(", "0", ",", "p", ".", "lineno", "(", "1", ")", ")" ]

[ "def", "_CanProcessKeyWithPlugin", "(", "self", ",", "registry_key", ",", "plugin", ")", ":", "for", "registry_key_filter", "in", "plugin", ".", "FILTERS", ":", "# Skip filters that define key paths since they are already", "# checked by the path filter.", "if", "getattr", "(", "registry_key_filter", ",", "'key_paths'", ",", "[", "]", ")", ":", "continue", "if", "registry_key_filter", ".", "Match", "(", "registry_key", ")", ":", "return", "True", "return", "False" ]

[ "def", "_prfx_setattr_", "(", "obj", ",", "item", ",", "value", ")", ":", "if", "item", ".", "startswith", "(", "'v_'", ")", ":", "return", "setattr", "(", "obj", ",", "item", "[", "2", ":", "]", ",", "value", ")", "else", ":", "return", "super", "(", "obj", ".", "__class__", ",", "obj", ")", ".", "__setattr__", "(", "item", ",", "value", ")" ]

[ "def", "get", "(", "key", ",", "default", "=", "-", "1", ")", ":", "if", "isinstance", "(", "key", ",", "int", ")", ":", "return", "ProtectionAuthority", "(", "key", ")", "if", "key", "not", "in", "ProtectionAuthority", ".", "_member_map_", ":", "extend_enum", "(", "ProtectionAuthority", ",", "key", ",", "default", ")", "return", "ProtectionAuthority", "[", "key", "]" ]

[ "def", "pull", "(", "i", ")", ":", "o", "=", "i", ".", "get", "(", "'out'", ",", "''", ")", "xrecache", "=", "False", "pp", "=", "[", "]", "px", "=", "i", ".", "get", "(", "'path'", ",", "''", ")", "t", "=", "i", ".", "get", "(", "'type'", ",", "''", ")", "url", "=", "i", ".", "get", "(", "'url'", ",", "''", ")", "stable", "=", "i", ".", "get", "(", "'stable'", ",", "''", ")", "version", "=", "i", ".", "get", "(", "'version'", ",", "''", ")", "if", "stable", "==", "'yes'", ":", "version", "=", "'stable'", "branch", "=", "i", ".", "get", "(", "'branch'", ",", "''", ")", "checkout", "=", "i", ".", "get", "(", "'checkout'", ",", "''", ")", "ip", "=", "i", ".", "get", "(", "'ignore_pull'", ",", "''", ")", "cr", "=", "i", ".", "get", "(", "'current_repos'", ",", "[", "]", ")", "tt", "=", "'pull'", "if", "i", ".", "get", "(", "'clone'", ",", "''", ")", "==", "'yes'", ":", "tt", "=", "'clone'", "if", "px", "!=", "''", ":", "pp", ".", "append", "(", "{", "'path'", ":", "px", ",", "'type'", ":", "t", ",", "'url'", ":", "url", "}", ")", "uoa", "=", "i", ".", "get", "(", "'data_uoa'", ",", "''", ")", "cids", "=", "i", ".", "get", "(", "'cids'", ",", "[", "]", ")", "if", "len", "(", "cids", ")", ">", "0", "and", "uoa", "==", "''", ":", "uoa", "=", "cids", "[", "0", "]", "# If url is not empty and uoa is empty, get name from URL:", "if", "url", "!=", "''", "and", "uoa", "==", "''", "and", "px", "==", "''", ":", "ix", "=", "url", ".", "rfind", "(", "'/'", ")", "if", "ix", ">", "0", ":", "uoa", "=", "url", "[", "ix", "+", "1", ":", "]", "if", "uoa", ".", "endswith", "(", "'.git'", ")", ":", "uoa", "=", "uoa", "[", ":", "-", "4", "]", "i", "[", "'data_uoa'", "]", "=", "uoa", "if", "uoa", "==", "''", "and", "len", "(", "pp", ")", "==", "0", "and", "url", "==", "''", ":", "uoa", "=", "'*'", "if", "uoa", "!=", "''", ":", "if", "uoa", ".", "find", "(", "'*'", ")", ">=", "0", "or", "uoa", ".", "find", "(", "'?'", ")", ">=", "0", ":", "r", "=", "ck", ".", "list_data", "(", "{", "'module_uoa'", ":", "work", "[", "'self_module_uoa'", "]", ",", "'data_uoa'", ":", "uoa", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "lst", "=", "r", "[", "'lst'", "]", "for", "q", "in", "lst", ":", "# Loading repo", "r", "=", "ck", ".", "access", "(", "{", "'action'", ":", "'load'", ",", "'module_uoa'", ":", "work", "[", "'self_module_uoa'", "]", ",", "'data_uoa'", ":", "q", "[", "'data_uoa'", "]", ",", "'common'", ":", "'yes'", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "d", "=", "r", "[", "'dict'", "]", "t", "=", "d", ".", "get", "(", "'shared'", ",", "''", ")", "duoa", "=", "r", "[", "'data_uoa'", "]", "if", "d", ".", "get", "(", "'recache'", ",", "''", ")", "==", "'yes'", ":", "xrecache", "=", "True", "if", "t", "!=", "''", ":", "p", "=", "d", ".", "get", "(", "'path'", ",", "''", ")", "url", "=", "d", ".", "get", "(", "'url'", ",", "''", ")", "checkouts", "=", "d", ".", "get", "(", "'checkouts'", ",", "{", "}", ")", "pp", ".", "append", "(", "{", "'path'", ":", "p", ",", "'type'", ":", "t", ",", "'url'", ":", "url", ",", "'data_uoa'", ":", "duoa", ",", "'checkouts'", ":", "checkouts", "}", ")", "else", ":", "# Loading repo", "r", "=", "ck", ".", "access", "(", "{", "'action'", ":", "'load'", ",", "'module_uoa'", ":", "work", "[", "'self_module_uoa'", "]", ",", "'data_uoa'", ":", "uoa", ",", "'common'", ":", "'yes'", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "if", "r", "[", "'return'", "]", "==", "16", ":", "# If not found, try to add from GIT", "i", "[", "'action'", "]", "=", "'add'", "i", "[", "'shared'", "]", "=", "'yes'", "x", "=", "i", ".", "get", "(", "'quiet'", ",", "''", ")", "if", "x", "==", "''", ":", "x", "=", "'yes'", "i", "[", "'quiet'", "]", "=", "x", "i", "[", "'current_repos'", "]", "=", "cr", "return", "add", "(", "i", ")", "else", ":", "return", "r", "d", "=", "r", "[", "'dict'", "]", "duoa", "=", "r", "[", "'data_uoa'", "]", "if", "d", ".", "get", "(", "'recache'", ",", "''", ")", "==", "'yes'", ":", "xrecache", "=", "True", "p", "=", "d", "[", "'path'", "]", "t", "=", "d", ".", "get", "(", "'shared'", ",", "''", ")", "url", "=", "d", ".", "get", "(", "'url'", ",", "''", ")", "checkouts", "=", "d", ".", "get", "(", "'checkouts'", ",", "{", "}", ")", "pp", ".", "append", "(", "{", "'path'", ":", "p", ",", "'type'", ":", "t", ",", "'url'", ":", "url", ",", "'data_uoa'", ":", "duoa", ",", "'checkouts'", ":", "checkouts", "}", ")", "# Updating ...", "for", "q", "in", "pp", ":", "p", "=", "q", ".", "get", "(", "'path'", ",", "''", ")", "duoa", "=", "q", ".", "get", "(", "'data_uoa'", ",", "''", ")", "t", "=", "q", ".", "get", "(", "'type'", ",", "''", ")", "url", "=", "q", ".", "get", "(", "'url'", ",", "''", ")", "# Semi hack (useful for Anton)", "if", "i", ".", "get", "(", "'git'", ",", "''", ")", "==", "'yes'", ":", "url", "=", "url", ".", "replace", "(", "'https://'", ",", "'git@'", ")", "j", "=", "url", ".", "find", "(", "'/'", ")", "if", "j", ">", "0", ":", "url", "=", "url", "[", ":", "j", "]", "+", "':'", "+", "url", "[", "j", "+", "1", ":", "]", "url", "+=", "'.git'", "if", "o", "==", "'con'", "and", "tt", "!=", "'clone'", ":", "ck", ".", "out", "(", "'******************************************************************'", ")", "ck", ".", "out", "(", "'Updating repo \"'", "+", "duoa", "+", "'\" ...'", ")", "ck", ".", "out", "(", "''", ")", "ck", ".", "out", "(", "' Local path: '", "+", "p", ")", "ck", ".", "out", "(", "' URL: '", "+", "url", ")", "if", "t", "==", "'git'", ":", "# Check if git is installed", "rq", "=", "ck", ".", "gen_tmp_file", "(", "{", "}", ")", "if", "rq", "[", "'return'", "]", ">", "0", ":", "return", "rq", "xfn", "=", "rq", "[", "'file_name'", "]", "os", ".", "system", "(", "'git --version > '", "+", "xfn", ")", "rq", "=", "ck", ".", "load_text_file", "(", "{", "'text_file'", ":", "xfn", ",", "'delete_after_read'", ":", "'yes'", "}", ")", "xs", "=", "''", "if", "rq", "[", "'return'", "]", "==", "0", ":", "xs", "=", "rq", "[", "'string'", "]", ".", "strip", "(", ")", "if", "xs", ".", "find", "(", "' version '", ")", "<", "0", ":", "return", "{", "'return'", ":", "1", ",", "'error'", ":", "'git command line client is not found - please, install it or download repo as zip'", "}", "# Continue", "try", ":", "px", "=", "os", ".", "getcwd", "(", ")", "except", "OSError", ":", "from", "os", ".", "path", "import", "expanduser", "px", "=", "expanduser", "(", "\"~\"", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "p", ")", ":", "os", ".", "makedirs", "(", "p", ")", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "''", ")", "ck", ".", "out", "(", "' cd '", "+", "p", ")", "os", ".", "chdir", "(", "p", ")", "r", "=", "0", "if", "ip", "!=", "'yes'", ":", "s", "=", "ck", ".", "cfg", "[", "'repo_types'", "]", "[", "t", "]", "[", "tt", "]", ".", "replace", "(", "'$#url#$'", ",", "url", ")", ".", "replace", "(", "'$#path#$'", ",", "p", ")", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "' '", "+", "s", ")", "ck", ".", "out", "(", "''", ")", "r", "=", "os", ".", "system", "(", "s", ")", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "''", ")", "os", ".", "chdir", "(", "px", ")", "# Restore path", "if", "r", ">", "0", ":", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "''", ")", "ck", ".", "out", "(", "' WARNING: repository update likely failed OR IN A DIFFERENT BRANCH/CHECKOUT (git exit code: '", "+", "str", "(", "r", ")", "+", "')'", ")", "ck", ".", "out", "(", "''", ")", "rx", "=", "ck", ".", "inp", "(", "{", "'text'", ":", "'Would you like to continue (Y/n)?: '", "}", ")", "x", "=", "rx", "[", "'string'", "]", ".", "lower", "(", ")", "if", "x", "==", "'n'", "or", "x", "==", "'no'", ":", "return", "{", "'return'", ":", "1", ",", "'error'", ":", "'repository update likely failed - exit code '", "+", "str", "(", "r", ")", "}", "else", ":", "return", "{", "'return'", ":", "1", ",", "'error'", ":", "'repository update likely failed - exit code '", "+", "str", "(", "r", ")", "}", "else", ":", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "'CK warning: this repository is not shared!'", ")", "# Check deps", "if", "tt", "!=", "'clone'", ":", "# clone is done in add ...", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "' ========================================'", ")", "ck", ".", "out", "(", "' Checking dependencies on other repos ...'", ")", "ck", ".", "out", "(", "''", ")", "r", "=", "deps", "(", "{", "'path'", ":", "p", ",", "'current_path'", ":", "cr", ",", "'how'", ":", "'pull'", ",", "'version'", ":", "version", ",", "'branch'", ":", "branch", ",", "'checkout'", ":", "checkout", ",", "'out'", ":", "o", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "# Re-caching ...", "if", "xrecache", ":", "if", "o", "==", "'con'", ":", "ck", ".", "out", "(", "' =============================================='", ")", "ck", ".", "out", "(", "' At least one repository requires recaching ...'", ")", "ck", ".", "out", "(", "''", ")", "r", "=", "recache", "(", "{", "'out'", ":", "o", "}", ")", "if", "r", "[", "'return'", "]", ">", "0", ":", "return", "r", "return", "{", "'return'", ":", "0", "}" ]

[ "def", "unnest_children", "(", "data", ",", "parent_name", "=", "''", ",", "pk_name", "=", "None", ",", "force_pk", "=", "False", ")", ":", "possible_fk_names", "=", "[", "'%s_id'", "%", "parent_name", ",", "'_%s_id'", "%", "parent_name", ",", "'parent_id'", ",", "]", "if", "pk_name", ":", "possible_fk_names", ".", "insert", "(", "0", ",", "'%s_%s'", "%", "(", "parent_name", ",", "pk_name", ".", "strip", "(", "'_'", ")", ")", ")", "children", "=", "defaultdict", "(", "list", ")", "field_names_used_by_children", "=", "defaultdict", "(", "set", ")", "child_fk_names", "=", "{", "}", "parent", "=", "ParentTable", "(", "data", ",", "parent_name", ",", "pk_name", "=", "pk_name", ",", "force_pk", "=", "force_pk", ")", "for", "row", "in", "parent", ":", "try", ":", "for", "(", "key", ",", "val", ")", "in", "row", ".", "items", "(", ")", ":", "if", "hasattr", "(", "val", ",", "'items'", ")", ":", "unnest_child_dict", "(", "parent", "=", "row", ",", "key", "=", "key", ",", "parent_name", "=", "parent_name", ")", "elif", "isinstance", "(", "val", ",", "list", ")", "or", "isinstance", "(", "val", ",", "tuple", ")", ":", "# force listed items to be dicts, not scalars", "row", "[", "key", "]", "=", "[", "v", "if", "hasattr", "(", "v", ",", "'items'", ")", "else", "{", "key", ":", "v", "}", "for", "v", "in", "val", "]", "except", "AttributeError", ":", "raise", "TypeError", "(", "'Each row should be a dictionary, got %s: %s'", "%", "(", "type", "(", "row", ")", ",", "row", ")", ")", "for", "(", "key", ",", "val", ")", "in", "row", ".", "items", "(", ")", ":", "if", "isinstance", "(", "val", ",", "list", ")", "or", "isinstance", "(", "val", ",", "tuple", ")", ":", "for", "child", "in", "val", ":", "field_names_used_by_children", "[", "key", "]", ".", "update", "(", "set", "(", "child", ".", "keys", "(", ")", ")", ")", "for", "(", "child_name", ",", "names_in_use", ")", "in", "field_names_used_by_children", ".", "items", "(", ")", ":", "if", "not", "parent", ".", "pk", ":", "parent", ".", "assign_pk", "(", ")", "for", "fk_name", "in", "possible_fk_names", ":", "if", "fk_name", "not", "in", "names_in_use", ":", "break", "else", ":", "raise", "Exception", "(", "\"Cannot find unused field name in %s.%s to use as foreign key\"", "%", "(", "parent_name", ",", "child_name", ")", ")", "child_fk_names", "[", "child_name", "]", "=", "fk_name", "for", "row", "in", "parent", ":", "if", "child_name", "in", "row", ":", "for", "child", "in", "row", "[", "child_name", "]", ":", "child", "[", "fk_name", "]", "=", "row", "[", "parent", ".", "pk", ".", "name", "]", "children", "[", "child_name", "]", ".", "append", "(", "child", ")", "row", ".", "pop", "(", "child_name", ")", "# TODO: What if rows have a mix of scalar / list / dict types?", "return", "(", "parent", ",", "parent", ".", "pk", ".", "name", "if", "parent", ".", "pk", "else", "None", ",", "children", ",", "child_fk_names", ")" ]

[ "def", "add_element", "(", "self", ",", "element", ")", ":", "self", ".", "elements", ".", "append", "(", "element", ")", "self", ".", "type_graph", ".", "add_element", "(", "element", ")" ]

[ "def", "main", "(", "tex_file", ",", "output", ",", "verbose", ")", ":", "Controller", "(", "OSFileSystem", "(", ")", ",", "Display", "(", "sys", ".", "stdout", ",", "verbose", ")", ")", ".", "run", "(", "tex_file", ",", "output", ")" ]

[ "def", "_apply_options", "(", "self", ",", "token", ")", ":", "# Apply work token filtering.", "if", "token", ".", "is_punct", "and", "self", ".", "remove_punct", ":", "return", "None", "if", "token", ".", "is_stop", "and", "self", ".", "remove_stop_words", ":", "return", "None", "if", "token", ".", "is_digit", "and", "self", ".", "remove_digits", ":", "return", "None", "if", "token", ".", "is_oov", "and", "self", ".", "exclude_oov", ":", "return", "None", "if", "token", ".", "pos_", "in", "self", ".", "exclude_pos_tags", ":", "return", "None", "if", "token", ".", "ent_type_", "in", "self", ".", "exclude_entities", ":", "return", "None", "# Lemmatized ones are already lowered.", "if", "self", ".", "lemmatize", ":", "return", "token", ".", "lemma_", "if", "self", ".", "lower", ":", "return", "token", ".", "lower_", "return", "token", ".", "orth_" ]

[ "def", "create_stoichiometric_matrix", "(", "model", ",", "array_type", "=", "'dense'", ",", "dtype", "=", "None", ")", ":", "if", "array_type", "not", "in", "(", "'DataFrame'", ",", "'dense'", ")", "and", "not", "dok_matrix", ":", "raise", "ValueError", "(", "'Sparse matrices require scipy'", ")", "if", "dtype", "is", "None", ":", "dtype", "=", "np", ".", "float64", "array_constructor", "=", "{", "'dense'", ":", "np", ".", "zeros", ",", "'dok'", ":", "dok_matrix", ",", "'lil'", ":", "lil_matrix", ",", "'DataFrame'", ":", "np", ".", "zeros", ",", "}", "n_metabolites", "=", "len", "(", "model", ".", "metabolites", ")", "n_reactions", "=", "len", "(", "model", ".", "reactions", ")", "array", "=", "array_constructor", "[", "array_type", "]", "(", "(", "n_metabolites", ",", "n_reactions", ")", ",", "dtype", "=", "dtype", ")", "m_ind", "=", "model", ".", "metabolites", ".", "index", "r_ind", "=", "model", ".", "reactions", ".", "index", "for", "reaction", "in", "model", ".", "reactions", ":", "for", "metabolite", ",", "stoich", "in", "iteritems", "(", "reaction", ".", "metabolites", ")", ":", "array", "[", "m_ind", "(", "metabolite", ")", ",", "r_ind", "(", "reaction", ")", "]", "=", "stoich", "if", "array_type", "==", "'DataFrame'", ":", "metabolite_ids", "=", "[", "met", ".", "id", "for", "met", "in", "model", ".", "metabolites", "]", "reaction_ids", "=", "[", "rxn", ".", "id", "for", "rxn", "in", "model", ".", "reactions", "]", "return", "pd", ".", "DataFrame", "(", "array", ",", "index", "=", "metabolite_ids", ",", "columns", "=", "reaction_ids", ")", "else", ":", "return", "array" ]

[ "def", "image_list", "(", "self", ",", "name", "=", "None", ")", ":", "nt_ks", "=", "self", ".", "compute_conn", "ret", "=", "{", "}", "for", "image", "in", "nt_ks", ".", "images", ".", "list", "(", ")", ":", "links", "=", "{", "}", "for", "link", "in", "image", ".", "links", ":", "links", "[", "link", "[", "'rel'", "]", "]", "=", "link", "[", "'href'", "]", "ret", "[", "image", ".", "name", "]", "=", "{", "'name'", ":", "image", ".", "name", ",", "'id'", ":", "image", ".", "id", ",", "'status'", ":", "image", ".", "status", ",", "'progress'", ":", "image", ".", "progress", ",", "'created'", ":", "image", ".", "created", ",", "'updated'", ":", "image", ".", "updated", ",", "'metadata'", ":", "image", ".", "metadata", ",", "'links'", ":", "links", ",", "}", "if", "hasattr", "(", "image", ",", "'minDisk'", ")", ":", "ret", "[", "image", ".", "name", "]", "[", "'minDisk'", "]", "=", "image", ".", "minDisk", "if", "hasattr", "(", "image", ",", "'minRam'", ")", ":", "ret", "[", "image", ".", "name", "]", "[", "'minRam'", "]", "=", "image", ".", "minRam", "if", "name", ":", "return", "{", "name", ":", "ret", "[", "name", "]", "}", "return", "ret" ]

[ "def", "_get_rows", "(", "self", ")", ":", "html", "=", "requests", ".", "get", "(", "self", ".", "url", ".", "build", "(", ")", ")", ".", "text", "if", "re", ".", "search", "(", "'did not match any documents'", ",", "html", ")", ":", "return", "[", "]", "pq", "=", "PyQuery", "(", "html", ")", "rows", "=", "pq", "(", "\"table.data\"", ")", ".", "find", "(", "\"tr\"", ")", "return", "map", "(", "rows", ".", "eq", ",", "range", "(", "rows", ".", "size", "(", ")", ")", ")", "[", "1", ":", "]" ]

[ "def", "attention_lm_translation", "(", ")", ":", "hparams", "=", "attention_lm_base", "(", ")", "hparams", ".", "layer_preprocess_sequence", "=", "\"n\"", "hparams", ".", "layer_postprocess_sequence", "=", "\"da\"", "hparams", ".", "learning_rate", "=", "0.4", "hparams", ".", "prepend_mode", "=", "\"prepend_inputs_masked_attention\"", "hparams", ".", "max_length", "=", "512", "hparams", ".", "label_smoothing", "=", "0.1", "hparams", ".", "shared_embedding_and_softmax_weights", "=", "True", "return", "hparams" ]

[ "def", "move_item_up", "(", "self", ",", "item", ")", ":", "prev_iter", "=", "self", ".", "_prev_iter_for", "(", "item", ")", "if", "prev_iter", "is", "not", "None", ":", "self", ".", "model", ".", "swap", "(", "prev_iter", ",", "self", ".", "_iter_for", "(", "item", ")", ")" ]

[ "def", "set_autosession", "(", "self", ",", "value", "=", "None", ")", ":", "if", "value", "is", "not", "None", ":", "self", ".", "rollback", "(", ")", "self", ".", "autosession", "=", "value", "return", "self", ".", "autosession" ]

[ "def", "_process_sample", "(", "self", ",", "ap1", ",", "ap2", ",", "ap3", ",", "triple", ",", "tflags", ")", ":", "# Frequency-resolved:", "np", ".", "divide", "(", "triple", ",", "np", ".", "abs", "(", "triple", ")", ",", "triple", ")", "phase", "=", "np", ".", "angle", "(", "triple", ")", "self", ".", "ap_spec_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "ap1", ",", "phase", ",", "tflags", "+", "0.", ")", "self", ".", "ap_spec_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "ap2", ",", "phase", ",", "tflags", "+", "0.", ")", "self", ".", "ap_spec_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "ap3", ",", "phase", ",", "tflags", "+", "0.", ")", "# Frequency-averaged:", "triple", "=", "np", ".", "dot", "(", "triple", ",", "tflags", ")", "/", "tflags", ".", "sum", "(", ")", "phase", "=", "np", ".", "angle", "(", "triple", ")", "self", ".", "global_stats_by_time", ".", "accum", "(", "self", ".", "cur_time", ",", "phase", ")", "self", ".", "ap_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "ap1", ",", "phase", ")", "self", ".", "ap_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "ap2", ",", "phase", ")", "self", ".", "ap_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "ap3", ",", "phase", ")", "self", ".", "bp_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "(", "ap1", ",", "ap2", ")", ",", "phase", ")", "self", ".", "bp_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "(", "ap1", ",", "ap3", ")", ",", "phase", ")", "self", ".", "bp_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "(", "ap2", ",", "ap3", ")", ",", "phase", ")", "self", ".", "ap_time_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "self", ".", "cur_time", ",", "ap1", ",", "phase", ")", "self", ".", "ap_time_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "self", ".", "cur_time", ",", "ap2", ",", "phase", ")", "self", ".", "ap_time_stats_by_ddid", "[", "self", ".", "cur_ddid", "]", ".", "accum", "(", "self", ".", "cur_time", ",", "ap3", ",", "phase", ")" ]

[ "def", "_time_string", "(", "self", ",", "value", ")", ":", "if", "self", ".", "max_time", "<", "60", ":", "return", "\"%02d\"", "%", "(", "value", ")", "elif", "self", ".", "max_time", "<", "3600", ":", "mm", "=", "value", "//", "60", "ss", "=", "value", "-", "mm", "*", "60", "return", "\"%02d:%02d\"", "%", "(", "mm", ",", "ss", ")", "hh", "=", "value", "//", "3600", "mm", "=", "(", "value", "-", "hh", "*", "3600", ")", "//", "60", "ss", "=", "(", "value", "-", "hh", "*", "3600", "-", "mm", "*", "60", ")", "return", "\"%02d:%02d:%02d\"", "%", "(", "hh", ",", "mm", ",", "ss", ")" ]

[ "def", "check_response", "(", "self", ",", "resp", ")", ":", "# For successful API call, response code will be 200 (OK)", "if", "resp", ".", "ok", ":", "json", "=", "resp", ".", "json", "(", ")", "self", ".", "response", "=", "ResponseHolder", "(", ")", "self", ".", "response", ".", "response", "=", "json", "# Check the code", "if", "'status'", "not", "in", "json", ":", "raise", "InvalidResponse", "(", "'No status field'", ")", "self", ".", "response", ".", "status", "=", "self", ".", "field_to_long", "(", "json", "[", "'status'", "]", ")", "if", "self", ".", "response", ".", "status", "!=", "EBConsts", ".", "STATUS_OK", ":", "txt_status", "=", "self", ".", "get_text_status", "(", "json", ")", "raise", "InvalidStatus", "(", "'Status is %s (%04X)'", "%", "(", "txt_status", "if", "txt_status", "is", "not", "None", "else", "\"\"", ",", "self", ".", "response", ".", "status", ")", ")", "if", "self", ".", "response_checker", "is", "not", "None", ":", "self", ".", "response_checker", "(", "self", ".", "response", ")", "return", "self", ".", "response", "else", ":", "# If response code is not ok (200), print the resulting http error code with description", "resp", ".", "raise_for_status", "(", ")", "pass" ]

[ "def", "blk_nd_short", "(", "blk", ",", "shape", ")", ":", "internals", "=", "(", "blk_1d_short", "(", "b", ",", "s", ")", "for", "b", ",", "s", "in", "zip", "(", "blk", ",", "shape", ")", ")", "return", "product", "(", "*", "internals", ")" ]

[ "def", "function_begin", "(", "self", ")", ":", "self", ".", "newline_label", "(", "self", ".", "shared", ".", "function_name", ",", "False", ",", "True", ")", "self", ".", "push", "(", "\"%14\"", ")", "self", ".", "move", "(", "\"%15\"", ",", "\"%14\"", ")" ]

[ "def", "toggle", "(", "s", ")", ":", "is_numeric", "=", "','", "in", "s", "or", "s", ".", "startswith", "(", "'0x'", ")", "or", "s", ".", "startswith", "(", "'#'", ")", "c", "=", "name_to_color", "(", "s", ")", "return", "color_to_name", "(", "c", ")", "if", "is_numeric", "else", "str", "(", "c", ")" ]

[ "def", "route_absent", "(", "name", ",", "route_table", ",", "resource_group", ",", "connection_auth", "=", "None", ")", ":", "ret", "=", "{", "'name'", ":", "name", ",", "'result'", ":", "False", ",", "'comment'", ":", "''", ",", "'changes'", ":", "{", "}", "}", "if", "not", "isinstance", "(", "connection_auth", ",", "dict", ")", ":", "ret", "[", "'comment'", "]", "=", "'Connection information must be specified via connection_auth dictionary!'", "return", "ret", "route", "=", "__salt__", "[", "'azurearm_network.route_get'", "]", "(", "name", ",", "route_table", ",", "resource_group", ",", "azurearm_log_level", "=", "'info'", ",", "*", "*", "connection_auth", ")", "if", "'error'", "in", "route", ":", "ret", "[", "'result'", "]", "=", "True", "ret", "[", "'comment'", "]", "=", "'Route {0} was not found.'", ".", "format", "(", "name", ")", "return", "ret", "elif", "__opts__", "[", "'test'", "]", ":", "ret", "[", "'comment'", "]", "=", "'Route {0} would be deleted.'", ".", "format", "(", "name", ")", "ret", "[", "'result'", "]", "=", "None", "ret", "[", "'changes'", "]", "=", "{", "'old'", ":", "route", ",", "'new'", ":", "{", "}", ",", "}", "return", "ret", "deleted", "=", "__salt__", "[", "'azurearm_network.route_delete'", "]", "(", "name", ",", "route_table", ",", "resource_group", ",", "*", "*", "connection_auth", ")", "if", "deleted", ":", "ret", "[", "'result'", "]", "=", "True", "ret", "[", "'comment'", "]", "=", "'Route {0} has been deleted.'", ".", "format", "(", "name", ")", "ret", "[", "'changes'", "]", "=", "{", "'old'", ":", "route", ",", "'new'", ":", "{", "}", "}", "return", "ret", "ret", "[", "'comment'", "]", "=", "'Failed to delete route {0}!'", ".", "format", "(", "name", ")", "return", "ret" ]

[ "def", "expand_branch_name", "(", "self", ",", "name", ")", ":", "# If no name is given we pick the default revision.", "if", "not", "name", ":", "return", "self", ".", "default_revision", "# Run `git for-each-ref' once and remember the results.", "branches", "=", "list", "(", "self", ".", "find_branches_raw", "(", ")", ")", "# Check for an exact match against a local branch.", "for", "prefix", ",", "other_name", ",", "revision_id", "in", "branches", ":", "if", "prefix", "==", "'refs/heads/'", "and", "name", "==", "other_name", ":", "# If we find a local branch whose name exactly matches the name", "# given by the caller then we consider the argument given by", "# the caller unambiguous.", "logger", ".", "debug", "(", "\"Branch name %r matches local branch.\"", ",", "name", ")", "return", "name", "# Check for an exact match against a remote branch.", "for", "prefix", ",", "other_name", ",", "revision_id", "in", "branches", ":", "if", "prefix", ".", "startswith", "(", "'refs/remotes/'", ")", "and", "name", "==", "other_name", ":", "# If we find a remote branch whose name exactly matches the", "# name given by the caller then we expand the name given by the", "# caller into the full %(refname) emitted by `git for-each-ref'.", "unambiguous_name", "=", "prefix", "+", "name", "logger", ".", "debug", "(", "\"Branch name %r matches remote branch %r.\"", ",", "name", ",", "unambiguous_name", ")", "return", "unambiguous_name", "# As a fall back we return the given name without expanding it.", "# This code path might not be necessary but was added out of", "# conservativeness, with the goal of trying to guarantee", "# backwards compatibility.", "logger", ".", "debug", "(", "\"Failed to expand branch name %r.\"", ",", "name", ")", "return", "name" ]

[ "async", "def", "_handle_container_timeout", "(", "self", ",", "container_id", ",", "timeout", ")", ":", "try", ":", "docker_stats", "=", "await", "self", ".", "_docker_interface", ".", "get_stats", "(", "container_id", ")", "source", "=", "AsyncIteratorWrapper", "(", "docker_stats", ")", "nano_timeout", "=", "timeout", "*", "(", "10", "**", "9", ")", "async", "for", "upd", "in", "source", ":", "if", "upd", "is", "None", ":", "await", "self", ".", "_kill_it_with_fire", "(", "container_id", ")", "self", ".", "_logger", ".", "debug", "(", "\"%i\"", ",", "upd", "[", "'cpu_stats'", "]", "[", "'cpu_usage'", "]", "[", "'total_usage'", "]", ")", "if", "upd", "[", "'cpu_stats'", "]", "[", "'cpu_usage'", "]", "[", "'total_usage'", "]", ">", "nano_timeout", ":", "self", ".", "_logger", ".", "info", "(", "\"Killing container %s as it used %i CPU seconds (max was %i)\"", ",", "container_id", ",", "int", "(", "upd", "[", "'cpu_stats'", "]", "[", "'cpu_usage'", "]", "[", "'total_usage'", "]", "/", "(", "10", "**", "9", ")", ")", ",", "timeout", ")", "await", "self", ".", "_kill_it_with_fire", "(", "container_id", ")", "return", "except", "asyncio", ".", "CancelledError", ":", "pass", "except", ":", "self", ".", "_logger", ".", "exception", "(", "\"Exception in _handle_container_timeout\"", ")" ]

[ "def", "trim_wav_pydub", "(", "in_path", ":", "Path", ",", "out_path", ":", "Path", ",", "start_time", ":", "int", ",", "end_time", ":", "int", ")", "->", "None", ":", "logger", ".", "info", "(", "\"Using pydub/ffmpeg to create {} from {}\"", ".", "format", "(", "out_path", ",", "in_path", ")", "+", "\" using a start_time of {} and an end_time of {}\"", ".", "format", "(", "start_time", ",", "end_time", ")", ")", "if", "out_path", ".", "is_file", "(", ")", ":", "return", "# TODO add logging here", "#print(\"in_fn: {}\".format(in_fn))", "#print(\"out_fn: {}\".format(out_fn))", "in_ext", "=", "in_path", ".", "suffix", "[", "1", ":", "]", "out_ext", "=", "out_path", ".", "suffix", "[", "1", ":", "]", "audio", "=", "AudioSegment", ".", "from_file", "(", "str", "(", "in_path", ")", ",", "in_ext", ")", "trimmed", "=", "audio", "[", "start_time", ":", "end_time", "]", "# pydub evidently doesn't actually use the parameters when outputting wavs,", "# since it doesn't use FFMPEG to deal with outputtting WAVs. This is a bit", "# of a leaky abstraction. No warning is given, so normalization to 16Khz", "# mono wavs has to happen later. Leaving the parameters here in case it", "# changes", "trimmed", ".", "export", "(", "str", "(", "out_path", ")", ",", "format", "=", "out_ext", ",", "parameters", "=", "[", "\"-ac\"", ",", "\"1\"", ",", "\"-ar\"", ",", "\"16000\"", "]", ")" ]

[ "def", "check_cli_version", "(", ")", ":", "should_exit", "=", "False", "server_version", "=", "VersionClient", "(", ")", ".", "get_cli_version", "(", ")", "current_version", "=", "get_cli_version", "(", ")", "if", "LooseVersion", "(", "current_version", ")", "<", "LooseVersion", "(", "server_version", ".", "min_version", ")", ":", "print", "(", "\"\\nYour version of CLI (%s) is no longer compatible with server.\"", "%", "current_version", ")", "should_exit", "=", "True", "elif", "LooseVersion", "(", "current_version", ")", "<", "LooseVersion", "(", "server_version", ".", "latest_version", ")", ":", "print", "(", "\"\\nNew version of CLI (%s) is now available.\"", "%", "server_version", ".", "latest_version", ")", "else", ":", "return", "# new version is ready", "if", "should_exit", "and", "click", ".", "confirm", "(", "'\\nDo you want to upgrade to version %s now?'", "%", "server_version", ".", "latest_version", ")", ":", "auto_upgrade", "(", ")", "sys", ".", "exit", "(", "0", ")", "else", ":", "msg_parts", "=", "[", "]", "msg_parts", ".", "append", "(", "\"\\nTo manually upgrade run:\"", ")", "msg_parts", ".", "append", "(", "\" pip install -U floyd-cli\"", ")", "if", "is_conda_env", "(", ")", ":", "msg_parts", ".", "append", "(", "\"Or if you prefer to use conda:\"", ")", "msg_parts", ".", "append", "(", "\" conda install -y -c conda-forge -c floydhub floyd-cli\"", ")", "print", "(", "\"\\n\"", ".", "join", "(", "msg_parts", ")", ")", "print", "(", "\"\"", ")", "if", "should_exit", ":", "sys", ".", "exit", "(", "0", ")" ]

[ "def", "enum_sigma_ort", "(", "cutoff", ",", "r_axis", ",", "c2_b2_a2_ratio", ")", ":", "sigmas", "=", "{", "}", "# make sure gcd(r_axis)==1", "if", "reduce", "(", "gcd", ",", "r_axis", ")", "!=", "1", ":", "r_axis", "=", "[", "int", "(", "round", "(", "x", "/", "reduce", "(", "gcd", ",", "r_axis", ")", ")", ")", "for", "x", "in", "r_axis", "]", "u", ",", "v", ",", "w", "=", "r_axis", "# make sure mu, lambda, mv are coprime integers.", "if", "None", "in", "c2_b2_a2_ratio", ":", "mu", ",", "lam", ",", "mv", "=", "c2_b2_a2_ratio", "non_none", "=", "[", "i", "for", "i", "in", "c2_b2_a2_ratio", "if", "i", "is", "not", "None", "]", "if", "len", "(", "non_none", ")", "<", "2", ":", "raise", "RuntimeError", "(", "'No CSL exist for two irrational numbers'", ")", "non1", ",", "non2", "=", "non_none", "if", "reduce", "(", "gcd", ",", "non_none", ")", "!=", "1", ":", "temp", "=", "reduce", "(", "gcd", ",", "non_none", ")", "non1", "=", "int", "(", "round", "(", "non1", "/", "temp", ")", ")", "non2", "=", "int", "(", "round", "(", "non2", "/", "temp", ")", ")", "if", "mu", "is", "None", ":", "lam", "=", "non1", "mv", "=", "non2", "mu", "=", "1", "if", "w", "!=", "0", ":", "if", "u", "!=", "0", "or", "(", "v", "!=", "0", ")", ":", "raise", "RuntimeError", "(", "'For irrational c2, CSL only exist for [0,0,1] '", "'or [u,v,0] and m = 0'", ")", "elif", "lam", "is", "None", ":", "mu", "=", "non1", "mv", "=", "non2", "lam", "=", "1", "if", "v", "!=", "0", ":", "if", "u", "!=", "0", "or", "(", "w", "!=", "0", ")", ":", "raise", "RuntimeError", "(", "'For irrational b2, CSL only exist for [0,1,0] '", "'or [u,0,w] and m = 0'", ")", "elif", "mv", "is", "None", ":", "mu", "=", "non1", "lam", "=", "non2", "mv", "=", "1", "if", "u", "!=", "0", ":", "if", "w", "!=", "0", "or", "(", "v", "!=", "0", ")", ":", "raise", "RuntimeError", "(", "'For irrational a2, CSL only exist for [1,0,0] '", "'or [0,v,w] and m = 0'", ")", "else", ":", "mu", ",", "lam", ",", "mv", "=", "c2_b2_a2_ratio", "if", "reduce", "(", "gcd", ",", "c2_b2_a2_ratio", ")", "!=", "1", ":", "temp", "=", "reduce", "(", "gcd", ",", "c2_b2_a2_ratio", ")", "mu", "=", "int", "(", "round", "(", "mu", "/", "temp", ")", ")", "mv", "=", "int", "(", "round", "(", "mv", "/", "temp", ")", ")", "lam", "=", "int", "(", "round", "(", "lam", "/", "temp", ")", ")", "if", "u", "==", "0", "and", "v", "==", "0", ":", "mu", "=", "1", "if", "u", "==", "0", "and", "w", "==", "0", ":", "lam", "=", "1", "if", "v", "==", "0", "and", "w", "==", "0", ":", "mv", "=", "1", "# refer to the meaning of d in reference", "d", "=", "(", "mv", "*", "u", "**", "2", "+", "lam", "*", "v", "**", "2", ")", "*", "mv", "+", "w", "**", "2", "*", "mu", "*", "mv", "# Compute the max n we need to enumerate.", "n_max", "=", "int", "(", "np", ".", "sqrt", "(", "(", "cutoff", "*", "4", "*", "mu", "*", "mv", "*", "mv", "*", "lam", ")", "/", "d", ")", ")", "# Enumerate all possible n, m to give possible sigmas within the cutoff.", "for", "n", "in", "range", "(", "1", ",", "n_max", "+", "1", ")", ":", "mu_temp", ",", "lam_temp", ",", "mv_temp", "=", "c2_b2_a2_ratio", "if", "(", "mu_temp", "is", "None", "and", "w", "==", "0", ")", "or", "(", "lam_temp", "is", "None", "and", "v", "==", "0", ")", "or", "(", "mv_temp", "is", "None", "and", "u", "==", "0", ")", ":", "m_max", "=", "0", "else", ":", "m_max", "=", "int", "(", "np", ".", "sqrt", "(", "(", "cutoff", "*", "4", "*", "mu", "*", "mv", "*", "lam", "*", "mv", "-", "n", "**", "2", "*", "d", ")", "/", "mu", "/", "lam", ")", ")", "for", "m", "in", "range", "(", "0", ",", "m_max", "+", "1", ")", ":", "if", "gcd", "(", "m", ",", "n", ")", "==", "1", "or", "m", "==", "0", ":", "# construct the rotation matrix, refer to the reference", "R_list", "=", "[", "(", "u", "**", "2", "*", "mv", "*", "mv", "-", "lam", "*", "v", "**", "2", "*", "mv", "-", "w", "**", "2", "*", "mu", "*", "mv", ")", "*", "n", "**", "2", "+", "lam", "*", "mu", "*", "m", "**", "2", ",", "2", "*", "lam", "*", "(", "v", "*", "u", "*", "mv", "*", "n", "**", "2", "-", "w", "*", "mu", "*", "m", "*", "n", ")", ",", "2", "*", "mu", "*", "(", "u", "*", "w", "*", "mv", "*", "n", "**", "2", "+", "v", "*", "lam", "*", "m", "*", "n", ")", ",", "2", "*", "mv", "*", "(", "u", "*", "v", "*", "mv", "*", "n", "**", "2", "+", "w", "*", "mu", "*", "m", "*", "n", ")", ",", "(", "v", "**", "2", "*", "mv", "*", "lam", "-", "u", "**", "2", "*", "mv", "*", "mv", "-", "w", "**", "2", "*", "mu", "*", "mv", ")", "*", "n", "**", "2", "+", "lam", "*", "mu", "*", "m", "**", "2", ",", "2", "*", "mv", "*", "mu", "*", "(", "v", "*", "w", "*", "n", "**", "2", "-", "u", "*", "m", "*", "n", ")", ",", "2", "*", "mv", "*", "(", "u", "*", "w", "*", "mv", "*", "n", "**", "2", "-", "v", "*", "lam", "*", "m", "*", "n", ")", ",", "2", "*", "lam", "*", "mv", "*", "(", "v", "*", "w", "*", "n", "**", "2", "+", "u", "*", "m", "*", "n", ")", ",", "(", "w", "**", "2", "*", "mu", "*", "mv", "-", "u", "**", "2", "*", "mv", "*", "mv", "-", "v", "**", "2", "*", "mv", "*", "lam", ")", "*", "n", "**", "2", "+", "lam", "*", "mu", "*", "m", "**", "2", "]", "m", "=", "-", "1", "*", "m", "# inverse of rotation matrix", "R_list_inv", "=", "[", "(", "u", "**", "2", "*", "mv", "*", "mv", "-", "lam", "*", "v", "**", "2", "*", "mv", "-", "w", "**", "2", "*", "mu", "*", "mv", ")", "*", "n", "**", "2", "+", "lam", "*", "mu", "*", "m", "**", "2", ",", "2", "*", "lam", "*", "(", "v", "*", "u", "*", "mv", "*", "n", "**", "2", "-", "w", "*", "mu", "*", "m", "*", "n", ")", ",", "2", "*", "mu", "*", "(", "u", "*", "w", "*", "mv", "*", "n", "**", "2", "+", "v", "*", "lam", "*", "m", "*", "n", ")", ",", "2", "*", "mv", "*", "(", "u", "*", "v", "*", "mv", "*", "n", "**", "2", "+", "w", "*", "mu", "*", "m", "*", "n", ")", ",", "(", "v", "**", "2", "*", "mv", "*", "lam", "-", "u", "**", "2", "*", "mv", "*", "mv", "-", "w", "**", "2", "*", "mu", "*", "mv", ")", "*", "n", "**", "2", "+", "lam", "*", "mu", "*", "m", "**", "2", ",", "2", "*", "mv", "*", "mu", "*", "(", "v", "*", "w", "*", "n", "**", "2", "-", "u", "*", "m", "*", "n", ")", ",", "2", "*", "mv", "*", "(", "u", "*", "w", "*", "mv", "*", "n", "**", "2", "-", "v", "*", "lam", "*", "m", "*", "n", ")", ",", "2", "*", "lam", "*", "mv", "*", "(", "v", "*", "w", "*", "n", "**", "2", "+", "u", "*", "m", "*", "n", ")", ",", "(", "w", "**", "2", "*", "mu", "*", "mv", "-", "u", "**", "2", "*", "mv", "*", "mv", "-", "v", "**", "2", "*", "mv", "*", "lam", ")", "*", "n", "**", "2", "+", "lam", "*", "mu", "*", "m", "**", "2", "]", "m", "=", "-", "1", "*", "m", "F", "=", "mu", "*", "lam", "*", "m", "**", "2", "+", "d", "*", "n", "**", "2", "all_list", "=", "R_list", "+", "R_list_inv", "+", "[", "F", "]", "# Compute the max common factors for the elements of the rotation matrix", "# and its inverse.", "com_fac", "=", "reduce", "(", "gcd", ",", "all_list", ")", "sigma", "=", "int", "(", "round", "(", "(", "mu", "*", "lam", "*", "m", "**", "2", "+", "d", "*", "n", "**", "2", ")", "/", "com_fac", ")", ")", "if", "(", "sigma", "<=", "cutoff", ")", "and", "(", "sigma", ">", "1", ")", ":", "if", "sigma", "not", "in", "list", "(", "sigmas", ".", "keys", "(", ")", ")", ":", "if", "m", "==", "0", ":", "angle", "=", "180.0", "else", ":", "angle", "=", "2", "*", "np", ".", "arctan", "(", "n", "/", "m", "*", "np", ".", "sqrt", "(", "d", "/", "mu", "/", "lam", ")", ")", "/", "np", ".", "pi", "*", "180", "sigmas", "[", "sigma", "]", "=", "[", "angle", "]", "else", ":", "if", "m", "==", "0", ":", "angle", "=", "180.0", "else", ":", "angle", "=", "2", "*", "np", ".", "arctan", "(", "n", "/", "m", "*", "np", ".", "sqrt", "(", "d", "/", "mu", "/", "lam", ")", ")", "/", "np", ".", "pi", "*", "180", "if", "angle", "not", "in", "sigmas", "[", "sigma", "]", ":", "sigmas", "[", "sigma", "]", ".", "append", "(", "angle", ")", "if", "m_max", "==", "0", ":", "break", "return", "sigmas" ]

[ "def", "base", "(", "self", ")", ":", "result", "=", "[", "p", "for", "p", "in", "self", ".", "lazy_properties", "if", "not", "(", "p", ".", "feature", ".", "incidental", "or", "p", ".", "feature", ".", "free", ")", "]", "result", ".", "extend", "(", "self", ".", "base_", ")", "return", "result" ]

[ "def", "set_one_var_from_string", "(", "name", ",", "param_type", ",", "checks", ")", ":", "ret", "=", "\"\"", "univar_mapper", "=", "{", "\"int\"", ":", "\"GetInt\"", ",", "\"double\"", ":", "\"GetDouble\"", ",", "\"bool\"", ":", "\"GetBool\"", ",", "\"std::string\"", ":", "\"GetString\"", "}", "if", "\"vector\"", "not", "in", "param_type", ":", "ret", "+=", "\" %s(params, \\\"%s\\\", &%s);\\n\"", "%", "(", "univar_mapper", "[", "param_type", "]", ",", "name", ",", "name", ")", "if", "len", "(", "checks", ")", ">", "0", ":", "for", "check", "in", "checks", ":", "ret", "+=", "\" CHECK(%s %s);\\n\"", "%", "(", "name", ",", "check", ")", "ret", "+=", "\"\\n\"", "else", ":", "ret", "+=", "\" if (GetString(params, \\\"%s\\\", &tmp_str)) {\\n\"", "%", "(", "name", ")", "type2", "=", "param_type", ".", "split", "(", "\"<\"", ")", "[", "1", "]", "[", ":", "-", "1", "]", "if", "type2", "==", "\"std::string\"", ":", "ret", "+=", "\" %s = Common::Split(tmp_str.c_str(), ',');\\n\"", "%", "(", "name", ")", "else", ":", "ret", "+=", "\" %s = Common::StringToArray<%s>(tmp_str, ',');\\n\"", "%", "(", "name", ",", "type2", ")", "ret", "+=", "\" }\\n\\n\"", "return", "ret" ]

[ "def", "Q_weir_rectangular_SIA", "(", "h1", ",", "h2", ",", "b", ",", "b1", ")", ":", "h", "=", "h1", "+", "h2", "Q", "=", "0.544", "*", "(", "1", "+", "0.064", "*", "(", "b", "/", "b1", ")", "**", "2", "+", "(", "0.00626", "-", "0.00519", "*", "(", "b", "/", "b1", ")", "**", "2", ")", "/", "(", "h1", "+", "0.0016", ")", ")", "*", "(", "1", "+", "0.5", "*", "(", "b", "/", "b1", ")", "**", "4", "*", "(", "h1", "/", "(", "h1", "+", "h2", ")", ")", "**", "2", ")", "*", "b", "*", "g", "**", "0.5", "*", "h", "**", "1.5", "return", "Q" ]

[ "def", "get_extension_by_id", "(", "self", ",", "extension_id", ",", "version", "=", "None", ",", "flags", "=", "None", ")", ":", "route_values", "=", "{", "}", "if", "extension_id", "is", "not", "None", ":", "route_values", "[", "'extensionId'", "]", "=", "self", ".", "_serialize", ".", "url", "(", "'extension_id'", ",", "extension_id", ",", "'str'", ")", "query_parameters", "=", "{", "}", "if", "version", "is", "not", "None", ":", "query_parameters", "[", "'version'", "]", "=", "self", ".", "_serialize", ".", "query", "(", "'version'", ",", "version", ",", "'str'", ")", "if", "flags", "is", "not", "None", ":", "query_parameters", "[", "'flags'", "]", "=", "self", ".", "_serialize", ".", "query", "(", "'flags'", ",", "flags", ",", "'str'", ")", "response", "=", "self", ".", "_send", "(", "http_method", "=", "'GET'", ",", "location_id", "=", "'a41192c8-9525-4b58-bc86-179fa549d80d'", ",", "version", "=", "'5.0-preview.2'", ",", "route_values", "=", "route_values", ",", "query_parameters", "=", "query_parameters", ")", "return", "self", ".", "_deserialize", "(", "'PublishedExtension'", ",", "response", ")" ]

[ "def", "_check_exception_inherit_from_stopiteration", "(", "exc", ")", ":", "stopiteration_qname", "=", "\"{}.StopIteration\"", ".", "format", "(", "utils", ".", "EXCEPTIONS_MODULE", ")", "return", "any", "(", "_class", ".", "qname", "(", ")", "==", "stopiteration_qname", "for", "_class", "in", "exc", ".", "mro", "(", ")", ")" ]

[ "def", "srem", "(", "self", ",", "name", ",", "*", "values", ")", ":", "return", "self", ".", "storage", ".", "srem", "(", "name", ",", "*", "self", ".", "dump", "(", "values", ",", "False", ")", ")" ]

[ "def", "from_json", "(", "cls", ",", "json_str", ")", ":", "vocab_dict", "=", "json", ".", "loads", "(", "json_str", ")", "unknown_token", "=", "vocab_dict", ".", "get", "(", "'unknown_token'", ")", "bert_vocab", "=", "cls", "(", "unknown_token", "=", "unknown_token", ")", "bert_vocab", ".", "_idx_to_token", "=", "vocab_dict", ".", "get", "(", "'idx_to_token'", ")", "bert_vocab", ".", "_token_to_idx", "=", "vocab_dict", ".", "get", "(", "'token_to_idx'", ")", "if", "unknown_token", ":", "bert_vocab", ".", "_token_to_idx", "=", "DefaultLookupDict", "(", "bert_vocab", ".", "_token_to_idx", "[", "unknown_token", "]", ",", "bert_vocab", ".", "_token_to_idx", ")", "bert_vocab", ".", "_reserved_tokens", "=", "vocab_dict", ".", "get", "(", "'reserved_tokens'", ")", "bert_vocab", ".", "_padding_token", "=", "vocab_dict", ".", "get", "(", "'padding_token'", ")", "bert_vocab", ".", "_bos_token", "=", "vocab_dict", ".", "get", "(", "'bos_token'", ")", "bert_vocab", ".", "_eos_token", "=", "vocab_dict", ".", "get", "(", "'eos_token'", ")", "bert_vocab", ".", "_mask_token", "=", "vocab_dict", ".", "get", "(", "'mask_token'", ")", "bert_vocab", ".", "_sep_token", "=", "vocab_dict", ".", "get", "(", "'sep_token'", ")", "bert_vocab", ".", "_cls_token", "=", "vocab_dict", ".", "get", "(", "'cls_token'", ")", "return", "bert_vocab" ]

[ "def", "_resample_data", "(", "self", ",", "gssha_var", ")", ":", "self", ".", "data", "=", "self", ".", "data", ".", "lsm", ".", "resample", "(", "gssha_var", ",", "self", ".", "gssha_grid", ")" ]

[ "def", "set_background", "(", "self", ",", "fname", "=", "None", ",", "genome", "=", "None", ",", "length", "=", "200", ",", "nseq", "=", "10000", ")", ":", "length", "=", "int", "(", "length", ")", "if", "genome", "and", "fname", ":", "raise", "ValueError", "(", "\"Need either genome or filename for background.\"", ")", "if", "fname", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "fname", ")", ":", "raise", "IOError", "(", "\"Background file {} does not exist!\"", ".", "format", "(", "fname", ")", ")", "self", ".", "background", "=", "Fasta", "(", "fname", ")", "self", ".", "background_hash", "=", "file_checksum", "(", "fname", ")", "return", "if", "not", "genome", ":", "if", "self", ".", "genome", ":", "genome", "=", "self", ".", "genome", "logger", ".", "info", "(", "\"Using default background: genome {} with length {}\"", ".", "format", "(", "genome", ",", "length", ")", ")", "else", ":", "raise", "ValueError", "(", "\"Need either genome or filename for background.\"", ")", "logger", ".", "info", "(", "\"Using background: genome {} with length {}\"", ".", "format", "(", "genome", ",", "length", ")", ")", "with", "Cache", "(", "CACHE_DIR", ")", "as", "cache", ":", "self", ".", "background_hash", "=", "\"{}\\{}\"", ".", "format", "(", "genome", ",", "int", "(", "length", ")", ")", "fa", "=", "cache", ".", "get", "(", "self", ".", "background_hash", ")", "if", "not", "fa", ":", "fa", "=", "RandomGenomicFasta", "(", "genome", ",", "length", ",", "nseq", ")", "cache", ".", "set", "(", "self", ".", "background_hash", ",", "fa", ")", "self", ".", "background", "=", "fa" ]

[ "def", "draw_char_screen", "(", "self", ")", ":", "self", ".", "screen", "=", "Image", ".", "new", "(", "\"RGB\"", ",", "(", "self", ".", "height", ",", "self", ".", "width", ")", ")", "self", ".", "drawer", "=", "ImageDraw", ".", "Draw", "(", "self", ".", "screen", ")", "for", "sy", ",", "line", "in", "enumerate", "(", "self", ".", "char_buffer", ")", ":", "for", "sx", ",", "tinfo", "in", "enumerate", "(", "line", ")", ":", "self", ".", "drawer", ".", "text", "(", "(", "sx", "*", "6", ",", "sy", "*", "9", ")", ",", "tinfo", "[", "0", "]", ",", "fill", "=", "tinfo", "[", "1", ":", "]", ")", "self", ".", "output_device", ".", "interrupt", "(", ")" ]

[ "def", "_refresh_state", "(", "self", ")", ":", "# DataFlow's DataflowPipelineResult does not refresh state, so we have to do it ourselves", "# as a workaround.", "self", ".", "_runner_results", ".", "_job", "=", "(", "self", ".", "_runner_results", ".", "_runner", ".", "dataflow_client", ".", "get_job", "(", "self", ".", "_runner_results", ".", "job_id", "(", ")", ")", ")", "self", ".", "_is_complete", "=", "self", ".", "_runner_results", ".", "state", "in", "[", "'STOPPED'", ",", "'DONE'", ",", "'FAILED'", ",", "'CANCELLED'", "]", "self", ".", "_fator_error", "=", "getattr", "(", "self", ".", "_runner_results", ".", "_runner", ",", "'last_error_msg'", ",", "None", ")" ]

[ "def", "collapse_addresses", "(", "addresses", ")", ":", "addrs", "=", "[", "]", "ips", "=", "[", "]", "nets", "=", "[", "]", "# split IP addresses and networks", "for", "ip", "in", "addresses", ":", "if", "isinstance", "(", "ip", ",", "_BaseAddress", ")", ":", "if", "ips", "and", "ips", "[", "-", "1", "]", ".", "_version", "!=", "ip", ".", "_version", ":", "raise", "TypeError", "(", "\"%s and %s are not of the same version\"", "%", "(", "ip", ",", "ips", "[", "-", "1", "]", ")", ")", "ips", ".", "append", "(", "ip", ")", "elif", "ip", ".", "_prefixlen", "==", "ip", ".", "_max_prefixlen", ":", "if", "ips", "and", "ips", "[", "-", "1", "]", ".", "_version", "!=", "ip", ".", "_version", ":", "raise", "TypeError", "(", "\"%s and %s are not of the same version\"", "%", "(", "ip", ",", "ips", "[", "-", "1", "]", ")", ")", "try", ":", "ips", ".", "append", "(", "ip", ".", "ip", ")", "except", "AttributeError", ":", "ips", ".", "append", "(", "ip", ".", "network_address", ")", "else", ":", "if", "nets", "and", "nets", "[", "-", "1", "]", ".", "_version", "!=", "ip", ".", "_version", ":", "raise", "TypeError", "(", "\"%s and %s are not of the same version\"", "%", "(", "ip", ",", "nets", "[", "-", "1", "]", ")", ")", "nets", ".", "append", "(", "ip", ")", "# sort and dedup", "ips", "=", "sorted", "(", "set", "(", "ips", ")", ")", "# find consecutive address ranges in the sorted sequence and summarize them", "if", "ips", ":", "for", "first", ",", "last", "in", "_find_address_range", "(", "ips", ")", ":", "addrs", ".", "extend", "(", "summarize_address_range", "(", "first", ",", "last", ")", ")", "return", "_collapse_addresses_internal", "(", "addrs", "+", "nets", ")" ]

[ "def", "kms_encrypt", "(", "kms_client", ",", "service", ",", "env", ",", "secret", ")", ":", "# Converting all periods to underscores because they are invalid in KMS alias names", "key_alias", "=", "'{}-{}'", ".", "format", "(", "env", ",", "service", ".", "replace", "(", "'.'", ",", "'_'", ")", ")", "try", ":", "response", "=", "kms_client", ".", "encrypt", "(", "KeyId", "=", "'alias/{}'", ".", "format", "(", "key_alias", ")", ",", "Plaintext", "=", "secret", ".", "encode", "(", ")", ")", "except", "ClientError", "as", "error", ":", "if", "error", ".", "response", "[", "'Error'", "]", "[", "'Code'", "]", "==", "\"NotFoundException\"", ":", "fail", "(", "\"Key '{}' not found. You may need to run ef-generate for this environment.\"", ".", "format", "(", "key_alias", ")", ",", "error", ")", "else", ":", "fail", "(", "\"boto3 exception occurred while performing kms encrypt operation.\"", ",", "error", ")", "encrypted_secret", "=", "base64", ".", "b64encode", "(", "response", "[", "'CiphertextBlob'", "]", ")", "return", "encrypted_secret" ]

[ "def", "_set_keepalive", "(", "self", ",", "v", ",", "load", "=", "False", ")", ":", "if", "hasattr", "(", "v", ",", "\"_utype\"", ")", ":", "v", "=", "v", ".", "_utype", "(", "v", ")", "try", ":", "t", "=", "YANGDynClass", "(", "v", ",", "base", "=", "keepalive", ".", "keepalive", ",", "is_container", "=", "'container'", ",", "presence", "=", "False", ",", "yang_name", "=", "\"keepalive\"", ",", "rest_name", "=", "\"keepalive\"", ",", "parent", "=", "self", ",", "path_helper", "=", "self", ".", "_path_helper", ",", "extmethods", "=", "self", ".", "_extmethods", ",", "register_paths", "=", "True", ",", "extensions", "=", "{", "u'tailf-common'", ":", "{", "u'info'", ":", "u'Tunnel keepalive'", ",", "u'cli-sequence-commands'", ":", "None", ",", "u'cli-full-no'", ":", "None", ",", "u'cli-incomplete-command'", ":", "None", "}", "}", ",", "namespace", "=", "'urn:brocade.com:mgmt:brocade-gre-vxlan'", ",", "defining_module", "=", "'brocade-gre-vxlan'", ",", "yang_type", "=", "'container'", ",", "is_config", "=", "True", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "raise", "ValueError", "(", "{", "'error-string'", ":", "\"\"\"keepalive must be of a type compatible with container\"\"\"", ",", "'defined-type'", ":", "\"container\"", ",", "'generated-type'", ":", "\"\"\"YANGDynClass(base=keepalive.keepalive, is_container='container', presence=False, yang_name=\"keepalive\", rest_name=\"keepalive\", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Tunnel keepalive', u'cli-sequence-commands': None, u'cli-full-no': None, u'cli-incomplete-command': None}}, namespace='urn:brocade.com:mgmt:brocade-gre-vxlan', defining_module='brocade-gre-vxlan', yang_type='container', is_config=True)\"\"\"", ",", "}", ")", "self", ".", "__keepalive", "=", "t", "if", "hasattr", "(", "self", ",", "'_set'", ")", ":", "self", ".", "_set", "(", ")" ]

[ "def", "plugin_info", "(", "self", ")", ":", "if", "self", ".", "_plugin_info_manager", "is", "None", ":", "self", ".", "_plugin_info_manager", "=", "PluginInfoManager", "(", "session", "=", "self", ".", "_session", ")", "return", "self", ".", "_plugin_info_manager" ]

[ "def", "highlight_text", "(", "needles", ",", "haystack", ",", "cls_name", "=", "'highlighted'", ",", "words", "=", "False", ",", "case", "=", "False", ")", ":", "if", "not", "needles", ":", "return", "haystack", "if", "not", "haystack", ":", "return", "''", "if", "words", ":", "pattern", "=", "r\"(%s)\"", "%", "\"|\"", ".", "join", "(", "[", "'\\\\b{}\\\\b'", ".", "format", "(", "re", ".", "escape", "(", "n", ")", ")", "for", "n", "in", "needles", "]", ")", "else", ":", "pattern", "=", "r\"(%s)\"", "%", "\"|\"", ".", "join", "(", "[", "re", ".", "escape", "(", "n", ")", "for", "n", "in", "needles", "]", ")", "if", "case", ":", "regex", "=", "re", ".", "compile", "(", "pattern", ")", "else", ":", "regex", "=", "re", ".", "compile", "(", "pattern", ",", "re", ".", "I", ")", "i", ",", "out", "=", "0", ",", "\"\"", "for", "m", "in", "regex", ".", "finditer", "(", "haystack", ")", ":", "out", "+=", "\"\"", ".", "join", "(", "[", "haystack", "[", "i", ":", "m", ".", "start", "(", ")", "]", ",", "'<span class=\"%s\">'", "%", "cls_name", ",", "haystack", "[", "m", ".", "start", "(", ")", ":", "m", ".", "end", "(", ")", "]", ",", "\"</span>\"", "]", ")", "i", "=", "m", ".", "end", "(", ")", "return", "mark_safe", "(", "out", "+", "haystack", "[", "i", ":", "]", ")" ]

[ "def", "split_leading_dim", "(", "tensor", ",", "inputs", ",", "n_dims", "=", "2", ")", ":", "input_shape_static", "=", "inputs", ".", "get_shape", "(", ")", "input_shape_list", "=", "input_shape_static", ".", "as_list", "(", ")", "tensor_shape_static", "=", "tensor", ".", "get_shape", "(", ")", "tensor_shape_list", "=", "tensor_shape_static", ".", "as_list", "(", ")", "if", "(", "input_shape_static", ".", "is_fully_defined", "(", ")", "and", "tensor_shape_static", ".", "is_fully_defined", "(", ")", ")", ":", "new_shape", "=", "input_shape_list", "[", ":", "n_dims", "]", "+", "tensor_shape_list", "[", "1", ":", "]", "return", "tf", ".", "reshape", "(", "tensor", ",", "new_shape", ")", "# Shape can't be inferred statically.", "dims_after_first", "=", "tf", ".", "shape", "(", "tensor", ")", "[", "1", ":", "]", "split_sizes", "=", "tf", ".", "shape", "(", "inputs", ")", "[", ":", "n_dims", "]", "known_split_sizes", "=", "input_shape_list", "[", ":", "n_dims", "]", "known_dims_after_first", "=", "tensor_shape_list", "[", "1", ":", "]", "output_size", "=", "tf", ".", "concat", "(", "[", "split_sizes", ",", "dims_after_first", "]", ",", "0", ")", "result", "=", "tf", ".", "reshape", "(", "tensor", ",", "output_size", ")", "result", ".", "set_shape", "(", "known_split_sizes", "+", "known_dims_after_first", ")", "return", "result" ]

[ "def", "get_surface_boundaries", "(", "self", ")", ":", "min_lon", ",", "min_lat", ",", "max_lon", ",", "max_lat", "=", "self", ".", "get_bounding_box", "(", ")", "return", "[", "[", "min_lon", ",", "max_lon", "]", "]", ",", "[", "[", "min_lat", ",", "max_lat", "]", "]" ]

[ "def", "_assert_safe_casting", "(", "cls", ",", "data", ",", "subarr", ")", ":", "if", "not", "issubclass", "(", "data", ".", "dtype", ".", "type", ",", "np", ".", "signedinteger", ")", ":", "if", "not", "np", ".", "array_equal", "(", "data", ",", "subarr", ")", ":", "raise", "TypeError", "(", "'Unsafe NumPy casting, you must '", "'explicitly cast'", ")" ]

[ "def", "get_future_days", "(", "self", ")", ":", "today", "=", "timezone", ".", "now", "(", ")", ".", "date", "(", ")", "return", "Day", ".", "objects", ".", "filter", "(", "date__gte", "=", "today", ")" ]

[ "def", "__truncate", "(", "self", ",", "line_arr", ",", "max_width", ")", ":", "def", "is_space", "(", "chunk", ")", ":", "return", "all", "(", "[", "True", "if", "i", "==", "' '", "else", "False", "for", "i", "in", "chunk", "]", ")", "def", "is_empty", "(", "chunks", ",", "markups", ")", ":", "result", "=", "[", "]", "for", "chunk", "in", "chunks", ":", "if", "chunk", "in", "markups", ":", "result", ".", "append", "(", "True", ")", "elif", "is_space", "(", "chunk", ")", ":", "result", ".", "append", "(", "True", ")", "else", ":", "result", ".", "append", "(", "False", ")", "return", "all", "(", "result", ")", "left", "=", "max_width", "result", "=", "''", "markups", "=", "self", ".", "markup", ".", "get_markup_vars", "(", ")", "for", "num", ",", "chunk", "in", "enumerate", "(", "line_arr", ")", ":", "if", "chunk", "in", "markups", ":", "result", "+=", "chunk", "else", ":", "if", "left", ">", "0", ":", "if", "len", "(", "chunk", ")", "<=", "left", ":", "result", "+=", "chunk", "left", "-=", "len", "(", "chunk", ")", "else", ":", "leftover", "=", "(", "chunk", "[", "left", ":", "]", ",", ")", "+", "line_arr", "[", "num", "+", "1", ":", "]", "was_cut", "=", "not", "is_empty", "(", "leftover", ",", "markups", ")", "if", "was_cut", ":", "result", "+=", "chunk", "[", ":", "left", "-", "1", "]", "+", "self", ".", "markup", ".", "RESET", "+", "u'\\u2026'", "else", ":", "result", "+=", "chunk", "[", ":", "left", "]", "left", "=", "0", "return", "result" ]

[ "def", "write", "(", "self", ",", "output_stream", ",", "kmip_version", "=", "enums", ".", "KMIPVersion", ".", "KMIP_1_0", ")", ":", "local_stream", "=", "utils", ".", "BytearrayStream", "(", ")", "if", "self", ".", "object_type", ":", "self", ".", "_object_type", ".", "write", "(", "local_stream", ",", "kmip_version", "=", "kmip_version", ")", "else", ":", "raise", "ValueError", "(", "\"Payload is missing the object type field.\"", ")", "if", "self", ".", "unique_identifier", ":", "self", ".", "_unique_identifier", ".", "write", "(", "local_stream", ",", "kmip_version", "=", "kmip_version", ")", "else", ":", "raise", "ValueError", "(", "\"Payload is missing the unique identifier field.\"", ")", "if", "self", ".", "secret", ":", "self", ".", "_secret", ".", "write", "(", "local_stream", ",", "kmip_version", "=", "kmip_version", ")", "else", ":", "raise", "ValueError", "(", "\"Payload is missing the secret field.\"", ")", "self", ".", "length", "=", "local_stream", ".", "length", "(", ")", "super", "(", "GetResponsePayload", ",", "self", ")", ".", "write", "(", "output_stream", ",", "kmip_version", "=", "kmip_version", ")", "output_stream", ".", "write", "(", "local_stream", ".", "buffer", ")" ]

[ "def", "subscriber_has_active_subscription", "(", "subscriber", ",", "plan", "=", "None", ")", ":", "if", "isinstance", "(", "subscriber", ",", "AnonymousUser", ")", ":", "raise", "ImproperlyConfigured", "(", "ANONYMOUS_USER_ERROR_MSG", ")", "if", "isinstance", "(", "subscriber", ",", "get_user_model", "(", ")", ")", ":", "if", "subscriber", ".", "is_superuser", "or", "subscriber", ".", "is_staff", ":", "return", "True", "from", ".", "models", "import", "Customer", "customer", ",", "created", "=", "Customer", ".", "get_or_create", "(", "subscriber", ")", "if", "created", "or", "not", "customer", ".", "has_active_subscription", "(", "plan", ")", ":", "return", "False", "return", "True" ]

[ "def", "firmware_download_input_rbridge_id", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "firmware_download", "=", "ET", ".", "Element", "(", "\"firmware_download\"", ")", "config", "=", "firmware_download", "input", "=", "ET", ".", "SubElement", "(", "firmware_download", ",", "\"input\"", ")", "rbridge_id", "=", "ET", ".", "SubElement", "(", "input", ",", "\"rbridge-id\"", ")", "rbridge_id", ".", "text", "=", "kwargs", ".", "pop", "(", "'rbridge_id'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

[ "def", "save_file", "(", "self", ",", "path", "=", "None", ",", "force_overwrite", "=", "False", ",", "just_settings", "=", "False", ",", "*", "*", "kwargs", ")", ":", "# Update the binary mode", "if", "not", "'binary'", "in", "kwargs", ":", "kwargs", "[", "'binary'", "]", "=", "self", ".", "combo_binary", ".", "get_text", "(", ")", "# if it's just the settings file, make a new databox", "if", "just_settings", ":", "d", "=", "_d", ".", "databox", "(", ")", "# otherwise use the internal databox", "else", ":", "d", "=", "self", "# add all the controls settings to the header", "for", "x", "in", "self", ".", "_autosettings_controls", ":", "self", ".", "_store_gui_setting", "(", "d", ",", "x", ")", "# save the file using the skeleton function, so as not to recursively ", "# call this one again!", "_d", ".", "databox", ".", "save_file", "(", "d", ",", "path", ",", "self", ".", "file_type", ",", "self", ".", "file_type", ",", "force_overwrite", ",", "*", "*", "kwargs", ")" ]

[ "def", "pymatgen_mol", "(", "self", ")", ":", "sp", "=", "[", "]", "coords", "=", "[", "]", "for", "atom", "in", "ob", ".", "OBMolAtomIter", "(", "self", ".", "_obmol", ")", ":", "sp", ".", "append", "(", "atom", ".", "GetAtomicNum", "(", ")", ")", "coords", ".", "append", "(", "[", "atom", ".", "GetX", "(", ")", ",", "atom", ".", "GetY", "(", ")", ",", "atom", ".", "GetZ", "(", ")", "]", ")", "return", "Molecule", "(", "sp", ",", "coords", ")" ]

[ "def", "viscosity_converter", "(", "val", ",", "old_scale", ",", "new_scale", ",", "extrapolate", "=", "False", ")", ":", "def", "range_check", "(", "visc", ",", "scale", ")", ":", "scale_min", ",", "scale_max", ",", "nu_min", ",", "nu_max", "=", "viscosity_converter_limits", "[", "scale", "]", "if", "visc", "<", "scale_min", "*", "(", "1.", "-", "1E-7", ")", "or", "visc", ">", "scale_max", "*", "(", "1.", "+", "1E-7", ")", ":", "raise", "Exception", "(", "'Viscosity conversion is outside the limits of the '", "'%s scale; given value is %s, but the range of the '", "'scale is from %s to %s. Set `extrapolate` to True '", "'to perform the conversion anyway.'", "%", "(", "scale", ",", "visc", ",", "scale_min", ",", "scale_max", ")", ")", "def", "range_check_linear", "(", "val", ",", "c", ",", "tmin", ",", "scale", ")", ":", "if", "val", "<", "tmin", ":", "raise", "Exception", "(", "'Viscosity conversion is outside the limits of the '", "'%s scale; given value is %s, but the minimum time '", "'for this scale is %s s. Set `extrapolate` to True '", "'to perform the conversion anyway.'", "%", "(", "scale", ",", "val", ",", "tmin", ")", ")", "old_scale", "=", "old_scale", ".", "lower", "(", ")", ".", "replace", "(", "'degrees'", ",", "''", ")", ".", "replace", "(", "'seconds'", ",", "''", ")", ".", "strip", "(", ")", "new_scale", "=", "new_scale", ".", "lower", "(", ")", ".", "replace", "(", "'degrees'", ",", "''", ")", ".", "replace", "(", "'seconds'", ",", "''", ")", ".", "strip", "(", ")", "def", "Saybolt_universal_eq", "(", "nu", ")", ":", "return", "(", "4.6324", "*", "nu", "+", "(", "1E5", "+", "3264.", "*", "nu", ")", "/", "(", "nu", "*", "(", "nu", "*", "(", "1.646", "*", "nu", "+", "23.97", ")", "+", "262.7", ")", "+", "3930.2", ")", ")", "# Convert to kinematic viscosity", "if", "old_scale", "==", "'kinematic viscosity'", ":", "val", "=", "1E6", "*", "val", "# convert to centistokes, the basis of the functions", "elif", "old_scale", "==", "'saybolt universal'", ":", "if", "not", "extrapolate", ":", "range_check", "(", "val", ",", "old_scale", ")", "to_solve", "=", "lambda", "nu", ":", "Saybolt_universal_eq", "(", "nu", ")", "-", "val", "val", "=", "newton", "(", "to_solve", ",", "1", ")", "elif", "old_scale", "in", "viscosity_converters_to_nu", ":", "if", "not", "extrapolate", ":", "range_check", "(", "val", ",", "old_scale", ")", "val", "=", "exp", "(", "viscosity_converters_to_nu", "[", "old_scale", "]", "(", "log", "(", "val", ")", ")", ")", "elif", "old_scale", "in", "viscosity_scales_linear", ":", "c", ",", "tmin", "=", "viscosity_scales_linear", "[", "old_scale", "]", "if", "not", "extrapolate", ":", "range_check_linear", "(", "val", ",", "c", ",", "tmin", ",", "old_scale", ")", "val", "=", "c", "*", "val", "# convert from seconds to centistokes", "else", ":", "keys", "=", "sorted", "(", "set", "(", "list", "(", "viscosity_scales", ".", "keys", "(", ")", ")", "+", "list", "(", "viscosity_scales_linear", ".", "keys", "(", ")", ")", ")", ")", "raise", "Exception", "(", "'Scale \"%s\" not recognized - allowable values are any of %s.'", "%", "(", "old_scale", ",", "keys", ")", ")", "# Convert to desired scale", "if", "new_scale", "==", "'kinematic viscosity'", ":", "val", "=", "1E-6", "*", "val", "# convert to m^2/s", "elif", "new_scale", "==", "'saybolt universal'", ":", "val", "=", "Saybolt_universal_eq", "(", "val", ")", "elif", "new_scale", "in", "viscosity_converters_from_nu", ":", "val", "=", "exp", "(", "viscosity_converters_from_nu", "[", "new_scale", "]", "(", "log", "(", "val", ")", ")", ")", "if", "not", "extrapolate", ":", "range_check", "(", "val", ",", "new_scale", ")", "elif", "new_scale", "in", "viscosity_scales_linear", ":", "c", ",", "tmin", "=", "viscosity_scales_linear", "[", "new_scale", "]", "val", "=", "val", "/", "c", "# convert from centistokes to seconds", "if", "not", "extrapolate", ":", "range_check_linear", "(", "val", ",", "c", ",", "tmin", ",", "new_scale", ")", "else", ":", "keys", "=", "sorted", "(", "set", "(", "list", "(", "viscosity_scales", ".", "keys", "(", ")", ")", "+", "list", "(", "viscosity_scales_linear", ".", "keys", "(", ")", ")", ")", ")", "raise", "Exception", "(", "'Scale \"%s\" not recognized - allowable values are any of %s.'", "%", "(", "new_scale", ",", "keys", ")", ")", "return", "float", "(", "val", ")" ]

[ "def", "get_nets_jpnic", "(", "self", ",", "response", ")", ":", "nets", "=", "[", "]", "# Iterate through all of the networks found, storing the CIDR value", "# and the start and end positions.", "for", "match", "in", "re", ".", "finditer", "(", "r'^.*?(\\[Network Number\\])[^\\S\\n]+.+?>(?P<val>.+?)</A>$'", ",", "response", ",", "re", ".", "MULTILINE", ")", ":", "try", ":", "net", "=", "copy", ".", "deepcopy", "(", "BASE_NET", ")", "tmp", "=", "ip_network", "(", "match", ".", "group", "(", "2", ")", ")", "try", ":", "# pragma: no cover", "network_address", "=", "tmp", ".", "network_address", "except", "AttributeError", ":", "# pragma: no cover", "network_address", "=", "tmp", ".", "ip", "pass", "try", ":", "# pragma: no cover", "broadcast_address", "=", "tmp", ".", "broadcast_address", "except", "AttributeError", ":", "# pragma: no cover", "broadcast_address", "=", "tmp", ".", "broadcast", "pass", "net", "[", "'range'", "]", "=", "'{0} - {1}'", ".", "format", "(", "network_address", "+", "1", ",", "broadcast_address", ")", "cidr", "=", "ip_network", "(", "match", ".", "group", "(", "2", ")", ".", "strip", "(", ")", ")", ".", "__str__", "(", ")", "net", "[", "'cidr'", "]", "=", "cidr", "net", "[", "'start'", "]", "=", "match", ".", "start", "(", ")", "net", "[", "'end'", "]", "=", "match", ".", "end", "(", ")", "nets", ".", "append", "(", "net", ")", "except", "(", "ValueError", ",", "TypeError", ")", ":", "pass", "return", "nets" ]

[ "def", "delete", "(", "ctx", ",", "archive_name", ")", ":", "_generate_api", "(", "ctx", ")", "var", "=", "ctx", ".", "obj", ".", "api", ".", "get_archive", "(", "archive_name", ")", "var", ".", "delete", "(", ")", "click", ".", "echo", "(", "'deleted archive {}'", ".", "format", "(", "var", ")", ")" ]

[ "def", "set_stable_spot_instance_settings", "(", "self", ",", "maximum_bid_price_percentage", "=", "None", ",", "timeout_for_request", "=", "None", ",", "allow_fallback", "=", "True", ")", ":", "self", ".", "hadoop_settings", "[", "'stable_spot_instance_settings'", "]", "=", "{", "'maximum_bid_price_percentage'", ":", "maximum_bid_price_percentage", ",", "'timeout_for_request'", ":", "timeout_for_request", ",", "'allow_fallback'", ":", "allow_fallback", "}" ]

[ "def", "harmonics_1d", "(", "harmonic_out", ",", "x", ",", "freqs", ",", "h_range", ",", "kind", "=", "'linear'", ",", "fill_value", "=", "0", ",", "axis", "=", "0", ")", ":", "# Note: this only works for fixed-grid, 1d interpolation", "f_interp", "=", "scipy", ".", "interpolate", ".", "interp1d", "(", "freqs", ",", "x", ",", "kind", "=", "kind", ",", "axis", "=", "axis", ",", "copy", "=", "False", ",", "bounds_error", "=", "False", ",", "fill_value", "=", "fill_value", ")", "idx_out", "=", "[", "slice", "(", "None", ")", "]", "*", "harmonic_out", ".", "ndim", "# Compute the output index of the interpolated values", "interp_axis", "=", "1", "+", "(", "axis", "%", "x", ".", "ndim", ")", "# Iterate over the harmonics range", "for", "h_index", ",", "harmonic", "in", "enumerate", "(", "h_range", ")", ":", "idx_out", "[", "0", "]", "=", "h_index", "# Iterate over frequencies", "for", "f_index", ",", "frequency", "in", "enumerate", "(", "freqs", ")", ":", "# Offset the output axis by 1 to account for the harmonic index", "idx_out", "[", "interp_axis", "]", "=", "f_index", "# Estimate the harmonic energy at this frequency across time", "harmonic_out", "[", "tuple", "(", "idx_out", ")", "]", "=", "f_interp", "(", "harmonic", "*", "frequency", ")" ]

[ "def", "Sanjari", "(", "T", ",", "Tc", ",", "Pc", ",", "omega", ")", ":", "Tr", "=", "T", "/", "Tc", "f0", "=", "6.83377", "+", "-", "5.76051", "/", "Tr", "+", "0.90654", "*", "log", "(", "Tr", ")", "+", "-", "1.16906", "*", "Tr", "**", "1.9", "f1", "=", "5.32034", "+", "-", "28.1460", "/", "Tr", "+", "-", "58.0352", "*", "log", "(", "Tr", ")", "+", "23.57466", "*", "Tr", "**", "1.9", "f2", "=", "18.19967", "+", "16.33839", "/", "Tr", "+", "65.6995", "*", "log", "(", "Tr", ")", "+", "-", "35.9739", "*", "Tr", "**", "1.9", "return", "Pc", "*", "exp", "(", "f0", "+", "omega", "*", "f1", "+", "omega", "**", "2", "*", "f2", ")" ]

[ "def", "linked", "(", "base_dir", ":", "str", ",", "rr_id", ":", "str", ")", "->", "str", ":", "LOGGER", ".", "debug", "(", "'Tails.linked >>> base_dir: %s, rr_id: %s'", ",", "base_dir", ",", "rr_id", ")", "if", "not", "ok_rev_reg_id", "(", "rr_id", ")", ":", "LOGGER", ".", "debug", "(", "'Tails.linked <!< Bad rev reg id %s'", ",", "rr_id", ")", "raise", "BadIdentifier", "(", "'Bad rev reg id {}'", ".", "format", "(", "rr_id", ")", ")", "cd_id", "=", "rev_reg_id2cred_def_id", "(", "rr_id", ")", "link", "=", "join", "(", "base_dir", ",", "cd_id", ",", "rr_id", ")", "rv", "=", "join", "(", "base_dir", ",", "cd_id", ",", "readlink", "(", "link", ")", ")", "if", "islink", "(", "link", ")", "else", "None", "LOGGER", ".", "debug", "(", "'Tails.linked <<< %s'", ",", "rv", ")", "return", "rv" ]

[ "def", "on_btn_unpack", "(", "self", ",", "event", ")", ":", "dlg", "=", "wx", ".", "FileDialog", "(", "None", ",", "message", "=", "\"choose txt file to unpack\"", ",", "defaultDir", "=", "self", ".", "WD", ",", "defaultFile", "=", "\"\"", ",", "style", "=", "wx", ".", "FD_OPEN", "#| wx.FD_CHANGE_DIR", ")", "if", "dlg", ".", "ShowModal", "(", ")", "==", "wx", ".", "ID_OK", ":", "FILE", "=", "dlg", ".", "GetPath", "(", ")", "input_dir", ",", "f", "=", "os", ".", "path", ".", "split", "(", "FILE", ")", "else", ":", "return", "False", "outstring", "=", "\"download_magic.py -f {} -WD {} -ID {} -DM {}\"", ".", "format", "(", "f", ",", "self", ".", "WD", ",", "input_dir", ",", "self", ".", "data_model_num", ")", "# run as module:", "print", "(", "\"-I- running python script:\\n %s\"", "%", "(", "outstring", ")", ")", "wait", "=", "wx", ".", "BusyInfo", "(", "\"Please wait, working...\"", ")", "wx", ".", "SafeYield", "(", ")", "ex", "=", "None", "try", ":", "if", "ipmag", ".", "download_magic", "(", "f", ",", "self", ".", "WD", ",", "input_dir", ",", "overwrite", "=", "True", ",", "data_model", "=", "self", ".", "data_model", ")", ":", "text", "=", "\"Successfully ran download_magic.py program.\\nMagIC files were saved in your working directory.\\nSee Terminal/message window for details.\"", "else", ":", "text", "=", "\"Something went wrong. Make sure you chose a valid file downloaded from the MagIC database and try again.\"", "except", "Exception", "as", "ex", ":", "text", "=", "\"Something went wrong. Make sure you chose a valid file downloaded from the MagIC database and try again.\"", "del", "wait", "dlg", "=", "wx", ".", "MessageDialog", "(", "self", ",", "caption", "=", "\"Saved\"", ",", "message", "=", "text", ",", "style", "=", "wx", ".", "OK", ")", "result", "=", "dlg", ".", "ShowModal", "(", ")", "if", "result", "==", "wx", ".", "ID_OK", ":", "dlg", ".", "Destroy", "(", ")", "if", "ex", ":", "raise", "(", "ex", ")", "self", ".", "contribution", "=", "cb", ".", "Contribution", "(", "self", ".", "WD", ")" ]

[ "def", "filter", "(", "self", ",", "request", ",", "queryset", ",", "view", ")", ":", "summary_queryset", "=", "queryset", "filtered_querysets", "=", "[", "]", "for", "queryset", "in", "summary_queryset", ".", "querysets", ":", "filter_class", "=", "self", ".", "_get_filter", "(", "queryset", ")", "queryset", "=", "filter_class", "(", "request", ".", "query_params", ",", "queryset", "=", "queryset", ")", ".", "qs", "filtered_querysets", ".", "append", "(", "queryset", ")", "summary_queryset", ".", "querysets", "=", "filtered_querysets", "return", "summary_queryset" ]

[ "def", "read_short", "(", "self", ")", ":", "self", ".", "bitcount", "=", "self", ".", "bits", "=", "0", "return", "unpack", "(", "'>H'", ",", "self", ".", "input", ".", "read", "(", "2", ")", ")", "[", "0", "]" ]

[ "def", "buildcontent", "(", "self", ")", ":", "self", ".", "buildcontainer", "(", ")", "self", ".", "option", "=", "json", ".", "dumps", "(", "self", ".", "options", ",", "cls", "=", "HighchartsEncoder", ")", "self", ".", "setoption", "=", "json", ".", "dumps", "(", "self", ".", "setOptions", ",", "cls", "=", "HighchartsEncoder", ")", "self", ".", "data", "=", "json", ".", "dumps", "(", "self", ".", "data_temp", ",", "cls", "=", "HighchartsEncoder", ")", "# DEM 2017/04/25: Make 'data' available as an array", "# ... this permits jinja2 array access to each data definition", "# ... which is useful for looping over multiple data sources", "self", ".", "data_list", "=", "[", "json", ".", "dumps", "(", "x", ",", "cls", "=", "HighchartsEncoder", ")", "for", "x", "in", "self", ".", "data_temp", "]", "if", "self", ".", "navi_seri_flag", ":", "self", ".", "navi_seri", "=", "json", ".", "dumps", "(", "self", ".", "navi_seri_temp", ",", "cls", "=", "HighchartsEncoder", ")", "self", ".", "_htmlcontent", "=", "self", ".", "template_content_highcharts", ".", "render", "(", "chart", "=", "self", ")", ".", "encode", "(", "'utf-8'", ")" ]

[ "def", "GetMessages", "(", "self", ",", "formatter_mediator", ",", "event", ")", ":", "if", "self", ".", "DATA_TYPE", "!=", "event", ".", "data_type", ":", "raise", "errors", ".", "WrongFormatter", "(", "'Unsupported data type: {0:s}.'", ".", "format", "(", "event", ".", "data_type", ")", ")", "event_values", "=", "event", ".", "CopyToDict", "(", ")", "priority_level", "=", "event_values", ".", "get", "(", "'level'", ",", "None", ")", "if", "isinstance", "(", "priority_level", ",", "py2to3", ".", "INTEGER_TYPES", ")", ":", "event_values", "[", "'level'", "]", "=", "'{0:s} ({1:d})'", ".", "format", "(", "self", ".", "_PRIORITY_LEVELS", ".", "get", "(", "priority_level", ",", "'UNKNOWN'", ")", ",", "priority_level", ")", "# If no rights are assigned the value is 0xffffffff (-1).", "read_uid", "=", "event_values", ".", "get", "(", "'read_uid'", ",", "None", ")", "if", "read_uid", "==", "-", "1", ":", "event_values", "[", "'read_uid'", "]", "=", "'ALL'", "# If no rights are assigned the value is 0xffffffff (-1).", "read_gid", "=", "event_values", ".", "get", "(", "'read_gid'", ",", "None", ")", "if", "read_gid", "==", "-", "1", ":", "event_values", "[", "'read_gid'", "]", "=", "'ALL'", "# TODO: get the real name for the user of the group having the uid or gid.", "return", "self", ".", "_ConditionalFormatMessages", "(", "event_values", ")" ]

[ "def", "create_relationship", "(", "self", ",", "relationship_form", ")", ":", "# Implemented from template for", "# osid.resource.ResourceAdminSession.create_resource_template", "collection", "=", "JSONClientValidated", "(", "'relationship'", ",", "collection", "=", "'Relationship'", ",", "runtime", "=", "self", ".", "_runtime", ")", "if", "not", "isinstance", "(", "relationship_form", ",", "ABCRelationshipForm", ")", ":", "raise", "errors", ".", "InvalidArgument", "(", "'argument type is not an RelationshipForm'", ")", "if", "relationship_form", ".", "is_for_update", "(", ")", ":", "raise", "errors", ".", "InvalidArgument", "(", "'the RelationshipForm is for update only, not create'", ")", "try", ":", "if", "self", ".", "_forms", "[", "relationship_form", ".", "get_id", "(", ")", ".", "get_identifier", "(", ")", "]", "==", "CREATED", ":", "raise", "errors", ".", "IllegalState", "(", "'relationship_form already used in a create transaction'", ")", "except", "KeyError", ":", "raise", "errors", ".", "Unsupported", "(", "'relationship_form did not originate from this session'", ")", "if", "not", "relationship_form", ".", "is_valid", "(", ")", ":", "raise", "errors", ".", "InvalidArgument", "(", "'one or more of the form elements is invalid'", ")", "insert_result", "=", "collection", ".", "insert_one", "(", "relationship_form", ".", "_my_map", ")", "self", ".", "_forms", "[", "relationship_form", ".", "get_id", "(", ")", ".", "get_identifier", "(", ")", "]", "=", "CREATED", "result", "=", "objects", ".", "Relationship", "(", "osid_object_map", "=", "collection", ".", "find_one", "(", "{", "'_id'", ":", "insert_result", ".", "inserted_id", "}", ")", ",", "runtime", "=", "self", ".", "_runtime", ",", "proxy", "=", "self", ".", "_proxy", ")", "return", "result" ]

[ "def", "get_trigger_data", "(", "value", ",", "mode", "=", "0", ")", ":", "if", "mode", "==", "2", ":", "return", "np", ".", "right_shift", "(", "np", ".", "bitwise_and", "(", "value", ",", "0x7FFF0000", ")", ",", "16", ")", ",", "np", ".", "bitwise_and", "(", "value", ",", "0x0000FFFF", ")", "else", ":", "return", "np", ".", "bitwise_and", "(", "value", ",", "0x7FFFFFFF", ")" ]

[ "def", "migrate", "(", "connection", ",", "dsn", ")", ":", "all_migrations", "=", "_get_all_migrations", "(", ")", "logger", ".", "debug", "(", "'Collected migrations: {}'", ".", "format", "(", "all_migrations", ")", ")", "for", "version", ",", "modname", "in", "all_migrations", ":", "if", "_is_missed", "(", "connection", ",", "version", ")", "and", "version", "<=", "SCHEMA_VERSION", ":", "logger", ".", "info", "(", "'Missed migration: {} migration is missed. Migrating...'", ".", "format", "(", "version", ")", ")", "module", "=", "__import__", "(", "modname", ",", "fromlist", "=", "'dummy'", ")", "# run each migration under its own transaction. This allows us to apply valid migrations", "# and break on invalid.", "trans", "=", "connection", ".", "begin", "(", ")", "try", ":", "module", ".", "Migration", "(", ")", ".", "migrate", "(", "connection", ")", "_update_version", "(", "connection", ",", "version", ")", "trans", ".", "commit", "(", ")", "except", ":", "trans", ".", "rollback", "(", ")", "logger", ".", "error", "(", "\"Failed to migrate '{}' on {} \"", ".", "format", "(", "version", ",", "dsn", ")", ")", "raise" ]

[ "def", "UNIFAC", "(", "T", ",", "xs", ",", "chemgroups", ",", "cached", "=", "None", ",", "subgroup_data", "=", "None", ",", "interaction_data", "=", "None", ",", "modified", "=", "False", ")", ":", "cmps", "=", "range", "(", "len", "(", "xs", ")", ")", "if", "subgroup_data", "is", "None", ":", "subgroups", "=", "UFSG", "else", ":", "subgroups", "=", "subgroup_data", "if", "interaction_data", "is", "None", ":", "interactions", "=", "UFIP", "else", ":", "interactions", "=", "interaction_data", "# Obtain r and q values using the subgroup values", "if", "not", "cached", ":", "rs", "=", "[", "]", "qs", "=", "[", "]", "for", "groups", "in", "chemgroups", ":", "ri", "=", "0.", "qi", "=", "0.", "for", "group", ",", "count", "in", "groups", ".", "items", "(", ")", ":", "ri", "+=", "subgroups", "[", "group", "]", ".", "R", "*", "count", "qi", "+=", "subgroups", "[", "group", "]", ".", "Q", "*", "count", "rs", ".", "append", "(", "ri", ")", "qs", ".", "append", "(", "qi", ")", "group_counts", "=", "{", "}", "for", "groups", "in", "chemgroups", ":", "for", "group", ",", "count", "in", "groups", ".", "items", "(", ")", ":", "if", "group", "in", "group_counts", ":", "group_counts", "[", "group", "]", "+=", "count", "else", ":", "group_counts", "[", "group", "]", "=", "count", "else", ":", "rs", ",", "qs", ",", "group_counts", "=", "cached", "# Sum the denominator for calculating Xs", "group_sum", "=", "sum", "(", "count", "*", "xs", "[", "i", "]", "for", "i", "in", "cmps", "for", "count", "in", "chemgroups", "[", "i", "]", ".", "values", "(", ")", ")", "# Caclulate each numerator for calculating Xs", "group_count_xs", "=", "{", "}", "for", "group", "in", "group_counts", ":", "tot_numerator", "=", "sum", "(", "chemgroups", "[", "i", "]", "[", "group", "]", "*", "xs", "[", "i", "]", "for", "i", "in", "cmps", "if", "group", "in", "chemgroups", "[", "i", "]", ")", "group_count_xs", "[", "group", "]", "=", "tot_numerator", "/", "group_sum", "rsxs", "=", "sum", "(", "[", "rs", "[", "i", "]", "*", "xs", "[", "i", "]", "for", "i", "in", "cmps", "]", ")", "Vis", "=", "[", "rs", "[", "i", "]", "/", "rsxs", "for", "i", "in", "cmps", "]", "qsxs", "=", "sum", "(", "[", "qs", "[", "i", "]", "*", "xs", "[", "i", "]", "for", "i", "in", "cmps", "]", ")", "Fis", "=", "[", "qs", "[", "i", "]", "/", "qsxs", "for", "i", "in", "cmps", "]", "if", "modified", ":", "rsxs2", "=", "sum", "(", "[", "rs", "[", "i", "]", "**", "0.75", "*", "xs", "[", "i", "]", "for", "i", "in", "cmps", "]", ")", "Vis2", "=", "[", "rs", "[", "i", "]", "**", "0.75", "/", "rsxs2", "for", "i", "in", "cmps", "]", "loggammacs", "=", "[", "1.", "-", "Vis2", "[", "i", "]", "+", "log", "(", "Vis2", "[", "i", "]", ")", "-", "5.", "*", "qs", "[", "i", "]", "*", "(", "1.", "-", "Vis", "[", "i", "]", "/", "Fis", "[", "i", "]", "+", "log", "(", "Vis", "[", "i", "]", "/", "Fis", "[", "i", "]", ")", ")", "for", "i", "in", "cmps", "]", "else", ":", "loggammacs", "=", "[", "1.", "-", "Vis", "[", "i", "]", "+", "log", "(", "Vis", "[", "i", "]", ")", "-", "5.", "*", "qs", "[", "i", "]", "*", "(", "1.", "-", "Vis", "[", "i", "]", "/", "Fis", "[", "i", "]", "+", "log", "(", "Vis", "[", "i", "]", "/", "Fis", "[", "i", "]", ")", ")", "for", "i", "in", "cmps", "]", "Q_sum_term", "=", "sum", "(", "[", "subgroups", "[", "group", "]", ".", "Q", "*", "group_count_xs", "[", "group", "]", "for", "group", "in", "group_counts", "]", ")", "area_fractions", "=", "{", "group", ":", "subgroups", "[", "group", "]", ".", "Q", "*", "group_count_xs", "[", "group", "]", "/", "Q_sum_term", "for", "group", "in", "group_counts", ".", "keys", "(", ")", "}", "UNIFAC_psis", "=", "{", "k", ":", "{", "m", ":", "(", "UNIFAC_psi", "(", "T", ",", "m", ",", "k", ",", "subgroups", ",", "interactions", ",", "modified", "=", "modified", ")", ")", "for", "m", "in", "group_counts", "}", "for", "k", "in", "group_counts", "}", "loggamma_groups", "=", "{", "}", "for", "k", "in", "group_counts", ":", "sum1", ",", "sum2", "=", "0.", ",", "0.", "for", "m", "in", "group_counts", ":", "sum1", "+=", "area_fractions", "[", "m", "]", "*", "UNIFAC_psis", "[", "k", "]", "[", "m", "]", "sum3", "=", "sum", "(", "area_fractions", "[", "n", "]", "*", "UNIFAC_psis", "[", "m", "]", "[", "n", "]", "for", "n", "in", "group_counts", ")", "sum2", "-=", "area_fractions", "[", "m", "]", "*", "UNIFAC_psis", "[", "m", "]", "[", "k", "]", "/", "sum3", "loggamma_groups", "[", "k", "]", "=", "subgroups", "[", "k", "]", ".", "Q", "*", "(", "1.", "-", "log", "(", "sum1", ")", "+", "sum2", ")", "loggammars", "=", "[", "]", "for", "groups", "in", "chemgroups", ":", "chem_loggamma_groups", "=", "{", "}", "chem_group_sum", "=", "sum", "(", "groups", ".", "values", "(", ")", ")", "chem_group_count_xs", "=", "{", "group", ":", "count", "/", "chem_group_sum", "for", "group", ",", "count", "in", "groups", ".", "items", "(", ")", "}", "Q_sum_term", "=", "sum", "(", "[", "subgroups", "[", "group", "]", ".", "Q", "*", "chem_group_count_xs", "[", "group", "]", "for", "group", "in", "groups", "]", ")", "chem_area_fractions", "=", "{", "group", ":", "subgroups", "[", "group", "]", ".", "Q", "*", "chem_group_count_xs", "[", "group", "]", "/", "Q_sum_term", "for", "group", "in", "groups", ".", "keys", "(", ")", "}", "for", "k", "in", "groups", ":", "sum1", ",", "sum2", "=", "0.", ",", "0.", "for", "m", "in", "groups", ":", "sum1", "+=", "chem_area_fractions", "[", "m", "]", "*", "UNIFAC_psis", "[", "k", "]", "[", "m", "]", "sum3", "=", "sum", "(", "chem_area_fractions", "[", "n", "]", "*", "UNIFAC_psis", "[", "m", "]", "[", "n", "]", "for", "n", "in", "groups", ")", "sum2", "-=", "chem_area_fractions", "[", "m", "]", "*", "UNIFAC_psis", "[", "m", "]", "[", "k", "]", "/", "sum3", "chem_loggamma_groups", "[", "k", "]", "=", "subgroups", "[", "k", "]", ".", "Q", "*", "(", "1.", "-", "log", "(", "sum1", ")", "+", "sum2", ")", "tot", "=", "sum", "(", "[", "count", "*", "(", "loggamma_groups", "[", "group", "]", "-", "chem_loggamma_groups", "[", "group", "]", ")", "for", "group", ",", "count", "in", "groups", ".", "items", "(", ")", "]", ")", "loggammars", ".", "append", "(", "tot", ")", "return", "[", "exp", "(", "loggammacs", "[", "i", "]", "+", "loggammars", "[", "i", "]", ")", "for", "i", "in", "cmps", "]" ]

[ "def", "read_pdb", "(", "self", ",", "path", ")", ":", "self", ".", "pdb_path", ",", "self", ".", "pdb_text", "=", "self", ".", "_read_pdb", "(", "path", "=", "path", ")", "self", ".", "_df", "=", "self", ".", "_construct_df", "(", "pdb_lines", "=", "self", ".", "pdb_text", ".", "splitlines", "(", "True", ")", ")", "self", ".", "header", ",", "self", ".", "code", "=", "self", ".", "_parse_header_code", "(", ")", "return", "self" ]