Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "finalize", "(", "self", ",", "*", "*", "kwargs", ")", ":", "# Set the title and add the legend", "self", ".", "set_title", "(", "'ROC Curves for {}'", ".", "format", "(", "self", ".", "name", ")", ")", "self", ".", "ax", ".", "legend", "(", "loc", "=", "'lower right'", ",", "frameon", "=", "True", ")", "# Set the limits for the ROC/AUC (always between 0 and 1)", "self", ".", "ax", ".", "set_xlim", "(", "[", "0.0", ",", "1.0", "]", ")", "self", ".", "ax", ".", "set_ylim", "(", "[", "0.0", ",", "1.0", "]", ")", "# Set x and y axis labels", "self", ".", "ax", ".", "set_ylabel", "(", "'True Postive Rate'", ")", "self", ".", "ax", ".", "set_xlabel", "(", "'False Positive Rate'", ")" ]

[ "Finalize", "executes", "any", "subclass", "-", "specific", "axes", "finalization", "steps", ".", "The", "user", "calls", "poof", "and", "poof", "calls", "finalize", "." ]

[ "def", "add_new_reset_method", "(", "obj", ")", ":", "#", "# Create and assign automatically generated reset() method", "#", "def", "new_reset", "(", "self", ",", "seed", "=", "None", ")", ":", "logger", ".", "debug", "(", "f'[EEE] Inside automatically generated reset() method for {self} (seed={seed})'", ")", "if", "seed", "is", "not", "None", ":", "self", ".", "seed_generator", ".", "reset", "(", "seed", ")", "for", "name", ",", "gen", "in", "self", ".", "field_gens", ".", "items", "(", ")", ":", "next_seed", "=", "next", "(", "self", ".", "seed_generator", ")", "gen", ".", "reset", "(", "next_seed", ")", "# TODO: the following should be covered by the newly added", "# reset() method in IndependentGeneratorMeta. However, for", "# some reason we can't call this via the usual `orig_reset()`", "# pattern, so we have to duplicate this here. Not ideal...", "for", "c", "in", "self", ".", "_dependent_generators", ":", "c", ".", "reset_dependent_generator", "(", "seed", ")", "return", "self", "obj", ".", "reset", "=", "new_reset" ]

[ "Attach", "a", "new", "reset", "()", "method", "to", "obj", "which", "resets", "the", "internal", "seed", "generator", "of", "obj", "and", "then", "resets", "each", "of", "its", "constituent", "field", "generators", "found", "in", "obj", ".", "field_gens", "." ]

[ "def", "pyx_is_cplus", "(", "path", ")", ":", "for", "line", "in", "open", "(", "path", ",", "'rt'", ")", ":", "if", "line", ".", "startswith", "(", "'#'", ")", "and", "'='", "in", "line", ":", "splitted", "=", "line", ".", "split", "(", "'='", ")", "if", "len", "(", "splitted", ")", "!=", "2", ":", "continue", "lhs", ",", "rhs", "=", "splitted", "if", "lhs", ".", "strip", "(", ")", ".", "split", "(", ")", "[", "-", "1", "]", ".", "lower", "(", ")", "==", "'language'", "and", "rhs", ".", "strip", "(", ")", ".", "split", "(", ")", "[", "0", "]", ".", "lower", "(", ")", "==", "'c++'", ":", "return", "True", "return", "False" ]

[ "Inspect", "a", "Cython", "source", "file", "(", ".", "pyx", ")", "and", "look", "for", "comment", "line", "like", ":" ]

[ "def", "setDraw", "(", "self", ",", "p0", "=", "(", "0", ",", "0", ")", ",", "angle", "=", "0", ",", "mode", "=", "'plain'", ")", ":", "sconf", "=", "self", ".", "getConfig", "(", "type", "=", "'simu'", ")", "if", "'l'", "in", "sconf", ":", "self", ".", "_style", "[", "'length'", "]", "=", "float", "(", "sconf", "[", "'l'", "]", ")", "else", ":", "self", ".", "_style", "[", "'length'", "]", "=", "0", "self", ".", "_style", "[", "'angle'", "]", "=", "angle", "_theta", "=", "angle", "/", "180.0", "*", "np", ".", "pi", "# deg to rad", "_length", "=", "self", ".", "_style", "[", "'length'", "]", "_lw", "=", "self", ".", "_style", "[", "'lw'", "]", "_fancyc", "=", "self", ".", "_style", "[", "'color'", "]", "_alpha", "=", "self", ".", "_style", "[", "'alpha'", "]", "_plainc", "=", "MagBlock", ".", "_MagBlock__styleconfig_dict", "[", "'drift'", "]", "[", "'color'", "]", "#", "# |", "# --p0--p1--", "# |", "# ", "if", "mode", "==", "'plain'", ":", "x0", ",", "y0", "=", "p0", "x1", ",", "y1", "=", "x0", "+", "_length", ",", "y0", "+", "_length", "*", "np", ".", "tan", "(", "_theta", ")", "pc", "=", "x0", "+", "0.5", "*", "_length", ",", "(", "y0", "+", "y1", ")", "*", "0.5", "vs", "=", "[", "(", "x0", ",", "y0", ")", ",", "(", "x1", ",", "y1", ")", "]", "cs", "=", "[", "Path", ".", "MOVETO", ",", "Path", ".", "LINETO", "]", "pth", "=", "Path", "(", "vs", ",", "cs", ")", "ptch", "=", "patches", ".", "PathPatch", "(", "pth", ",", "lw", "=", "_lw", ",", "fc", "=", "_plainc", ",", "ec", "=", "_plainc", ",", "alpha", "=", "_alpha", ")", "self", ".", "_patches", "=", "[", "]", "self", ".", "_patches", ".", "append", "(", "ptch", ")", "self", ".", "next_p0", "=", "x1", ",", "y1", "self", ".", "next_inc_angle", "=", "0", "else", ":", "# fancy mode, same as plain, could be more fancy(Apr.08, 2016)", "x0", ",", "y0", "=", "p0", "# x1, y1 = x0 + _length, y0 + _length * np.tan(_theta)", "# pc = x0 + 0.5*_length, (y0 + y1)*0.5", "x1", ",", "y1", "=", "x0", ",", "y0", "+", "0.5", "*", "_length", "x2", ",", "y2", "=", "x1", "+", "1.", "/", "3.0", "*", "_length", ",", "y1", "x3", ",", "y3", "=", "x2", "+", "1.", "/", "3.0", "*", "_length", ",", "y1", "x4", ",", "y4", "=", "x3", "+", "1.", "/", "3.0", "*", "_length", ",", "y1", "x5", ",", "y5", "=", "x4", ",", "y0", "x6", ",", "y6", "=", "x5", ",", "y5", "-", "0.5", "*", "_length", "x7", ",", "y7", "=", "x3", ",", "y6", "x8", ",", "y8", "=", "x3", ",", "y7", "+", "1.", "/", "3.0", "*", "_length", "x9", ",", "y9", "=", "x2", ",", "y8", "x10", ",", "y10", "=", "x9", ",", "y7", "x11", ",", "y11", "=", "x0", ",", "y7", "pc", "=", "(", "x0", "+", "x5", ")", "*", "0.5", ",", "(", "y0", "+", "y5", ")", "*", "0.5", "verts1", "=", "[", "(", "x0", ",", "y0", ")", ",", "(", "x1", ",", "y1", ")", ",", "(", "x2", ",", "y2", ")", ",", "pc", ",", "(", "x3", ",", "y3", ")", ",", "(", "x4", ",", "y4", ")", ",", "(", "x5", ",", "y5", ")", ",", "(", "x6", ",", "y6", ")", ",", "(", "x7", ",", "y7", ")", ",", "(", "x8", ",", "y8", ")", ",", "(", "x9", ",", "y9", ")", ",", "(", "x10", ",", "y10", ")", ",", "(", "x11", ",", "y11", ")", ",", "(", "x0", ",", "y0", ")", ",", "]", "codes1", "=", "[", "Path", ".", "MOVETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "LINETO", ",", "Path", ".", "CLOSEPOLY", ",", "]", "pth", "=", "Path", "(", "verts1", ",", "codes1", ")", "ptch", "=", "patches", ".", "PathPatch", "(", "pth", ",", "lw", "=", "_lw", ",", "fc", "=", "_fancyc", ",", "ec", "=", "_fancyc", ",", "alpha", "=", "_alpha", ")", "self", ".", "_patches", "=", "[", "]", "self", ".", "_patches", ".", "append", "(", "ptch", ")", "# self.next_p0 = x1, y1", "self", ".", "next_p0", "=", "x5", ",", "y5", "self", ".", "next_inc_angle", "=", "0", "self", ".", "_anote", "=", "{", "'xypos'", ":", "pc", ",", "'textpos'", ":", "pc", ",", "'name'", ":", "self", ".", "name", ".", "upper", "(", ")", ",", "'type'", ":", "self", ".", "typename", "}" ]

[ "set", "element", "visualization", "drawing", ":", "param", "p0", ":", "start", "drawing", "position", "(", "x", "y", ")", ":", "param", "angle", ":", "angle", "[", "deg", "]", "between", "x", "-", "axis", "angle", "is", "rotating", "from", "x", "-", "axis", "to", "be", "+", "or", "-", "+", ":", "clockwise", "-", ":", "anticlockwise", ":", "param", "mode", ":", "artist", "mode", "plain", "or", "fancy", "plain", "by", "default" ]

[ "def", "dtype_reduce", "(", "dtype", ",", "level", "=", "0", ",", "depth", "=", "0", ")", ":", "dtype", "=", "np", ".", "dtype", "(", "dtype", ")", "fields", "=", "dtype", ".", "fields", "# No fields", "if", "fields", "is", "None", ":", "if", "len", "(", "dtype", ".", "shape", ")", ":", "count", "=", "reduce", "(", "mul", ",", "dtype", ".", "shape", ")", "else", ":", "count", "=", "1", "# size = dtype.itemsize / count", "if", "dtype", ".", "subdtype", ":", "name", "=", "str", "(", "dtype", ".", "subdtype", "[", "0", "]", ")", "else", ":", "name", "=", "str", "(", "dtype", ")", "return", "[", "''", ",", "count", ",", "name", "]", "else", ":", "items", "=", "[", "]", "name", "=", "''", "# Get reduced fields", "for", "key", ",", "value", "in", "fields", ".", "items", "(", ")", ":", "l", "=", "dtype_reduce", "(", "value", "[", "0", "]", ",", "level", ",", "depth", "+", "1", ")", "if", "type", "(", "l", "[", "0", "]", ")", "is", "str", ":", "items", ".", "append", "(", "[", "key", ",", "l", "[", "1", "]", ",", "l", "[", "2", "]", "]", ")", "else", ":", "items", ".", "append", "(", "l", ")", "name", "+=", "key", "+", "','", "# Check if we can reduce item list", "ctype", "=", "None", "count", "=", "0", "for", "i", ",", "item", "in", "enumerate", "(", "items", ")", ":", "# One item is a list, we cannot reduce", "if", "type", "(", "item", "[", "0", "]", ")", "is", "not", "str", ":", "return", "items", "else", ":", "if", "i", "==", "0", ":", "ctype", "=", "item", "[", "2", "]", "count", "+=", "item", "[", "1", "]", "else", ":", "if", "item", "[", "2", "]", "!=", "ctype", ":", "return", "items", "count", "+=", "item", "[", "1", "]", "if", "depth", ">=", "level", ":", "return", "[", "name", ",", "count", ",", "ctype", "]", "else", ":", "return", "items" ]

[ "Try", "to", "reduce", "dtype", "up", "to", "a", "given", "level", "when", "it", "is", "possible" ]

[ "def", "encrypt", "(", "cls", ",", "private_key", ",", "password", ",", "kdf", "=", "None", ",", "iterations", "=", "None", ")", ":", "if", "isinstance", "(", "private_key", ",", "keys", ".", "PrivateKey", ")", ":", "key_bytes", "=", "private_key", ".", "to_bytes", "(", ")", "else", ":", "key_bytes", "=", "HexBytes", "(", "private_key", ")", "if", "kdf", "is", "None", ":", "kdf", "=", "cls", ".", "default_kdf", "password_bytes", "=", "text_if_str", "(", "to_bytes", ",", "password", ")", "assert", "len", "(", "key_bytes", ")", "==", "32", "return", "create_keyfile_json", "(", "key_bytes", ",", "password_bytes", ",", "kdf", "=", "kdf", ",", "iterations", "=", "iterations", ")" ]

[ "Creates", "a", "dictionary", "with", "an", "encrypted", "version", "of", "your", "private", "key", ".", "To", "import", "this", "keyfile", "into", "Ethereum", "clients", "like", "geth", "and", "parity", ":", "encode", "this", "dictionary", "with", ":", "func", ":", "json", ".", "dumps", "and", "save", "it", "to", "disk", "where", "your", "client", "keeps", "key", "files", "." ]

[ "def", "debounce", "(", "wait", ")", ":", "def", "decorator", "(", "fn", ")", ":", "def", "debounced", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "def", "call_it", "(", ")", ":", "fn", "(", "*", "args", ",", "*", "*", "kwargs", ")", "try", ":", "debounced", ".", "t", ".", "cancel", "(", ")", "except", "(", "AttributeError", ")", ":", "pass", "debounced", ".", "t", "=", "threading", ".", "Timer", "(", "wait", ",", "call_it", ")", "debounced", ".", "t", ".", "start", "(", ")", "return", "debounced", "return", "decorator" ]

[ "Decorator", "that", "will", "postpone", "a", "functions", "execution", "until", "after", "wait", "seconds", "have", "elapsed", "since", "the", "last", "time", "it", "was", "invoked", "." ]

[ "def", "merge", "(", "self", ",", "other_cell", ")", ":", "tc_range", "=", "TcRange", "(", "self", ".", "_tc", ",", "other_cell", ".", "_tc", ")", "if", "not", "tc_range", ".", "in_same_table", ":", "raise", "ValueError", "(", "'other_cell from different table'", ")", "if", "tc_range", ".", "contains_merged_cell", ":", "raise", "ValueError", "(", "'range contains one or more merged cells'", ")", "tc_range", ".", "move_content_to_origin", "(", ")", "row_count", ",", "col_count", "=", "tc_range", ".", "dimensions", "for", "tc", "in", "tc_range", ".", "iter_top_row_tcs", "(", ")", ":", "tc", ".", "rowSpan", "=", "row_count", "for", "tc", "in", "tc_range", ".", "iter_left_col_tcs", "(", ")", ":", "tc", ".", "gridSpan", "=", "col_count", "for", "tc", "in", "tc_range", ".", "iter_except_left_col_tcs", "(", ")", ":", "tc", ".", "hMerge", "=", "True", "for", "tc", "in", "tc_range", ".", "iter_except_top_row_tcs", "(", ")", ":", "tc", ".", "vMerge", "=", "True" ]

[ "Create", "merged", "cell", "from", "this", "cell", "to", "*", "other_cell", "*", "." ]

[ "def", "update_cache", "(", "force", "=", "False", ",", "cache_file", "=", "None", ")", ":", "if", "not", "cache_file", ":", "cache_file", "=", "find_config", "(", ")", "cache_config", "=", "devpipeline_configure", ".", "parser", ".", "read_config", "(", "cache_file", ")", "cache", "=", "devpipeline_configure", ".", "cache", ".", "_CachedConfig", "(", "cache_config", ",", "cache_file", ")", "if", "force", "or", "_is_outdated", "(", "cache_file", ",", "cache", ")", ":", "cache", "=", "devpipeline_configure", ".", "config", ".", "process_config", "(", "cache_config", ".", "get", "(", "\"DEFAULT\"", ",", "\"dp.build_config\"", ")", ",", "os", ".", "path", ".", "dirname", "(", "cache_file", ")", ",", "\"build.cache\"", ",", "profiles", "=", "cache_config", ".", "get", "(", "\"DEFAULT\"", ",", "\"dp.profile_name\"", ",", "fallback", "=", "None", ")", ",", "overrides", "=", "cache_config", ".", "get", "(", "\"DEFAULT\"", ",", "\"dp.overrides\"", ",", "fallback", "=", "None", ")", ",", ")", "devpipeline_core", ".", "sanitizer", ".", "sanitize", "(", "cache", ",", "lambda", "n", ",", "m", ":", "print", "(", "\"{} [{}]\"", ".", "format", "(", "m", ",", "n", ")", ")", ")", "return", "cache" ]

