Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "set_gridcolor", "(", "self", ",", "color", ")", ":", "self", ".", "gridcolor", "=", "color", "for", "ax", "in", "self", ".", "canvas", ".", "figure", ".", "get_axes", "(", ")", ":", "for", "i", "in", "ax", ".", "get_xgridlines", "(", ")", "+", "ax", ".", "get_ygridlines", "(", ")", ":", "i", ".", "set_color", "(", "color", ")", "i", ".", "set_zorder", "(", "-", "1", ")", "if", "callable", "(", "self", ".", "theme_color_callback", ")", ":", "self", ".", "theme_color_callback", "(", "color", ",", "'grid'", ")" ]

[ "set", "color", "for", "grid" ]

[ "def", "range_initialization", "(", "X", ",", "num_weights", ")", ":", "# Randomly initialize weights to cover the range of each feature.", "X_", "=", "X", ".", "reshape", "(", "-", "1", ",", "X", ".", "shape", "[", "-", "1", "]", ")", "min_val", ",", "max_val", "=", "X_", ".", "min", "(", "0", ")", ",", "X_", ".", "max", "(", "0", ")", "data_range", "=", "max_val", "-", "min_val", "return", "data_range", "*", "np", ".", "random", ".", "rand", "(", "num_weights", ",", "X", ".", "shape", "[", "-", "1", "]", ")", "+", "min_val" ]

[ "Initialize", "the", "weights", "by", "calculating", "the", "range", "of", "the", "data", "." ]

[ "def", "list_", "(", ")", ":", "ret", "=", "{", "}", "cmd", "=", "'cpan -l'", "out", "=", "__salt__", "[", "'cmd.run'", "]", "(", "cmd", ")", ".", "splitlines", "(", ")", "for", "line", "in", "out", ":", "comps", "=", "line", ".", "split", "(", ")", "ret", "[", "comps", "[", "0", "]", "]", "=", "comps", "[", "1", "]", "return", "ret" ]

[ "List", "installed", "Perl", "modules", "and", "the", "version", "installed" ]

[ "def", "export_distributions", "(", "region", "=", "None", ",", "key", "=", "None", ",", "keyid", "=", "None", ",", "profile", "=", "None", ")", ":", "results", "=", "OrderedDict", "(", ")", "conn", "=", "_get_conn", "(", "region", "=", "region", ",", "key", "=", "key", ",", "keyid", "=", "keyid", ",", "profile", "=", "profile", ")", "try", ":", "for", "name", ",", "distribution", "in", "_list_distributions", "(", "conn", ",", "region", "=", "region", ",", "key", "=", "key", ",", "keyid", "=", "keyid", ",", "profile", "=", "profile", ",", ")", ":", "config", "=", "distribution", "[", "'distribution'", "]", "[", "'DistributionConfig'", "]", "tags", "=", "distribution", "[", "'tags'", "]", "distribution_sls_data", "=", "[", "{", "'name'", ":", "name", "}", ",", "{", "'config'", ":", "config", "}", ",", "{", "'tags'", ":", "tags", "}", ",", "]", "results", "[", "'Manage CloudFront distribution {0}'", ".", "format", "(", "name", ")", "]", "=", "{", "'boto_cloudfront.present'", ":", "distribution_sls_data", ",", "}", "except", "botocore", ".", "exceptions", ".", "ClientError", "as", "err", ":", "# Raise an exception, as this is meant to be user-invoked at the CLI", "# as opposed to being called from execution or state modules", "raise", "err", "dumper", "=", "__utils__", "[", "'yaml.get_dumper'", "]", "(", "'IndentedSafeOrderedDumper'", ")", "return", "__utils__", "[", "'yaml.dump'", "]", "(", "results", ",", "default_flow_style", "=", "False", ",", "Dumper", "=", "dumper", ",", ")" ]

[ "Get", "details", "of", "all", "CloudFront", "distributions", ".", "Produces", "results", "that", "can", "be", "used", "to", "create", "an", "SLS", "file", "." ]

[ "def", "untrace_property", "(", "cls", ",", "accessor", ")", ":", "if", "not", "is_traced", "(", "accessor", ".", "fget", ")", "or", "not", "is_traced", "(", "accessor", ".", "fset", ")", "or", "not", "is_traced", "(", "accessor", ".", "fdel", ")", ":", "return", "False", "name", "=", "get_method_name", "(", "accessor", ")", "setattr", "(", "cls", ",", "name", ",", "property", "(", "untracer", "(", "accessor", ".", "fget", ")", ",", "untracer", "(", "accessor", ".", "fset", ")", ",", "untracer", "(", "accessor", ".", "fdel", ")", ")", ")", "return", "True" ]

[ "Untraces", "given", "class", "property", "." ]

[ "def", "get", "(", "self", ",", "metric_id", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "metric_id", "is", "None", ":", "raise", "AttributeError", "(", "'metric_id is required to get metric points.'", ")", "return", "self", ".", "_get", "(", "'metrics/%s/points'", "%", "metric_id", ",", "data", "=", "kwargs", ")" ]

[ "https", ":", "//", "docs", ".", "cachethq", ".", "io", "/", "docs", "/", "get", "-", "metric", "-", "points" ]

[ "def", "main", "(", ")", ":", "arguments", "=", "sys", ".", "argv", "[", "1", ":", "]", "print", "(", "'Managing solution with arguments: '", ")", "print", "(", "arguments", ")", "SwarmManager", ".", "HandleManagement", "(", "arguments", ")" ]

[ "Entry", "point", "for", "the", "application", "script" ]

[ "def", "stop_cont", "(", "self", ",", "cont", "=", "True", ")", ":", "for", "proc", "in", "psutil", ".", "process_iter", "(", ")", ":", "if", "proc", ".", "name", "(", ")", "==", "self", ".", "process_name", ":", "sig", "=", "psutil", ".", "signal", ".", "SIGCONT", "if", "cont", "else", "psutil", ".", "signal", ".", "SIGSTOP", "proc", ".", "send_signal", "(", "sig", ")", "if", "self", ".", "debug", ":", "sig", "=", "'CONT'", "if", "cont", "else", "'STOP'", "print", "(", "\"Sent SIG%s to process %d\"", "%", "(", "sig", ",", "proc", ".", "pid", ")", ")" ]

[ "Send", "SIGSTOP", "/", "SIGCONT", "to", "processes", "called", "<name", ">" ]

[ "def", "_duplicate_example", "(", "self", ",", "request", ")", ":", "index", "=", "int", "(", "request", ".", "args", ".", "get", "(", "'index'", ")", ")", "if", "index", ">=", "len", "(", "self", ".", "examples", ")", ":", "return", "http_util", ".", "Respond", "(", "request", ",", "{", "'error'", ":", "'invalid index provided'", "}", ",", "'application/json'", ",", "code", "=", "400", ")", "new_example", "=", "self", ".", "example_class", "(", ")", "new_example", ".", "CopyFrom", "(", "self", ".", "examples", "[", "index", "]", ")", "self", ".", "examples", ".", "append", "(", "new_example", ")", "self", ".", "updated_example_indices", ".", "add", "(", "len", "(", "self", ".", "examples", ")", "-", "1", ")", "self", ".", "generate_sprite", "(", "[", "ex", ".", "SerializeToString", "(", ")", "for", "ex", "in", "self", ".", "examples", "]", ")", "return", "http_util", ".", "Respond", "(", "request", ",", "{", "}", ",", "'application/json'", ")" ]

[ "Duplicates", "the", "specified", "example", "." ]

[ "def", "_compute_delta_beta", "(", "self", ",", "X", ",", "T", ",", "E", ",", "weights", ",", "index", "=", "None", ")", ":", "score_residuals", "=", "self", ".", "_compute_score", "(", "X", ",", "T", ",", "E", ",", "weights", ",", "index", "=", "index", ")", "d", "=", "X", ".", "shape", "[", "1", "]", "scaled_variance_matrix", "=", "self", ".", "variance_matrix_", "*", "np", ".", "tile", "(", "self", ".", "_norm_std", ".", "values", ",", "(", "d", ",", "1", ")", ")", ".", "T", "delta_betas", "=", "score_residuals", ".", "dot", "(", "scaled_variance_matrix", ")", "delta_betas", ".", "columns", "=", "self", ".", "hazards_", ".", "index", "return", "delta_betas" ]

[ "approximate", "change", "in", "betas", "as", "a", "result", "of", "excluding", "ith", "row", ".", "Good", "for", "finding", "outliers", "/", "specific", "subjects", "that", "influence", "the", "model", "disproportionately", ".", "Good", "advice", ":", "don", "t", "drop", "these", "outliers", "model", "them", "." ]

[ "def", "map", "(", "self", ",", "*", "sequences", ")", ":", "# set _map as a flag for use inside self.__call__", "self", ".", "_map", "=", "True", "try", ":", "ret", "=", "self", ".", "__call__", "(", "*", "sequences", ")", "finally", ":", "del", "self", ".", "_map", "return", "ret" ]

[ "call", "a", "function", "on", "each", "element", "of", "a", "sequence", "remotely", ".", "This", "should", "behave", "very", "much", "like", "the", "builtin", "map", "but", "return", "an", "AsyncMapResult", "if", "self", ".", "block", "is", "False", "." ]

[ "def", "set_data", "(", "self", ",", "data", ")", ":", "self", ".", "shape", "=", "data", ".", "shape", "if", "self", ".", "_data", "is", "None", ":", "assert", "self", ".", "_deferred_init", ",", "\"Parameter '%s' has not been initialized\"", "%", "self", ".", "name", "self", ".", "_deferred_init", "=", "self", ".", "_deferred_init", "[", ":", "3", "]", "+", "(", "data", ",", ")", "return", "# if update_on_kvstore, we need to make sure the copy stored in kvstore is in sync", "if", "self", ".", "_trainer", "and", "self", ".", "_trainer", ".", "_kv_initialized", "and", "self", ".", "_trainer", ".", "_update_on_kvstore", ":", "if", "self", "not", "in", "self", ".", "_trainer", ".", "_params_to_init", ":", "self", ".", "_trainer", ".", "_reset_kvstore", "(", ")", "for", "arr", "in", "self", ".", "_check_and_get", "(", "self", ".", "_data", ",", "list", ")", ":", "arr", "[", ":", "]", "=", "data" ]

[ "Sets", "this", "parameter", "s", "value", "on", "all", "contexts", "." ]

[ "def", "control_gate", "(", "control", ":", "Qubit", ",", "gate", ":", "Gate", ")", "->", "Gate", ":", "if", "control", "in", "gate", ".", "qubits", ":", "raise", "ValueError", "(", "'Gate and control qubits overlap'", ")", "qubits", "=", "[", "control", ",", "*", "gate", ".", "qubits", "]", "gate_tensor", "=", "join_gates", "(", "P0", "(", "control", ")", ",", "identity_gate", "(", "gate", ".", "qubits", ")", ")", ".", "tensor", "+", "join_gates", "(", "P1", "(", "control", ")", ",", "gate", ")", ".", "tensor", "controlled_gate", "=", "Gate", "(", "qubits", "=", "qubits", ",", "tensor", "=", "gate_tensor", ")", "return", "controlled_gate" ]

[ "Return", "a", "controlled", "unitary", "gate", ".", "Given", "a", "gate", "acting", "on", "K", "qubits", "return", "a", "new", "gate", "on", "K", "+", "1", "qubits", "prepended", "with", "a", "control", "bit", "." ]

[ "def", "quote_edge", "(", "identifier", ")", ":", "node", ",", "_", ",", "rest", "=", "identifier", ".", "partition", "(", "':'", ")", "parts", "=", "[", "quote", "(", "node", ")", "]", "if", "rest", ":", "port", ",", "_", ",", "compass", "=", "rest", ".", "partition", "(", "':'", ")", "parts", ".", "append", "(", "quote", "(", "port", ")", ")", "if", "compass", ":", "parts", ".", "append", "(", "compass", ")", "return", "':'", ".", "join", "(", "parts", ")" ]

[ "Return", "DOT", "edge", "statement", "node_id", "from", "string", "quote", "if", "needed", "." ]