[ "Load", "a", "build", "cache", "updating", "it", "if", "necessary", "." ]

[ "def", "has_cache", "(", "self", ")", ":", "if", "not", "self", ".", "cache_enabled", ":", "return", "False", "if", "self", ".", "_cache", "is", "None", ":", "self", ".", "build_cache", "(", ")", "return", "True" ]

[ "Intended", "to", "be", "called", "before", "any", "call", "that", "might", "access", "the", "cache", ".", "If", "the", "cache", "is", "not", "selected", "then", "returns", "False", "otherwise", "the", "cache", "is", "build", "if", "needed", "and", "returns", "True", "." ]

[ "def", "add_sub_directory", "(", "self", ",", "key", ",", "path", ")", ":", "sub_dir_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "results_root", ",", "path", ")", "os", ".", "makedirs", "(", "sub_dir_path", ",", "exist_ok", "=", "True", ")", "self", ".", "_directories", "[", "key", "]", "=", "sub_dir_path", "return", "sub_dir_path" ]

[ "Adds", "a", "sub", "-", "directory", "to", "the", "results", "directory", "." ]

[ "def", "check_insert_size", "(", "data", ",", "sample", ")", ":", "## pipe stats output to grep", "cmd1", "=", "[", "ipyrad", ".", "bins", ".", "samtools", ",", "\"stats\"", ",", "sample", ".", "files", ".", "mapped_reads", "]", "cmd2", "=", "[", "\"grep\"", ",", "\"SN\"", "]", "proc1", "=", "sps", ".", "Popen", "(", "cmd1", ",", "stderr", "=", "sps", ".", "STDOUT", ",", "stdout", "=", "sps", ".", "PIPE", ")", "proc2", "=", "sps", ".", "Popen", "(", "cmd2", ",", "stderr", "=", "sps", ".", "STDOUT", ",", "stdout", "=", "sps", ".", "PIPE", ",", "stdin", "=", "proc1", ".", "stdout", ")", "## get piped result", "res", "=", "proc2", ".", "communicate", "(", ")", "[", "0", "]", "## raise exception on failure and do cleanup", "if", "proc2", ".", "returncode", ":", "raise", "IPyradWarningExit", "(", "\"error in %s: %s\"", ",", "cmd2", ",", "res", ")", "## starting vals", "avg_insert", "=", "0", "stdv_insert", "=", "0", "avg_len", "=", "0", "## iterate over results", "for", "line", "in", "res", ".", "split", "(", "\"\\n\"", ")", ":", "if", "\"insert size average\"", "in", "line", ":", "avg_insert", "=", "float", "(", "line", ".", "split", "(", "\":\"", ")", "[", "-", "1", "]", ".", "strip", "(", ")", ")", "elif", "\"insert size standard deviation\"", "in", "line", ":", "## hack to fix sim data when stdv is 0.0. Shouldn't", "## impact real data bcz stdv gets rounded up below", "stdv_insert", "=", "float", "(", "line", ".", "split", "(", "\":\"", ")", "[", "-", "1", "]", ".", "strip", "(", ")", ")", "+", "0.1", "elif", "\"average length\"", "in", "line", ":", "avg_len", "=", "float", "(", "line", ".", "split", "(", "\":\"", ")", "[", "-", "1", "]", ".", "strip", "(", ")", ")", "LOGGER", ".", "debug", "(", "\"avg {} stdv {} avg_len {}\"", ".", "format", "(", "avg_insert", ",", "stdv_insert", ",", "avg_len", ")", ")", "## If all values return successfully set the max inner mate distance.", "## This is tricky. avg_insert is the average length of R1+R2+inner mate", "## distance. avg_len is the average length of a read. If there are lots", "## of reads that overlap then avg_insert will be close to but bigger than", "## avg_len. We are looking for the right value for `bedtools merge -d`", "## which wants to know the max distance between reads. ", "if", "all", "(", "[", "avg_insert", ",", "stdv_insert", ",", "avg_len", "]", ")", ":", "## If 2 * the average length of a read is less than the average", "## insert size then most reads DO NOT overlap", "if", "stdv_insert", "<", "5", ":", "stdv_insert", "=", "5.", "if", "(", "2", "*", "avg_len", ")", "<", "avg_insert", ":", "hack", "=", "avg_insert", "+", "(", "3", "*", "np", ".", "math", ".", "ceil", "(", "stdv_insert", ")", ")", "-", "(", "2", "*", "avg_len", ")", "## If it is > than the average insert size then most reads DO", "## overlap, so we have to calculate inner mate distance a little ", "## differently.", "else", ":", "hack", "=", "(", "avg_insert", "-", "avg_len", ")", "+", "(", "3", "*", "np", ".", "math", ".", "ceil", "(", "stdv_insert", ")", ")", "## set the hackerdict value", "LOGGER", ".", "info", "(", "\"stdv: hacked insert size is %s\"", ",", "hack", ")", "data", ".", "_hackersonly", "[", "\"max_inner_mate_distance\"", "]", "=", "int", "(", "np", ".", "math", ".", "ceil", "(", "hack", ")", ")", "else", ":", "## If something fsck then set a relatively conservative distance", "data", ".", "_hackersonly", "[", "\"max_inner_mate_distance\"", "]", "=", "300", "LOGGER", ".", "debug", "(", "\"inner mate distance for {} - {}\"", ".", "format", "(", "sample", ".", "name", ",", "data", ".", "_hackersonly", "[", "\"max_inner_mate_distance\"", "]", ")", ")" ]

[ "check", "mean", "insert", "size", "for", "this", "sample", "and", "update", "hackersonly", ".", "max_inner_mate_distance", "if", "need", "be", ".", "This", "value", "controls", "how", "far", "apart", "mate", "pairs", "can", "be", "to", "still", "be", "considered", "for", "bedtools", "merging", "downstream", "." ]

[ "def", "int", "(", "self", ",", "item", ",", "default", "=", "None", ")", ":", "try", ":", "item", "=", "self", ".", "__getattr__", "(", "item", ")", "except", "AttributeError", "as", "err", ":", "if", "default", "is", "not", "None", ":", "return", "default", "raise", "err", "return", "int", "(", "item", ")" ]

[ "Return", "value", "of", "key", "as", "an", "int" ]

[ "def", "select", "(", "self", ",", "filter_by", "=", "None", ")", ":", "iterator", "=", "self", ".", "_records", "if", "filter_by", "is", "None", "else", "filter", "(", "filter_by", ",", "self", ".", "_records", ")", "return", "Queryset", "(", "self", ".", "_table", ",", "iterator", ")" ]

[ "Parameters", "----------", "filter_by", ":", "callable", "default", "None", "Callable", "must", "take", "one", "argument", "(", "a", "record", "of", "queryset", ")", "and", "return", "True", "to", "keep", "record", "or", "False", "to", "skip", "it", ".", "Example", ":", ".", "select", "(", "lambda", "x", ":", "x", ".", "name", "==", "my_name", ")", ".", "If", "None", "records", "are", "not", "filtered", "." ]

[ "def", "_add_ssh_key", "(", "ret", ")", ":", "priv", "=", "None", "if", "__opts__", ".", "get", "(", "'ssh_use_home_key'", ")", "and", "os", ".", "path", ".", "isfile", "(", "os", ".", "path", ".", "expanduser", "(", "'~/.ssh/id_rsa'", ")", ")", ":", "priv", "=", "os", ".", "path", ".", "expanduser", "(", "'~/.ssh/id_rsa'", ")", "else", ":", "priv", "=", "__opts__", ".", "get", "(", "'ssh_priv'", ",", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "join", "(", "__opts__", "[", "'pki_dir'", "]", ",", "'ssh'", ",", "'salt-ssh.rsa'", ")", ")", ")", "if", "priv", "and", "os", ".", "path", ".", "isfile", "(", "priv", ")", ":", "ret", "[", "'priv'", "]", "=", "priv" ]

[ "Setups", "the", "salt", "-", "ssh", "minion", "to", "be", "accessed", "with", "salt", "-", "ssh", "default", "key" ]

[ "def", "start", "(", "self", ")", ":", "cert_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "work_dir", ",", "'certificates'", ")", "public_keys_dir", "=", "os", ".", "path", ".", "join", "(", "cert_path", ",", "'public_keys'", ")", "private_keys_dir", "=", "os", ".", "path", ".", "join", "(", "cert_path", ",", "'private_keys'", ")", "client_secret_file", "=", "os", ".", "path", ".", "join", "(", "private_keys_dir", ",", "\"client.key\"", ")", "client_public", ",", "client_secret", "=", "zmq", ".", "auth", ".", "load_certificate", "(", "client_secret_file", ")", "server_public_file", "=", "os", ".", "path", ".", "join", "(", "public_keys_dir", ",", "\"server.key\"", ")", "server_public", ",", "_", "=", "zmq", ".", "auth", ".", "load_certificate", "(", "server_public_file", ")", "self", ".", "outgoing_msg_greenlet", "=", "gevent", ".", "spawn", "(", "self", ".", "outgoing_server_comms", ",", "server_public", ",", "client_public", ",", "client_secret", ")", "self", ".", "outgoing_msg_greenlet", ".", "link_exception", "(", "self", ".", "on_exception", ")", "self", ".", "incoming_msg_greenlet", "=", "gevent", ".", "spawn", "(", "self", ".", "incoming_server_comms", ",", "server_public", ",", "client_public", ",", "client_secret", ")", "self", ".", "incoming_msg_greenlet", ".", "link_exception", "(", "self", ".", "on_exception", ")", "logger", ".", "info", "(", "'Waiting for detailed configuration from Beeswarm server.'", ")", "gevent", ".", "joinall", "(", "[", "self", ".", "outgoing_msg_greenlet", "]", ")" ]

[ "Starts", "services", "." ]

[ "def", "_return_retry_timer", "(", "self", ")", ":", "msg", "=", "'Minion return retry timer set to %s seconds'", "if", "self", ".", "opts", ".", "get", "(", "'return_retry_timer_max'", ")", ":", "try", ":", "random_retry", "=", "randint", "(", "self", ".", "opts", "[", "'return_retry_timer'", "]", ",", "self", ".", "opts", "[", "'return_retry_timer_max'", "]", ")", "retry_msg", "=", "msg", "%", "random_retry", "log", ".", "debug", "(", "'%s (randomized)'", ",", "msg", "%", "random_retry", ")", "return", "random_retry", "except", "ValueError", ":", "# Catch wiseguys using negative integers here", "log", ".", "error", "(", "'Invalid value (return_retry_timer: %s or '", "'return_retry_timer_max: %s). Both must be positive '", "'integers.'", ",", "self", ".", "opts", "[", "'return_retry_timer'", "]", ",", "self", ".", "opts", "[", "'return_retry_timer_max'", "]", ",", ")", "log", ".", "debug", "(", "msg", ",", "DEFAULT_MINION_OPTS", "[", "'return_retry_timer'", "]", ")", "return", "DEFAULT_MINION_OPTS", "[", "'return_retry_timer'", "]", "else", ":", "log", ".", "debug", "(", "msg", ",", "self", ".", "opts", ".", "get", "(", "'return_retry_timer'", ")", ")", "return", "self", ".", "opts", ".", "get", "(", "'return_retry_timer'", ")" ]

[ "Based", "on", "the", "minion", "configuration", "either", "return", "a", "randomized", "timer", "or", "just", "return", "the", "value", "of", "the", "return_retry_timer", "." ]

[ "def", "size", "(", "self", ")", ":", "size", "=", "{", "}", "if", "self", ".", "_w3c", ":", "size", "=", "self", ".", "_execute", "(", "Command", ".", "GET_ELEMENT_RECT", ")", "[", "'value'", "]", "else", ":", "size", "=", "self", ".", "_execute", "(", "Command", ".", "GET_ELEMENT_SIZE", ")", "[", "'value'", "]", "new_size", "=", "{", "\"height\"", ":", "size", "[", "\"height\"", "]", ",", "\"width\"", ":", "size", "[", "\"width\"", "]", "}", "return", "new_size" ]

[ "The", "size", "of", "the", "element", "." ]

[ "def", "clear_n_of_m", "(", "self", ")", ":", "if", "(", "self", ".", "get_n_of_m_metadata", "(", ")", ".", "is_read_only", "(", ")", "or", "self", ".", "get_n_of_m_metadata", "(", ")", ".", "is_required", "(", ")", ")", ":", "raise", "NoAccess", "(", ")", "self", ".", "my_osid_object_form", ".", "_my_map", "[", "'nOfM'", "]", "=", "int", "(", "self", ".", "_n_of_m_metadata", "[", "'default_object_values'", "]", "[", "0", "]", ")" ]

[ "stub" ]

[ "def", "define_association", "(", "self", ",", "rel_id", ",", "source_kind", ",", "source_keys", ",", "source_many", ",", "source_conditional", ",", "source_phrase", ",", "target_kind", ",", "target_keys", ",", "target_many", ",", "target_conditional", ",", "target_phrase", ")", ":", "if", "isinstance", "(", "rel_id", ",", "int", ")", ":", "rel_id", "=", "'R%d'", "%", "rel_id", "source_metaclass", "=", "self", ".", "find_metaclass", "(", "source_kind", ")", "target_metaclass", "=", "self", ".", "find_metaclass", "(", "target_kind", ")", "source_link", "=", "target_metaclass", ".", "add_link", "(", "source_metaclass", ",", "rel_id", ",", "many", "=", "source_many", ",", "phrase", "=", "target_phrase", ",", "conditional", "=", "source_conditional", ")", "target_link", "=", "source_metaclass", ".", "add_link", "(", "target_metaclass", ",", "rel_id", ",", "many", "=", "target_many", ",", "phrase", "=", "source_phrase", ",", "conditional", "=", "target_conditional", ")", "ass", "=", "Association", "(", "rel_id", ",", "source_keys", ",", "source_link", ",", "target_keys", ",", "target_link", ")", "source_link", ".", "key_map", "=", "dict", "(", "zip", "(", "source_keys", ",", "target_keys", ")", ")", "target_link", ".", "key_map", "=", "dict", "(", "zip", "(", "target_keys", ",", "source_keys", ")", ")", "self", ".", "associations", ".", "append", "(", "ass", ")", "return", "ass" ]

[ "Define", "and", "return", "an", "association", "from", "one", "kind", "of", "class", "(", "the", "source", "kind", ")", "to", "some", "other", "kind", "of", "class", "(", "the", "target", "kind", ")", "." ]

[ "def", "__parseThunkData", "(", "self", ",", "thunk", ",", "importSection", ")", ":", "offset", "=", "to_offset", "(", "thunk", ".", "header", ".", "AddressOfData", ",", "importSection", ")", "if", "0xf0000000", "&", "thunk", ".", "header", ".", "AddressOfData", "==", "0x80000000", ":", "thunk", ".", "ordinal", "=", "thunk", ".", "header", ".", "AddressOfData", "&", "0x0fffffff", "else", ":", "ibn", "=", "IMAGE_IMPORT_BY_NAME", ".", "from_buffer", "(", "importSection", ".", "raw", ",", "offset", ")", "checkOffset", "(", "offset", "+", "2", ",", "importSection", ")", "name", "=", "get_str", "(", "importSection", ".", "raw", ",", "offset", "+", "2", ")", "thunk", ".", "importByName", "=", "ImportByNameData", "(", "header", "=", "ibn", ",", "hint", "=", "ibn", ".", "Hint", ",", "name", "=", "name", ")" ]

[ "Parses", "the", "data", "of", "a", "thunk", "and", "sets", "the", "data" ]

[ "def", "Md5", "(", "depends_on", ",", "encoder", "=", "ENC_STR_DEFAULT", ",", "fuzzable", "=", "False", ",", "name", "=", "None", ")", ":", "return", "Hash", "(", "depends_on", "=", "depends_on", ",", "algorithm", "=", "'md5'", ",", "encoder", "=", "encoder", ",", "fuzzable", "=", "fuzzable", ",", "name", "=", "name", ")" ]

[ ":", "rtype", ":", ":", "class", ":", "~kitty", ".", "model", ".", "low_level", ".", "calculated", ".", "Hash", ":", "return", ":", "MD5", "hash", "field" ]

[ "def", "_NotifyLegacy", "(", "username", ",", "notification_type", ",", "message", ",", "object_reference", ")", ":", "try", ":", "with", "aff4", ".", "FACTORY", ".", "Open", "(", "aff4", ".", "ROOT_URN", ".", "Add", "(", "\"users\"", ")", ".", "Add", "(", "username", ")", ",", "aff4_type", "=", "aff4_users", ".", "GRRUser", ",", "mode", "=", "\"rw\"", ")", "as", "fd", ":", "args", "=", "_MapLegacyArgs", "(", "notification_type", ",", "message", ",", "object_reference", ")", "args", "[", "0", "]", "+=", "\":%s\"", "%", "notification_type", "fd", ".", "Notify", "(", "*", "args", ")", "except", "aff4", ".", "InstantiationError", ":", "logging", ".", "error", "(", "\"Trying to notify non-existent user: %s\"", ",", "username", ")" ]

[ "Schedules", "a", "legacy", "AFF4", "user", "notification", "." ]

[ "def", "push", "(", "self", ",", "local", ":", "_PATH", "=", "'LICENSE'", ",", "remote", ":", "_PATH", "=", "'/sdcard/LICENSE'", ")", "->", "None", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "local", ")", ":", "raise", "FileNotFoundError", "(", "f'Local {local!r} does not exist.'", ")", "self", ".", "_execute", "(", "'-s'", ",", "self", ".", "device_sn", ",", "'push'", ",", "local", ",", "remote", ")" ]

[ "Copy", "local", "files", "/", "directories", "to", "device", "." ]

[ "def", "main", "(", ")", ":", "if", "len", "(", "sys", ".", "argv", ")", "==", "2", ":", "fname", "=", "sys", ".", "argv", "[", "1", "]", "data", "=", "json", ".", "load", "(", "open", "(", "fname", ",", "'rb'", ")", ")", "else", ":", "data", "=", "json", ".", "loads", "(", "sys", ".", "stdin", ".", "read", "(", ")", ")", "print", "(", "pydeps2reqs", "(", "data", ")", ")" ]

[ "Cli", "entrypoint", "." ]

[ "def", "_receiving", "(", "self", ")", ":", "while", "self", ".", "_is_running", ":", "try", ":", "rlist", ",", "wlist", ",", "xlist", "=", "select", ".", "select", "(", "self", ".", "_listening", ",", "[", "]", ",", "[", "]", ",", "self", ".", "_select_timeout", ")", "except", ":", "self", ".", "exception", "(", "\"Failed to select socket\"", ")", "continue", "for", "sock", "in", "rlist", ":", "try", ":", "self", ".", "_get_packet", "(", "sock", ")", "except", ":", "self", ".", "exception", "(", "\"Failed to receive packet\"", ")" ]

[ "Receiving", "loop" ]

[ "def", "send", "(", "self", ",", "load", ",", "tries", "=", "None", ",", "timeout", "=", "None", ",", "raw", "=", "False", ")", ":", "# pylint: disable=unused-argument", "if", "'cmd'", "not", "in", "load", ":", "log", ".", "error", "(", "'Malformed request, no cmd: %s'", ",", "load", ")", "return", "{", "}", "cmd", "=", "load", "[", "'cmd'", "]", ".", "lstrip", "(", "'_'", ")", "if", "cmd", "in", "self", ".", "cmd_stub", ":", "return", "self", ".", "cmd_stub", "[", "cmd", "]", "if", "not", "hasattr", "(", "self", ".", "fs", ",", "cmd", ")", ":", "log", ".", "error", "(", "'Malformed request, invalid cmd: %s'", ",", "load", ")", "return", "{", "}", "return", "getattr", "(", "self", ".", "fs", ",", "cmd", ")", "(", "load", ")" ]

[ "Emulate", "the", "channel", "send", "method", "the", "tries", "and", "timeout", "are", "not", "used" ]

[ "def", "clear_completion", "(", "self", ")", ":", "# Implemented from template for osid.grading.GradeSystemForm.clear_lowest_numeric_score", "if", "(", "self", ".", "get_completion_metadata", "(", ")", ".", "is_read_only", "(", ")", "or", "self", ".", "get_completion_metadata", "(", ")", ".", "is_required", "(", ")", ")", ":", "raise", "errors", ".", "NoAccess", "(", ")", "self", ".", "_my_map", "[", "'completion'", "]", "=", "self", ".", "_completion_default" ]

[ "Clears", "the", "completion", "." ]

[ "def", "update_hash", "(", "cls", ",", "filelike", ",", "digest", ")", ":", "block_size", "=", "digest", ".", "block_size", "*", "1024", "for", "chunk", "in", "iter", "(", "lambda", ":", "filelike", ".", "read", "(", "block_size", ")", ",", "b''", ")", ":", "digest", ".", "update", "(", "chunk", ")" ]

[ "Update", "the", "digest", "of", "a", "single", "file", "in", "a", "memory", "-", "efficient", "manner", "." ]

[ "def", "rel_path", "(", "self", ",", "other", ")", ":", "# This complicated and expensive method, which constructs relative", "# paths between arbitrary Node.FS objects, is no longer used", "# by SCons itself. It was introduced to store dependency paths", "# in .sconsign files relative to the target, but that ended up", "# being significantly inefficient.", "#", "# We're continuing to support the method because some SConstruct", "# files out there started using it when it was available, and", "# we're all about backwards compatibility..", "try", ":", "memo_dict", "=", "self", ".", "_memo", "[", "'rel_path'", "]", "except", "KeyError", ":", "memo_dict", "=", "{", "}", "self", ".", "_memo", "[", "'rel_path'", "]", "=", "memo_dict", "else", ":", "try", ":", "return", "memo_dict", "[", "other", "]", "except", "KeyError", ":", "pass", "if", "self", "is", "other", ":", "result", "=", "'.'", "elif", "not", "other", "in", "self", ".", "_path_elements", ":", "try", ":", "other_dir", "=", "other", ".", "get_dir", "(", ")", "except", "AttributeError", ":", "result", "=", "str", "(", "other", ")", "else", ":", "if", "other_dir", "is", "None", ":", "result", "=", "other", ".", "name", "else", ":", "dir_rel_path", "=", "self", ".", "rel_path", "(", "other_dir", ")", "if", "dir_rel_path", "==", "'.'", ":", "result", "=", "other", ".", "name", "else", ":", "result", "=", "dir_rel_path", "+", "OS_SEP", "+", "other", ".", "name", "else", ":", "i", "=", "self", ".", "_path_elements", ".", "index", "(", "other", ")", "+", "1", "path_elems", "=", "[", "'..'", "]", "*", "(", "len", "(", "self", ".", "_path_elements", ")", "-", "i", ")", "+", "[", "n", ".", "name", "for", "n", "in", "other", ".", "_path_elements", "[", "i", ":", "]", "]", "result", "=", "OS_SEP", ".", "join", "(", "path_elems", ")", "memo_dict", "[", "other", "]", "=", "result", "return", "result" ]

[ "Return", "a", "path", "to", "other", "relative", "to", "this", "directory", "." ]

[ "def", "select_paths", "(", "cls", ",", "dataset", ",", "selection", ")", ":", "return", "[", "s", "[", "0", "]", "for", "s", "in", "np", ".", "array", "(", "[", "{", "0", ":", "p", "}", "for", "p", "in", "dataset", ".", "data", "]", ")", "[", "selection", "]", "]" ]

[ "Allows", "selecting", "paths", "with", "usual", "NumPy", "slicing", "index", "." ]

[ "def", "set_neighbor_in_filter", "(", "neigh_ip_address", ",", "filters", ")", ":", "core", "=", "CORE_MANAGER", ".", "get_core_service", "(", ")", "peer", "=", "core", ".", "peer_manager", ".", "get_by_addr", "(", "neigh_ip_address", ")", "peer", ".", "in_filters", "=", "filters", "return", "True" ]

[ "Returns", "a", "neighbor", "in_filter", "for", "given", "ip", "address", "if", "exists", "." ]

[ "def", "create_information", "(", "self", ")", ":", "info", "=", "self", ".", "_info_type", "(", ")", "(", "origin", "=", "self", ",", "contents", "=", "self", ".", "_contents", "(", ")", ")", "return", "info" ]

[ "Create", "new", "infos", "on", "demand", "." ]

[ "def", "get_gpg_home", "(", "appname", ",", "config_dir", "=", "None", ")", ":", "assert", "is_valid_appname", "(", "appname", ")", "config_dir", "=", "get_config_dir", "(", "config_dir", ")", "path", "=", "os", ".", "path", ".", "join", "(", "config_dir", ",", "\"gpgkeys\"", ",", "appname", ")", "return", "path" ]

[ "Get", "the", "GPG", "keyring", "directory", "for", "a", "particular", "application", ".", "Return", "the", "path", "." ]

[ "def", "police_priority_map_conform_map_pri7_conform", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "police_priority_map", "=", "ET", ".", "SubElement", "(", "config", ",", "\"police-priority-map\"", ",", "xmlns", "=", "\"urn:brocade.com:mgmt:brocade-policer\"", ")", "name_key", "=", "ET", ".", "SubElement", "(", "police_priority_map", ",", "\"name\"", ")", "name_key", ".", "text", "=", "kwargs", ".", "pop", "(", "'name'", ")", "conform", "=", "ET", ".", "SubElement", "(", "police_priority_map", ",", "\"conform\"", ")", "map_pri7_conform", "=", "ET", ".", "SubElement", "(", "conform", ",", "\"map-pri7-conform\"", ")", "map_pri7_conform", ".", "text", "=", "kwargs", ".", "pop", "(", "'map_pri7_conform'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "convert_gempak_color", "(", "c", ",", "style", "=", "'psc'", ")", ":", "def", "normalize", "(", "x", ")", ":", "\"\"\"Transform input x to an int in range 0 to 31 consistent with GEMPAK color quirks.\"\"\"", "x", "=", "int", "(", "x", ")", "if", "x", "<", "0", "or", "x", "==", "101", ":", "x", "=", "0", "else", ":", "x", "=", "x", "%", "32", "return", "x", "# Define GEMPAK colors (Matplotlib doesn't appear to like numbered variants)", "cols", "=", "[", "'white'", ",", "# 0/32", "'black'", ",", "# 1", "'red'", ",", "# 2", "'green'", ",", "# 3", "'blue'", ",", "# 4", "'yellow'", ",", "# 5", "'cyan'", ",", "# 6", "'magenta'", ",", "# 7", "'#CD6839'", ",", "# 8 (sienna3)", "'#FF8247'", ",", "# 9 (sienna1)", "'#FFA54F'", ",", "# 10 (tan1)", "'#FFAEB9'", ",", "# 11 (LightPink1)", "'#FF6A6A'", ",", "# 12 (IndianRed1)", "'#EE2C2C'", ",", "# 13 (firebrick2)", "'#8B0000'", ",", "# 14 (red4)", "'#CD0000'", ",", "# 15 (red3)", "'#EE4000'", ",", "# 16 (OrangeRed2)", "'#FF7F00'", ",", "# 17 (DarkOrange1)", "'#CD8500'", ",", "# 18 (orange3)", "'gold'", ",", "# 19", "'#EEEE00'", ",", "# 20 (yellow2)", "'chartreuse'", ",", "# 21", "'#00CD00'", ",", "# 22 (green3)", "'#008B00'", ",", "# 23 (green4)", "'#104E8B'", ",", "# 24 (DodgerBlue4)", "'DodgerBlue'", ",", "# 25", "'#00B2EE'", ",", "# 26 (DeepSkyBlue2)", "'#00EEEE'", ",", "# 27 (cyan2)", "'#8968CD'", ",", "# 28 (MediumPurple3)", "'#912CEE'", ",", "# 29 (purple2)", "'#8B008B'", ",", "# 30 (magenta4)", "'bisque'", "]", "# 31", "if", "style", "!=", "'psc'", ":", "if", "style", "==", "'xw'", ":", "cols", "[", "0", "]", "=", "'black'", "cols", "[", "1", "]", "=", "'bisque'", "cols", "[", "31", "]", "=", "'white'", "else", ":", "raise", "ValueError", "(", "'Unknown style parameter'", ")", "try", ":", "c_list", "=", "list", "(", "c", ")", "res", "=", "[", "cols", "[", "normalize", "(", "x", ")", "]", "for", "x", "in", "c_list", "]", "except", "TypeError", ":", "res", "=", "cols", "[", "normalize", "(", "c", ")", "]", "return", "res" ]

[ "Convert", "GEMPAK", "color", "numbers", "into", "corresponding", "Matplotlib", "colors", "." ]

[ "def", "register_entrypoints", "(", "self", ")", ":", "for", "spec", "in", "iter_entry_points", "(", "self", ".", "entry_point_group", ")", ":", "format_properties", "=", "{", "\"name\"", ":", "spec", ".", "name", "}", "try", ":", "format_properties", ".", "update", "(", "spec", ".", "load", "(", ")", ")", "except", "(", "DistributionNotFound", ",", "ImportError", ")", "as", "err", ":", "self", ".", "log", ".", "info", "(", "\"ipymd format {} could not be loaded: {}\"", ".", "format", "(", "spec", ".", "name", ",", "err", ")", ")", "continue", "self", ".", "register", "(", "*", "*", "format_properties", ")", "return", "self" ]

[ "Look", "through", "the", "setup_tools", "entry_points", "and", "load", "all", "of", "the", "formats", "." ]

[ "def", "start", "(", "name", ")", ":", "ret", "=", "{", "}", "cmd", "=", "'{0} startvm {1}'", ".", "format", "(", "vboxcmd", "(", ")", ",", "name", ")", "ret", "=", "salt", ".", "modules", ".", "cmdmod", ".", "run", "(", "cmd", ")", ".", "splitlines", "(", ")", "return", "ret" ]

[ "Start", "a", "VM" ]

[ "def", "render", "(", "template", ",", "*", "*", "kwargs", ")", ":", "import", "jinja2", "import", "os", ".", "path", "as", "path", "searchpath", "=", "path", ".", "join", "(", "path", ".", "dirname", "(", "__file__", ")", ",", "\"templates\"", ")", "loader", "=", "jinja2", ".", "FileSystemLoader", "(", "searchpath", "=", "searchpath", ")", "env", "=", "jinja2", ".", "Environment", "(", "loader", "=", "loader", ")", "temp", "=", "env", ".", "get_template", "(", "template", ")", "return", "temp", ".", "render", "(", "*", "*", "kwargs", ")" ]

[ "Renders", "the", "HTML", "containing", "provided", "summaries", ".", "The", "summary", "has", "to", "be", "an", "instance", "of", "summary", ".", "Summary", "or", "at", "least", "contain", "similar", "properties", ":", "title", "image", "url", "description", "and", "collections", ":", "titles", "images", "descriptions", "." ]

[ "def", "divmod", "(", "x", ",", "y", ",", "context", "=", "None", ")", ":", "return", "floordiv", "(", "x", ",", "y", ",", "context", "=", "context", ")", ",", "mod", "(", "x", ",", "y", ",", "context", "=", "context", ")" ]

[ "Return", "the", "pair", "(", "floordiv", "(", "x", "y", "context", ")", "mod", "(", "x", "y", "context", "))", "." ]

[ "def", "jamieson_pst", "(", "v", ",", "v0", ",", "c0", ",", "s", ",", "gamma0", ",", "q", ",", "theta0", ",", "n", ",", "z", ",", "mass", ",", "c_v", ",", "three_r", "=", "3.", "*", "constants", ".", "R", ",", "t_ref", "=", "300.", ")", ":", "rho", "=", "mass", "/", "vol_uc2mol", "(", "v", ",", "z", ")", "*", "1.e-6", "rho0", "=", "mass", "/", "vol_uc2mol", "(", "v0", ",", "z", ")", "*", "1.e-6", "p_h", "=", "hugoniot_p", "(", "rho", ",", "rho0", ",", "c0", ",", "s", ")", "p_th_h", "=", "jamieson_pth", "(", "v", ",", "v0", ",", "c0", ",", "s", ",", "gamma0", ",", "q", ",", "theta0", ",", "n", ",", "z", ",", "mass", ",", "c_v", ",", "three_r", "=", "three_r", ",", "t_ref", "=", "t_ref", ")", "p_st", "=", "p_h", "-", "p_th_h", "return", "p_st" ]

[ "calculate", "static", "pressure", "at", "300", "K", "from", "Hugoniot", "data", "using", "the", "constq", "formulation" ]