[ "def", "daemonize", "(", ")", ":", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stderr", ".", "flush", "(", ")", "# UNIX double-fork magic. We need to fork before any threads are", "# created.", "pid", "=", "os", ".", "fork", "(", ")", "if", "pid", ">", "0", ":", "# Exit first parent.", "sys", ".", "exit", "(", "0", ")", "# Decouple from parent environment.", "os", ".", "chdir", "(", "'/'", ")", "os", ".", "setsid", "(", ")", "os", ".", "umask", "(", "0", ")", "# Now fork again.", "pid", "=", "os", ".", "fork", "(", ")", "if", "pid", ">", "0", ":", "# Exit second parent.", "sys", ".", "exit", "(", "0", ")", "_redirect_output", "(", "os", ".", "devnull", ")" ]

[ "Forks", "and", "daemonizes", "the", "current", "process", ".", "Does", "not", "automatically", "track", "the", "process", "id", ";", "to", "do", "this", "use", ":", "class", ":", "Exscript", ".", "util", ".", "pidutil", "." ]

[ "def", "trace_requirements", "(", "requirements", ")", ":", "requirements", "=", "tuple", "(", "pretty_req", "(", "r", ")", "for", "r", "in", "requirements", ")", "working_set", "=", "fresh_working_set", "(", ")", "# breadth-first traversal:", "from", "collections", "import", "deque", "queue", "=", "deque", "(", "requirements", ")", "queued", "=", "{", "_package_req_to_pkg_resources_req", "(", "req", ".", "req", ")", "for", "req", "in", "queue", "}", "errors", "=", "[", "]", "result", "=", "[", "]", "while", "queue", ":", "req", "=", "queue", ".", "popleft", "(", ")", "logger", ".", "debug", "(", "'tracing: %s'", ",", "req", ")", "try", ":", "dist", "=", "working_set", ".", "find_normalized", "(", "_package_req_to_pkg_resources_req", "(", "req", ".", "req", ")", ")", "except", "pkg_resources", ".", "VersionConflict", "as", "conflict", ":", "dist", "=", "conflict", ".", "args", "[", "0", "]", "errors", ".", "append", "(", "'Error: version conflict: {} ({}) <-> {}'", ".", "format", "(", "dist", ",", "timid_relpath", "(", "dist", ".", "location", ")", ",", "req", ")", ")", "assert", "dist", "is", "not", "None", ",", "'Should be unreachable in pip8+'", "result", ".", "append", "(", "dist_to_req", "(", "dist", ")", ")", "# TODO: pip does no validation of extras. should we?", "extras", "=", "[", "extra", "for", "extra", "in", "req", ".", "extras", "if", "extra", "in", "dist", ".", "extras", "]", "for", "sub_req", "in", "sorted", "(", "dist", ".", "requires", "(", "extras", "=", "extras", ")", ",", "key", "=", "lambda", "req", ":", "req", ".", "key", ")", ":", "sub_req", "=", "InstallRequirement", "(", "sub_req", ",", "req", ")", "if", "req_cycle", "(", "sub_req", ")", ":", "logger", ".", "warning", "(", "'Circular dependency! %s'", ",", "sub_req", ")", "continue", "elif", "sub_req", ".", "req", "in", "queued", ":", "logger", ".", "debug", "(", "'already queued: %s'", ",", "sub_req", ")", "continue", "else", ":", "logger", ".", "debug", "(", "'adding sub-requirement %s'", ",", "sub_req", ")", "queue", ".", "append", "(", "sub_req", ")", "queued", ".", "add", "(", "sub_req", ".", "req", ")", "if", "errors", ":", "raise", "InstallationError", "(", "'\\n'", ".", "join", "(", "errors", ")", ")", "return", "result" ]

[ "given", "an", "iterable", "of", "pip", "InstallRequirements", "return", "the", "set", "of", "required", "packages", "given", "their", "transitive", "requirements", "." ]

[ "def", "_decrypt_object", "(", "obj", ")", ":", "if", "isinstance", "(", "obj", ",", "six", ".", "string_types", ")", ":", "return", "_fetch_secret", "(", "obj", ")", "elif", "isinstance", "(", "obj", ",", "dict", ")", ":", "for", "pass_key", ",", "pass_path", "in", "six", ".", "iteritems", "(", "obj", ")", ":", "obj", "[", "pass_key", "]", "=", "_decrypt_object", "(", "pass_path", ")", "elif", "isinstance", "(", "obj", ",", "list", ")", ":", "for", "pass_key", ",", "pass_path", "in", "enumerate", "(", "obj", ")", ":", "obj", "[", "pass_key", "]", "=", "_decrypt_object", "(", "pass_path", ")", "return", "obj" ]

[ "Recursively", "try", "to", "find", "a", "pass", "path", "(", "string", ")", "that", "can", "be", "handed", "off", "to", "pass" ]

[ "def", "filter_lines", "(", "input_file", ",", "output_file", ",", "translate", "=", "lambda", "line", ":", "line", ")", ":", "filepath", ",", "lines", "=", "get_lines", "(", "[", "input_file", "]", ")", "[", "0", "]", "return", "filepath", ",", "[", "(", "tag", ",", "translate", "(", "line", "=", "line", ",", "tag", "=", "tag", ")", ")", "for", "(", "tag", ",", "line", ")", "in", "lines", "]" ]

[ "Translate", "all", "the", "lines", "of", "a", "single", "file" ]

[ "def", "import_locations", "(", "self", ",", "data", ")", ":", "self", ".", "_data", "=", "data", "if", "hasattr", "(", "data", ",", "'read'", ")", ":", "data", "=", "data", ".", "read", "(", ")", ".", "split", "(", "'//\\n'", ")", "elif", "isinstance", "(", "data", ",", "list", ")", ":", "pass", "elif", "isinstance", "(", "data", ",", "basestring", ")", ":", "data", "=", "open", "(", "data", ")", ".", "read", "(", ")", ".", "split", "(", "'//\\n'", ")", "else", ":", "raise", "TypeError", "(", "'Unable to handle data of type %r'", "%", "type", "(", "data", ")", ")", "keys", "=", "(", "'identifier'", ",", "'ptype'", ",", "'population'", ",", "'size'", ",", "'name'", ",", "'country'", ",", "'region'", ",", "'location'", ",", "'longitude'", ",", "'latitude'", ",", "'altitude'", ",", "'date'", ",", "'entered'", ")", "for", "record", "in", "data", ":", "# We truncate after splitting because the v1.4.2 datafile contains", "# a broken separator between 229 and 230 that would otherwise break", "# the import", "data", "=", "[", "i", ".", "split", "(", "':'", ")", "[", "1", "]", ".", "strip", "(", ")", "for", "i", "in", "record", ".", "splitlines", "(", ")", "[", ":", "13", "]", "]", "entries", "=", "dict", "(", "zip", "(", "keys", ",", "data", ")", ")", "# Entry for Utrecht has the incorrect value of 0.000 for elevation.", "if", "entries", "[", "'altitude'", "]", "==", "'0.000'", ":", "logging", ".", "debug", "(", "\"Ignoring `0.000' value for elevation in %r \"", "'entry'", "%", "record", ")", "entries", "[", "'altitude'", "]", "=", "''", "for", "i", "in", "(", "'identifier'", ",", "'population'", ",", "'size'", ",", "'altitude'", ")", ":", "entries", "[", "i", "]", "=", "int", "(", "entries", "[", "i", "]", ")", "if", "entries", "[", "i", "]", "else", "None", "for", "i", "in", "(", "'longitude'", ",", "'latitude'", ")", ":", "entries", "[", "i", "]", "=", "float", "(", "entries", "[", "i", "]", ")", "if", "entries", "[", "i", "]", "else", "None", "entries", "[", "'date'", "]", "=", "time", ".", "strptime", "(", "entries", "[", "'date'", "]", ",", "'%Y%m%d'", ")", "self", ".", "append", "(", "City", "(", "*", "*", "entries", ")", ")" ]

[ "Parse", "GNU", "miscfiles", "_", "cities", "data", "files", "." ]

[ "def", "model_length", "(", "gene", ",", "domain", ")", ":", "if", "gene", "==", "'16S'", ":", "domain2max", "=", "{", "'E_coli_K12'", ":", "int", "(", "1538", ")", ",", "'bacteria'", ":", "int", "(", "1689", ")", ",", "'archaea'", ":", "int", "(", "1563", ")", ",", "'eukarya'", ":", "int", "(", "2652", ")", "}", "return", "domain2max", "[", "domain", "]", "elif", "gene", "==", "'23S'", ":", "domain2max", "=", "{", "'E_coli_K12'", ":", "int", "(", "2903", ")", ",", "'bacteria'", ":", "int", "(", "3146", ")", ",", "'archaea'", ":", "int", "(", "3774", ")", ",", "'eukarya'", ":", "int", "(", "9079", ")", "}", "return", "domain2max", "[", "domain", "]", "else", ":", "print", "(", "sys", ".", "stderr", ",", "'# length unknown for gene: %s, domain: %s'", "%", "(", "gene", ",", "domain", ")", ")", "exit", "(", ")" ]

[ "get", "length", "of", "model" ]

[ "def", "run_freidman_supsmu", "(", "x", ",", "y", ",", "bass_enhancement", "=", "0.0", ")", ":", "N", "=", "len", "(", "x", ")", "weight", "=", "numpy", ".", "ones", "(", "N", ")", "results", "=", "numpy", ".", "zeros", "(", "N", ")", "flags", "=", "numpy", ".", "zeros", "(", "(", "N", ",", "7", ")", ")", "mace", ".", "supsmu", "(", "x", ",", "y", ",", "weight", ",", "1", ",", "0.0", ",", "bass_enhancement", ",", "results", ",", "flags", ")", "return", "results" ]

[ "Run", "the", "FORTRAN", "supersmoother", "." ]

[ "def", "set_special", "(", "index", ",", "color", ",", "iterm_name", "=", "\"h\"", ",", "alpha", "=", "100", ")", ":", "if", "OS", "==", "\"Darwin\"", "and", "iterm_name", ":", "return", "\"\\033]P%s%s\\033\\\\\"", "%", "(", "iterm_name", ",", "color", ".", "strip", "(", "\"#\"", ")", ")", "if", "index", "in", "[", "11", ",", "708", "]", "and", "alpha", "!=", "\"100\"", ":", "return", "\"\\033]%s;[%s]%s\\033\\\\\"", "%", "(", "index", ",", "alpha", ",", "color", ")", "return", "\"\\033]%s;%s\\033\\\\\"", "%", "(", "index", ",", "color", ")" ]

[ "Convert", "a", "hex", "color", "to", "a", "special", "sequence", "." ]

[ "def", "sentence_bytes", "(", "self", ",", "sentence", ")", ":", "result", "=", "[", "TOKENS", "[", "sentence", "[", "0", "]", "]", "]", "for", "i", "in", "sentence", "[", "1", ":", "]", ":", "# Remaining bytes", "if", "isinstance", "(", "i", ",", "str", ")", ":", "result", ".", "extend", "(", "self", ".", "literal", "(", "i", ")", ")", "elif", "isinstance", "(", "i", ",", "float", ")", "or", "isinstance", "(", "i", ",", "int", ")", ":", "# A number?", "result", ".", "extend", "(", "self", ".", "number", "(", "i", ")", ")", "else", ":", "result", ".", "extend", "(", "i", ")", "# Must be another thing", "return", "result" ]

[ "Return", "bytes", "of", "a", "sentence", ".", "This", "is", "a", "very", "simple", "parser", ".", "Sentence", "is", "a", "list", "of", "strings", "and", "numbers", ".", "1st", "element", "of", "sentence", "MUST", "match", "a", "token", "." ]

[ "def", "get_magic_info", "(", "self", ",", "child_type", ",", "parent_type", "=", "None", ",", "attr", "=", "'er'", ",", "filename", "=", "None", ",", "sort_by_file_type", "=", "False", ")", ":", "parent", "=", "''", "grandparent_type", "=", "None", "magic_name", "=", "'er_'", "+", "child_type", "+", "'_name'", "expected_item_type", "=", "child_type", "if", "not", "filename", ":", "short_filename", "=", "attr", "+", "'_'", "+", "child_type", "+", "'s.txt'", "magic_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "WD", ",", "short_filename", ")", "else", ":", "short_filename", "=", "os", ".", "path", ".", "split", "(", "filename", ")", "[", "1", "]", "magic_file", "=", "filename", "attr", "=", "short_filename", ".", "split", "(", "'_'", ")", "[", "0", "]", "print", "(", "'-I- Attempting to read {}'", ".", "format", "(", "magic_file", ")", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "magic_file", ")", ":", "print", "(", "'-W- Could not find {}'", ".", "format", "(", "magic_file", ")", ")", "return", "False", "# get the data from the appropriate .txt file", "data_dict", ",", "header", ",", "file_type", "=", "self", ".", "read_magic_file", "(", "magic_file", ",", "magic_name", ",", "sort_by_file_type", "=", "sort_by_file_type", ")", "if", "not", "data_dict", ":", "print", "(", "'-W- Could not read in file: {}.\\n Make sure it is a MagIC-format file'", ".", "format", "(", "magic_file", ")", ")", "return", "False", "item_type", "=", "file_type", ".", "split", "(", "'_'", ")", "[", "1", "]", "[", ":", "-", "1", "]", "# if a file was named wrong, use the type of data that is actually in that file", "if", "item_type", "!=", "expected_item_type", ":", "print", "(", "'-W- Expected data of type: {} but instead got: {}'", ".", "format", "(", "expected_item_type", ",", "item_type", ")", ")", "print", "(", "'-W- Using type: {}'", ".", "format", "(", "item_type", ")", ")", "if", "item_type", "==", "'age'", ":", "self", ".", "get_age_info", "(", "filename", ")", "return", "'age'", "child_type", "=", "item_type", "magic_name", "=", "'er_'", "+", "child_type", "+", "'_name'", "ind", "=", "self", ".", "ancestry", ".", "index", "(", "child_type", ")", "parent_type", "=", "self", ".", "ancestry", "[", "ind", "+", "1", "]", "if", "item_type", "!=", "'location'", ":", "grandparent_type", "=", "self", ".", "ancestry", "[", "ind", "+", "2", "]", "else", ":", "grandparent_type", "=", "''", "if", "not", "grandparent_type", ":", "ind", "=", "self", ".", "ancestry", ".", "index", "(", "child_type", ")", "try", ":", "grandparent_type", "=", "self", ".", "ancestry", "[", "ind", "+", "2", "]", "except", "IndexError", ":", "grandparent_type", "=", "None", "child_list", ",", "child_class", ",", "child_constructor", "=", "self", ".", "data_lists", "[", "child_type", "]", "if", "parent_type", ":", "parent_list", ",", "parent_class", ",", "parent_constructor", "=", "self", ".", "data_lists", "[", "parent_type", "]", "else", ":", "parent_list", ",", "parent_name", "=", "None", ",", "None", "for", "child_name", "in", "data_dict", ":", "# if there is a possible parent, try to find parent object in the data model", "if", "parent_type", ":", "parent_name", "=", "data_dict", "[", "child_name", "]", ".", "get", "(", "'er_'", "+", "parent_type", "+", "'_name'", ",", "''", ")", "parent", "=", "self", ".", "find_by_name", "(", "parent_name", ",", "parent_list", ")", "if", "parent", ":", "remove_dict_headers", "(", "parent", ".", "er_data", ")", "remove_dict_headers", "(", "parent", ".", "pmag_data", ")", "# if there should be a parent", "# (meaning there is a name for it and the child object should have a parent)", "# but none exists in the data model, go ahead and create that parent object.", "if", "parent_name", "and", "parent_type", "and", "not", "parent", ":", "# try to get grandparent", "grandparent", "=", "None", "grandparent_name", "=", "None", "if", "grandparent_type", ":", "grandparent_list", ",", "grandparent_class", ",", "grandparent_constructor", "=", "self", ".", "data_lists", "[", "grandparent_type", "]", "grandparent_name", "=", "data_dict", "[", "child_name", "]", "[", "'er_'", "+", "grandparent_type", "+", "'_name'", "]", "grandparent", "=", "self", ".", "find_by_name", "(", "grandparent_name", ",", "grandparent_list", ")", "if", "grandparent_name", "and", "not", "grandparent", ":", "grandparent", "=", "grandparent_constructor", "(", "grandparent_name", ",", "None", ")", "parent", "=", "parent_constructor", "(", "parent_name", ",", "grandparent_name", ")", "# otherwise there is no parent and none can be created, so use an empty string", "elif", "not", "parent", ":", "parent_name", "=", "None", "parent", "=", "''", "child", "=", "self", ".", "find_by_name", "(", "child_name", ",", "child_list", ")", "# if the child object does not exist yet in the data model", "if", "not", "child", ":", "child", "=", "child_constructor", "(", "child_name", ",", "parent_name", ")", "else", ":", "# bind parent to child and child to parent", "if", "parent", ":", "child", ".", "set_parent", "(", "parent", ")", "if", "parent", "and", "(", "child", "not", "in", "parent", ".", "children", ")", ":", "parent", ".", "add_child", "(", "child", ")", "# add in the appropriate data dictionary to the child object", "if", "attr", "==", "'er'", ":", "self", ".", "update_methods", "[", "child_type", "]", "(", "child_name", ",", "child_name", ",", "parent_name", ",", "new_er_data", "=", "data_dict", "[", "child_name", "]", ")", "else", ":", "self", ".", "update_methods", "[", "child_type", "]", "(", "child_name", ",", "child_name", ",", "parent_name", ",", "new_pmag_data", "=", "data_dict", "[", "child_name", "]", ")", "# old way", "#child.__setattr__(attr + '_data', data_dict[child_name])", "remove_dict_headers", "(", "child", ".", "er_data", ")", "remove_dict_headers", "(", "child", ".", "pmag_data", ")", "#", "return", "child_type" ]

[ "Read", "er_", "*", ".", "txt", "or", "pmag_", "*", ".", "txt", "file", ".", "If", "no", "filename", "is", "provided", "use", "er_", "*", "or", "pmag_", "*", "file", "in", "WD", ".", "If", "sort_by_file_type", "use", "file", "header", "to", "determine", "child", "parent", "types", "instead", "of", "passing", "those", "in", "as", "arguments", ".", "Once", "file", "is", "open", "parse", "information", "into", "dictionaries", "for", "each", "item", ".", "If", "the", "item", "does", "not", "yet", "exist", "add", "it", "to", "the", "builder", "data", "object", ".", "Then", "add", "info", "to", "the", "item", "object", "as", "object", ".", "er_data", "or", "object", ".", "pmag_data", "." ]

[ "def", "arange", "(", "start", ",", "stop", "=", "None", ",", "step", "=", "1.0", ",", "repeat", "=", "1", ",", "infer_range", "=", "None", ",", "ctx", "=", "None", ",", "dtype", "=", "mx_real_t", ")", ":", "if", "infer_range", "is", "not", "None", ":", "warnings", ".", "warn", "(", "'`infer_range` argument has been deprecated'", ",", "DeprecationWarning", ")", "if", "ctx", "is", "None", ":", "ctx", "=", "current_context", "(", ")", "return", "_internal", ".", "_arange", "(", "start", "=", "start", ",", "stop", "=", "stop", ",", "step", "=", "step", ",", "repeat", "=", "repeat", ",", "infer_range", "=", "False", ",", "dtype", "=", "dtype", ",", "ctx", "=", "str", "(", "ctx", ")", ")" ]

[ "Returns", "evenly", "spaced", "values", "within", "a", "given", "interval", "." ]

[ "def", "deletePartials", "(", "self", ",", "dryrun", "=", "False", ")", ":", "for", "(", "vol", ",", "path", ")", "in", "self", ".", "extraVolumes", ".", "items", "(", ")", ":", "if", "not", "path", ".", "endswith", "(", "\".part\"", ")", ":", "continue", "if", "self", ".", "_skipDryRun", "(", "logger", ",", "'INFO'", ",", "dryrun", "=", "dryrun", ")", "(", "\"Delete subvolume %s\"", ",", "path", ")", ":", "continue", "self", ".", "butterVolumes", "[", "vol", ".", "uuid", "]", ".", "destroy", "(", ")" ]

[ "Delete", "any", "old", "partial", "uploads", "/", "downloads", "in", "path", "." ]

[ "def", "composer", "(", "self", ",", "type", ",", "*", "*", "meta", ")", ":", "def", "decorator", "(", "f", ")", ":", "self", ".", "register_composer", "(", "type", ",", "f", ")", "if", "meta", ":", "self", ".", "register_meta", "(", "type", ",", "*", "*", "meta", ")", "return", "f", "return", "decorator" ]

[ "Registers", "the", "decorated", "method", "as", "the", "composer", "of", "a", "format", "." ]

[ "def", "get_tip_labels", "(", "self", ",", "idx", "=", "None", ")", ":", "if", "not", "idx", ":", "return", "self", ".", "treenode", ".", "get_leaf_names", "(", ")", "[", ":", ":", "-", "1", "]", "else", ":", "treenode", "=", "self", ".", "treenode", ".", "search_nodes", "(", "idx", "=", "idx", ")", "[", "0", "]", "return", "treenode", ".", "get_leaf_names", "(", ")", "[", ":", ":", "-", "1", "]" ]

[ "Returns", "tip", "labels", "in", "the", "order", "they", "will", "be", "plotted", "on", "the", "tree", "i", ".", "e", ".", "starting", "from", "zero", "axis", "and", "counting", "up", "by", "units", "of", "1", "(", "bottom", "to", "top", "in", "right", "-", "facing", "trees", ";", "left", "to", "right", "in", "down", "-", "facing", ")", ".", "If", "idx", "is", "indicated", "then", "a", "list", "of", "tip", "labels", "descended", "from", "that", "node", "will", "be", "returned", "instead", "of", "all", "tip", "labels", ".", "This", "is", "useful", "in", "combination", "with", "other", "functions", "that", "select", "nodes", "/", "clades", "of", "the", "tree", "based", "on", "a", "list", "of", "tip", "labels", ".", "You", "can", "use", "the", "toytree", "draw", "()", "command", "with", "tip_labels", "=", "idx", "or", "tip_labels", "=", "True", "to", "see", "idx", "labels", "plotted", "on", "nodes", "." ]

[ "def", "intersection_update", "(", "self", ",", "*", "iterables", ")", ":", "_set", "=", "self", ".", "_set", "_list", "=", "self", ".", "_list", "_set", ".", "intersection_update", "(", "*", "iterables", ")", "_list", ".", "clear", "(", ")", "_list", ".", "update", "(", "_set", ")", "return", "self" ]

[ "Update", "the", "set", "keeping", "only", "elements", "found", "in", "it", "and", "all", "*", "iterables", "*", "." ]

[ "def", "start", "(", "self", ")", ":", "self", ".", "music", ".", "start", "(", ")", "if", "not", "self", ".", "start_paused", ":", "self", ".", "rocket", ".", "start", "(", ")" ]

[ "Start", "the", "timer" ]

[ "def", "initialize", "(", "state", ")", ":", "logger", ".", "debug", "(", "f\"Copying {stack_top - state.cpu.SP} bytes in the stack..\"", ")", "stack_bottom", "=", "min", "(", "state", ".", "cpu", ".", "SP", ",", "gdb", ".", "getR", "(", "'SP'", ")", ")", "for", "address", "in", "range", "(", "stack_bottom", ",", "stack_top", ")", ":", "b", "=", "state", ".", "cpu", ".", "read_int", "(", "address", ",", "8", ")", "gdb", ".", "setByte", "(", "address", ",", "chr", "(", "b", ")", ")", "logger", ".", "debug", "(", "\"Done\"", ")", "# Qemu fd's start at 5, ours at 3. Add two filler fds", "mcore_stdout", "=", "state", ".", "platform", ".", "files", "[", "1", "]", "state", ".", "platform", ".", "files", ".", "append", "(", "mcore_stdout", ")", "state", ".", "platform", ".", "files", ".", "append", "(", "mcore_stdout", ")", "# Sync gdb's regs", "for", "gdb_reg", "in", "gdb", ".", "getCanonicalRegisters", "(", ")", ":", "if", "gdb_reg", ".", "endswith", "(", "'psr'", ")", ":", "mcore_reg", "=", "'APSR'", "else", ":", "mcore_reg", "=", "gdb_reg", ".", "upper", "(", ")", "value", "=", "state", ".", "cpu", ".", "read_register", "(", "mcore_reg", ")", "gdb", ".", "setR", "(", "gdb_reg", ",", "value", ")" ]

[ "Synchronize", "the", "stack", "and", "register", "state", "(", "manticore", "-", ">", "qemu", ")" ]

[ "def", "mktmpenv_cmd", "(", "argv", ")", ":", "parser", "=", "mkvirtualenv_argparser", "(", ")", "env", "=", "'.'", "while", "(", "workon_home", "/", "env", ")", ".", "exists", "(", ")", ":", "env", "=", "hex", "(", "random", ".", "getrandbits", "(", "64", ")", ")", "[", "2", ":", "-", "1", "]", "args", ",", "rest", "=", "parser", ".", "parse_known_args", "(", "argv", ")", "mkvirtualenv", "(", "env", ",", "args", ".", "python", ",", "args", ".", "packages", ",", "requirements", "=", "args", ".", "requirements", ",", "rest", "=", "rest", ")", "print", "(", "'This is a temporary environment. It will be deleted when you exit'", ")", "try", ":", "if", "args", ".", "activate", ":", "# only used for testing on windows", "shell", "(", "env", ")", "finally", ":", "return", "rmvirtualenvs", "(", "[", "env", "]", ")" ]

[ "Create", "a", "temporary", "virtualenv", "." ]

[ "def", "compile", "(", "marker", ")", ":", "try", ":", "return", "_cache", "[", "marker", "]", "except", "KeyError", ":", "pass", "if", "not", "marker", ".", "strip", "(", ")", ":", "def", "marker_fn", "(", "environment", "=", "None", ",", "override", "=", "None", ")", ":", "\"\"\"\"\"\"", "return", "True", "else", ":", "compiled_marker", "=", "compile_marker", "(", "parse_marker", "(", "marker", ")", ")", "def", "marker_fn", "(", "environment", "=", "None", ",", "override", "=", "None", ")", ":", "\"\"\"override updates environment\"\"\"", "if", "override", "is", "None", ":", "override", "=", "{", "}", "if", "environment", "is", "None", ":", "environment", "=", "default_environment", "(", ")", "environment", ".", "update", "(", "override", ")", "return", "eval", "(", "compiled_marker", ",", "environment", ")", "marker_fn", ".", "__doc__", "=", "marker", "_cache", "[", "marker", "]", "=", "marker_fn", "return", "_cache", "[", "marker", "]" ]

[ "Return", "compiled", "marker", "as", "a", "function", "accepting", "an", "environment", "dict", "." ]

[ "def", "DiagonalGate", "(", "x", ",", "params", ",", "*", "*", "kwargs", ")", ":", "del", "params", "del", "kwargs", "# x : [batch, 1, length, depth]", "x", "=", "np", ".", "pad", "(", "x", ",", "[", "(", "0", ",", "0", ")", ",", "(", "0", ",", "0", ")", ",", "(", "1", ",", "1", ")", ",", "(", "0", ",", "0", ")", "]", ",", "mode", "=", "'constant'", ",", "constant_values", "=", "0.0", ")", "depth", "=", "x", ".", "shape", "[", "-", "1", "]", "//", "3", "assert", "3", "*", "depth", "==", "x", ".", "shape", "[", "-", "1", "]", ",", "(", "'Depth must be divisible by 3'", ",", "depth", ",", "x", ".", "shape", ")", "xs", "=", "[", "x", "[", ":", ",", ":", ",", ":", "-", "2", ",", ":", "depth", "]", ",", "x", "[", ":", ",", ":", ",", "1", ":", "-", "1", ",", "depth", ":", "2", "*", "depth", "]", ",", "x", "[", ":", ",", ":", ",", "2", ":", ",", "2", "*", "depth", ":", "3", "*", "depth", "]", "]", "return", "np", ".", "concatenate", "(", "xs", ",", "axis", "=", "3", ")" ]

[ "Split", "channels", "in", "3", "parts", ".", "Shifts", "1st", "and", "3rd", "sections", "to", "left", "/", "right", "." ]

[ "def", "encode", "(", "self", ",", "word", ",", "max_length", "=", "5", ",", "zero_pad", "=", "True", ")", ":", "word", "=", "unicode_normalize", "(", "'NFKD'", ",", "text_type", "(", "word", ".", "upper", "(", ")", ")", ")", "word", "=", "word", ".", "replace", "(", "'ß',", " ", "SS')", "", "# Clamp max_length to [4, 64]", "if", "max_length", "!=", "-", "1", ":", "max_length", "=", "min", "(", "max", "(", "4", ",", "max_length", ")", ",", "64", ")", "else", ":", "max_length", "=", "64", "if", "not", "word", ":", "if", "zero_pad", ":", "return", "'0'", "*", "max_length", "return", "'0'", "if", "word", "[", ":", "2", "]", "in", "{", "'CS'", ",", "'CZ'", ",", "'TS'", ",", "'TZ'", "}", ":", "word", "=", "'SS'", "+", "word", "[", "2", ":", "]", "elif", "word", "[", ":", "2", "]", "==", "'GN'", ":", "word", "=", "'NN'", "+", "word", "[", "2", ":", "]", "elif", "word", "[", ":", "2", "]", "in", "{", "'HR'", ",", "'WR'", "}", ":", "word", "=", "'RR'", "+", "word", "[", "2", ":", "]", "elif", "word", "[", ":", "2", "]", "==", "'HW'", ":", "word", "=", "'WW'", "+", "word", "[", "2", ":", "]", "elif", "word", "[", ":", "2", "]", "in", "{", "'KN'", ",", "'NG'", "}", ":", "word", "=", "'NN'", "+", "word", "[", "2", ":", "]", "if", "word", "[", "-", "2", ":", "]", "==", "'CH'", ":", "word", "=", "word", "[", ":", "-", "2", "]", "+", "'KK'", "elif", "word", "[", "-", "2", ":", "]", "==", "'NT'", ":", "word", "=", "word", "[", ":", "-", "2", "]", "+", "'TT'", "elif", "word", "[", "-", "2", ":", "]", "==", "'RT'", ":", "word", "=", "word", "[", ":", "-", "2", "]", "+", "'RR'", "elif", "word", "[", "-", "3", ":", "]", "==", "'RDT'", ":", "word", "=", "word", "[", ":", "-", "3", "]", "+", "'RR'", "word", "=", "word", ".", "replace", "(", "'CA'", ",", "'KA'", ")", "word", "=", "word", ".", "replace", "(", "'CC'", ",", "'KK'", ")", "word", "=", "word", ".", "replace", "(", "'CK'", ",", "'KK'", ")", "word", "=", "word", ".", "replace", "(", "'CE'", ",", "'SE'", ")", "word", "=", "word", ".", "replace", "(", "'CHL'", ",", "'KL'", ")", "word", "=", "word", ".", "replace", "(", "'CL'", ",", "'KL'", ")", "word", "=", "word", ".", "replace", "(", "'CHR'", ",", "'KR'", ")", "word", "=", "word", ".", "replace", "(", "'CR'", ",", "'KR'", ")", "word", "=", "word", ".", "replace", "(", "'CI'", ",", "'SI'", ")", "word", "=", "word", ".", "replace", "(", "'CO'", ",", "'KO'", ")", "word", "=", "word", ".", "replace", "(", "'CU'", ",", "'KU'", ")", "word", "=", "word", ".", "replace", "(", "'CY'", ",", "'SY'", ")", "word", "=", "word", ".", "replace", "(", "'DG'", ",", "'GG'", ")", "word", "=", "word", ".", "replace", "(", "'GH'", ",", "'HH'", ")", "word", "=", "word", ".", "replace", "(", "'MAC'", ",", "'MK'", ")", "word", "=", "word", ".", "replace", "(", "'MC'", ",", "'MK'", ")", "word", "=", "word", ".", "replace", "(", "'NST'", ",", "'NSS'", ")", "word", "=", "word", ".", "replace", "(", "'PF'", ",", "'FF'", ")", "word", "=", "word", ".", "replace", "(", "'PH'", ",", "'FF'", ")", "word", "=", "word", ".", "replace", "(", "'SCH'", ",", "'SSS'", ")", "word", "=", "word", ".", "replace", "(", "'TIO'", ",", "'SIO'", ")", "word", "=", "word", ".", "replace", "(", "'TIA'", ",", "'SIO'", ")", "word", "=", "word", ".", "replace", "(", "'TCH'", ",", "'CHH'", ")", "sdx", "=", "word", ".", "translate", "(", "self", ".", "_trans", ")", "sdx", "=", "sdx", ".", "replace", "(", "'-'", ",", "''", ")", "# remove repeating characters", "sdx", "=", "self", ".", "_delete_consecutive_repeats", "(", "sdx", ")", "if", "word", "[", "0", "]", "in", "{", "'H'", ",", "'W'", ",", "'Y'", "}", ":", "sdx", "=", "word", "[", "0", "]", "+", "sdx", "else", ":", "sdx", "=", "word", "[", "0", "]", "+", "sdx", "[", "1", ":", "]", "sdx", "=", "sdx", ".", "replace", "(", "'0'", ",", "''", ")", "if", "zero_pad", ":", "sdx", "+=", "'0'", "*", "max_length", "return", "sdx", "[", ":", "max_length", "]" ]

[ "Return", "the", "Fuzzy", "Soundex", "code", "for", "a", "word", "." ]

[ "def", "getGLMRegularizationPath", "(", "model", ")", ":", "x", "=", "h2o", ".", "api", "(", "\"GET /3/GetGLMRegPath\"", ",", "data", "=", "{", "\"model\"", ":", "model", ".", "_model_json", "[", "\"model_id\"", "]", "[", "\"name\"", "]", "}", ")", "ns", "=", "x", ".", "pop", "(", "\"coefficient_names\"", ")", "res", "=", "{", "\"lambdas\"", ":", "x", "[", "\"lambdas\"", "]", ",", "\"explained_deviance_train\"", ":", "x", "[", "\"explained_deviance_train\"", "]", ",", "\"explained_deviance_valid\"", ":", "x", "[", "\"explained_deviance_valid\"", "]", ",", "\"coefficients\"", ":", "[", "dict", "(", "zip", "(", "ns", ",", "y", ")", ")", "for", "y", "in", "x", "[", "\"coefficients\"", "]", "]", ",", "}", "if", "\"coefficients_std\"", "in", "x", ":", "res", "[", "\"coefficients_std\"", "]", "=", "[", "dict", "(", "zip", "(", "ns", ",", "y", ")", ")", "for", "y", "in", "x", "[", "\"coefficients_std\"", "]", "]", "return", "res" ]

[ "Extract", "full", "regularization", "path", "explored", "during", "lambda", "search", "from", "glm", "model", "." ]

[ "def", "select_many", "(", "self", ",", "func", "=", "lambda", "x", ":", "x", ")", ":", "return", "Enumerable3", "(", "itertools", ".", "chain", ".", "from_iterable", "(", "self", ".", "select", "(", "func", ")", ")", ")" ]

[ "Flattens", "an", "iterable", "of", "iterables", "returning", "a", "new", "Enumerable", ":", "param", "func", ":", "selector", "as", "lambda", "expression", ":", "return", ":", "new", "Enumerable", "object" ]

[ "def", "_sanitize_acronyms", "(", "unsafe_acronyms", ")", ":", "valid_acronym", "=", "regex", ".", "compile", "(", "u'^[\\p{Ll}\\p{Lu}\\p{Nd}]+$'", ")", "acronyms", "=", "[", "]", "for", "a", "in", "unsafe_acronyms", ":", "if", "valid_acronym", ".", "match", "(", "a", ")", ":", "acronyms", ".", "append", "(", "a", ".", "upper", "(", ")", ")", "else", ":", "raise", "InvalidAcronymError", "(", "a", ")", "return", "acronyms" ]

[ "Check", "acronyms", "against", "regex", "." ]

[ "def", "data_types", "(", "self", ")", ":", "data", "=", "self", ".", "gencloud", ".", "project_data", "(", "self", ".", "id", ")", "return", "sorted", "(", "set", "(", "d", ".", "type", "for", "d", "in", "data", ")", ")" ]

[ "Return", "a", "list", "of", "data", "types", "." ]

[ "def", "from_config", "(", "cls", ",", "cp", ",", "section", ",", "variable_args", ")", ":", "return", "super", "(", "UniformPowerLaw", ",", "cls", ")", ".", "from_config", "(", "cp", ",", "section", ",", "variable_args", ",", "bounds_required", "=", "True", ")" ]

[ "Returns", "a", "distribution", "based", "on", "a", "configuration", "file", ".", "The", "parameters", "for", "the", "distribution", "are", "retrieved", "from", "the", "section", "titled", "[", "section", "-", "variable_args", "]", "in", "the", "config", "file", "." ]

[ "async", "def", "emit", "(", "self", ",", "event", ",", "data", ",", "namespace", ",", "room", "=", "None", ",", "skip_sid", "=", "None", ",", "callback", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "namespace", "not", "in", "self", ".", "rooms", "or", "room", "not", "in", "self", ".", "rooms", "[", "namespace", "]", ":", "return", "tasks", "=", "[", "]", "for", "sid", "in", "self", ".", "get_participants", "(", "namespace", ",", "room", ")", ":", "if", "sid", "!=", "skip_sid", ":", "if", "callback", "is", "not", "None", ":", "id", "=", "self", ".", "_generate_ack_id", "(", "sid", ",", "namespace", ",", "callback", ")", "else", ":", "id", "=", "None", "tasks", ".", "append", "(", "self", ".", "server", ".", "_emit_internal", "(", "sid", ",", "event", ",", "data", ",", "namespace", ",", "id", ")", ")", "if", "tasks", "==", "[", "]", ":", "# pragma: no cover", "return", "await", "asyncio", ".", "wait", "(", "tasks", ")" ]

[ "Emit", "a", "message", "to", "a", "single", "client", "a", "room", "or", "all", "the", "clients", "connected", "to", "the", "namespace", "." ]

[ "def", "_normalize_assets", "(", "self", ",", "assets", ")", ":", "new_assets", "=", "[", "]", "for", "asset", "in", "assets", ":", "# For example: giAxucdaEeWJTQ5WTi8YJQ@1", "if", "len", "(", "asset", ")", "==", "24", ":", "# Turn it into: giAxucdaEeWJTQ5WTi8YJQ", "asset", "=", "asset", "[", ":", "-", "2", "]", "new_assets", ".", "append", "(", "asset", ")", "return", "new_assets" ]

[ "Perform", "asset", "normalization", ".", "For", "some", "reason", "assets", "that", "are", "sometimes", "present", "in", "lectures", "have", "@1", "at", "the", "end", "of", "their", "id", ".", "Such", "uncut", "asset", "id", "when", "fed", "to", "OPENCOURSE_ASSETS_URL", "results", "in", "error", "that", "says", ":", "Routing", "error", ":", "get", "-", "all", "not", "implemented", ".", "To", "avoid", "that", "the", "last", "two", "characters", "from", "asset", "id", "are", "cut", "off", "and", "after", "that", "that", "method", "works", "fine", ".", "It", "looks", "like", "Web", "UI", "is", "doing", "the", "same", "." ]

[ "def", "validated_type", "(", "base_type", ",", "name", "=", "None", ",", "validate", "=", "None", ")", ":", "if", "validate", "is", "None", ":", "validate", "=", "[", "]", "if", "not", "is_sequence", "(", "validate", ")", ":", "validate", "=", "[", "validate", "]", "class", "ValidatedSubtype", "(", "base_type", ")", ":", "if", "name", "is", "not", "None", ":", "__name__", "=", "name", "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "super", "(", "ValidatedSubtype", ",", "self", ")", ".", "__init__", "(", "*", "args", ",", "*", "*", "kwargs", ")", "for", "validator", "in", "reversed", "(", "validate", ")", ":", "self", ".", "validators", ".", "insert", "(", "0", ",", "validator", ")", "return", "ValidatedSubtype" ]

[ "Convenient", "way", "to", "create", "a", "new", "type", "by", "adding", "validation", "to", "existing", "type", "." ]

[ "def", "_create_record", "(", "self", ",", "rtype", ",", "name", ",", "content", ")", ":", "with", "self", ".", "_session", "(", "self", ".", "domain", ",", "self", ".", "domain_id", ")", "as", "ddata", ":", "# Validate method parameters", "if", "not", "rtype", "or", "not", "name", "or", "not", "content", ":", "LOGGER", ".", "warning", "(", "'Hetzner => Record has no rtype|name|content specified'", ")", "return", "False", "# Add record to zone", "name", "=", "ddata", "[", "'cname'", "]", "if", "ddata", "[", "'cname'", "]", "else", "self", ".", "_fqdn_name", "(", "name", ")", "rrset", "=", "ddata", "[", "'zone'", "]", "[", "'data'", "]", ".", "get_rdataset", "(", "name", ",", "rdtype", "=", "rtype", ",", "create", "=", "True", ")", "for", "rdata", "in", "rrset", ":", "if", "self", ".", "_convert_content", "(", "rtype", ",", "content", ")", "==", "rdata", ".", "to_text", "(", ")", ":", "LOGGER", ".", "info", "(", "'Hetzner => Record with content \\'%s\\' already exists'", ",", "content", ")", "return", "True", "ttl", "=", "(", "rrset", ".", "ttl", "if", "0", "<", "rrset", ".", "ttl", "<", "self", ".", "_get_lexicon_option", "(", "'ttl'", ")", "else", "self", ".", "_get_lexicon_option", "(", "'ttl'", ")", ")", "rdataset", "=", "dns", ".", "rdataset", ".", "from_text", "(", "rrset", ".", "rdclass", ",", "rrset", ".", "rdtype", ",", "ttl", ",", "self", ".", "_convert_content", "(", "rtype", ",", "content", ")", ")", "rrset", ".", "update", "(", "rdataset", ")", "# Post zone to Hetzner", "synced_change", "=", "self", ".", "_post_zone", "(", "ddata", "[", "'zone'", "]", ")", "if", "synced_change", ":", "self", ".", "_propagated_record", "(", "rtype", ",", "name", ",", "self", ".", "_convert_content", "(", "rtype", ",", "content", ")", ",", "ddata", "[", "'nameservers'", "]", ")", "return", "synced_change" ]

[ "Connects", "to", "Hetzner", "account", "adds", "a", "new", "record", "to", "the", "zone", "and", "returns", "a", "boolean", "if", "creation", "was", "successful", "or", "not", ".", "Needed", "record", "rtype", "name", "and", "content", "for", "record", "to", "create", "." ]

[ "def", "init_connection_file", "(", "self", ")", ":", "if", "self", ".", "existing", ":", "try", ":", "cf", "=", "find_connection_file", "(", "self", ".", "existing", ")", "except", "Exception", ":", "self", ".", "log", ".", "critical", "(", "\"Could not find existing kernel connection file %s\"", ",", "self", ".", "existing", ")", "self", ".", "exit", "(", "1", ")", "self", ".", "log", ".", "info", "(", "\"Connecting to existing kernel: %s\"", "%", "cf", ")", "self", ".", "connection_file", "=", "cf", "else", ":", "# not existing, check if we are going to write the file", "# and ensure that self.connection_file is a full path, not just the shortname", "try", ":", "cf", "=", "find_connection_file", "(", "self", ".", "connection_file", ")", "except", "Exception", ":", "# file might not exist", "if", "self", ".", "connection_file", "==", "os", ".", "path", ".", "basename", "(", "self", ".", "connection_file", ")", ":", "# just shortname, put it in security dir", "cf", "=", "os", ".", "path", ".", "join", "(", "self", ".", "profile_dir", ".", "security_dir", ",", "self", ".", "connection_file", ")", "else", ":", "cf", "=", "self", ".", "connection_file", "self", ".", "connection_file", "=", "cf", "# should load_connection_file only be used for existing?", "# as it is now, this allows reusing ports if an existing", "# file is requested", "try", ":", "self", ".", "load_connection_file", "(", ")", "except", "Exception", ":", "self", ".", "log", ".", "error", "(", "\"Failed to load connection file: %r\"", ",", "self", ".", "connection_file", ",", "exc_info", "=", "True", ")", "self", ".", "exit", "(", "1", ")" ]

[ "find", "the", "connection", "file", "and", "load", "the", "info", "if", "found", ".", "The", "current", "working", "directory", "and", "the", "current", "profile", "s", "security", "directory", "will", "be", "searched", "for", "the", "file", "if", "it", "is", "not", "given", "by", "absolute", "path", ".", "When", "attempting", "to", "connect", "to", "an", "existing", "kernel", "and", "the", "--", "existing", "argument", "does", "not", "match", "an", "existing", "file", "it", "will", "be", "interpreted", "as", "a", "fileglob", "and", "the", "matching", "file", "in", "the", "current", "profile", "s", "security", "dir", "with", "the", "latest", "access", "time", "will", "be", "used", ".", "After", "this", "method", "is", "called", "self", ".", "connection_file", "contains", "the", "*", "full", "path", "*", "to", "the", "connection", "file", "never", "just", "its", "name", "." ]

[ "def", "init_async", "(", "self", ",", "loop", ")", ":", "super", "(", "PooledAIODatabase", ",", "self", ")", ".", "init_async", "(", "loop", ")", "self", ".", "_waiters", "=", "collections", ".", "deque", "(", ")" ]

[ "Initialize", "self", "." ]

[ "def", "main", "(", ")", ":", "# Define Parser object and add to Toil", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "main", ".", "__doc__", ",", "formatter_class", "=", "argparse", ".", "RawTextHelpFormatter", ")", "subparsers", "=", "parser", ".", "add_subparsers", "(", "dest", "=", "'command'", ")", "# Generate subparsers", "subparsers", ".", "add_parser", "(", "'generate-config'", ",", "help", "=", "'Generates an editable config in the current working directory.'", ")", "subparsers", ".", "add_parser", "(", "'generate-manifest'", ",", "help", "=", "'Generates an editable manifest in the current working directory.'", ")", "subparsers", ".", "add_parser", "(", "'generate'", ",", "help", "=", "'Generates a config and manifest in the current working directory.'", ")", "# Run subparser", "parser_run", "=", "subparsers", ".", "add_parser", "(", "'run'", ",", "help", "=", "'Runs the BWA alignment pipeline'", ")", "group", "=", "parser_run", ".", "add_mutually_exclusive_group", "(", ")", "parser_run", ".", "add_argument", "(", "'--config'", ",", "default", "=", "'config-toil-bwa.yaml'", ",", "type", "=", "str", ",", "help", "=", "'Path to the (filled in) config file, generated with \"generate-config\".'", ")", "group", ".", "add_argument", "(", "'--manifest'", ",", "default", "=", "'manifest-toil-bwa.tsv'", ",", "type", "=", "str", ",", "help", "=", "'Path to the (filled in) manifest file, generated with \"generate-manifest\". '", "'\\nDefault value: \"%(default)s\".'", ")", "group", ".", "add_argument", "(", "'--sample'", ",", "nargs", "=", "'+'", ",", "action", "=", "required_length", "(", "2", ",", "3", ")", ",", "help", "=", "'Space delimited sample UUID and fastq files in the format: uuid url1 [url2].'", ")", "# Print docstring help if no arguments provided", "if", "len", "(", "sys", ".", "argv", ")", "==", "1", ":", "parser", ".", "print_help", "(", ")", "sys", ".", "exit", "(", "1", ")", "Job", ".", "Runner", ".", "addToilOptions", "(", "parser_run", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "# Parse subparsers related to generation of config and manifest", "cwd", "=", "os", ".", "getcwd", "(", ")", "if", "args", ".", "command", "==", "'generate-config'", "or", "args", ".", "command", "==", "'generate'", ":", "generate_file", "(", "os", ".", "path", ".", "join", "(", "cwd", ",", "'config-toil-bwa.yaml'", ")", ",", "generate_config", ")", "if", "args", ".", "command", "==", "'generate-manifest'", "or", "args", ".", "command", "==", "'generate'", ":", "generate_file", "(", "os", ".", "path", ".", "join", "(", "cwd", ",", "'manifest-toil-bwa.tsv'", ")", ",", "generate_manifest", ")", "# Pipeline execution", "elif", "args", ".", "command", "==", "'run'", ":", "require", "(", "os", ".", "path", ".", "exists", "(", "args", ".", "config", ")", ",", "'{} not found. Please run generate-config'", ".", "format", "(", "args", ".", "config", ")", ")", "if", "not", "args", ".", "sample", ":", "args", ".", "sample", "=", "None", "require", "(", "os", ".", "path", ".", "exists", "(", "args", ".", "manifest", ")", ",", "'{} not found and no sample provided. '", "'Please run \"generate-manifest\"'", ".", "format", "(", "args", ".", "manifest", ")", ")", "# Parse config", "parsed_config", "=", "{", "x", ".", "replace", "(", "'-'", ",", "'_'", ")", ":", "y", "for", "x", ",", "y", "in", "yaml", ".", "load", "(", "open", "(", "args", ".", "config", ")", ".", "read", "(", ")", ")", ".", "iteritems", "(", ")", "}", "config", "=", "argparse", ".", "Namespace", "(", "*", "*", "parsed_config", ")", "config", ".", "maxCores", "=", "int", "(", "args", ".", "maxCores", ")", "if", "args", ".", "maxCores", "else", "sys", ".", "maxint", "samples", "=", "[", "args", ".", "sample", "[", "0", "]", ",", "args", ".", "sample", "[", "1", ":", "]", "]", "if", "args", ".", "sample", "else", "parse_manifest", "(", "args", ".", "manifest", ")", "# Sanity checks", "require", "(", "config", ".", "ref", ",", "'Missing URL for reference file: {}'", ".", "format", "(", "config", ".", "ref", ")", ")", "require", "(", "config", ".", "output_dir", ",", "'No output location specified: {}'", ".", "format", "(", "config", ".", "output_dir", ")", ")", "# Launch Pipeline", "Job", ".", "Runner", ".", "startToil", "(", "Job", ".", "wrapJobFn", "(", "download_reference_files", ",", "config", ",", "samples", ")", ",", "args", ")" ]

[ "Computational", "Genomics", "Lab", "Genomics", "Institute", "UC", "Santa", "Cruz", "Toil", "BWA", "pipeline" ]

[ "def", "changeKeybind", "(", "self", ",", "kbname", ",", "combo", ")", ":", "for", "key", ",", "value", "in", "self", ".", "keybinds", ".", "items", "(", ")", ":", "if", "kbname", "in", "value", ":", "del", "value", "[", "value", ".", "index", "(", "kbname", ")", "]", "break", "if", "combo", "not", "in", "self", ".", "keybinds", ":", "self", ".", "keybinds", "[", "combo", "]", "=", "[", "]", "self", ".", "keybinds", "[", "combo", "]", ".", "append", "(", "kbname", ")", "self", ".", "peng", ".", "sendEvent", "(", "\"peng3d.keybind.change\"", ",", "{", "\"peng\"", ":", "self", ".", "peng", ",", "\"kbname\"", ":", "kbname", ",", "\"combo\"", ":", "combo", "}", ")" ]

[ "Changes", "a", "keybind", "of", "a", "specific", "keybindname", ".", ":", "param", "str", "kbname", ":", "Same", "as", "kbname", "of", ":", "py", ":", "meth", ":", "add", "()", ":", "param", "str", "combo", ":", "New", "key", "combination" ]

[ "async", "def", "download_file", "(", "self", ",", "url", ":", "str", ")", "->", "bytes", ":", "await", "self", ".", "ensure_registered", "(", ")", "url", "=", "self", ".", "client", ".", "get_download_url", "(", "url", ")", "async", "with", "self", ".", "client", ".", "session", ".", "get", "(", "url", ")", "as", "response", ":", "return", "await", "response", ".", "read", "(", ")" ]

[ "Download", "a", "file", "from", "the", "content", "repository", ".", "See", "also", ":", "API", "reference", "_" ]

[ "def", "get_objects_by_offset", "(", "self", ",", "start", ")", ":", "_", ",", "container", "=", "self", ".", "_get_container", "(", "start", ")", "if", "container", "is", "None", ":", "return", "set", "(", ")", "else", ":", "return", "container", ".", "internal_objects" ]

[ "Find", "objects", "covering", "the", "given", "region", "offset", "." ]

[ "def", "review", "(", "self", ",", "change_id", ",", "revision", ",", "review", ")", ":", "endpoint", "=", "\"changes/%s/revisions/%s/review\"", "%", "(", "change_id", ",", "revision", ")", "self", ".", "post", "(", "endpoint", ",", "data", "=", "str", "(", "review", ")", ")" ]

[ "Submit", "a", "review", "." ]

[ "def", "write_intro", "(", "self", ")", ":", "self", ".", "comment", "(", "_", "(", "\"created by %(app)s at %(time)s\"", ")", "%", "{", "\"app\"", ":", "configuration", ".", "AppName", ",", "\"time\"", ":", "strformat", ".", "strtime", "(", "self", ".", "starttime", ")", "}", ")", "self", ".", "comment", "(", "_", "(", "\"Get the newest version at %(url)s\"", ")", "%", "{", "'url'", ":", "configuration", ".", "Url", "}", ")", "self", ".", "comment", "(", "_", "(", "\"Write comments and bugs to %(url)s\"", ")", "%", "{", "'url'", ":", "configuration", ".", "SupportUrl", "}", ")", "self", ".", "comment", "(", "_", "(", "\"Support this project at %(url)s\"", ")", "%", "{", "'url'", ":", "configuration", ".", "DonateUrl", "}", ")", "self", ".", "check_date", "(", ")" ]

[ "Write", "intro", "comments", "." ]

[ "def", "coords_string_parser", "(", "self", ",", "coords", ")", ":", "lat", ",", "lon", "=", "coords", ".", "split", "(", "','", ")", "return", "{", "\"lat\"", ":", "lat", ".", "strip", "(", ")", ",", "\"lon\"", ":", "lon", ".", "strip", "(", ")", ",", "\"bounds\"", ":", "{", "}", "}" ]

[ "Pareses", "the", "address", "string", "into", "coordinates", "to", "match", "address_to_coords", "return", "object" ]

[ "def", "rank_pv", "(", "self", ",", "dt", ",", "dt2", ",", "memlimit", "=", "-", "1", ")", ":", "if", "self", ".", "lib", "is", "None", ":", "raise", "ValueError", "(", "\"Not initialized.\"", ")", "import", "numpy", "as", "np", "from", ".", "auto", "import", "ftype_np", ",", "gtype_np", "from", ".", "types", "import", "isint", "if", "dt", ".", "dtype", ".", "char", "!=", "ftype_np", "or", "dt2", ".", "dtype", ".", "char", "!=", "ftype_np", ":", "raise", "ValueError", "(", "'Wrong input dtype for gene expression data'", ")", "if", "len", "(", "dt", ".", "shape", ")", "!=", "2", "or", "len", "(", "dt2", ".", "shape", ")", "!=", "2", ":", "raise", "ValueError", "(", "'Wrong input shape'", ")", "if", "not", "isint", "(", "memlimit", ")", ":", "raise", "ValueError", "(", "'Wrong memlimit type'", ")", "ng", "=", "dt", ".", "shape", "[", "0", "]", "nt", "=", "dt2", ".", "shape", "[", "0", "]", "ns", "=", "dt", ".", "shape", "[", "1", "]", "if", "dt2", ".", "shape", "[", "1", "]", "!=", "ns", ":", "raise", "ValueError", "(", "'Wrong input shape'", ")", "if", "np", ".", "isnan", "(", "dt", ")", ".", "sum", "(", ")", "+", "np", ".", "isnan", "(", "dt2", ")", ".", "sum", "(", ")", ">", "0", ":", "raise", "ValueError", "(", "'NaN found.'", ")", "dp", "=", "np", ".", "require", "(", "np", ".", "zeros", "(", "(", "ng", ",", "nt", ")", ",", "dtype", "=", "dt", ".", "dtype", ")", ",", "requirements", "=", "[", "'A'", ",", "'C'", ",", "'O'", ",", "'W'", "]", ")", "dtr", "=", "np", ".", "require", "(", "dt", ",", "requirements", "=", "[", "'A'", ",", "'C'", ",", "'O'", ",", "'W'", "]", ")", "dt2r", "=", "np", ".", "require", "(", "dt2", ",", "requirements", "=", "[", "'A'", ",", "'C'", ",", "'O'", ",", "'W'", "]", ")", "arglist", "=", "[", "'const MATRIXF*'", ",", "'const MATRIXF*'", ",", "'MATRIXF*'", ",", "'size_t'", "]", "args", "=", "[", "dtr", ",", "dt2r", ",", "dp", ",", "memlimit", "]", "func", "=", "self", ".", "cfunc", "(", "'pij_rank_pv'", ",", "rettype", "=", "'int'", ",", "argtypes", "=", "arglist", ")", "ret", "=", "func", "(", "*", "args", ")", "ans", "=", "{", "'ret'", ":", "ret", ",", "'p'", ":", "dp", "}", "return", "ans" ]

[ "Calculates", "p", "-", "values", "of", "gene", "i", "correlating", "with", "gene", "j", "by", "converting", "log", "likelihoods", "into", "probabilities", "per", "A", "for", "all", "B", ".", "dt", ":", "numpy", ".", "ndarray", "(", "nt", "ns", "dtype", "=", "ftype", "(", "=", "=", "f4", "by", "default", "))", "Gene", "expression", "data", "for", "A", "Entry", "dt", "[", "i", "j", "]", "is", "gene", "i", "s", "expression", "level", "for", "sample", "j", ".", "dt2", ":", "numpy", ".", "ndarray", "(", "nt2", "ns", "dtype", "=", "ftype", "(", "=", "=", "f4", "by", "default", "))", "Gene", "expression", "data", "for", "B", ".", "dt2", "has", "the", "same", "format", "as", "dt", "and", "can", "be", "identical", "with", "different", "from", "a", "subset", "of", "or", "a", "superset", "of", "dt", ".", "memlimit", ":", "The", "approximate", "memory", "usage", "limit", "in", "bytes", "for", "the", "library", ".", "For", "datasets", "require", "a", "larger", "memory", "calculation", "will", "fail", "with", "an", "error", "message", ".", "memlimit", "=", "0", "defaults", "to", "unlimited", "memory", "usage", ".", "Return", ":", "dictionary", "with", "following", "keys", ":", "ret", ":", "0", "iff", "execution", "succeeded", ".", "p", ":", "numpy", ".", "ndarray", "((", "nt", "nt2", ")", "dtype", "=", "ftype", "(", "=", "=", "f4", "by", "default", "))", ".", "P", "-", "values", "for", "A", "--", "B", ".", "ftype", "and", "gtype", "can", "be", "found", "in", "auto", ".", "py", ".", "Example", ":", "see", "findr", ".", "examples", ".", "geuvadis1", "(", "similar", "format", ")" ]

[ "def", "copy_with_new_str", "(", "self", ",", "new_str", ")", ":", "# What to do when there are multiple Chunks with conflicting atts?", "old_atts", "=", "dict", "(", "(", "att", ",", "value", ")", "for", "bfs", "in", "self", ".", "chunks", "for", "(", "att", ",", "value", ")", "in", "bfs", ".", "atts", ".", "items", "(", ")", ")", "return", "FmtStr", "(", "Chunk", "(", "new_str", ",", "old_atts", ")", ")" ]

[ "Copies", "the", "current", "FmtStr", "s", "attributes", "while", "changing", "its", "string", "." ]

[ "def", "authorize_url", "(", "self", ",", "redirect_uri", ",", "state", "=", "None", ")", ":", "redirect_uri", "=", "six", ".", "moves", ".", "urllib", ".", "parse", ".", "quote", "(", "redirect_uri", ",", "safe", "=", "b''", ")", "url_list", "=", "[", "self", ".", "OAUTH_BASE_URL", ",", "'?appid='", ",", "self", ".", "_client", ".", "corp_id", ",", "'&redirect_uri='", ",", "redirect_uri", ",", "'&response_type=code&scope=snsapi_base'", ",", "]", "if", "state", ":", "url_list", ".", "extend", "(", "[", "'&state='", ",", "state", "]", ")", "url_list", ".", "append", "(", "'#wechat_redirect'", ")", "return", "''", ".", "join", "(", "url_list", ")" ]

[ "构造网页授权链接", "详情请参考", "https", ":", "//", "work", ".", "weixin", ".", "qq", ".", "com", "/", "api", "/", "doc#90000", "/", "90135", "/", "91022" ]

[ "def", "next_row", "(", "self", ")", ":", "row", "=", "self", ".", "currentIndex", "(", ")", ".", "row", "(", ")", "rows", "=", "self", ".", "proxy_model", ".", "rowCount", "(", ")", "if", "row", "+", "1", "==", "rows", ":", "row", "=", "-", "1", "self", ".", "selectRow", "(", "row", "+", "1", ")" ]

[ "Move", "to", "next", "row", "from", "currently", "selected", "row", "." ]

[ "def", "_proxy", "(", "self", ")", ":", "if", "self", ".", "_context", "is", "None", ":", "self", ".", "_context", "=", "CompositionContext", "(", "self", ".", "_version", ",", "sid", "=", "self", ".", "_solution", "[", "'sid'", "]", ",", ")", "return", "self", ".", "_context" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "def", "get_points", "(", "self", ")", ":", "return", "[", "(", "k", ",", "self", ".", "runtime", ".", "_ring", "[", "k", "]", ")", "for", "k", "in", "self", ".", "runtime", ".", "_keys", "]" ]

[ "Returns", "a", "ketama", "compatible", "list", "of", "(", "position", "nodename", ")", "tuples", "." ]

[ "def", "send", "(", "self", ",", "*", "*", "req_kwargs", ")", ":", "i", "=", "0", "while", "True", ":", "response", "=", "self", ".", "_send", "(", "*", "*", "req_kwargs", ")", ".", "json", "(", ")", "if", "'error'", "not", "in", "response", ":", "break", "error", "=", "response", "[", "'error'", "]", "if", "error", "[", "'code'", "]", "!=", "401", ":", "raise", "exception", ".", "APIException", "(", "error", "[", "'code'", "]", ",", "error", ")", "if", "i", ">=", "self", ".", "RETRY_CNT", ":", "raise", "exception", ".", "APIException", "(", "error", "[", "'code'", "]", ",", "error", ")", "logger", ".", "info", "(", "'Refreshing access token'", ")", "self", ".", "_auth", ".", "refresh", "(", ")", "i", "+=", "1", "return", "response" ]

[ "Send", "an", "authenticated", "request", "to", "a", "Google", "API", ".", "Automatically", "retries", "if", "the", "access", "token", "has", "expired", "." ]

[ "def", "vrrp_vip", "(", "self", ",", "*", "*", "kwargs", ")", ":", "int_type", "=", "kwargs", ".", "pop", "(", "'int_type'", ")", ".", "lower", "(", ")", "name", "=", "kwargs", ".", "pop", "(", "'name'", ")", "vrid", "=", "kwargs", ".", "pop", "(", "'vrid'", ")", "vip", "=", "kwargs", ".", "pop", "(", "'vip'", ")", "rbridge_id", "=", "kwargs", ".", "pop", "(", "'rbridge_id'", ",", "'1'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "valid_int_types", "=", "[", "'gigabitethernet'", ",", "'tengigabitethernet'", ",", "'fortygigabitethernet'", ",", "'hundredgigabitethernet'", ",", "'port_channel'", ",", "'ve'", "]", "ipaddress", "=", "ip_interface", "(", "unicode", "(", "vip", ")", ")", "vrrp_vip", "=", "None", "vrrp_args", "=", "dict", "(", "name", "=", "name", ",", "vrid", "=", "vrid", ",", "virtual_ipaddr", "=", "str", "(", "ipaddress", ".", "ip", ")", ")", "method_class", "=", "self", ".", "_interface", "if", "int_type", "not", "in", "valid_int_types", ":", "raise", "ValueError", "(", "'`int_type` must be one of: %s'", "%", "repr", "(", "valid_int_types", ")", ")", "if", "ipaddress", ".", "version", "==", "4", ":", "vrrp_args", "[", "'version'", "]", "=", "'3'", "method_name", "=", "'interface_%s_vrrp_virtual_ip_virtual_'", "'ipaddr'", "%", "int_type", "elif", "ipaddress", ".", "version", "==", "6", ":", "method_name", "=", "'interface_%s_ipv6_vrrpv3_group_virtual_ip_'", "'virtual_ipaddr'", "%", "int_type", "if", "int_type", "==", "'ve'", ":", "method_name", "=", "'rbridge_id_%s'", "%", "method_name", "if", "ipaddress", ".", "version", "==", "6", ":", "method_name", "=", "method_name", ".", "replace", "(", "'group_'", ",", "''", ")", "method_class", "=", "self", ".", "_rbridge", "vrrp_args", "[", "'rbridge_id'", "]", "=", "rbridge_id", "if", "not", "pynos", ".", "utilities", ".", "valid_vlan_id", "(", "name", ")", ":", "raise", "InvalidVlanId", "(", "\"`name` must be between `1` and `8191`\"", ")", "elif", "not", "pynos", ".", "utilities", ".", "valid_interface", "(", "int_type", ",", "name", ")", ":", "raise", "ValueError", "(", "'`name` must be in the format of x/y/z for '", "'physical interfaces or x for port channel.'", ")", "vrrp_vip", "=", "getattr", "(", "method_class", ",", "method_name", ")", "config", "=", "vrrp_vip", "(", "*", "*", "vrrp_args", ")", "return", "callback", "(", "config", ")" ]

[ "Set", "VRRP", "VIP", ".", "Args", ":", "int_type", "(", "str", ")", ":", "Type", "of", "interface", ".", "(", "gigabitethernet", "tengigabitethernet", "etc", ")", ".", "name", "(", "str", ")", ":", "Name", "of", "interface", ".", "(", "1", "/", "0", "/", "5", "1", "/", "0", "/", "10", "etc", ")", ".", "vrid", "(", "str", ")", ":", "VRRPv3", "ID", ".", "vip", "(", "str", ")", ":", "IPv4", "/", "IPv6", "Virtual", "IP", "Address", ".", "rbridge_id", "(", "str", ")", ":", "rbridge", "-", "id", "for", "device", ".", "Only", "required", "when", "type", "is", "ve", ".", "callback", "(", "function", ")", ":", "A", "function", "executed", "upon", "completion", "of", "the", "method", ".", "The", "only", "parameter", "passed", "to", "callback", "will", "be", "the", "ElementTree", "config", ".", "Returns", ":", "Return", "value", "of", "callback", ".", "Raises", ":", "KeyError", ":", "if", "int_type", "name", "vrid", "or", "vip", "is", "not", "passed", ".", "ValueError", ":", "if", "int_type", "name", "vrid", "or", "vip", "is", "invalid", ".", "Examples", ":", ">>>", "import", "pynos", ".", "device", ">>>", "switches", "=", "[", "10", ".", "24", ".", "39", ".", "211", "10", ".", "24", ".", "39", ".", "203", "]", ">>>", "auth", "=", "(", "admin", "password", ")", ">>>", "for", "switch", "in", "switches", ":", "...", "conn", "=", "(", "switch", "22", ")", "...", "with", "pynos", ".", "device", ".", "Device", "(", "conn", "=", "conn", "auth", "=", "auth", ")", "as", "dev", ":", "...", "output", "=", "dev", ".", "interface", ".", "anycast_mac", "(", "rbridge_id", "=", "225", "...", "mac", "=", "aabb", ".", "ccdd", ".", "eeff", "delete", "=", "True", ")", "...", "output", "=", "dev", ".", "services", ".", "vrrp", "(", "ip_version", "=", "6", "...", "enabled", "=", "True", "rbridge_id", "=", "225", ")", "...", "output", "=", "dev", ".", "services", ".", "vrrp", "(", "enabled", "=", "True", "...", "rbridge_id", "=", "225", ")", "...", "output", "=", "dev", ".", "interface", ".", "set_ip", "(", "tengigabitethernet", "...", "225", "/", "0", "/", "18", "10", ".", "1", ".", "1", ".", "2", "/", "24", ")", "...", "output", "=", "dev", ".", "interface", ".", "ip_address", "(", "name", "=", "225", "/", "0", "/", "18", "...", "int_type", "=", "tengigabitethernet", "...", "ip_addr", "=", "2001", ":", "4818", ":", "f000", ":", "1ab", ":", "cafe", ":", "beef", ":", "1000", ":", "2", "/", "64", ")", "...", "dev", ".", "interface", ".", "vrrp_vip", "(", "int_type", "=", "tengigabitethernet", "...", "name", "=", "225", "/", "0", "/", "18", "vrid", "=", "1", "vip", "=", "10", ".", "1", ".", "1", ".", "1", "/", "24", ")", "...", "dev", ".", "interface", ".", "vrrp_vip", "(", "int_type", "=", "tengigabitethernet", "...", "name", "=", "225", "/", "0", "/", "18", "vrid", "=", "1", "...", "vip", "=", "fe80", "::", "cafe", ":", "beef", ":", "1000", ":", "1", "/", "64", ")", "...", "dev", ".", "interface", ".", "vrrp_vip", "(", "int_type", "=", "tengigabitethernet", "...", "name", "=", "225", "/", "0", "/", "18", "vrid", "=", "1", "...", "vip", "=", "2001", ":", "4818", ":", "f000", ":", "1ab", ":", "cafe", ":", "beef", ":", "1000", ":", "1", "/", "64", ")", "...", "output", "=", "dev", ".", "interface", ".", "add_vlan_int", "(", "89", ")", "...", "output", "=", "dev", ".", "interface", ".", "ip_address", "(", "name", "=", "89", "...", "int_type", "=", "ve", "ip_addr", "=", "172", ".", "16", ".", "1", ".", "1", "/", "24", "...", "rbridge_id", "=", "225", ")", "...", "output", "=", "dev", ".", "interface", ".", "ip_address", "(", "name", "=", "89", "...", "int_type", "=", "ve", "rbridge_id", "=", "225", "...", "ip_addr", "=", "2002", ":", "4818", ":", "f000", ":", "1ab", ":", "cafe", ":", "beef", ":", "1000", ":", "2", "/", "64", ")", "...", "dev", ".", "interface", ".", "vrrp_vip", "(", "int_type", "=", "ve", "name", "=", "89", "...", "vrid", "=", "1", "vip", "=", "172", ".", "16", ".", "1", ".", "2", "/", "24", "rbridge_id", "=", "225", ")", "...", "dev", ".", "interface", ".", "vrrp_vip", "(", "int_type", "=", "ve", "name", "=", "89", "...", "vrid", "=", "1", "vip", "=", "fe80", "::", "dafe", ":", "beef", ":", "1000", ":", "1", "/", "64", "...", "rbridge_id", "=", "225", ")", "...", "dev", ".", "interface", ".", "vrrp_vip", "(", "int_type", "=", "ve", "name", "=", "89", "...", "vrid", "=", "1", "vip", "=", "2002", ":", "4818", ":", "f000", ":", "1ab", ":", "cafe", ":", "beef", ":", "1000", ":", "1", "/", "64", "...", "rbridge_id", "=", "225", ")", "...", "output", "=", "dev", ".", "services", ".", "vrrp", "(", "ip_version", "=", "6", "...", "enabled", "=", "False", "rbridge_id", "=", "225", ")", "...", "output", "=", "dev", ".", "services", ".", "vrrp", "(", "enabled", "=", "False", "...", "rbridge_id", "=", "225", ")" ]

[ "def", "package", "(", "input_dir", ",", "output_dir", ",", "meta_path", "=", "None", ",", "create_meta", "=", "False", ",", "force", "=", "False", ")", ":", "msg", "=", "Printer", "(", ")", "input_path", "=", "util", ".", "ensure_path", "(", "input_dir", ")", "output_path", "=", "util", ".", "ensure_path", "(", "output_dir", ")", "meta_path", "=", "util", ".", "ensure_path", "(", "meta_path", ")", "if", "not", "input_path", "or", "not", "input_path", ".", "exists", "(", ")", ":", "msg", ".", "fail", "(", "\"Can't locate model data\"", ",", "input_path", ",", "exits", "=", "1", ")", "if", "not", "output_path", "or", "not", "output_path", ".", "exists", "(", ")", ":", "msg", ".", "fail", "(", "\"Output directory not found\"", ",", "output_path", ",", "exits", "=", "1", ")", "if", "meta_path", "and", "not", "meta_path", ".", "exists", "(", ")", ":", "msg", ".", "fail", "(", "\"Can't find model meta.json\"", ",", "meta_path", ",", "exits", "=", "1", ")", "meta_path", "=", "meta_path", "or", "input_path", "/", "\"meta.json\"", "if", "meta_path", ".", "is_file", "(", ")", ":", "meta", "=", "srsly", ".", "read_json", "(", "meta_path", ")", "if", "not", "create_meta", ":", "# only print if user doesn't want to overwrite", "msg", ".", "good", "(", "\"Loaded meta.json from file\"", ",", "meta_path", ")", "else", ":", "meta", "=", "generate_meta", "(", "input_dir", ",", "meta", ",", "msg", ")", "for", "key", "in", "(", "\"lang\"", ",", "\"name\"", ",", "\"version\"", ")", ":", "if", "key", "not", "in", "meta", "or", "meta", "[", "key", "]", "==", "\"\"", ":", "msg", ".", "fail", "(", "\"No '{}' setting found in meta.json\"", ".", "format", "(", "key", ")", ",", "\"This setting is required to build your package.\"", ",", "exits", "=", "1", ",", ")", "model_name", "=", "meta", "[", "\"lang\"", "]", "+", "\"_\"", "+", "meta", "[", "\"name\"", "]", "model_name_v", "=", "model_name", "+", "\"-\"", "+", "meta", "[", "\"version\"", "]", "main_path", "=", "output_path", "/", "model_name_v", "package_path", "=", "main_path", "/", "model_name", "if", "package_path", ".", "exists", "(", ")", ":", "if", "force", ":", "shutil", ".", "rmtree", "(", "path2str", "(", "package_path", ")", ")", "else", ":", "msg", ".", "fail", "(", "\"Package directory already exists\"", ",", "\"Please delete the directory and try again, or use the \"", "\"`--force` flag to overwrite existing \"", "\"directories.\"", ".", "format", "(", "path", "=", "path2str", "(", "package_path", ")", ")", ",", "exits", "=", "1", ",", ")", "Path", ".", "mkdir", "(", "package_path", ",", "parents", "=", "True", ")", "shutil", ".", "copytree", "(", "path2str", "(", "input_path", ")", ",", "path2str", "(", "package_path", "/", "model_name_v", ")", ")", "create_file", "(", "main_path", "/", "\"meta.json\"", ",", "srsly", ".", "json_dumps", "(", "meta", ",", "indent", "=", "2", ")", ")", "create_file", "(", "main_path", "/", "\"setup.py\"", ",", "TEMPLATE_SETUP", ")", "create_file", "(", "main_path", "/", "\"MANIFEST.in\"", ",", "TEMPLATE_MANIFEST", ")", "create_file", "(", "package_path", "/", "\"__init__.py\"", ",", "TEMPLATE_INIT", ")", "msg", ".", "good", "(", "\"Successfully created package '{}'\"", ".", "format", "(", "model_name_v", ")", ",", "main_path", ")", "msg", ".", "text", "(", "\"To build the package, run `python setup.py sdist` in this directory.\"", ")" ]

[ "Generate", "Python", "package", "for", "model", "data", "including", "meta", "and", "required", "installation", "files", ".", "A", "new", "directory", "will", "be", "created", "in", "the", "specified", "output", "directory", "and", "model", "data", "will", "be", "copied", "over", ".", "If", "--", "create", "-", "meta", "is", "set", "and", "a", "meta", ".", "json", "already", "exists", "in", "the", "output", "directory", "the", "existing", "values", "will", "be", "used", "as", "the", "defaults", "in", "the", "command", "-", "line", "prompt", "." ]

[ "def", "read_config", "(", "self", ",", "correlation_id", ",", "parameters", ")", ":", "value", "=", "self", ".", "_read_object", "(", "correlation_id", ",", "parameters", ")", "return", "ConfigParams", ".", "from_value", "(", "value", ")" ]

[ "Reads", "configuration", "and", "parameterize", "it", "with", "given", "values", "." ]

[ "def", "_create_ret_object", "(", "self", ",", "status", "=", "SUCCESS", ",", "data", "=", "None", ",", "error", "=", "False", ",", "error_message", "=", "None", ",", "error_cause", "=", "None", ")", ":", "ret", "=", "{", "}", "if", "status", "==", "self", ".", "FAILURE", ":", "ret", "[", "'status'", "]", "=", "self", ".", "FAILURE", "else", ":", "ret", "[", "'status'", "]", "=", "self", ".", "SUCCESS", "ret", "[", "'data'", "]", "=", "data", "if", "error", ":", "ret", "[", "'error'", "]", "=", "{", "}", "if", "error_message", "is", "not", "None", ":", "ret", "[", "'error'", "]", "[", "'message'", "]", "=", "error_message", "if", "error_cause", "is", "not", "None", ":", "ret", "[", "'error'", "]", "[", "'cause'", "]", "=", "error_cause", "else", ":", "ret", "[", "'error'", "]", "=", "None", "return", "ret" ]

[ "Create", "generic", "reponse", "objects", "." ]

[ "def", "postinit", "(", "self", ",", "test", "=", "None", ",", "fail", "=", "None", ")", ":", "self", ".", "fail", "=", "fail", "self", ".", "test", "=", "test" ]

[ "Do", "some", "setup", "after", "initialisation", "." ]

[ "def", "image_similarity", "(", "fixed_image", ",", "moving_image", ",", "metric_type", "=", "'MeanSquares'", ",", "fixed_mask", "=", "None", ",", "moving_mask", "=", "None", ",", "sampling_strategy", "=", "'regular'", ",", "sampling_percentage", "=", "1.", ")", ":", "metric", "=", "mio2", ".", "create_ants_metric", "(", "fixed_image", ",", "moving_image", ",", "metric_type", ",", "fixed_mask", ",", "moving_mask", ",", "sampling_strategy", ",", "sampling_percentage", ")", "return", "metric", ".", "get_value", "(", ")" ]

[ "Measure", "similarity", "between", "two", "images", "ANTsR", "function", ":", "imageSimilarity" ]

[ "def", "get_user", "(", "self", ",", "nick_or_jid", ",", "create", "=", "False", ")", ":", "if", "isinstance", "(", "nick_or_jid", ",", "JID", ")", ":", "if", "not", "nick_or_jid", ".", "resource", ":", "return", "None", "for", "u", "in", "self", ".", "users", ".", "values", "(", ")", ":", "if", "nick_or_jid", "in", "(", "u", ".", "room_jid", ",", "u", ".", "real_jid", ")", ":", "return", "u", "if", "create", ":", "return", "MucRoomUser", "(", "nick_or_jid", ")", "else", ":", "return", "None", "return", "self", ".", "users", ".", "get", "(", "nick_or_jid", ")" ]

[ "Get", "a", "room", "user", "with", "given", "nick", "or", "JID", "." ]

[ "def", "_read_header", "(", "self", ",", "header_str", ")", ":", "# regular expressions", "re_float", "=", "'[-+]?(\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?'", "re_uint", "=", "'\\d+'", "re_binning", "=", "'{d} in (?P<nbins>'", "+", "re_uint", "+", "') bin[ s] '", "re_binning", "+=", "'of (?P<binwidth>'", "+", "re_float", "+", "') {unit}'", "# map of dimensions and units", "dim_units", "=", "{", "'X'", ":", "'cm'", ",", "'Y'", ":", "'cm'", ",", "'Z'", ":", "'cm'", ",", "'R'", ":", "'cm'", ",", "'Phi'", ":", "'deg'", ",", "'Theta'", ":", "'deg'", ",", "}", "# retrieve binning info", "self", ".", "dimensions", "=", "[", "]", "for", "line", "in", "header_str", ".", "splitlines", "(", ")", ":", "for", "dim", ",", "unit", "in", "dim_units", ".", "items", "(", ")", ":", "re_tmp", "=", "re_binning", ".", "format", "(", "d", "=", "dim", ",", "unit", "=", "unit", ")", "regex", "=", "re", ".", "compile", "(", "re_tmp", ")", "match", "=", "regex", ".", "search", "(", "line", ")", "if", "match", ":", "N", "=", "int", "(", "match", ".", "group", "(", "'nbins'", ")", ")", "width", "=", "float", "(", "match", ".", "group", "(", "'binwidth'", ")", ")", "dimension", "=", "BinnedDimension", "(", "dim", ",", "unit", ",", "N", ",", "width", ")", "self", ".", "dimensions", ".", "append", "(", "dimension", ")", "# retrieve scored quantity info", "re_score_unit", "=", "'# (?P<quant>.+) \\( (?P<unit>.+) \\) : (?P<stats>.+)'", "re_score_unitless", "=", "'# (?P<quant>.+) : (?P<stats>.+)'", "regex_unit", "=", "re", ".", "compile", "(", "re_score_unit", ")", "regex_unitless", "=", "re", ".", "compile", "(", "re_score_unitless", ")", "for", "line", "in", "header_str", ".", "splitlines", "(", ")", ":", "match", "=", "regex_unit", ".", "search", "(", "line", ")", "if", "match", ":", "self", ".", "quantity", "=", "match", ".", "group", "(", "'quant'", ")", "self", ".", "unit", "=", "match", ".", "group", "(", "'unit'", ")", "self", ".", "statistics", "=", "match", ".", "group", "(", "'stats'", ")", ".", "split", "(", ")", "break", "match", "=", "regex_unitless", ".", "search", "(", "line", ")", "if", "match", ":", "self", ".", "quantity", "=", "match", ".", "group", "(", "'quant'", ")", "self", ".", "unit", "=", "None", "self", ".", "statistics", "=", "match", ".", "group", "(", "'stats'", ")", ".", "split", "(", ")", "break" ]

[ "Reads", "metadata", "from", "the", "header", "." ]

[ "def", "put_path", "(", "self", ",", "url", ",", "path", ")", ":", "cache_path", "=", "self", ".", "_url_to_path", "(", "url", ")", "# Ensure that cache directories exist", "try", ":", "dir", "=", "os", ".", "path", ".", "dirname", "(", "cache_path", ")", "os", ".", "makedirs", "(", "dir", ")", "except", "OSError", "as", "e", ":", "if", "e", ".", "errno", "!=", "errno", ".", "EEXIST", ":", "raise", "Error", "(", "'Failed to create cache directories for '", "%", "cache_path", ")", "# Remove the resource already exist", "try", ":", "os", ".", "unlink", "(", "cache_path", ")", "except", "OSError", ":", "pass", "try", ":", "# First try hard link to avoid wasting disk space & overhead", "os", ".", "link", "(", "path", ",", "cache_path", ")", "except", "OSError", ":", "try", ":", "# Use file copy as fallaback", "shutil", ".", "copyfile", "(", "path", ",", "cache_path", ")", "except", "IOError", ":", "raise", "Error", "(", "'Failed to cache %s as %s for %s'", "%", "(", "path", ",", "cache_path", ",", "url", ")", ")" ]

[ "Puts", "a", "resource", "already", "on", "disk", "into", "the", "disk", "cache", "." ]

[ "def", "migrate", "(", "self", ",", "host", ",", "port", ",", "keys", ",", "destination_db", ",", "timeout", ",", "copy", "=", "False", ",", "replace", "=", "False", ",", "auth", "=", "None", ")", ":", "keys", "=", "list_or_args", "(", "keys", ",", "[", "]", ")", "if", "not", "keys", ":", "raise", "DataError", "(", "'MIGRATE requires at least one key'", ")", "pieces", "=", "[", "]", "if", "copy", ":", "pieces", ".", "append", "(", "Token", ".", "get_token", "(", "'COPY'", ")", ")", "if", "replace", ":", "pieces", ".", "append", "(", "Token", ".", "get_token", "(", "'REPLACE'", ")", ")", "if", "auth", ":", "pieces", ".", "append", "(", "Token", ".", "get_token", "(", "'AUTH'", ")", ")", "pieces", ".", "append", "(", "auth", ")", "pieces", ".", "append", "(", "Token", ".", "get_token", "(", "'KEYS'", ")", ")", "pieces", ".", "extend", "(", "keys", ")", "return", "self", ".", "execute_command", "(", "'MIGRATE'", ",", "host", ",", "port", ",", "''", ",", "destination_db", ",", "timeout", ",", "*", "pieces", ")" ]

[ "Migrate", "1", "or", "more", "keys", "from", "the", "current", "Redis", "server", "to", "a", "different", "server", "specified", "by", "the", "host", "port", "and", "destination_db", "." ]

[ "def", "make_ner_file", "(", "tagger_id", ",", "tmp_cleansed_path", ",", "tmp_ner_path", ",", "pipeline_root", ")", ":", "params", "=", "dict", "(", "INPUT_FILE", "=", "tmp_cleansed_path", ",", "#RAW_OUTPUT_FILE=tmp_ner_raw_path,", "OUTPUT_FILE", "=", "tmp_ner_path", ",", "PIPELINE_ROOT", "=", "pipeline_root", ")", "pipeline_cmd", "=", "pipeline_cmd_templates", "[", "tagger_id", "]", "%", "params", "print", "pipeline_cmd", "## replace this with log.info()", "print", "'creating %s'", "%", "tmp_ner_path", "start_time", "=", "time", ".", "time", "(", ")", "gpg_child", "=", "subprocess", ".", "Popen", "(", "pipeline_cmd", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "shell", "=", "True", ")", "s_out", ",", "errors", "=", "gpg_child", ".", "communicate", "(", ")", "assert", "gpg_child", ".", "returncode", "==", "0", "and", "'Exception'", "not", "in", "errors", ",", "errors", "elapsed", "=", "time", ".", "time", "(", ")", "-", "start_time", "## replace this with log.info()", "print", "'created %s in %.1f sec'", "%", "(", "tmp_ner_path", ",", "elapsed", ")", "'''\n postproc_cmd = postproc_cmd_templates[tagger_id] % params\n\n print postproc_cmd\n\n ## replace this with log.info()\n print 'creating %s' % tmp_ner_raw_path\n start_time = time.time()\n gpg_child = subprocess.Popen(\n postproc_cmd,\n stderr=subprocess.PIPE, shell=True)\n s_out, errors = gpg_child.communicate()\n assert gpg_child.returncode == 0 and 'Exception' not in errors, errors\n elapsed = time.time() - start_time\n\n ## replace this with log.info()\n print 'created %s in %.1f sec' % (tmp_ner_path, elapsed)\n '''" ]

[ "run", "child", "process", "to", "get", "OWPL", "output" ]

[ "def", "draw", "(", "self", ")", ":", "devs", "=", "normal", "(", "size", "=", "self", ".", "_sig", ".", "shape", "[", "1", "]", ")", "p", "=", "inner", "(", "self", ".", "_sig", ",", "devs", ")", "+", "self", ".", "_mu", "self", ".", "_set_stochastics", "(", "p", ")" ]

[ "N", ".", "draw", "()" ]

[ "def", "S", "(", "Document", ",", "*", "fields", ")", ":", "result", "=", "[", "]", "for", "field", "in", "fields", ":", "if", "isinstance", "(", "field", ",", "tuple", ")", ":", "# Unpack existing tuple.", "field", ",", "direction", "=", "field", "result", ".", "append", "(", "(", "field", ",", "direction", ")", ")", "continue", "direction", "=", "ASCENDING", "if", "not", "field", ".", "startswith", "(", "'__'", ")", ":", "field", "=", "field", ".", "replace", "(", "'__'", ",", "'.'", ")", "if", "field", "[", "0", "]", "==", "'-'", ":", "direction", "=", "DESCENDING", "if", "field", "[", "0", "]", "in", "(", "'+'", ",", "'-'", ")", ":", "field", "=", "field", "[", "1", ":", "]", "_field", "=", "traverse", "(", "Document", ",", "field", ",", "default", "=", "None", ")", "result", ".", "append", "(", "(", "(", "~", "_field", ")", "if", "_field", "else", "field", ",", "direction", ")", ")", "return", "result" ]

[ "Generate", "a", "MongoDB", "sort", "order", "list", "using", "the", "Django", "ORM", "style", "." ]

[ "def", "login", "(", "self", ",", "url", "=", "None", ",", "api_key", "=", "None", ",", "login", "=", "None", ",", "pwd", "=", "None", ",", "api_version", "=", "None", ",", "timeout", "=", "None", ",", "verify", "=", "True", ",", "alt_filepath", "=", "None", ",", "domain", "=", "None", ",", "*", "*", "kwargs", ")", ":", "params", "=", "{", "}", "if", "not", "url", "or", "(", "not", "api_key", "and", "not", "(", "login", "and", "pwd", ")", ")", ":", "try", ":", "# First try load from file", "params", "=", "load_from_file", "(", "alt_filepath", ")", "if", "alt_filepath", "is", "not", "None", "else", "load_from_file", "(", ")", "logger", ".", "debug", "(", "'Read config data from file: %s'", ",", "params", ")", "except", "ConfigLoadError", ":", "# Last ditch effort, try to load from environment", "params", "=", "load_from_environ", "(", ")", "logger", ".", "debug", "(", "'Read config data from environ: %s'", ",", "params", ")", "params", "=", "params", "or", "dict", "(", "url", "=", "url", ",", "api_key", "=", "api_key", ",", "login", "=", "login", ",", "pwd", "=", "pwd", ",", "api_version", "=", "api_version", ",", "verify", "=", "verify", ",", "timeout", "=", "timeout", ",", "domain", "=", "domain", ",", "kwargs", "=", "kwargs", "or", "{", "}", ")", "# Check to see this session is already logged in. If so, return.", "# The session object represents a single connection. Log out to", "# re-use the same session object or get_session() from the", "# SessionManager to track multiple sessions.", "if", "self", ".", "manager", "and", "(", "self", ".", "session", "and", "self", "in", "self", ".", "manager", ")", ":", "logger", ".", "info", "(", "'An attempt to log in occurred when a session already '", "'exists, bypassing login for session: %s'", "%", "self", ")", "return", "self", ".", "_params", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "params", ".", "items", "(", ")", "if", "v", "is", "not", "None", "}", "verify_ssl", "=", "self", ".", "_params", ".", "get", "(", "'verify'", ",", "True", ")", "# Determine and set the API version we will use.", "self", ".", "_params", ".", "update", "(", "api_version", "=", "get_api_version", "(", "self", ".", "url", ",", "self", ".", "api_version", ",", "self", ".", "timeout", ",", "verify_ssl", ")", ")", "extra_args", "=", "self", ".", "_params", ".", "get", "(", "'kwargs'", ",", "{", "}", ")", "# Retries configured", "retry_on_busy", "=", "extra_args", ".", "pop", "(", "'retry_on_busy'", ",", "False", ")", "request", "=", "self", ".", "_build_auth_request", "(", "verify_ssl", ",", "*", "*", "extra_args", ")", "# This will raise if session login fails...", "self", ".", "_session", "=", "self", ".", "_get_session", "(", "request", ")", "self", ".", "session", ".", "verify", "=", "verify_ssl", "if", "retry_on_busy", ":", "self", ".", "set_retry_on_busy", "(", ")", "# Load entry points", "load_entry_points", "(", "self", ")", "# Put session in manager", "self", ".", "manager", ".", "_register", "(", "self", ")", "logger", ".", "debug", "(", "'Login succeeded for admin: %s in domain: %s, session: %s'", ",", "self", ".", "name", ",", "self", ".", "domain", ",", "self", ".", "session_id", ")" ]

[ "Login", "to", "SMC", "API", "and", "retrieve", "a", "valid", "session", ".", "Sessions", "use", "a", "pool", "connection", "manager", "to", "provide", "dynamic", "scalability", "during", "times", "of", "increased", "load", ".", "Each", "session", "is", "managed", "by", "a", "global", "session", "manager", "making", "it", "possible", "to", "have", "more", "than", "one", "session", "per", "interpreter", "." ]

[ "def", "GetBoundingRectangles", "(", "self", ")", "->", "list", ":", "floats", "=", "self", ".", "textRange", ".", "GetBoundingRectangles", "(", ")", "rects", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "floats", ")", "//", "4", ")", ":", "rect", "=", "Rect", "(", "int", "(", "floats", "[", "i", "*", "4", "]", ")", ",", "int", "(", "floats", "[", "i", "*", "4", "+", "1", "]", ")", ",", "int", "(", "floats", "[", "i", "*", "4", "]", ")", "+", "int", "(", "floats", "[", "i", "*", "4", "+", "2", "]", ")", ",", "int", "(", "floats", "[", "i", "*", "4", "+", "1", "]", ")", "+", "int", "(", "floats", "[", "i", "*", "4", "+", "3", "]", ")", ")", "rects", ".", "append", "(", "rect", ")", "return", "rects" ]

[ "Call", "IUIAutomationTextRange", "::", "GetBoundingRectangles", ".", "textAttributeId", ":", "int", "a", "value", "in", "class", "TextAttributeId", ".", "Return", "list", "a", "list", "of", "Rect", ".", "bounding", "rectangles", "for", "each", "fully", "or", "partially", "visible", "line", "of", "text", "in", "a", "text", "range", "..", "Refer", "https", ":", "//", "docs", ".", "microsoft", ".", "com", "/", "en", "-", "us", "/", "windows", "/", "desktop", "/", "api", "/", "uiautomationclient", "/", "nf", "-", "uiautomationclient", "-", "iuiautomationtextrange", "-", "getboundingrectangles" ]

[ "def", "urlunparse", "(", "components", ")", ":", "scheme", ",", "netloc", ",", "url", ",", "params", ",", "query", ",", "fragment", ",", "_coerce_result", "=", "(", "_coerce_args", "(", "*", "components", ")", ")", "if", "params", ":", "url", "=", "\"%s;%s\"", "%", "(", "url", ",", "params", ")", "return", "_coerce_result", "(", "urlunsplit", "(", "(", "scheme", ",", "netloc", ",", "url", ",", "query", ",", "fragment", ")", ")", ")" ]

[ "Put", "a", "parsed", "URL", "back", "together", "again", ".", "This", "may", "result", "in", "a", "slightly", "different", "but", "equivalent", "URL", "if", "the", "URL", "that", "was", "parsed", "originally", "had", "redundant", "delimiters", "e", ".", "g", ".", "a", "?", "with", "an", "empty", "query", "(", "the", "draft", "states", "that", "these", "are", "equivalent", ")", "." ]

[ "def", "_stdout_raw", "(", "self", ",", "s", ")", ":", "print", "(", "s", ",", "end", "=", "''", ",", "file", "=", "sys", ".", "stdout", ")", "sys", ".", "stdout", ".", "flush", "(", ")" ]

[ "Writes", "the", "string", "to", "stdout" ]

[ "def", "hash", "(", "key", ",", "seed", "=", "0x0", ")", ":", "key", "=", "bytearray", "(", "xencode", "(", "key", ")", ")", "def", "fmix", "(", "h", ")", ":", "h", "^=", "h", ">>", "16", "h", "=", "(", "h", "*", "0x85ebca6b", ")", "&", "0xFFFFFFFF", "h", "^=", "h", ">>", "13", "h", "=", "(", "h", "*", "0xc2b2ae35", ")", "&", "0xFFFFFFFF", "h", "^=", "h", ">>", "16", "return", "h", "length", "=", "len", "(", "key", ")", "nblocks", "=", "int", "(", "length", "/", "4", ")", "h1", "=", "seed", "c1", "=", "0xcc9e2d51", "c2", "=", "0x1b873593", "# body", "for", "block_start", "in", "xrange", "(", "0", ",", "nblocks", "*", "4", ",", "4", ")", ":", "# ??? big endian?", "k1", "=", "key", "[", "block_start", "+", "3", "]", "<<", "24", "|", "key", "[", "block_start", "+", "2", "]", "<<", "16", "|", "key", "[", "block_start", "+", "1", "]", "<<", "8", "|", "key", "[", "block_start", "+", "0", "]", "k1", "=", "(", "c1", "*", "k1", ")", "&", "0xFFFFFFFF", "k1", "=", "(", "k1", "<<", "15", "|", "k1", ">>", "17", ")", "&", "0xFFFFFFFF", "# inlined ROTL32", "k1", "=", "(", "c2", "*", "k1", ")", "&", "0xFFFFFFFF", "h1", "^=", "k1", "h1", "=", "(", "h1", "<<", "13", "|", "h1", ">>", "19", ")", "&", "0xFFFFFFFF", "# inlined ROTL32", "h1", "=", "(", "h1", "*", "5", "+", "0xe6546b64", ")", "&", "0xFFFFFFFF", "# tail", "tail_index", "=", "nblocks", "*", "4", "k1", "=", "0", "tail_size", "=", "length", "&", "3", "if", "tail_size", ">=", "3", ":", "k1", "^=", "key", "[", "tail_index", "+", "2", "]", "<<", "16", "if", "tail_size", ">=", "2", ":", "k1", "^=", "key", "[", "tail_index", "+", "1", "]", "<<", "8", "if", "tail_size", ">=", "1", ":", "k1", "^=", "key", "[", "tail_index", "+", "0", "]", "if", "tail_size", ">", "0", ":", "k1", "=", "(", "k1", "*", "c1", ")", "&", "0xFFFFFFFF", "k1", "=", "(", "k1", "<<", "15", "|", "k1", ">>", "17", ")", "&", "0xFFFFFFFF", "# inlined ROTL32", "k1", "=", "(", "k1", "*", "c2", ")", "&", "0xFFFFFFFF", "h1", "^=", "k1", "#finalization", "unsigned_val", "=", "fmix", "(", "h1", "^", "length", ")", "if", "unsigned_val", "&", "0x80000000", "==", "0", ":", "return", "unsigned_val", "else", ":", "return", "-", "(", "(", "unsigned_val", "^", "0xFFFFFFFF", ")", "+", "1", ")" ]

[ "Implements", "32bit", "murmur3", "hash", "." ]

[ "def", "_request", "(", "self", ",", "method", ",", "url", ",", "headers", "=", "None", ",", "params", "=", "None", ",", "*", "*", "aio_kwargs", ")", ":", "access_token", "=", "params", ".", "pop", "(", "self", ".", "access_token_key", ",", "None", ")", "if", "access_token", ":", "headers", "[", "'Authorization'", "]", "=", "\"Bearer %s\"", "%", "access_token", "return", "super", "(", "DiscordClient", ",", "self", ")", ".", "_request", "(", "method", ",", "url", ",", "headers", "=", "headers", ",", "params", "=", "params", ",", "*", "*", "aio_kwargs", ")" ]

[ "Setup", "Authorization", "Header", ".." ]

[ "def", "dereference_run", "(", "self", ",", "arg_r", ")", ":", "wc", "=", "0", "der_run", "=", "[", "]", "for", "line", "in", "arg_r", ":", "args", "=", "[", "]", "for", "argument", "in", "line", "[", "3", "]", ":", "logging", ".", "debug", "(", "\"dereference run: handling argument \"", "+", "str", "(", "argument", ")", ")", "if", "(", "isinstance", "(", "argument", ",", "int", ")", ")", ":", "logging", ".", "debug", "(", "\"Argument interpreted as integer\"", ")", "args", ".", "append", "(", "argument", ")", "continue", "if", "(", "(", "not", "argument", "in", "self", ".", "refs", ")", "and", "(", "not", "argument", "in", "self", ".", "static_refs", ")", ")", ":", "raise", "ArgumentError", "(", "\"[line {}]: Argument '{}' is neither an int nor a reference.\"", ".", "format", "(", "line", "[", "0", "]", ",", "argument", ")", ")", "if", "(", "argument", "in", "self", ".", "static_refs", ")", ":", "logging", ".", "debug", "(", "\"Argument interpreted as static reference\"", ")", "args", ".", "append", "(", "self", ".", "static_refs", "[", "argument", "]", "[", "0", "]", ")", "continue", "my_word", "=", "wc", "ref_word", "=", "self", ".", "refs", "[", "argument", "]", "[", "0", "]", "args", ".", "append", "(", "ref_word", "-", "my_word", ")", "logging", ".", "debug", "(", "\"Argument interpreted as reference\"", ")", "data", "=", "[", "]", "if", "(", "line", "[", "1", "]", "==", "\"command\"", ")", ":", "data", "=", "[", "line", "[", "2", "]", ".", "opcode", "(", ")", "]", "data", ".", "extend", "(", "args", ")", "wc", "+=", "len", "(", "data", ")", "der_run", ".", "append", "(", "(", "line", "[", "0", "]", ",", "line", "[", "1", "]", ",", "data", ")", ")", "return", "der_run" ]

[ "..", "_dereference_run", ":" ]

[ "def", "progress_string", "(", "self", ")", ":", "if", "not", "self", ".", "last_result", ":", "return", "self", ".", "_status_string", "(", ")", "def", "location_string", "(", "hostname", ",", "pid", ")", ":", "if", "hostname", "==", "os", ".", "uname", "(", ")", "[", "1", "]", ":", "return", "\"pid={}\"", ".", "format", "(", "pid", ")", "else", ":", "return", "\"{} pid={}\"", ".", "format", "(", "hostname", ",", "pid", ")", "pieces", "=", "[", "\"{}\"", ".", "format", "(", "self", ".", "_status_string", "(", ")", ")", ",", "\"[{}]\"", ".", "format", "(", "self", ".", "resources", ".", "summary_string", "(", ")", ")", ",", "\"[{}]\"", ".", "format", "(", "location_string", "(", "self", ".", "last_result", ".", "get", "(", "HOSTNAME", ")", ",", "self", ".", "last_result", ".", "get", "(", "PID", ")", ")", ")", ",", "\"{} s\"", ".", "format", "(", "int", "(", "self", ".", "last_result", ".", "get", "(", "TIME_TOTAL_S", ")", ")", ")", "]", "if", "self", ".", "last_result", ".", "get", "(", "TRAINING_ITERATION", ")", "is", "not", "None", ":", "pieces", ".", "append", "(", "\"{} iter\"", ".", "format", "(", "self", ".", "last_result", "[", "TRAINING_ITERATION", "]", ")", ")", "if", "self", ".", "last_result", ".", "get", "(", "TIMESTEPS_TOTAL", ")", "is", "not", "None", ":", "pieces", ".", "append", "(", "\"{} ts\"", ".", "format", "(", "self", ".", "last_result", "[", "TIMESTEPS_TOTAL", "]", ")", ")", "if", "self", ".", "last_result", ".", "get", "(", "EPISODE_REWARD_MEAN", ")", "is", "not", "None", ":", "pieces", ".", "append", "(", "\"{} rew\"", ".", "format", "(", "format", "(", "self", ".", "last_result", "[", "EPISODE_REWARD_MEAN", "]", ",", "\".3g\"", ")", ")", ")", "if", "self", ".", "last_result", ".", "get", "(", "MEAN_LOSS", ")", "is", "not", "None", ":", "pieces", ".", "append", "(", "\"{} loss\"", ".", "format", "(", "format", "(", "self", ".", "last_result", "[", "MEAN_LOSS", "]", ",", "\".3g\"", ")", ")", ")", "if", "self", ".", "last_result", ".", "get", "(", "MEAN_ACCURACY", ")", "is", "not", "None", ":", "pieces", ".", "append", "(", "\"{} acc\"", ".", "format", "(", "format", "(", "self", ".", "last_result", "[", "MEAN_ACCURACY", "]", ",", "\".3g\"", ")", ")", ")", "return", "\", \"", ".", "join", "(", "pieces", ")" ]

[ "Returns", "a", "progress", "message", "for", "printing", "out", "to", "the", "console", "." ]

[ "def", "getattr", "(", "self", ",", "c", ",", "attr", ",", "default", "=", "None", ",", "match_only", "=", "None", ")", ":", "matching_decor", "=", "self", ".", "get_decor", "(", "c", ",", "match_only", "=", "match_only", ")", "try", ":", "return", "getattr", "(", "matching_decor", ",", "attr", ")", "except", "AttributeError", ":", "return", "default" ]

[ "Get", "the", "attribute", "of", "a", "component", "." ]

[ "def", "fillet", "(", "self", ",", "radius", ",", "points_per_2pi", "=", "128", ",", "max_points", "=", "199", ",", "precision", "=", "1e-3", ")", ":", "two_pi", "=", "2", "*", "numpy", ".", "pi", "fracture", "=", "False", "for", "jj", "in", "range", "(", "len", "(", "self", ".", "polygons", ")", ")", ":", "vec", "=", "self", ".", "polygons", "[", "jj", "]", ".", "astype", "(", "float", ")", "-", "numpy", ".", "roll", "(", "self", ".", "polygons", "[", "jj", "]", ",", "1", ",", "0", ")", "length", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "vec", "**", "2", ",", "1", ")", ")", "ii", "=", "numpy", ".", "flatnonzero", "(", "length", ")", "if", "len", "(", "ii", ")", "<", "len", "(", "length", ")", ":", "self", ".", "polygons", "[", "jj", "]", "=", "self", ".", "polygons", "[", "jj", "]", "[", "ii", "]", "vec", "=", "self", ".", "polygons", "[", "jj", "]", "-", "numpy", ".", "roll", "(", "self", ".", "polygons", "[", "jj", "]", ",", "1", ",", "0", ")", "length", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "vec", "**", "2", ",", "1", ")", ")", "vec", "[", ":", ",", "0", "]", "=", "vec", "[", ":", ",", "0", "]", "/", "length", "vec", "[", ":", ",", "1", "]", "=", "vec", "[", ":", ",", "1", "]", "/", "length", "dvec", "=", "numpy", ".", "roll", "(", "vec", ",", "-", "1", ",", "0", ")", "-", "vec", "norm", "=", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "dvec", "**", "2", ",", "1", ")", ")", "ii", "=", "numpy", ".", "flatnonzero", "(", "norm", ")", "dvec", "[", "ii", ",", "0", "]", "=", "dvec", "[", "ii", ",", "0", "]", "/", "norm", "[", "ii", "]", "dvec", "[", "ii", ",", "1", "]", "=", "dvec", "[", "ii", ",", "1", "]", "/", "norm", "[", "ii", "]", "theta", "=", "numpy", ".", "arccos", "(", "numpy", ".", "sum", "(", "numpy", ".", "roll", "(", "vec", ",", "-", "1", ",", "0", ")", "*", "vec", ",", "1", ")", ")", "ct", "=", "numpy", ".", "cos", "(", "theta", "*", "0.5", ")", "tt", "=", "numpy", ".", "tan", "(", "theta", "*", "0.5", ")", "new_points", "=", "[", "]", "for", "ii", "in", "range", "(", "-", "1", ",", "len", "(", "self", ".", "polygons", "[", "jj", "]", ")", "-", "1", ")", ":", "if", "theta", "[", "ii", "]", ">", "0", ":", "a0", "=", "-", "vec", "[", "ii", "]", "*", "tt", "[", "ii", "]", "-", "dvec", "[", "ii", "]", "/", "ct", "[", "ii", "]", "a0", "=", "numpy", ".", "arctan2", "(", "a0", "[", "1", "]", ",", "a0", "[", "0", "]", ")", "a1", "=", "vec", "[", "ii", "+", "1", "]", "*", "tt", "[", "ii", "]", "-", "dvec", "[", "ii", "]", "/", "ct", "[", "ii", "]", "a1", "=", "numpy", ".", "arctan2", "(", "a1", "[", "1", "]", ",", "a1", "[", "0", "]", ")", "if", "a1", "-", "a0", ">", "numpy", ".", "pi", ":", "a1", "-=", "two_pi", "elif", "a1", "-", "a0", "<", "-", "numpy", ".", "pi", ":", "a1", "+=", "two_pi", "n", "=", "max", "(", "int", "(", "numpy", ".", "ceil", "(", "abs", "(", "a1", "-", "a0", ")", "/", "two_pi", "*", "points_per_2pi", ")", "+", "0.5", ")", ",", "2", ")", "a", "=", "numpy", ".", "linspace", "(", "a0", ",", "a1", ",", "n", ")", "l", "=", "radius", "*", "tt", "[", "ii", "]", "if", "l", ">", "0.49", "*", "length", "[", "ii", "]", ":", "r", "=", "0.49", "*", "length", "[", "ii", "]", "/", "tt", "[", "ii", "]", "l", "=", "0.49", "*", "length", "[", "ii", "]", "else", ":", "r", "=", "radius", "if", "l", ">", "0.49", "*", "length", "[", "ii", "+", "1", "]", ":", "r", "=", "0.49", "*", "length", "[", "ii", "+", "1", "]", "/", "tt", "[", "ii", "]", "new_points", ".", "extend", "(", "r", "*", "dvec", "[", "ii", "]", "/", "ct", "[", "ii", "]", "+", "self", ".", "polygons", "[", "jj", "]", "[", "ii", "]", "+", "numpy", ".", "vstack", "(", "(", "r", "*", "numpy", ".", "cos", "(", "a", ")", ",", "r", "*", "numpy", ".", "sin", "(", "a", ")", ")", ")", ".", "transpose", "(", ")", ")", "else", ":", "new_points", ".", "append", "(", "self", ".", "polygons", "[", "jj", "]", "[", "ii", "]", ")", "self", ".", "polygons", "[", "jj", "]", "=", "numpy", ".", "array", "(", "new_points", ")", "if", "len", "(", "new_points", ")", ">", "max_points", ":", "fracture", "=", "True", "if", "fracture", ":", "self", ".", "fracture", "(", "max_points", ",", "precision", ")", "return", "self" ]

[ "Round", "the", "corners", "of", "these", "polygons", "and", "fractures", "them", "into", "polygons", "with", "less", "vertices", "if", "necessary", "." ]

[ "def", "eth_getCode", "(", "self", ",", "address", ",", "default_block", "=", "BLOCK_TAG_LATEST", ")", ":", "if", "isinstance", "(", "default_block", ",", "str", ")", ":", "if", "default_block", "not", "in", "BLOCK_TAGS", ":", "raise", "ValueError", "return", "self", ".", "_call", "(", "\"eth_getCode\"", ",", "[", "address", ",", "default_block", "]", ")" ]

[ "TODO", ":", "documentation" ]

[ "def", "check_ups_estimated_minutes_remaining", "(", "the_session", ",", "the_helper", ",", "the_snmp_value", ")", ":", "the_helper", ".", "add_metric", "(", "label", "=", "the_helper", ".", "options", ".", "type", ",", "value", "=", "the_snmp_value", ",", "uom", "=", "\"minutes\"", ")", "the_helper", ".", "set_summary", "(", "\"Remaining runtime on battery is {} minutes\"", ".", "format", "(", "the_snmp_value", ")", ")" ]

[ "OID", ".", "1", ".", "3", ".", "6", ".", "1", ".", "2", ".", "1", ".", "33", ".", "1", ".", "2", ".", "3", ".", "0", "MIB", "excerpt", "An", "estimate", "of", "the", "time", "to", "battery", "charge", "depletion", "under", "the", "present", "load", "conditions", "if", "the", "utility", "power", "is", "off", "and", "remains", "off", "or", "if", "it", "were", "to", "be", "lost", "and", "remain", "off", "." ]

[ "async", "def", "get_resources", "(", "self", ")", ":", "facade", "=", "client", ".", "ResourcesFacade", ".", "from_connection", "(", "self", ".", "connection", ")", "response", "=", "await", "facade", ".", "ListResources", "(", "[", "client", ".", "Entity", "(", "self", ".", "tag", ")", "]", ")", "resources", "=", "dict", "(", ")", "for", "result", "in", "response", ".", "results", ":", "for", "resource", "in", "result", ".", "charm_store_resources", "or", "[", "]", ":", "resources", "[", "resource", ".", "name", "]", "=", "resource", "for", "resource", "in", "result", ".", "resources", "or", "[", "]", ":", "if", "resource", ".", "charmresource", ":", "resource", "=", "resource", ".", "charmresource", "resources", "[", "resource", ".", "name", "]", "=", "resource", "return", "resources" ]

[ "Return", "resources", "for", "this", "application", "." ]

[ "def", "get", "(", "self", ",", "key", ")", ":", "data", "=", "self", ".", "_store", ".", "get", "(", "key", ")", "if", "not", "data", ":", "return", "None", "value", ",", "expire", "=", "data", "if", "expire", "and", "time", ".", "time", "(", ")", ">", "expire", ":", "del", "self", ".", "_store", "[", "key", "]", "return", "None", "return", "value" ]

[ "Get", "an", "item", "from", "the", "cache", "Args", ":", "key", ":", "item", "key", "Returns", ":", "the", "value", "of", "the", "item", "or", "None", "if", "the", "item", "isn", "t", "in", "the", "cache" ]

[ "def", "from_dict", "(", "cls", ",", "d", ")", ":", "result", "=", "super", "(", "ActorHandler", ",", "cls", ")", ".", "from_dict", "(", "d", ")", "if", "\"actors\"", "in", "d", ":", "l", "=", "d", "[", "\"actors\"", "]", "for", "e", "in", "l", ":", "if", "u\"type\"", "in", "e", ":", "typestr", "=", "e", "[", "u\"type\"", "]", "else", ":", "typestr", "=", "e", "[", "\"type\"", "]", "result", ".", "actors", ".", "append", "(", "classes", ".", "get_dict_handler", "(", "typestr", ")", "(", "e", ")", ")", "return", "result" ]

[ "Restores", "an", "object", "state", "from", "a", "dictionary", "used", "in", "de", "-", "JSONification", "." ]

[ "def", "create_panel_of_normals", "(", "items", ",", "group_id", ",", "work_dir", ")", ":", "out_file", "=", "os", ".", "path", ".", "join", "(", "work_dir", ",", "\"%s-%s-pon.hdf5\"", "%", "(", "dd", ".", "get_sample_name", "(", "items", "[", "0", "]", ")", ",", "group_id", ")", ")", "if", "not", "utils", ".", "file_exists", "(", "out_file", ")", ":", "with", "file_transaction", "(", "items", "[", "0", "]", ",", "out_file", ")", "as", "tx_out_file", ":", "params", "=", "[", "\"-T\"", ",", "\"CreateReadCountPanelOfNormals\"", ",", "\"-O\"", ",", "tx_out_file", ",", "\"--annotated-intervals\"", ",", "tz", ".", "get_in", "(", "[", "\"regions\"", ",", "\"bins\"", ",", "\"gcannotated\"", "]", ",", "items", "[", "0", "]", ")", "]", "for", "data", "in", "items", ":", "params", "+=", "[", "\"-I\"", ",", "tz", ".", "get_in", "(", "[", "\"depth\"", ",", "\"bins\"", ",", "\"target\"", "]", ",", "data", ")", "]", "_run_with_memory_scaling", "(", "params", ",", "tx_out_file", ",", "items", "[", "0", "]", ",", "ld_preload", "=", "True", ")", "return", "out_file" ]

[ "Create", "a", "panel", "of", "normals", "from", "one", "or", "more", "background", "read", "counts", "." ]

[ "def", "fontsize", "(", "self", ",", "fontsize", "=", "None", ")", ":", "if", "fontsize", "is", "not", "None", ":", "self", ".", "_canvas", ".", "fontsize", "=", "fontsize", "else", ":", "return", "self", ".", "_canvas", ".", "fontsize" ]

[ "Set", "or", "return", "size", "of", "current", "font", "." ]

[ "def", "run_hierarchical", "(", "audio_file", ",", "bounds_module", ",", "labels_module", ",", "frame_times", ",", "config", ",", "annotator_id", "=", "0", ")", ":", "# Sanity check", "if", "bounds_module", "is", "None", ":", "raise", "NoHierBoundaryError", "(", "\"A boundary algorithm is needed when using \"", "\"hierarchical segmentation.\"", ")", "# Get features to make code nicer", "features", "=", "config", "[", "\"features\"", "]", ".", "features", "# Compute boundaries", "S", "=", "bounds_module", ".", "Segmenter", "(", "audio_file", ",", "*", "*", "config", ")", "est_idxs", ",", "est_labels", "=", "S", ".", "processHierarchical", "(", ")", "# Compute labels if needed", "if", "labels_module", "is", "not", "None", "and", "bounds_module", ".", "__name__", "!=", "labels_module", ".", "__name__", ":", "# Compute labels for each level in the hierarchy", "flat_config", "=", "deepcopy", "(", "config", ")", "flat_config", "[", "\"hier\"", "]", "=", "False", "for", "i", ",", "level_idxs", "in", "enumerate", "(", "est_idxs", ")", ":", "S", "=", "labels_module", ".", "Segmenter", "(", "audio_file", ",", "in_bound_idxs", "=", "level_idxs", ",", "*", "*", "flat_config", ")", "est_labels", "[", "i", "]", "=", "S", ".", "processFlat", "(", ")", "[", "1", "]", "# Make sure the first and last boundaries are included for each", "# level in the hierarchy", "est_times", "=", "[", "]", "cleaned_est_labels", "=", "[", "]", "for", "level", "in", "range", "(", "len", "(", "est_idxs", ")", ")", ":", "est_level_times", ",", "est_level_labels", "=", "utils", ".", "process_segmentation_level", "(", "est_idxs", "[", "level", "]", ",", "est_labels", "[", "level", "]", ",", "features", ".", "shape", "[", "0", "]", ",", "frame_times", ",", "config", "[", "\"features\"", "]", ".", "dur", ")", "est_times", ".", "append", "(", "est_level_times", ")", "cleaned_est_labels", ".", "append", "(", "est_level_labels", ")", "est_labels", "=", "cleaned_est_labels", "return", "est_times", ",", "est_labels" ]

[ "Runs", "hierarchical", "algorithms", "with", "the", "specified", "identifiers", "on", "the", "audio_file", ".", "See", "run_algorithm", "for", "more", "information", "." ]

[ "def", "calculateDatasets", "(", "self", ",", "scene", ",", "axes", ",", "datasets", ")", ":", "items", "=", "self", ".", "calculateDatasetItems", "(", "scene", ",", "datasets", ")", "if", "not", "items", ":", "scene", ".", "clear", "(", ")", "return", "rect", "=", "self", ".", "buildData", "(", "'axis_rect'", ")", "for", "dataset", ",", "item", "in", "items", ".", "items", "(", ")", ":", "first", "=", "True", "pos", "=", "None", "home", "=", "None", "ellipses", "=", "[", "]", "path", "=", "QPainterPath", "(", ")", "for", "value", "in", "dataset", ".", "values", "(", ")", ":", "pos", "=", "self", ".", "pointAt", "(", "axes", ",", "value", ")", "ellipses", ".", "append", "(", "pos", ")", "if", "first", ":", "path", ".", "moveTo", "(", "pos", ")", "first", "=", "False", "else", ":", "path", ".", "lineTo", "(", "pos", ")", "item", ".", "setPath", "(", "path", ")", "item", ".", "setBuildData", "(", "'ellipses'", ",", "ellipses", ")" ]

[ "Builds", "the", "datasets", "for", "this", "renderer", ".", "Each", "renderer", "will", "need", "to", "subclass", "and", "implemenent", "this", "method", "otherwise", "no", "data", "will", "be", "shown", "in", "the", "chart", ".", ":", "param", "scene", "|", "<XChartScene", ">", "axes", "|", "[", "<", "datasets", "|", "[", "<XChartDataset", ">", "..", "]" ]

[ "def", "main", "(", "args", ")", ":", "# get options and arguments", "ui", "=", "getUI", "(", "args", ")", "if", "ui", ".", "optionIsSet", "(", "\"test\"", ")", ":", "# just run unit tests", "unittest", ".", "main", "(", "argv", "=", "[", "sys", ".", "argv", "[", "0", "]", "]", ")", "elif", "ui", ".", "optionIsSet", "(", "\"help\"", ")", ":", "# just show help", "ui", ".", "usage", "(", ")", "else", ":", "verbose", "=", "ui", ".", "optionIsSet", "(", "\"verbose\"", ")", "stranded", "=", "ui", ".", "optionIsSet", "(", "\"stranded\"", ")", "if", "stranded", ":", "sys", ".", "stderr", ".", "write", "(", "\"Sorry, stranded mode hasn't been implemented yet.\"", ")", "sys", ".", "exit", "(", ")", "# we required two input files, so we know these will be present...", "regions_1", "=", "[", "e", "for", "e", "in", "BEDIterator", "(", "ui", ".", "getArgument", "(", "0", ")", ",", "verbose", "=", "verbose", ")", "]", "regions_2", "=", "[", "e", "for", "e", "in", "BEDIterator", "(", "ui", ".", "getArgument", "(", "1", ")", ",", "verbose", "=", "verbose", ")", "]", "print", "jaccardIndex", "(", "regions_1", ",", "regions_2", ")" ]

[ "main", "entry", "point", "for", "the", "GenomicIntJaccard", "script", "." ]

[ "def", "i_ww", "(", "self", ")", ":", "d_values", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "n_pads_l", ")", ":", "d_values", ".", "append", "(", "self", ".", "pad_position_l", "(", "i", ")", ")", "d_values", "=", "np", ".", "array", "(", "d_values", ")", "-", "self", ".", "length", "/", "2", "area_d_sqrd", "=", "sum", "(", "self", ".", "pad_area", "*", "d_values", "**", "2", ")", "*", "self", ".", "n_pads_w", "i_second", "=", "self", ".", "pad_i_ww", "*", "self", ".", "n_pads", "return", "area_d_sqrd", "+", "i_second" ]

[ "Second", "moment", "of", "inertia", "around", "the", "width", "axis", ".", ":", "return", ":" ]

[ "def", "router_main", "(", "self", ")", ":", "while", "True", ":", "gotpkt", "=", "True", "try", ":", "timestamp", ",", "dev", ",", "pkt", "=", "self", ".", "net", ".", "recv_packet", "(", "timeout", "=", "1.0", ")", "except", "NoPackets", ":", "log_debug", "(", "\"No packets available in recv_packet\"", ")", "gotpkt", "=", "False", "except", "Shutdown", ":", "log_debug", "(", "\"Got shutdown signal\"", ")", "break", "if", "gotpkt", ":", "log_debug", "(", "\"Got a packet: {}\"", ".", "format", "(", "str", "(", "pkt", ")", ")", ")" ]

[ "Main", "method", "for", "router", ";", "we", "stay", "in", "a", "loop", "in", "this", "method", "receiving", "packets", "until", "the", "end", "of", "time", "." ]

[ "def", "get_checks_paths", "(", "checks_paths", "=", "None", ")", ":", "p", "=", "os", ".", "path", ".", "join", "(", "__file__", ",", "os", ".", "pardir", ",", "os", ".", "pardir", ",", "os", ".", "pardir", ",", "\"checks\"", ")", "p", "=", "os", ".", "path", ".", "abspath", "(", "p", ")", "# let's utilize the default upstream checks always", "if", "checks_paths", ":", "p", "+=", "[", "os", ".", "path", ".", "abspath", "(", "x", ")", "for", "x", "in", "checks_paths", "]", "return", "[", "p", "]" ]

[ "Get", "path", "to", "checks", "." ]

[ "def", "import_vmesh", "(", "file", ")", ":", "imported_elements", "=", "[", "]", "if", "os", ".", "path", ".", "isfile", "(", "file", ")", ":", "imported_elements", ".", "append", "(", "exch", ".", "import_vol_mesh", "(", "file", ")", ")", "elif", "os", ".", "path", ".", "isdir", "(", "file", ")", ":", "files", "=", "sorted", "(", "[", "os", ".", "path", ".", "join", "(", "file", ",", "f", ")", "for", "f", "in", "os", ".", "listdir", "(", "file", ")", "]", ")", "for", "f", "in", "files", ":", "imported_elements", ".", "append", "(", "exch", ".", "import_vol_mesh", "(", "f", ")", ")", "else", ":", "raise", "exch", ".", "GeomdlException", "(", "\"Input is not a file or a directory\"", ")", "return", "imported_elements" ]

[ "Imports", "NURBS", "volume", "(", "s", ")", "from", "volume", "mesh", "(", "vmesh", ")", "file", "(", "s", ")", "." ]

[ "def", "repair_mongo", "(", "name", ",", "dbpath", ")", ":", "log_file", "=", "os", ".", "path", ".", "join", "(", "dbpath", ",", "'mongod.log'", ")", "cmd", "=", "[", "name", ",", "\"--dbpath\"", ",", "dbpath", ",", "\"--logpath\"", ",", "log_file", ",", "\"--logappend\"", ",", "\"--repair\"", "]", "proc", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "universal_newlines", "=", "True", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "STDOUT", ")", "timeout", "=", "45", "t_start", "=", "time", ".", "time", "(", ")", "while", "time", ".", "time", "(", ")", "-", "t_start", "<", "timeout", ":", "line", "=", "str", "(", "proc", ".", "stdout", ".", "readline", "(", ")", ")", "logger", ".", "info", "(", "\"repair output: %s\"", "%", "(", "line", ",", ")", ")", "return_code", "=", "proc", ".", "poll", "(", ")", "if", "return_code", "is", "not", "None", ":", "if", "return_code", ":", "raise", "Exception", "(", "\"mongod --repair failed with exit code %s, \"", "\"check log file: %s\"", "%", "(", "return_code", ",", "log_file", ")", ")", "# Success when poll() returns 0", "return", "time", ".", "sleep", "(", "1", ")", "proc", ".", "terminate", "(", ")", "raise", "Exception", "(", "\"mongod --repair failed to exit after %s seconds, \"", "\"check log file: %s\"", "%", "(", "timeout", ",", "log_file", ")", ")" ]

[ "repair", "mongodb", "after", "usafe", "shutdown" ]

[ "def", "repeat_str", "(", "state", ")", ":", "if", "state", "==", "const", ".", "REPEAT_STATE_OFF", ":", "return", "'Off'", "if", "state", "==", "const", ".", "REPEAT_STATE_TRACK", ":", "return", "'Track'", "if", "state", "==", "const", ".", "REPEAT_STATE_ALL", ":", "return", "'All'", "return", "'Unsupported'" ]

[ "Convert", "internal", "API", "repeat", "state", "to", "string", "." ]

[ "def", "_embedded_frames", "(", "frame_list", ",", "frame_format", ")", ":", "template", "=", "' frames[{0}] = \"data:image/{1};base64,{2}\"\\n'", "embedded", "=", "\"\\n\"", "for", "i", ",", "frame_data", "in", "enumerate", "(", "frame_list", ")", ":", "embedded", "+=", "template", ".", "format", "(", "i", ",", "frame_format", ",", "frame_data", ".", "replace", "(", "'\\n'", ",", "'\\\\\\n'", ")", ")", "return", "embedded" ]

[ "frame_list", "should", "be", "a", "list", "of", "base64", "-", "encoded", "png", "files" ]