[ "def", "run", "(", "self", ",", "data", ",", "max_epochs", "=", "1", ")", ":", "self", ".", "state", "=", "State", "(", "dataloader", "=", "data", ",", "epoch", "=", "0", ",", "max_epochs", "=", "max_epochs", ",", "metrics", "=", "{", "}", ")", "try", ":", "self", ".", "_logger", ".", "info", "(", "\"Engine run starting with max_epochs={}.\"", ".", "format", "(", "max_epochs", ")", ")", "start_time", "=", "time", ".", "time", "(", ")", "self", ".", "_fire_event", "(", "Events", ".", "STARTED", ")", "while", "self", ".", "state", ".", "epoch", "<", "max_epochs", "and", "not", "self", ".", "should_terminate", ":", "self", ".", "state", ".", "epoch", "+=", "1", "self", ".", "_fire_event", "(", "Events", ".", "EPOCH_STARTED", ")", "hours", ",", "mins", ",", "secs", "=", "self", ".", "_run_once_on_dataset", "(", ")", "self", ".", "_logger", ".", "info", "(", "\"Epoch[%s] Complete. Time taken: %02d:%02d:%02d\"", ",", "self", ".", "state", ".", "epoch", ",", "hours", ",", "mins", ",", "secs", ")", "if", "self", ".", "should_terminate", ":", "break", "self", ".", "_fire_event", "(", "Events", ".", "EPOCH_COMPLETED", ")", "self", ".", "_fire_event", "(", "Events", ".", "COMPLETED", ")", "time_taken", "=", "time", ".", "time", "(", ")", "-", "start_time", "hours", ",", "mins", ",", "secs", "=", "_to_hours_mins_secs", "(", "time_taken", ")", "self", ".", "_logger", ".", "info", "(", "\"Engine run complete. Time taken %02d:%02d:%02d\"", "%", "(", "hours", ",", "mins", ",", "secs", ")", ")", "except", "BaseException", "as", "e", ":", "self", ".", "_logger", ".", "error", "(", "\"Engine run is terminating due to exception: %s.\"", ",", "str", "(", "e", ")", ")", "self", ".", "_handle_exception", "(", "e", ")", "return", "self", ".", "state" ]

[ "Runs", "the", "process_function", "over", "the", "passed", "data", "." ]

[ "def", "clean", "(", "self", ",", "remove_working_directory", "=", "True", ")", ":", "if", "remove_working_directory", "is", "not", "None", ":", "self", ".", "log", "(", "u\"Removing working directory... \"", ")", "gf", ".", "delete_directory", "(", "self", ".", "working_directory", ")", "self", ".", "working_directory", "=", "None", "self", ".", "log", "(", "u\"Removing working directory... done\"", ")", "self", ".", "log", "(", "u\"Removing temporary directory... \"", ")", "gf", ".", "delete_directory", "(", "self", ".", "tmp_directory", ")", "self", ".", "tmp_directory", "=", "None", "self", ".", "log", "(", "u\"Removing temporary directory... done\"", ")" ]

[ "Remove", "the", "temporary", "directory", ".", "If", "remove_working_directory", "is", "True", "remove", "the", "working", "directory", "as", "well", "otherwise", "just", "remove", "the", "temporary", "directory", "." ]

[ "def", "countdown", "(", "template", ",", "duration", "=", "datetime", ".", "timedelta", "(", "seconds", "=", "5", ")", ")", ":", "now", "=", "datetime", ".", "datetime", ".", "now", "(", ")", "deadline", "=", "now", "+", "duration", "remaining", "=", "deadline", "-", "datetime", ".", "datetime", ".", "now", "(", ")", "while", "remaining", ":", "remaining", "=", "deadline", "-", "datetime", ".", "datetime", ".", "now", "(", ")", "remaining", "=", "max", "(", "datetime", ".", "timedelta", "(", ")", ",", "remaining", ")", "msg", "=", "template", ".", "format", "(", "remaining", ".", "total_seconds", "(", ")", ")", "print", "(", "msg", ",", "end", "=", "' '", "*", "10", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "time", ".", "sleep", "(", ".1", ")", "print", "(", "'\\b'", "*", "80", ",", "end", "=", "''", ")", "sys", ".", "stdout", ".", "flush", "(", ")", "print", "(", ")" ]

[ "Do", "a", "countdown", "for", "duration", "printing", "the", "template", "(", "which", "may", "accept", "one", "positional", "argument", ")", ".", "Template", "should", "be", "something", "like", "countdown", "complete", "in", "{}", "seconds", "." ]

[ "def", "delete", "(", "self", ",", "main_type", ",", "sub_type", ",", "unique_id", ",", "owner", "=", "None", ")", ":", "params", "=", "{", "'owner'", ":", "owner", "}", "if", "owner", "else", "{", "}", "if", "not", "sub_type", ":", "url", "=", "'/v2/{}/{}'", ".", "format", "(", "main_type", ",", "unique_id", ")", "else", ":", "url", "=", "'/v2/{}/{}/{}'", ".", "format", "(", "main_type", ",", "sub_type", ",", "unique_id", ")", "return", "self", ".", "tcex", ".", "session", ".", "delete", "(", "url", ",", "params", "=", "params", ")" ]

[ "Deletes", "the", "Indicator", "/", "Group", "/", "Victim", "or", "Security", "Label", "Args", ":", "main_type", ":", "sub_type", ":", "unique_id", ":", "owner", ":" ]

[ "def", "serialize_value", "(", "value", ",", "ty", ")", ":", "ty", "=", "ty", ".", "upper", "(", ")", "null_value", "=", "{", "'BOOLEAN'", ":", "False", ",", "'INTEGER'", ":", "0", ",", "'REAL'", ":", "0.0", ",", "'STRING'", ":", "''", ",", "'UNIQUE_ID'", ":", "0", "}", "transfer_fn", "=", "{", "'BOOLEAN'", ":", "lambda", "v", ":", "'%d'", "%", "int", "(", "v", ")", ",", "'INTEGER'", ":", "lambda", "v", ":", "'%d'", "%", "v", ",", "'REAL'", ":", "lambda", "v", ":", "'%f'", "%", "v", ",", "'STRING'", ":", "lambda", "v", ":", "\"'%s'\"", "%", "v", ".", "replace", "(", "\"'\"", ",", "\"''\"", ")", ",", "'UNIQUE_ID'", ":", "lambda", "v", ":", "'\"%s\"'", "%", "uuid", ".", "UUID", "(", "int", "=", "v", ")", "}", "if", "value", "is", "None", ":", "value", "=", "null_value", "[", "ty", "]", "return", "transfer_fn", "[", "ty", "]", "(", "value", ")" ]

[ "Serialize", "a", "value", "from", "an", "xtuml", "metamodel", "instance", "." ]

[ "def", "__Build", "(", "leaves", ")", ":", "if", "len", "(", "leaves", ")", "<", "1", ":", "raise", "Exception", "(", "'Leaves must have length'", ")", "if", "len", "(", "leaves", ")", "==", "1", ":", "return", "leaves", "[", "0", "]", "num_parents", "=", "int", "(", "(", "len", "(", "leaves", ")", "+", "1", ")", "/", "2", ")", "parents", "=", "[", "MerkleTreeNode", "(", ")", "for", "i", "in", "range", "(", "0", ",", "num_parents", ")", "]", "for", "i", "in", "range", "(", "0", ",", "num_parents", ")", ":", "node", "=", "parents", "[", "i", "]", "node", ".", "LeftChild", "=", "leaves", "[", "i", "*", "2", "]", "leaves", "[", "i", "*", "2", "]", ".", "Parent", "=", "node", "if", "(", "i", "*", "2", "+", "1", "==", "len", "(", "leaves", ")", ")", ":", "node", ".", "RightChild", "=", "node", ".", "LeftChild", "else", ":", "node", ".", "RightChild", "=", "leaves", "[", "i", "*", "2", "+", "1", "]", "leaves", "[", "i", "*", "2", "+", "1", "]", ".", "Parent", "=", "node", "hasharray", "=", "bytearray", "(", "node", ".", "LeftChild", ".", "Hash", ".", "ToArray", "(", ")", "+", "node", ".", "RightChild", ".", "Hash", ".", "ToArray", "(", ")", ")", "node", ".", "Hash", "=", "UInt256", "(", "data", "=", "Crypto", ".", "Hash256", "(", "hasharray", ")", ")", "return", "MerkleTree", ".", "__Build", "(", "parents", ")" ]

[ "Build", "the", "merkle", "tree", "." ]

[ "def", "utcnow", "(", "cls", ")", ":", "obj", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", "obj", "=", "cls", "(", "obj", ",", "tzinfo", "=", "pytz", ".", "utc", ")", "return", "obj" ]

[ "Return", "a", "new", "datetime", "representing", "UTC", "day", "and", "time", "." ]

[ "def", "iri_to_uri", "(", "value", ",", "normalize", "=", "False", ")", ":", "if", "not", "isinstance", "(", "value", ",", "str_cls", ")", ":", "raise", "TypeError", "(", "unwrap", "(", "'''\n value must be a unicode string, not %s\n '''", ",", "type_name", "(", "value", ")", ")", ")", "scheme", "=", "None", "# Python 2.6 doesn't split properly is the URL doesn't start with http:// or https://", "if", "sys", ".", "version_info", "<", "(", "2", ",", "7", ")", "and", "not", "value", ".", "startswith", "(", "'http://'", ")", "and", "not", "value", ".", "startswith", "(", "'https://'", ")", ":", "real_prefix", "=", "None", "prefix_match", "=", "re", ".", "match", "(", "'^[^:]*://'", ",", "value", ")", "if", "prefix_match", ":", "real_prefix", "=", "prefix_match", ".", "group", "(", "0", ")", "value", "=", "'http://'", "+", "value", "[", "len", "(", "real_prefix", ")", ":", "]", "parsed", "=", "urlsplit", "(", "value", ")", "if", "real_prefix", ":", "value", "=", "real_prefix", "+", "value", "[", "7", ":", "]", "scheme", "=", "_urlquote", "(", "real_prefix", "[", ":", "-", "3", "]", ")", "else", ":", "parsed", "=", "urlsplit", "(", "value", ")", "if", "scheme", "is", "None", ":", "scheme", "=", "_urlquote", "(", "parsed", ".", "scheme", ")", "hostname", "=", "parsed", ".", "hostname", "if", "hostname", "is", "not", "None", ":", "hostname", "=", "hostname", ".", "encode", "(", "'idna'", ")", "# RFC 3986 allows userinfo to contain sub-delims", "username", "=", "_urlquote", "(", "parsed", ".", "username", ",", "safe", "=", "'!$&\\'()*+,;='", ")", "password", "=", "_urlquote", "(", "parsed", ".", "password", ",", "safe", "=", "'!$&\\'()*+,;='", ")", "port", "=", "parsed", ".", "port", "if", "port", "is", "not", "None", ":", "port", "=", "str_cls", "(", "port", ")", ".", "encode", "(", "'ascii'", ")", "netloc", "=", "b''", "if", "username", "is", "not", "None", ":", "netloc", "+=", "username", "if", "password", ":", "netloc", "+=", "b':'", "+", "password", "netloc", "+=", "b'@'", "if", "hostname", "is", "not", "None", ":", "netloc", "+=", "hostname", "if", "port", "is", "not", "None", ":", "default_http", "=", "scheme", "==", "b'http'", "and", "port", "==", "b'80'", "default_https", "=", "scheme", "==", "b'https'", "and", "port", "==", "b'443'", "if", "not", "normalize", "or", "(", "not", "default_http", "and", "not", "default_https", ")", ":", "netloc", "+=", "b':'", "+", "port", "# RFC 3986 allows a path to contain sub-delims, plus \"@\" and \":\"", "path", "=", "_urlquote", "(", "parsed", ".", "path", ",", "safe", "=", "'/!$&\\'()*+,;=@:'", ")", "# RFC 3986 allows the query to contain sub-delims, plus \"@\", \":\" , \"/\" and \"?\"", "query", "=", "_urlquote", "(", "parsed", ".", "query", ",", "safe", "=", "'/?!$&\\'()*+,;=@:'", ")", "# RFC 3986 allows the fragment to contain sub-delims, plus \"@\", \":\" , \"/\" and \"?\"", "fragment", "=", "_urlquote", "(", "parsed", ".", "fragment", ",", "safe", "=", "'/?!$&\\'()*+,;=@:'", ")", "if", "normalize", "and", "query", "is", "None", "and", "fragment", "is", "None", "and", "path", "==", "b'/'", ":", "path", "=", "None", "# Python 2.7 compat", "if", "path", "is", "None", ":", "path", "=", "''", "output", "=", "urlunsplit", "(", "(", "scheme", ",", "netloc", ",", "path", ",", "query", ",", "fragment", ")", ")", "if", "isinstance", "(", "output", ",", "str_cls", ")", ":", "output", "=", "output", ".", "encode", "(", "'latin1'", ")", "return", "output" ]

[ "Encodes", "a", "unicode", "IRI", "into", "an", "ASCII", "byte", "string", "URI" ]

[ "def", "display", "(", "text", ",", "mode", "=", "'exec'", ",", "file", "=", "None", ")", ":", "if", "file", "is", "None", ":", "file", "=", "sys", ".", "stdout", "ast_section", "=", "StringIO", "(", ")", "a", "(", "text", ",", "mode", "=", "mode", ",", "file", "=", "ast_section", ")", "code_section", "=", "StringIO", "(", ")", "d", "(", "text", ",", "mode", "=", "mode", ",", "file", "=", "code_section", ")", "rendered", "=", "_DISPLAY_TEMPLATE", ".", "format", "(", "text", "=", "text", ",", "ast", "=", "ast_section", ".", "getvalue", "(", ")", ",", "code", "=", "code_section", ".", "getvalue", "(", ")", ",", ")", "print", "(", "rendered", ",", "file", "=", "file", ")" ]

[ "Show", "text", "rendered", "as", "AST", "and", "as", "Bytecode", "." ]

[ "def", "get_targets", "(", "self", ",", "config", ")", ":", "return", "{", "urllib", ".", "parse", ".", "urljoin", "(", "self", ".", "url", ",", "attrs", "[", "'href'", "]", ")", "for", "attrs", "in", "self", ".", "_targets", "if", "self", ".", "_check_rel", "(", "attrs", ",", "config", ".", "rel_whitelist", ",", "config", ".", "rel_blacklist", ")", "and", "self", ".", "_domain_differs", "(", "attrs", "[", "'href'", "]", ")", "}" ]

[ "Given", "an", "Entry", "object", "return", "all", "of", "the", "outgoing", "links", "." ]

[ "def", "show_subnetwork", "(", "kwargs", "=", "None", ",", "call", "=", "None", ")", ":", "if", "call", "!=", "'function'", ":", "raise", "SaltCloudSystemExit", "(", "'The show_subnetwork function must be called with -f or --function.'", ")", "if", "not", "kwargs", "or", "'name'", "not", "in", "kwargs", ":", "log", ".", "error", "(", "'Must specify name of subnet.'", ")", "return", "False", "if", "'region'", "not", "in", "kwargs", ":", "log", ".", "error", "(", "'Must specify region of subnet.'", ")", "return", "False", "name", "=", "kwargs", "[", "'name'", "]", "region", "=", "kwargs", "[", "'region'", "]", "conn", "=", "get_conn", "(", ")", "return", "_expand_item", "(", "conn", ".", "ex_get_subnetwork", "(", "name", ",", "region", ")", ")" ]

[ "...", "versionadded", "::", "2017", ".", "7", ".", "0", "Show", "details", "of", "an", "existing", "GCE", "Subnetwork", ".", "Must", "specify", "name", "and", "region", "." ]

[ "def", "compute", "(", "self", ",", "x", ")", ":", "q_learning", "=", "copy", "(", "self", ".", "__greedy_q_learning", ")", "q_learning", ".", "epsilon_greedy_rate", "=", "x", "[", "0", "]", "q_learning", ".", "alpha_value", "=", "x", "[", "1", "]", "q_learning", ".", "gamma_value", "=", "x", "[", "2", "]", "if", "self", ".", "__init_state_key", "is", "not", "None", ":", "q_learning", ".", "learn", "(", "state_key", "=", "self", ".", "__init_state_key", ",", "limit", "=", "int", "(", "x", "[", "3", "]", ")", ")", "else", ":", "q_learning", ".", "learn", "(", "limit", "=", "x", "[", "3", "]", ")", "q_sum", "=", "q_learning", ".", "q_df", ".", "q_value", ".", "sum", "(", ")", "if", "q_sum", "!=", "0", ":", "cost", "=", "q_learning", ".", "q_df", ".", "shape", "[", "0", "]", "/", "q_sum", "else", ":", "cost", "=", "q_learning", ".", "q_df", ".", "shape", "[", "0", "]", "/", "1e-4", "return", "cost" ]

[ "Compute", "cost", ".", "Args", ":", "x", ":", "np", ".", "ndarray", "of", "explanatory", "variables", ".", "Returns", ":", "cost" ]

[ "def", "login", "(", "self", ",", "subject", ",", "authc_token", ")", ":", "try", ":", "# account_id is a SimpleIdentifierCollection", "account_id", "=", "self", ".", "authenticator", ".", "authenticate_account", "(", "subject", ".", "identifiers", ",", "authc_token", ")", "# implies multi-factor authc not complete:", "except", "AdditionalAuthenticationRequired", "as", "exc", ":", "# identity needs to be accessible for subsequent authentication:", "self", ".", "update_subject_identity", "(", "exc", ".", "account_id", ",", "subject", ")", "# no need to propagate account further:", "raise", "AdditionalAuthenticationRequired", "except", "AuthenticationException", "as", "authc_ex", ":", "try", ":", "self", ".", "on_failed_login", "(", "authc_token", ",", "authc_ex", ",", "subject", ")", "except", "Exception", ":", "msg", "=", "(", "\"on_failed_login method raised an exception. Logging \"", "\"and propagating original AuthenticationException.\"", ")", "logger", ".", "info", "(", "msg", ",", "exc_info", "=", "True", ")", "raise", "logged_in", "=", "self", ".", "create_subject", "(", "authc_token", "=", "authc_token", ",", "account_id", "=", "account_id", ",", "existing_subject", "=", "subject", ")", "self", ".", "on_successful_login", "(", "authc_token", ",", "account_id", ",", "logged_in", ")", "return", "logged_in" ]

[ "Login", "authenticates", "a", "user", "using", "an", "AuthenticationToken", ".", "If", "authentication", "is", "successful", "AND", "the", "Authenticator", "has", "determined", "that", "authentication", "is", "complete", "for", "the", "account", "login", "constructs", "a", "Subject", "instance", "representing", "the", "authenticated", "account", "s", "identity", ".", "Once", "a", "subject", "instance", "is", "constructed", "it", "is", "bound", "to", "the", "application", "for", "subsequent", "access", "before", "being", "returned", "to", "the", "caller", "." ]

[ "def", "check_label", "(", "labels", ",", "required", ",", "value_regex", ",", "target_labels", ")", ":", "present", "=", "target_labels", "is", "not", "None", "and", "not", "set", "(", "labels", ")", ".", "isdisjoint", "(", "set", "(", "target_labels", ")", ")", "if", "present", ":", "if", "required", "and", "not", "value_regex", ":", "return", "True", "elif", "value_regex", ":", "pattern", "=", "re", ".", "compile", "(", "value_regex", ")", "present_labels", "=", "set", "(", "labels", ")", "&", "set", "(", "target_labels", ")", "for", "l", "in", "present_labels", ":", "if", "not", "bool", "(", "pattern", ".", "search", "(", "target_labels", "[", "l", "]", ")", ")", ":", "return", "False", "return", "True", "else", ":", "return", "False", "else", ":", "return", "not", "required" ]

[ "Check", "if", "the", "label", "is", "required", "and", "match", "the", "regex" ]

[ "def", "has_gravatar", "(", "email", ")", ":", "# Request a 404 response if the gravatar does not exist", "url", "=", "get_gravatar_url", "(", "email", ",", "default", "=", "GRAVATAR_DEFAULT_IMAGE_404", ")", "# Verify an OK response was received", "try", ":", "request", "=", "Request", "(", "url", ")", "request", ".", "get_method", "=", "lambda", ":", "'HEAD'", "return", "200", "==", "urlopen", "(", "request", ")", ".", "code", "except", "(", "HTTPError", ",", "URLError", ")", ":", "return", "False" ]

[ "Returns", "True", "if", "the", "user", "has", "a", "gravatar", "False", "if", "otherwise" ]

[ "def", "flipcheck", "(", "content", ")", ":", "# Prevent tampering with flip", "punct", "=", "\"\"\"!\"#$%&'*+,-./:;<=>?@[\\]^_`{|}~ ━─\"\"\"", "tamperdict", "=", "str", ".", "maketrans", "(", "''", ",", "''", ",", "punct", ")", "tamperproof", "=", "content", ".", "translate", "(", "tamperdict", ")", "# Unflip", "if", "\"(╯°□°）╯︵\" in tamperpr", "of", "", "", "# For tables", "if", "\"┻┻\" in ", "am", "erproof:", "", "# Calculate table length", "length", "=", "0", "for", "letter", "in", "content", ":", "if", "letter", "==", "\"━\":", "", "length", "+=", "1.36", "elif", "letter", "==", "\"─\":", "", "length", "+=", "1", "elif", "letter", "==", "\"-\"", ":", "length", "+=", "0.50", "# Construct table", "putitback", "=", "\"┬\"", "for", "i", "in", "range", "(", "int", "(", "length", ")", ")", ":", "putitback", "+=", "\"─\"", "putitback", "+=", "\"┬ ノ( ゜-゜ノ)\"", "return", "putitback", "# For text", "else", ":", "# Create dictionary for flipping text", "flipdict", "=", "str", ".", "maketrans", "(", "'abcdefghijklmnopqrstuvwxyzɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎz😅🙃😞😟😠😡☹🙁😱😨😰😦😧😢😓😥😭',", "", "'ɐqɔpǝɟbɥıظʞןɯuodbɹsʇnʌʍxʎzabcdefghijklmnopqrstuvwxyz😄🙂🙂🙂🙂🙂🙂😀😀🙂😄🙂🙂😄😄😄😁'", ")", "# Construct flipped text", "flipstart", "=", "content", ".", "index", "(", "'︵')", "", "flipped", "=", "content", "[", "flipstart", "+", "1", ":", "]", "flipped", "=", "str", ".", "lower", "(", "flipped", ")", ".", "translate", "(", "flipdict", ")", "putitback", "=", "''", ".", "join", "(", "list", "(", "reversed", "(", "list", "(", "flipped", ")", ")", ")", ")", "putitback", "+=", "\"ノ( ゜-゜ノ)\"", "return", "putitback", "else", ":", "return", "False" ]

[ "Checks", "a", "string", "for", "anger", "and", "soothes", "said", "anger" ]

[ "def", "sample", "(", "self", ",", "model", ",", "num_samples", ",", "epsilon", ",", "lmin", "=", "1", ",", "lmax", "=", "1", ",", "thin", "=", "1", ",", "burn", "=", "0", ",", "session", "=", "None", ",", "initialize", "=", "True", ",", "anchor", "=", "True", ",", "logprobs", "=", "True", ")", ":", "if", "lmax", "<=", "0", "or", "lmin", "<=", "0", ":", "raise", "ValueError", "(", "'The lmin and lmax parameters must be greater zero.'", ")", "if", "thin", "<=", "0", ":", "raise", "ValueError", "(", "'The thin parameter must be greater zero.'", ")", "if", "burn", "<", "0", ":", "raise", "ValueError", "(", "'The burn parameter must be equal or greater zero.'", ")", "lmax", "+=", "1", "session", "=", "model", ".", "enquire_session", "(", "session", ")", "model", ".", "initialize", "(", "session", "=", "session", ",", "force", "=", "initialize", ")", "with", "tf", ".", "name_scope", "(", "'hmc'", ")", ":", "params", "=", "list", "(", "model", ".", "trainable_parameters", ")", "xs", "=", "list", "(", "model", ".", "trainable_tensors", ")", "def", "logprob_grads", "(", ")", ":", "logprob", "=", "tf", ".", "negative", "(", "model", ".", "build_objective", "(", ")", ")", "grads", "=", "tf", ".", "gradients", "(", "logprob", ",", "xs", ")", "return", "logprob", ",", "grads", "thin_args", "=", "[", "logprob_grads", ",", "xs", ",", "thin", ",", "epsilon", ",", "lmin", ",", "lmax", "]", "if", "burn", ">", "0", ":", "burn_op", "=", "_burning", "(", "burn", ",", "*", "thin_args", ")", "session", ".", "run", "(", "burn_op", ",", "feed_dict", "=", "model", ".", "feeds", ")", "xs_dtypes", "=", "_map", "(", "lambda", "x", ":", "x", ".", "dtype", ",", "xs", ")", "logprob_dtype", "=", "model", ".", "objective", ".", "dtype", "dtypes", "=", "_flat", "(", "xs_dtypes", ",", "[", "logprob_dtype", "]", ")", "indices", "=", "np", ".", "arange", "(", "num_samples", ")", "def", "map_body", "(", "_", ")", ":", "xs_sample", ",", "logprob_sample", "=", "_thinning", "(", "*", "thin_args", ")", "return", "_flat", "(", "xs_sample", ",", "[", "logprob_sample", "]", ")", "hmc_output", "=", "tf", ".", "map_fn", "(", "map_body", ",", "indices", ",", "dtype", "=", "dtypes", ",", "back_prop", "=", "False", ",", "parallel_iterations", "=", "1", ")", "with", "tf", ".", "control_dependencies", "(", "hmc_output", ")", ":", "unconstrained_trace", ",", "logprob_trace", "=", "hmc_output", "[", ":", "-", "1", "]", ",", "hmc_output", "[", "-", "1", "]", "constrained_trace", "=", "_map", "(", "lambda", "x", ",", "param", ":", "param", ".", "transform", ".", "forward_tensor", "(", "x", ")", ",", "unconstrained_trace", ",", "params", ")", "hmc_output", "=", "constrained_trace", "+", "[", "logprob_trace", "]", "names", "=", "[", "param", ".", "pathname", "for", "param", "in", "params", "]", "raw_traces", "=", "session", ".", "run", "(", "hmc_output", ",", "feed_dict", "=", "model", ".", "feeds", ")", "if", "anchor", ":", "model", ".", "anchor", "(", "session", ")", "traces", "=", "dict", "(", "zip", "(", "names", ",", "map", "(", "list", ",", "raw_traces", "[", ":", "-", "1", "]", ")", ")", ")", "if", "logprobs", ":", "traces", ".", "update", "(", "{", "'logprobs'", ":", "raw_traces", "[", "-", "1", "]", "}", ")", "return", "pd", ".", "DataFrame", "(", "traces", ")" ]

[ "A", "straight", "-", "forward", "HMC", "implementation", ".", "The", "mass", "matrix", "is", "assumed", "to", "be", "the", "identity", "." ]

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

[ "create", "a", "CertificateSigningRequest", "This", "method", "makes", "a", "synchronous", "HTTP", "request", "by", "default", ".", "To", "make", "an", "asynchronous", "HTTP", "request", "please", "pass", "async_req", "=", "True", ">>>", "thread", "=", "api", ".", "create_certificate_signing_request", "(", "body", "async_req", "=", "True", ")", ">>>", "result", "=", "thread", ".", "get", "()" ]

[ "def", "gradient", "(", "self", ")", ":", "functional", "=", "self", "class", "HuberGradient", "(", "Operator", ")", ":", "\"\"\"The gradient operator of this functional.\"\"\"", "def", "__init__", "(", "self", ")", ":", "\"\"\"Initialize a new instance.\"\"\"", "super", "(", "HuberGradient", ",", "self", ")", ".", "__init__", "(", "functional", ".", "domain", ",", "functional", ".", "domain", ",", "linear", "=", "False", ")", "def", "_call", "(", "self", ",", "x", ")", ":", "\"\"\"Apply the gradient operator to the given point.\"\"\"", "if", "isinstance", "(", "self", ".", "domain", ",", "ProductSpace", ")", ":", "norm", "=", "PointwiseNorm", "(", "self", ".", "domain", ",", "2", ")", "(", "x", ")", "else", ":", "norm", "=", "x", ".", "ufuncs", ".", "absolute", "(", ")", "grad", "=", "x", "/", "functional", ".", "gamma", "index", "=", "norm", ".", "ufuncs", ".", "greater_equal", "(", "functional", ".", "gamma", ")", "if", "isinstance", "(", "self", ".", "domain", ",", "ProductSpace", ")", ":", "for", "xi", ",", "gi", "in", "zip", "(", "x", ",", "grad", ")", ":", "gi", "[", "index", "]", "=", "xi", "[", "index", "]", "/", "norm", "[", "index", "]", "else", ":", "grad", "[", "index", "]", "=", "x", "[", "index", "]", "/", "norm", "[", "index", "]", "return", "grad", "return", "HuberGradient", "(", ")" ]

[ "r", "Gradient", "operator", "of", "the", "functional", "." ]

[ "def", "split_dae_alg", "(", "eqs", ":", "SYM", ",", "dx", ":", "SYM", ")", "->", "Dict", "[", "str", ",", "SYM", "]", ":", "dae", "=", "[", "]", "alg", "=", "[", "]", "for", "eq", "in", "ca", ".", "vertsplit", "(", "eqs", ")", ":", "if", "ca", ".", "depends_on", "(", "eq", ",", "dx", ")", ":", "dae", ".", "append", "(", "eq", ")", "else", ":", "alg", ".", "append", "(", "eq", ")", "return", "{", "'dae'", ":", "ca", ".", "vertcat", "(", "*", "dae", ")", ",", "'alg'", ":", "ca", ".", "vertcat", "(", "*", "alg", ")", "}" ]

[ "Split", "equations", "into", "differential", "algebraic", "and", "algebraic", "only" ]

[ "def", "convert_sbcs_model", "(", "old_model", ",", "alphabet", ")", ":", "# Setup tables necessary for computing transition frequencies for model", "char_to_order", "=", "{", "i", ":", "order", "for", "i", ",", "order", "in", "enumerate", "(", "old_model", "[", "'char_to_order_map'", "]", ")", "}", "pos_ratio", "=", "old_model", "[", "'typical_positive_ratio'", "]", "keep_ascii_letters", "=", "old_model", "[", "'keep_english_letter'", "]", "curr_model", "=", "SingleByteCharSetModel", "(", "charset_name", "=", "old_model", "[", "'charset_name'", "]", ",", "language", "=", "old_model", "[", "'language'", "]", ",", "char_to_order_map", "=", "char_to_order", ",", "# language_model is filled in later", "language_model", "=", "None", ",", "typical_positive_ratio", "=", "pos_ratio", ",", "keep_ascii_letters", "=", "keep_ascii_letters", ",", "alphabet", "=", "alphabet", ")", "return", "curr_model" ]

[ "Create", "a", "SingleByteCharSetModel", "object", "representing", "the", "charset", "." ]

[ "def", "get_login_credentials", "(", "args", ")", ":", "if", "not", "args", ".", "username", ":", "args", ".", "username", "=", "raw_input", "(", "\"Enter Username: \"", ")", "if", "not", "args", ".", "password", ":", "args", ".", "password", "=", "getpass", ".", "getpass", "(", "\"Enter Password: \"", ")" ]

[ "Gets", "the", "login", "credentials", "from", "the", "user", "if", "not", "specified", "while", "invoking", "the", "script", "." ]

[ "def", "build_mode", "(", "arg_namespace", ")", ":", "custom_temps", "=", "arg_namespace", ".", "template", "or", "[", "]", "temp_paths", "=", "[", "rel_to_cwd", "(", "'templates'", ",", "temp", ")", "for", "temp", "in", "custom_temps", "]", "try", ":", "builder", ".", "build", "(", "templates", "=", "temp_paths", ",", "schemes", "=", "arg_namespace", ".", "scheme", ",", "base_output_dir", "=", "arg_namespace", ".", "output", ")", "except", "(", "LookupError", ",", "PermissionError", ")", "as", "exception", ":", "if", "isinstance", "(", "exception", ",", "LookupError", ")", ":", "print", "(", "'Necessary resources for building not found in current '", "'working directory.'", ")", "if", "isinstance", "(", "exception", ",", "PermissionError", ")", ":", "print", "(", "\"No write permission for output directory.\"", ")" ]

[ "Check", "command", "line", "arguments", "and", "run", "build", "function", "." ]

[ "def", "request_system_arm", "(", "blink", ",", "network", ")", ":", "url", "=", "\"{}/network/{}/arm\"", ".", "format", "(", "blink", ".", "urls", ".", "base_url", ",", "network", ")", "return", "http_post", "(", "blink", ",", "url", ")" ]

[ "Arm", "system", "." ]

[ "def", "generateDefaultColorRamp", "(", "cls", ",", "colorRampEnum", ")", ":", "hue", "=", "[", "(", "255", ",", "0", ",", "255", ")", ",", "(", "231", ",", "0", ",", "255", ")", ",", "(", "208", ",", "0", ",", "255", ")", ",", "(", "185", ",", "0", ",", "255", ")", ",", "(", "162", ",", "0", ",", "255", ")", ",", "(", "139", ",", "0", ",", "255", ")", ",", "(", "115", ",", "0", ",", "255", ")", ",", "(", "92", ",", "0", ",", "255", ")", ",", "(", "69", ",", "0", ",", "255", ")", ",", "(", "46", ",", "0", ",", "255", ")", ",", "(", "23", ",", "0", ",", "255", ")", ",", "# magenta to blue", "(", "0", ",", "0", ",", "255", ")", ",", "(", "0", ",", "23", ",", "255", ")", ",", "(", "0", ",", "46", ",", "255", ")", ",", "(", "0", ",", "69", ",", "255", ")", ",", "(", "0", ",", "92", ",", "255", ")", ",", "(", "0", ",", "115", ",", "255", ")", ",", "(", "0", ",", "139", ",", "255", ")", ",", "(", "0", ",", "162", ",", "255", ")", ",", "(", "0", ",", "185", ",", "255", ")", ",", "(", "0", ",", "208", ",", "255", ")", ",", "(", "0", ",", "231", ",", "255", ")", ",", "# blue to cyan", "(", "0", ",", "255", ",", "255", ")", ",", "(", "0", ",", "255", ",", "231", ")", ",", "(", "0", ",", "255", ",", "208", ")", ",", "(", "0", ",", "255", ",", "185", ")", ",", "(", "0", ",", "255", ",", "162", ")", ",", "(", "0", ",", "255", ",", "139", ")", ",", "(", "0", ",", "255", ",", "115", ")", ",", "(", "0", ",", "255", ",", "92", ")", ",", "(", "0", ",", "255", ",", "69", ")", ",", "(", "0", ",", "255", ",", "46", ")", ",", "(", "0", ",", "255", ",", "23", ")", ",", "# cyan to green", "(", "0", ",", "255", ",", "0", ")", ",", "(", "23", ",", "255", ",", "0", ")", ",", "(", "46", ",", "255", ",", "0", ")", ",", "(", "69", ",", "255", ",", "0", ")", ",", "(", "92", ",", "255", ",", "0", ")", ",", "(", "115", ",", "255", ",", "0", ")", ",", "(", "139", ",", "255", ",", "0", ")", ",", "(", "162", ",", "255", ",", "0", ")", ",", "(", "185", ",", "255", ",", "0", ")", ",", "(", "208", ",", "255", ",", "0", ")", ",", "(", "231", ",", "255", ",", "0", ")", ",", "# green to yellow", "(", "255", ",", "255", ",", "0", ")", ",", "(", "255", ",", "243", ",", "0", ")", ",", "(", "255", ",", "231", ",", "0", ")", ",", "(", "255", ",", "220", ",", "0", ")", ",", "(", "255", ",", "208", ",", "0", ")", ",", "(", "255", ",", "197", ",", "0", ")", ",", "(", "255", ",", "185", ",", "0", ")", ",", "(", "255", ",", "174", ",", "0", ")", ",", "(", "255", ",", "162", ",", "0", ")", ",", "(", "255", ",", "151", ",", "0", ")", ",", "(", "255", ",", "139", ",", "0", ")", ",", "# yellow to orange", "(", "255", ",", "128", ",", "0", ")", ",", "(", "255", ",", "116", ",", "0", ")", ",", "(", "255", ",", "104", ",", "0", ")", ",", "(", "255", ",", "93", ",", "0", ")", ",", "(", "255", ",", "81", ",", "0", ")", ",", "(", "255", ",", "69", ",", "0", ")", ",", "(", "255", ",", "58", ",", "0", ")", ",", "(", "255", ",", "46", ",", "0", ")", ",", "(", "255", ",", "34", ",", "0", ")", ",", "(", "255", ",", "23", ",", "0", ")", ",", "(", "255", ",", "11", ",", "0", ")", ",", "# orange to red", "(", "255", ",", "0", ",", "0", ")", "]", "# red", "terrain", "=", "[", "(", "0", ",", "100", ",", "0", ")", ",", "(", "19", ",", "107", ",", "0", ")", ",", "(", "38", ",", "114", ",", "0", ")", ",", "(", "57", ",", "121", ",", "0", ")", ",", "(", "76", ",", "129", ",", "0", ")", ",", "(", "95", ",", "136", ",", "0", ")", ",", "(", "114", ",", "143", ",", "0", ")", ",", "(", "133", ",", "150", ",", "0", ")", ",", "(", "152", ",", "158", ",", "0", ")", ",", "(", "171", ",", "165", ",", "0", ")", ",", "(", "190", ",", "172", ",", "0", ")", ",", "# dark green to golden rod yellow", "(", "210", ",", "180", ",", "0", ")", ",", "(", "210", ",", "167", ",", "5", ")", ",", "(", "210", ",", "155", ",", "10", ")", ",", "(", "210", ",", "142", ",", "15", ")", ",", "(", "210", ",", "130", ",", "20", ")", ",", "(", "210", ",", "117", ",", "25", ")", ",", "# golden rod yellow to orange brown", "(", "210", ",", "105", ",", "30", ")", ",", "(", "188", ",", "94", ",", "25", ")", ",", "(", "166", ",", "83", ",", "21", ")", ",", "(", "145", ",", "72", ",", "17", ")", ",", "(", "123", ",", "61", ",", "13", ")", ",", "(", "101", ",", "50", ",", "9", ")", ",", "# orange brown to dark brown", "(", "80", ",", "40", ",", "5", ")", ",", "(", "95", ",", "59", ",", "27", ")", ",", "(", "111", ",", "79", ",", "50", ")", ",", "(", "127", ",", "98", ",", "73", ")", ",", "(", "143", ",", "118", ",", "95", ")", ",", "(", "159", ",", "137", ",", "118", ")", ",", "(", "175", ",", "157", ",", "141", ")", ",", "(", "191", ",", "176", ",", "164", ")", ",", "(", "207", ",", "196", ",", "186", ")", ",", "(", "223", ",", "215", ",", "209", ")", ",", "(", "239", ",", "235", ",", "232", ")", ",", "# dark brown to white", "(", "255", ",", "255", ",", "255", ")", "]", "# white", "aqua", "=", "[", "(", "150", ",", "255", ",", "255", ")", ",", "(", "136", ",", "240", ",", "250", ")", ",", "(", "122", ",", "226", ",", "245", ")", ",", "(", "109", ",", "212", ",", "240", ")", ",", "(", "95", ",", "198", ",", "235", ")", ",", "(", "81", ",", "184", ",", "230", ")", ",", "(", "68", ",", "170", ",", "225", ")", ",", "(", "54", ",", "156", ",", "220", ")", ",", "(", "40", ",", "142", ",", "215", ")", ",", "(", "27", ",", "128", ",", "210", ")", ",", "(", "13", ",", "114", ",", "205", ")", ",", "# aqua to blue", "(", "0", ",", "100", ",", "200", ")", ",", "(", "0", ",", "94", ",", "195", ")", ",", "(", "0", ",", "89", ",", "191", ")", ",", "(", "0", ",", "83", ",", "187", ")", ",", "(", "0", ",", "78", ",", "182", ")", ",", "(", "0", ",", "72", ",", "178", ")", ",", "(", "0", ",", "67", ",", "174", ")", ",", "(", "0", ",", "61", ",", "170", ")", ",", "(", "0", ",", "56", ",", "165", ")", ",", "(", "0", ",", "50", ",", "161", ")", ",", "(", "0", ",", "45", ",", "157", ")", ",", "(", "0", ",", "40", ",", "153", ")", ",", "# blue to navy blue", "(", "0", ",", "36", ",", "143", ")", ",", "(", "0", ",", "32", ",", "134", ")", ",", "(", "0", ",", "29", ",", "125", ")", ",", "(", "0", ",", "25", ",", "115", ")", ",", "(", "0", ",", "21", ",", "106", ")", ",", "(", "0", ",", "18", ",", "97", ")", ",", "(", "0", ",", "14", ",", "88", ")", ",", "(", "0", ",", "10", ",", "78", ")", ",", "(", "0", ",", "7", ",", "69", ")", ",", "(", "0", ",", "3", ",", "60", ")", ",", "(", "0", ",", "0", ",", "51", ")", "]", "# navy blue to dark navy blue", "if", "(", "colorRampEnum", "==", "ColorRampEnum", ".", "COLOR_RAMP_HUE", ")", ":", "return", "hue", "elif", "(", "colorRampEnum", "==", "ColorRampEnum", ".", "COLOR_RAMP_TERRAIN", ")", ":", "return", "terrain", "elif", "(", "colorRampEnum", "==", "ColorRampEnum", ".", "COLOR_RAMP_AQUA", ")", ":", "return", "aqua" ]

[ "Returns", "the", "color", "ramp", "as", "a", "list", "of", "RGB", "tuples", ":", "param", "colorRampEnum", ":", "One", "of", "the" ]

[ "def", "get_data", "(", "self", ",", "typename", ",", "init_func", "=", "None", ")", ":", "if", "typename", "not", "in", "self", ".", "data_products", ":", "if", "not", "init_func", ":", "return", "None", "self", ".", "data_products", "[", "typename", "]", "=", "init_func", "(", ")", "return", "self", ".", "data_products", ".", "get", "(", "typename", ")" ]

[ "Returns", "a", "data", "product", "." ]

[ "def", "delete", "(", "self", ",", "image", ")", ":", "from", ".", "entity", "import", "Image", "if", "not", "isinstance", "(", "image", ",", "Image", ")", ":", "raise", "TypeError", "(", "'image must be a sqlalchemy_imageattach.entity.'", "'Image instance, not '", "+", "repr", "(", "image", ")", ")", "self", ".", "delete_file", "(", "image", ".", "object_type", ",", "image", ".", "object_id", ",", "image", ".", "width", ",", "image", ".", "height", ",", "image", ".", "mimetype", ")" ]

[ "Delete", "the", "file", "of", "the", "given", "image", "." ]

[ "def", "process_message", "(", "message", ")", ":", "message", "[", "\"type\"", "]", "=", "message", ".", "pop", "(", "\"MsgType\"", ")", ".", "lower", "(", ")", "if", "message", "[", "\"type\"", "]", "==", "'event'", ":", "message", "[", "\"type\"", "]", "=", "str", "(", "message", ".", "pop", "(", "\"Event\"", ")", ")", ".", "lower", "(", ")", "+", "'_event'", "message_type", "=", "EventMetaClass", ".", "TYPES", ".", "get", "(", "message", "[", "\"type\"", "]", ",", "UnknownEvent", ")", "else", ":", "message_type", "=", "MessageMetaClass", ".", "TYPES", ".", "get", "(", "message", "[", "\"type\"", "]", ",", "UnknownMessage", ")", "return", "message_type", "(", "message", ")" ]

[ "Process", "a", "message", "dict", "and", "return", "a", "Message", "Object", ":", "param", "message", ":", "Message", "dict", "returned", "by", "parse_xml", "function", ":", "return", ":", "Message", "Object" ]

[ "def", "attach_session", "(", "self", ")", ":", "assert", "self", ".", "session", "is", "None", "root", "=", "self", ".", "find_root", "(", ")", "session", "=", "self", ".", "Session", "(", "root", ")", "root", ".", "inject_context", "(", "session", "=", "session", ")", "return", "session" ]

[ "Create", "a", "session", "and", "inject", "it", "as", "context", "for", "this", "command", "and", "any", "subcommands", "." ]

[ "def", "option", "(", "*", "param_decls", ",", "cls", "=", "None", ",", "*", "*", "attrs", ")", ":", "return", "click", ".", "option", "(", "*", "param_decls", ",", "cls", "=", "cls", "or", "Option", ",", "*", "*", "attrs", ")" ]

[ "Options", "are", "usually", "optional", "values", "on", "the", "command", "line", "and", "have", "some", "extra", "features", "that", "arguments", "don", "t", "have", "." ]

[ "def", "gtf_to_bed", "(", "gtf", ",", "alt_out_dir", "=", "None", ")", ":", "out_file", "=", "os", ".", "path", ".", "splitext", "(", "gtf", ")", "[", "0", "]", "+", "'.bed'", "if", "file_exists", "(", "out_file", ")", ":", "return", "out_file", "if", "not", "os", ".", "access", "(", "os", ".", "path", ".", "dirname", "(", "out_file", ")", ",", "os", ".", "W_OK", "|", "os", ".", "X_OK", ")", ":", "if", "not", "alt_out_dir", ":", "raise", "IOError", "(", "'Cannot write transcript BED output file %s'", "%", "out_file", ")", "else", ":", "out_file", "=", "os", ".", "path", ".", "join", "(", "alt_out_dir", ",", "os", ".", "path", ".", "basename", "(", "out_file", ")", ")", "with", "open", "(", "out_file", ",", "\"w\"", ")", "as", "out_handle", ":", "db", "=", "get_gtf_db", "(", "gtf", ")", "for", "feature", "in", "db", ".", "features_of_type", "(", "'transcript'", ",", "order_by", "=", "(", "\"seqid\"", ",", "\"start\"", ",", "\"end\"", ")", ")", ":", "chrom", "=", "feature", ".", "chrom", "start", "=", "feature", ".", "start", "end", "=", "feature", ".", "end", "attributes", "=", "feature", ".", "attributes", ".", "keys", "(", ")", "strand", "=", "feature", ".", "strand", "name", "=", "(", "feature", "[", "'gene_name'", "]", "[", "0", "]", "if", "'gene_name'", "in", "attributes", "else", "feature", "[", "'gene_id'", "]", "[", "0", "]", ")", "line", "=", "\"\\t\"", ".", "join", "(", "[", "str", "(", "x", ")", "for", "x", "in", "[", "chrom", ",", "start", ",", "end", ",", "name", ",", "\".\"", ",", "strand", "]", "]", ")", "out_handle", ".", "write", "(", "line", "+", "\"\\n\"", ")", "return", "out_file" ]

[ "create", "a", "BED", "file", "of", "transcript", "-", "level", "features", "with", "attached", "gene", "name", "or", "gene", "ids" ]

[ "def", "write_def_decl", "(", "self", ",", "node", ",", "identifiers", ")", ":", "funcname", "=", "node", ".", "funcname", "namedecls", "=", "node", ".", "get_argument_expressions", "(", ")", "nameargs", "=", "node", ".", "get_argument_expressions", "(", "as_call", "=", "True", ")", "if", "not", "self", ".", "in_def", "and", "(", "len", "(", "self", ".", "identifiers", ".", "locally_assigned", ")", ">", "0", "or", "len", "(", "self", ".", "identifiers", ".", "argument_declared", ")", ">", "0", ")", ":", "nameargs", ".", "insert", "(", "0", ",", "'context._locals(__M_locals)'", ")", "else", ":", "nameargs", ".", "insert", "(", "0", ",", "'context'", ")", "self", ".", "printer", ".", "writeline", "(", "\"def %s(%s):\"", "%", "(", "funcname", ",", "\",\"", ".", "join", "(", "namedecls", ")", ")", ")", "self", ".", "printer", ".", "writeline", "(", "\"return render_%s(%s)\"", "%", "(", "funcname", ",", "\",\"", ".", "join", "(", "nameargs", ")", ")", ")", "self", ".", "printer", ".", "writeline", "(", "None", ")" ]

[ "write", "a", "locally", "-", "available", "callable", "referencing", "a", "top", "-", "level", "def" ]

[ "def", "run_ffitch", "(", "distfile", ",", "outtreefile", ",", "intreefile", "=", "None", ",", "*", "*", "kwargs", ")", ":", "cl", "=", "FfitchCommandline", "(", "datafile", "=", "distfile", ",", "outtreefile", "=", "outtreefile", ",", "intreefile", "=", "intreefile", ",", "*", "*", "kwargs", ")", "r", ",", "e", "=", "cl", ".", "run", "(", ")", "if", "e", ":", "print", "(", "\"***ffitch could not run\"", ",", "file", "=", "sys", ".", "stderr", ")", "return", "None", "else", ":", "print", "(", "\"ffitch:\"", ",", "cl", ",", "file", "=", "sys", ".", "stderr", ")", "return", "outtreefile" ]

[ "Infer", "tree", "branch", "lengths", "using", "ffitch", "in", "EMBOSS", "PHYLIP" ]

[ "def", "append_to_keys", "(", "adict", ",", "preffix", ")", ":", "return", "{", "preffix", "+", "str", "(", "key", ")", ":", "(", "value", "if", "isinstance", "(", "value", ",", "dict", ")", "else", "value", ")", "for", "key", ",", "value", "in", "list", "(", "adict", ".", "items", "(", ")", ")", "}" ]

[ "Parameters", "----------", "adict", ":", "preffix", ":" ]

[ "def", "run", "(", "self", ",", "limit", "=", "None", ",", "timeout", "=", "None", ")", ":", "counter", "=", "0", "self", ".", "stream", "=", "sseclient", ".", "SSEClient", "(", "self", ".", "endpoint", ")", "while", "True", ":", "with", "utils", ".", "Timeout", "(", "timeout", ")", ":", "try", ":", "event", "=", "next", "(", "self", ".", "stream", ")", "except", "StopIteration", ":", "continue", "else", ":", "if", "not", "event", ".", "data", ":", "continue", "self", ".", "main_callback", "(", "event", ".", "data", ")", "counter", "+=", "1", "if", "limit", "and", "counter", ">=", "limit", ":", "return" ]

[ "Consume", "the", "event", "stream", ".", ":", "param", "timeout", ":", "Duration", "of", "the", "connection", "timeout", ".", ":", "type", "timeout", ":", "int", ":", "param", "limit", ":", "Number", "of", "events", "to", "consume", ".", ":", "type", "limit", ":", "int", ":", "rtype", ":", "None" ]

[ "def", "register_minter", "(", "self", ",", "name", ",", "minter", ")", ":", "assert", "name", "not", "in", "self", ".", "minters", "self", ".", "minters", "[", "name", "]", "=", "minter" ]

[ "Register", "a", "minter", "." ]

[ "def", "coord_wrap", "(", "self", ",", "*", "args", ")", ":", "yield", "from", "self", ".", "cell", ".", "coord", ".", "start", "(", "self", ")", "yield", "from", "self", ".", "coro", "(", "*", "args", ")", "yield", "from", "self", ".", "cell", ".", "coord", ".", "finish", "(", "self", ")" ]

[ "Wrap", "the", "coroutine", "with", "coordination", "throttles", "." ]

[ "def", "write_length_and_key", "(", "fp", ",", "value", ")", ":", "written", "=", "write_fmt", "(", "fp", ",", "'I'", ",", "0", "if", "value", "in", "_TERMS", "else", "len", "(", "value", ")", ")", "written", "+=", "write_bytes", "(", "fp", ",", "value", ")", "return", "written" ]

[ "Helper", "to", "write", "descriptor", "key", "." ]

[ "def", "_translate_segment_glob", "(", "pattern", ")", ":", "# NOTE: This is derived from `fnmatch.translate()` and is similar to", "# the POSIX function `fnmatch()` with the `FNM_PATHNAME` flag set.", "escape", "=", "False", "regex", "=", "''", "i", ",", "end", "=", "0", ",", "len", "(", "pattern", ")", "while", "i", "<", "end", ":", "# Get next character.", "char", "=", "pattern", "[", "i", "]", "i", "+=", "1", "if", "escape", ":", "# Escape the character.", "escape", "=", "False", "regex", "+=", "re", ".", "escape", "(", "char", ")", "elif", "char", "==", "'\\\\'", ":", "# Escape character, escape next character.", "escape", "=", "True", "elif", "char", "==", "'*'", ":", "# Multi-character wildcard. Match any string (except slashes),", "# including an empty string.", "regex", "+=", "'[^/]*'", "elif", "char", "==", "'?'", ":", "# Single-character wildcard. Match any single character (except", "# a slash).", "regex", "+=", "'[^/]'", "elif", "char", "==", "'['", ":", "# Braket expression wildcard. Except for the beginning", "# exclamation mark, the whole braket expression can be used", "# directly as regex but we have to find where the expression", "# ends.", "# - \"[][!]\" matchs ']', '[' and '!'.", "# - \"[]-]\" matchs ']' and '-'.", "# - \"[!]a-]\" matchs any character except ']', 'a' and '-'.", "j", "=", "i", "# Pass brack expression negation.", "if", "j", "<", "end", "and", "pattern", "[", "j", "]", "==", "'!'", ":", "j", "+=", "1", "# Pass first closing braket if it is at the beginning of the", "# expression.", "if", "j", "<", "end", "and", "pattern", "[", "j", "]", "==", "']'", ":", "j", "+=", "1", "# Find closing braket. Stop once we reach the end or find it.", "while", "j", "<", "end", "and", "pattern", "[", "j", "]", "!=", "']'", ":", "j", "+=", "1", "if", "j", "<", "end", ":", "# Found end of braket expression. Increment j to be one past", "# the closing braket:", "#", "# [...]", "# ^ ^", "# i j", "#", "j", "+=", "1", "expr", "=", "'['", "if", "pattern", "[", "i", "]", "==", "'!'", ":", "# Braket expression needs to be negated.", "expr", "+=", "'^'", "i", "+=", "1", "elif", "pattern", "[", "i", "]", "==", "'^'", ":", "# POSIX declares that the regex braket expression negation", "# \"[^...]\" is undefined in a glob pattern. Python's", "# `fnmatch.translate()` escapes the caret ('^') as a", "# literal. To maintain consistency with undefined behavior,", "# I am escaping the '^' as well.", "expr", "+=", "'\\\\^'", "i", "+=", "1", "# Build regex braket expression. Escape slashes so they are", "# treated as literal slashes by regex as defined by POSIX.", "expr", "+=", "pattern", "[", "i", ":", "j", "]", ".", "replace", "(", "'\\\\'", ",", "'\\\\\\\\'", ")", "# Add regex braket expression to regex result.", "regex", "+=", "expr", "# Set i to one past the closing braket.", "i", "=", "j", "else", ":", "# Failed to find closing braket, treat opening braket as a", "# braket literal instead of as an expression.", "regex", "+=", "'\\\\['", "else", ":", "# Regular character, escape it for regex.", "regex", "+=", "re", ".", "escape", "(", "char", ")", "return", "regex" ]

[ "Translates", "the", "glob", "pattern", "to", "a", "regular", "expression", ".", "This", "is", "used", "in", "the", "constructor", "to", "translate", "a", "path", "segment", "glob", "pattern", "to", "its", "corresponding", "regular", "expression", "." ]

[ "def", "open", "(", "self", ")", ":", "is_url", "=", "self", ".", "is_url", "(", "self", ".", "path", ")", "compression_type", "=", "self", ".", "is_compressed", "(", "self", ".", "path", ")", "if", "not", "compression_type", ":", "if", "is_url", ":", "filehandle", "=", "urlopen", "(", "self", ".", "path", ")", "else", ":", "filehandle", "=", "open", "(", "self", ".", "path", ",", "\"r\"", ")", "source", "=", "self", ".", "path", "yield", "filehandle", ",", "source", "filehandle", ".", "close", "(", ")", "elif", "compression_type", ":", "if", "is_url", ":", "response", "=", "urlopen", "(", "self", ".", "path", ")", "path", "=", "response", ".", "read", "(", ")", "response", ".", "close", "(", ")", "else", ":", "path", "=", "self", ".", "path", "if", "compression_type", "==", "\"zip\"", ":", "ziparchive", "=", "zipfile", ".", "ZipFile", "(", "io", ".", "BytesIO", "(", "path", ")", ",", "\"r\"", ")", "if", "is_url", "else", "zipfile", ".", "ZipFile", "(", "path", ")", "for", "name", "in", "ziparchive", ".", "infolist", "(", ")", ":", "if", "not", "name", ".", "filename", ".", "endswith", "(", "\"/\"", ")", ":", "filehandle", "=", "ziparchive", ".", "open", "(", "name", ")", "source", "=", "self", ".", "path", "+", "\"/\"", "+", "name", ".", "filename", "yield", "filehandle", ",", "source", "filehandle", ".", "close", "(", ")", "elif", "compression_type", "in", "(", "\"tar\"", ",", "\"tar.bz2\"", ",", "\"tar.gz\"", ")", ":", "tararchive", "=", "tarfile", ".", "open", "(", "fileobj", "=", "io", ".", "BytesIO", "(", "path", ")", ")", "if", "is_url", "else", "tarfile", ".", "open", "(", "path", ")", "for", "name", "in", "tararchive", ":", "if", "name", ".", "isfile", "(", ")", ":", "filehandle", "=", "tararchive", ".", "extractfile", "(", "name", ")", "source", "=", "self", ".", "path", "+", "\"/\"", "+", "name", ".", "name", "yield", "filehandle", ",", "source", "filehandle", ".", "close", "(", ")", "elif", "compression_type", "==", "\"bz2\"", ":", "filehandle", "=", "bz2", ".", "BZ2File", "(", "io", ".", "BytesIO", "(", "path", ")", ")", "if", "is_url", "else", "bz2", ".", "BZ2File", "(", "path", ")", "source", "=", "self", ".", "path", "yield", "filehandle", ",", "source", "filehandle", ".", "close", "(", ")", "elif", "compression_type", "==", "\"gz\"", ":", "filehandle", "=", "gzip", ".", "open", "(", "io", ".", "BytesIO", "(", "path", ")", ")", "if", "is_url", "else", "gzip", ".", "open", "(", "path", ")", "source", "=", "self", ".", "path", "yield", "filehandle", ",", "source", "filehandle", ".", "close", "(", ")" ]

[ "Generator", "that", "opens", "and", "yields", "filehandles", "using", "appropriate", "facilities", ":", "test", "if", "path", "represents", "a", "local", "file", "or", "file", "over", "URL", "if", "file", "is", "compressed", "or", "not", "." ]

[ "def", "_col_widths2xls", "(", "self", ",", "worksheets", ")", ":", "xls_max_cols", ",", "xls_max_tabs", "=", "self", ".", "xls_max_cols", ",", "self", ".", "xls_max_tabs", "dict_grid", "=", "self", ".", "code_array", ".", "dict_grid", "for", "col", ",", "tab", "in", "dict_grid", ".", "col_widths", ":", "if", "col", "<", "xls_max_cols", "and", "tab", "<", "xls_max_tabs", ":", "pys_width", "=", "dict_grid", ".", "col_widths", "[", "(", "col", ",", "tab", ")", "]", "xls_width", "=", "self", ".", "pys_width2xls_width", "(", "pys_width", ")", "worksheets", "[", "tab", "]", ".", "col", "(", "col", ")", ".", "width", "=", "xls_width" ]

[ "Writes", "col_widths", "to", "xls", "file" ]

[ "def", "K_branch_diverging_Crane", "(", "D_run", ",", "D_branch", ",", "Q_run", ",", "Q_branch", ",", "angle", "=", "90", ")", ":", "beta", "=", "(", "D_branch", "/", "D_run", ")", "beta2", "=", "beta", "*", "beta", "Q_comb", "=", "Q_run", "+", "Q_branch", "Q_ratio", "=", "Q_branch", "/", "Q_comb", "if", "angle", "<", "60", "or", "beta", "<=", "2", "/", "3.", ":", "H", ",", "J", "=", "1.", ",", "2.", "else", ":", "H", ",", "J", "=", "0.3", ",", "0", "if", "angle", "<", "75", ":", "if", "beta2", "<=", "0.35", ":", "if", "Q_ratio", "<=", "0.4", ":", "G", "=", "1.1", "-", "0.7", "*", "Q_ratio", "else", ":", "G", "=", "0.85", "else", ":", "if", "Q_ratio", "<=", "0.6", ":", "G", "=", "1.0", "-", "0.6", "*", "Q_ratio", "else", ":", "G", "=", "0.6", "else", ":", "if", "beta2", "<=", "2", "/", "3.", ":", "G", "=", "1", "else", ":", "G", "=", "1", "+", "0.3", "*", "Q_ratio", "*", "Q_ratio", "angle_rad", "=", "radians", "(", "angle", ")", "K_branch", "=", "G", "*", "(", "1", "+", "H", "*", "(", "Q_ratio", "/", "beta2", ")", "**", "2", "-", "J", "*", "(", "Q_ratio", "/", "beta2", ")", "*", "cos", "(", "angle_rad", ")", ")", "return", "K_branch" ]

[ "r", "Returns", "the", "loss", "coefficient", "for", "the", "branch", "of", "a", "diverging", "tee", "or", "wye", "according", "to", "the", "Crane", "method", "[", "1", "]", "_", ".", "..", "math", "::", "K_", "{", "branch", "}", "=", "G", "\\", "left", "[", "1", "+", "H", "\\", "left", "(", "\\", "frac", "{", "Q_", "{", "branch", "}}", "{", "Q_", "{", "comb", "}", "\\", "beta_", "{", "branch", "}", "^2", "}", "\\", "right", ")", "^2", "-", "J", "\\", "left", "(", "\\", "frac", "{", "Q_", "{", "branch", "}}", "{", "Q_", "{", "comb", "}", "\\", "beta_", "{", "branch", "}", "^2", "}", "\\", "right", ")", "\\", "cos", "\\", "theta", "\\", "right", "]", "..", "math", "::", "\\", "beta_", "{", "branch", "}", "=", "\\", "frac", "{", "D_", "{", "branch", "}}", "{", "D_", "{", "comb", "}}", "See", "the", "notes", "for", "definitions", "of", "H", "J", "and", "G", "." ]

[ "def", "process_tag", "(", "self", ",", "tag", ")", ":", "try", ":", "if", "not", "self", ".", "_is_function", "(", "tag", ")", ":", "self", ".", "_tag_type_processor", "[", "tag", ".", "data_type", "]", "(", "tag", ")", "except", "KeyError", "as", "ex", ":", "raise", "Exception", "(", "'Tag type {0} not recognized for tag {1}'", ".", "format", "(", "tag", ".", "data_type", ",", "tag", ".", "name", ")", ",", "ex", ")" ]

[ "Processes", "tag", "and", "detects", "which", "function", "to", "use" ]

[ "def", "Wang_Chiang_Lu", "(", "m", ",", "x", ",", "rhol", ",", "rhog", ",", "mul", ",", "mug", ",", "D", ",", "roughness", "=", "0", ",", "L", "=", "1", ")", ":", "G_tp", "=", "m", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "# Actual Liquid flow", "v_l", "=", "m", "*", "(", "1", "-", "x", ")", "/", "rhol", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "Re_l", "=", "Reynolds", "(", "V", "=", "v_l", ",", "rho", "=", "rhol", ",", "mu", "=", "mul", ",", "D", "=", "D", ")", "fd_l", "=", "friction_factor", "(", "Re", "=", "Re_l", ",", "eD", "=", "roughness", "/", "D", ")", "dP_l", "=", "fd_l", "*", "L", "/", "D", "*", "(", "0.5", "*", "rhol", "*", "v_l", "**", "2", ")", "# Actual gas flow", "v_g", "=", "m", "*", "x", "/", "rhog", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "Re_g", "=", "Reynolds", "(", "V", "=", "v_g", ",", "rho", "=", "rhog", ",", "mu", "=", "mug", ",", "D", "=", "D", ")", "fd_g", "=", "friction_factor", "(", "Re", "=", "Re_g", ",", "eD", "=", "roughness", "/", "D", ")", "dP_g", "=", "fd_g", "*", "L", "/", "D", "*", "(", "0.5", "*", "rhog", "*", "v_g", "**", "2", ")", "X", "=", "(", "dP_l", "/", "dP_g", ")", "**", "0.5", "if", "G_tp", ">=", "200", ":", "phi_g2", "=", "1", "+", "9.397", "*", "X", "**", "0.62", "+", "0.564", "*", "X", "**", "2.45", "else", ":", "# Liquid-only flow; Re_lo is oddly needed", "v_lo", "=", "m", "/", "rhol", "/", "(", "pi", "/", "4", "*", "D", "**", "2", ")", "Re_lo", "=", "Reynolds", "(", "V", "=", "v_lo", ",", "rho", "=", "rhol", ",", "mu", "=", "mul", ",", "D", "=", "D", ")", "C", "=", "0.000004566", "*", "X", "**", "0.128", "*", "Re_lo", "**", "0.938", "*", "(", "rhol", "/", "rhog", ")", "**", "-", "2.15", "*", "(", "mul", "/", "mug", ")", "**", "5.1", "phi_g2", "=", "1", "+", "C", "*", "X", "+", "X", "**", "2", "return", "dP_g", "*", "phi_g2" ]

[ "r", "Calculates", "two", "-", "phase", "pressure", "drop", "with", "the", "Wang", "Chiang", "and", "Lu", "(", "1997", ")", "correlation", "given", "in", "[", "1", "]", "_", "and", "reviewed", "in", "[", "2", "]", "_", "and", "[", "3", "]", "_", "." ]

[ "def", "treeWithAppliedTxns", "(", "self", ",", "txns", ":", "List", ",", "currentTree", "=", "None", ")", ":", "currentTree", "=", "currentTree", "or", "self", ".", "tree", "# Copying the tree is not a problem since its a Compact Merkle Tree", "# so the size of the tree would be 32*(lg n) bytes where n is the", "# number of leaves (no. of txns)", "tempTree", "=", "copy", "(", "currentTree", ")", "for", "txn", "in", "txns", ":", "s", "=", "self", ".", "serialize_for_tree", "(", "txn", ")", "tempTree", ".", "append", "(", "s", ")", "return", "tempTree" ]

[ "Return", "a", "copy", "of", "merkle", "tree", "after", "applying", "the", "txns", ":", "param", "txns", ":", ":", "return", ":" ]

[ "def", "cache", "(", "self", ")", ":", "self", ".", "is_cached", "=", "True", "self", ".", "persist", "(", "StorageLevel", ".", "MEMORY_ONLY", ")", "return", "self" ]

[ "Persist", "this", "RDD", "with", "the", "default", "storage", "level", "(", "C", "{", "MEMORY_ONLY", "}", ")", "." ]

[ "def", "_refresh", "(", "self", ")", ":", "## clear any existing results files", "oldfiles", "=", "[", "self", ".", "files", ".", "qdump", "]", "+", "self", ".", "database", ".", "__dict__", ".", "values", "(", ")", "+", "self", ".", "trees", ".", "__dict__", ".", "values", "(", ")", "for", "oldfile", "in", "oldfiles", ":", "if", "oldfile", ":", "if", "os", ".", "path", ".", "exists", "(", "oldfile", ")", ":", "os", ".", "remove", "(", "oldfile", ")", "## store old ipcluster info", "oldcluster", "=", "copy", ".", "deepcopy", "(", "self", ".", "_ipcluster", ")", "## reinit the tetrad object data.", "self", ".", "__init__", "(", "name", "=", "self", ".", "name", ",", "data", "=", "self", ".", "files", ".", "data", ",", "mapfile", "=", "self", ".", "files", ".", "mapfile", ",", "workdir", "=", "self", ".", "dirs", ",", "method", "=", "self", ".", "params", ".", "method", ",", "guidetree", "=", "self", ".", "files", ".", "tree", ",", "resolve_ambigs", "=", "self", ".", "params", ".", "resolve_ambigs", ",", "save_invariants", "=", "self", ".", "params", ".", "save_invariants", ",", "nboots", "=", "self", ".", "params", ".", "nboots", ",", "nquartets", "=", "self", ".", "params", ".", "nquartets", ",", "initarr", "=", "True", ",", "quiet", "=", "True", ",", "cli", "=", "self", ".", "kwargs", ".", "get", "(", "\"cli\"", ")", ")", "## retain the same ipcluster info", "self", ".", "_ipcluster", "=", "oldcluster" ]

[ "Remove", "all", "existing", "results", "files", "and", "reinit", "the", "h5", "arrays", "so", "that", "the", "tetrad", "object", "is", "just", "like", "fresh", "from", "a", "CLI", "start", "." ]

[ "def", "splitext", "(", "fname", ")", ":", "from", "pathlib", "import", "Path", "basename", "=", "str", "(", "Path", "(", "fname", ")", ".", "name", ")", "stem", "=", "Path", "(", "basename", ".", "rstrip", "(", "'.gz'", ")", ")", ".", "stem", "return", "stem", ",", "basename", "[", "len", "(", "stem", ")", ":", "]" ]

[ "Splits", "filename", "and", "extension", "(", ".", "gz", "safe", ")" ]

[ "def", "tagAttributes_while", "(", "fdef_master_list", ",", "root", ")", ":", "depth", "=", "0", "current", "=", "root", "untagged_nodes", "=", "[", "root", "]", "while", "untagged_nodes", ":", "current", "=", "untagged_nodes", ".", "pop", "(", ")", "for", "x", "in", "fdef_master_list", ":", "if", "jsName", "(", "x", ".", "path", ",", "x", ".", "name", ")", "==", "current", "[", "'name'", "]", ":", "current", "[", "'path'", "]", "=", "x", ".", "path", "if", "children", "in", "current", ":", "for", "child", "in", "children", ":", "child", "[", "\"depth\"", "]", "=", "depth", "untagged_nodes", ".", "append", "(", "child", ")", "if", "depth", "not", "in", "current", ":", "current", "[", "\"depth\"", "]", "=", "depth", "depth", "+=", "1", "return", "root" ]

[ "Tag", "each", "node", "under", "root", "with", "the", "appropriate", "depth", "." ]

[ "def", "set_description", "(", "self", ",", "description", ",", "lang", "=", "None", ")", ":", "description", "=", "Validation", ".", "description_check_convert", "(", "description", ")", "lang", "=", "Validation", ".", "lang_check_convert", "(", "lang", ",", "default", "=", "self", ".", "_default_lang", ")", "# remove any other descriptions with this language before adding", "self", ".", "delete_description", "(", "lang", ")", "subj", "=", "self", ".", "_get_uuid_uriref", "(", ")", "self", ".", "_graph", ".", "add", "(", "(", "subj", ",", "self", ".", "_commentPredicate", ",", "Literal", "(", "description", ",", "lang", ")", ")", ")" ]

[ "Sets", "the", "description", "metadata", "property", "on", "your", "Thing", "/", "Point", ".", "Only", "one", "description", "is", "allowed", "per", "language", "so", "any", "other", "descriptions", "in", "this", "language", "are", "removed", "before", "adding", "this", "one" ]

[ "def", "validate", "(", "self", ",", "options", ")", ":", "try", ":", "codecs", ".", "getencoder", "(", "options", ".", "char_encoding", ")", "except", "LookupError", ":", "self", ".", "parser", ".", "error", "(", "\"invalid 'char-encoding' %s\"", "%", "options", ".", "char_encoding", ")" ]

[ "Validate", "the", "options", "or", "exit", "()" ]

[ "def", "after_initial_csrf", "(", "self", ",", "response", ")", ":", "login_url", "=", "(", "URLObject", "(", "\"http://\"", ")", ".", "with_hostname", "(", "self", ".", "domain", ")", ".", "with_port", "(", "self", ".", "port", ")", ".", "with_path", "(", "LOGIN_API_PATH", ")", ")", "credentials", "=", "{", "\"email\"", ":", "self", ".", "login_email", ",", "\"password\"", ":", "self", ".", "login_password", ",", "}", "headers", "=", "{", "b\"X-CSRFToken\"", ":", "get_csrf_token", "(", "response", ")", ",", "}", "yield", "scrapy", ".", "FormRequest", "(", "login_url", ",", "formdata", "=", "credentials", ",", "headers", "=", "headers", ",", "callback", "=", "self", ".", "after_initial_login", ",", "errback", "=", "self", ".", "handle_error", ")" ]

[ "This", "method", "is", "called", "*", "only", "*", "if", "the", "crawler", "is", "started", "with", "an", "email", "and", "password", "combination", ".", "In", "order", "to", "log", "in", "we", "need", "a", "CSRF", "token", "from", "a", "GET", "request", ".", "This", "method", "takes", "the", "result", "of", "a", "GET", "request", "extracts", "the", "CSRF", "token", "and", "uses", "it", "to", "make", "a", "login", "request", ".", "The", "response", "to", "this", "login", "request", "will", "be", "handled", "by", "the", "after_initial_login", "method", "." ]

[ "def", "responseInColor", "(", "request", ",", "status", ",", "headers", ",", "prefix", "=", "'Response'", ",", "opts", "=", "None", ")", ":", "code", ",", "message", "=", "status", ".", "split", "(", "None", ",", "1", ")", "message", "=", "'%s [%s] => Request %s %s %s on pid %d'", "%", "(", "prefix", ",", "code", ",", "str", "(", "request", ".", "host", ")", ",", "request", ".", "method", ",", "request", ".", "path", ",", "os", ".", "getpid", "(", ")", ")", "signal", "=", "int", "(", "code", ")", "/", "100", "if", "signal", "==", "2", ":", "chalk", ".", "green", "(", "message", ",", "opts", "=", "opts", ")", "elif", "signal", "==", "3", ":", "chalk", ".", "blue", "(", "message", ",", "opts", "=", "opts", ")", "else", ":", "chalk", ".", "red", "(", "message", ",", "opts", "=", "opts", ")" ]

[ "Prints", "the", "response", "info", "in", "color" ]

[ "def", "Bahadori_liquid", "(", "T", ",", "M", ")", ":", "A", "=", "[", "-", "6.48326E-2", ",", "2.715015E-3", ",", "-", "1.08580E-5", ",", "9.853917E-9", "]", "B", "=", "[", "1.565612E-2", ",", "-", "1.55833E-4", ",", "5.051114E-7", ",", "-", "4.68030E-10", "]", "C", "=", "[", "-", "1.80304E-4", ",", "1.758693E-6", ",", "-", "5.55224E-9", ",", "5.201365E-12", "]", "D", "=", "[", "5.880443E-7", ",", "-", "5.65898E-9", ",", "1.764384E-11", ",", "-", "1.65944E-14", "]", "X", ",", "Y", "=", "M", ",", "T", "a", "=", "A", "[", "0", "]", "+", "B", "[", "0", "]", "*", "X", "+", "C", "[", "0", "]", "*", "X", "**", "2", "+", "D", "[", "0", "]", "*", "X", "**", "3", "b", "=", "A", "[", "1", "]", "+", "B", "[", "1", "]", "*", "X", "+", "C", "[", "1", "]", "*", "X", "**", "2", "+", "D", "[", "1", "]", "*", "X", "**", "3", "c", "=", "A", "[", "2", "]", "+", "B", "[", "2", "]", "*", "X", "+", "C", "[", "2", "]", "*", "X", "**", "2", "+", "D", "[", "2", "]", "*", "X", "**", "3", "d", "=", "A", "[", "3", "]", "+", "B", "[", "3", "]", "*", "X", "+", "C", "[", "3", "]", "*", "X", "**", "2", "+", "D", "[", "3", "]", "*", "X", "**", "3", "return", "a", "+", "b", "*", "Y", "+", "c", "*", "Y", "**", "2", "+", "d", "*", "Y", "**", "3" ]

[ "r", "Estimates", "the", "thermal", "conductivity", "of", "parafin", "liquid", "hydrocarbons", ".", "Fits", "their", "data", "well", "and", "is", "useful", "as", "only", "MW", "is", "required", ".", "X", "is", "the", "Molecular", "weight", "and", "Y", "the", "temperature", "." ]

[ "def", "main", "(", ")", ":", "#TODO: need to be mv in .rst doc", "from", "reliure", ".", "pipeline", "import", "Composable", "@", "Composable", "def", "doc_analyse", "(", "docs", ")", ":", "for", "doc", "in", "docs", ":", "yield", "{", "\"title\"", ":", "doc", ",", "\"url\"", ":", "\"http://lost.com/%s\"", "%", "doc", ",", "}", "@", "Composable", "def", "print_ulrs", "(", "docs", ")", ":", "for", "doc", "in", "docs", ":", "print", "(", "doc", "[", "\"url\"", "]", ")", "yield", "doc", "pipeline", "=", "doc_analyse", "|", "print_ulrs", "documents", "=", "(", "\"doc_%s\"", "%", "d", "for", "d", "in", "xrange", "(", "20", ")", ")", "res", "=", "run_parallel", "(", "pipeline", ",", "documents", ",", "ncpu", "=", "2", ",", "chunksize", "=", "5", ")", "print", "(", "res", ")" ]

[ "Small", "run", "usage", "exemple" ]

[ "def", "decrypt", "(", "data", ",", "digest", "=", "True", ")", ":", "alg", ",", "_", ",", "data", "=", "data", ".", "rpartition", "(", "\"$\"", ")", "if", "not", "alg", ":", "return", "data", "data", "=", "_from_hex_digest", "(", "data", ")", "if", "digest", "else", "data", "try", ":", "return", "implementations", "[", "\"decryption\"", "]", "[", "alg", "]", "(", "data", ",", "implementations", "[", "\"get_key\"", "]", "(", ")", ")", "except", "KeyError", ":", "raise", "CryptError", "(", "\"Can not decrypt key for algorithm: %s\"", "%", "alg", ")" ]

[ "Decrypt", "provided", "data", "." ]

[ "def", "vectorize", "(", "fn", ")", ":", "@", "functools", ".", "wraps", "(", "fn", ")", "def", "vectorized_method", "(", "self", ",", "values", ",", "*", "vargs", ",", "*", "*", "kwargs", ")", ":", "wrap", "=", "not", "isinstance", "(", "values", ",", "(", "list", ",", "tuple", ")", ")", "should_unwrap", "=", "not", "kwargs", ".", "setdefault", "(", "'wrap'", ",", "False", ")", "unwrap", "=", "wrap", "and", "should_unwrap", "del", "kwargs", "[", "'wrap'", "]", "if", "wrap", ":", "values", "=", "[", "values", "]", "results", "=", "[", "fn", "(", "self", ",", "value", ",", "*", "vargs", ",", "*", "*", "kwargs", ")", "for", "value", "in", "values", "]", "if", "unwrap", ":", "results", "=", "results", "[", "0", "]", "return", "results", "return", "vectorized_method" ]

[ "Allows", "a", "method", "to", "accept", "one", "or", "more", "values", "but", "internally", "deal", "only", "with", "a", "single", "item", "and", "returning", "a", "list", "or", "a", "single", "item", "depending", "on", "what", "is", "desired", "." ]

[ "def", "find_field", "(", "self", ",", "field", "=", "None", ",", "alias", "=", "None", ")", ":", "if", "alias", ":", "field", "=", "alias", "field", "=", "FieldFactory", "(", "field", ",", "table", "=", "self", ",", "alias", "=", "alias", ")", "identifier", "=", "field", ".", "get_identifier", "(", ")", "for", "field", "in", "self", ".", "fields", ":", "if", "field", ".", "get_identifier", "(", ")", "==", "identifier", ":", "return", "field", "return", "None" ]

[ "Finds", "a", "field", "by", "name", "or", "alias", "." ]

[ "def", "_get_output_nodes", "(", "self", ",", "output_path", ",", "error_path", ")", ":", "status", "=", "cod_deposition_states", ".", "UNKNOWN", "messages", "=", "[", "]", "if", "output_path", "is", "not", "None", ":", "content", "=", "None", "with", "open", "(", "output_path", ")", "as", "f", ":", "content", "=", "f", ".", "read", "(", ")", "status", ",", "message", "=", "CifCodDepositParser", ".", "_deposit_result", "(", "content", ")", "messages", ".", "extend", "(", "message", ".", "split", "(", "'\\n'", ")", ")", "if", "error_path", "is", "not", "None", ":", "with", "open", "(", "error_path", ")", "as", "f", ":", "content", "=", "f", ".", "readlines", "(", ")", "lines", "=", "[", "x", ".", "strip", "(", "'\\n'", ")", "for", "x", "in", "content", "]", "messages", ".", "extend", "(", "lines", ")", "parameters", "=", "{", "'output_messages'", ":", "messages", ",", "'status'", ":", "status", "}", "output_nodes", "=", "[", "]", "output_nodes", ".", "append", "(", "(", "'messages'", ",", "Dict", "(", "dict", "=", "parameters", ")", ")", ")", "if", "status", "==", "cod_deposition_states", ".", "SUCCESS", ":", "return", "True", ",", "output_nodes", "return", "False", ",", "output_nodes" ]

[ "Extracts", "output", "nodes", "from", "the", "standard", "output", "and", "standard", "error", "files" ]