Datasets:

kejian

/

codesearchnet-python-raw

like 1

[ "def", "debugger", "(", ")", ":", "dbg", "=", "_current", "[", "0", "]", "if", "dbg", "is", "None", "or", "not", "dbg", ".", "active", ":", "dbg", "=", "_current", "[", "0", "]", "=", "RemoteCeleryTrepan", "(", ")", "return", "dbg" ]

[ "Return", "the", "current", "debugger", "instance", "(", "if", "any", ")", "or", "creates", "a", "new", "one", "." ]

[ "def", "file", "(", "suffix", "=", "''", ",", "prefix", "=", "'tmp'", ",", "parent", "=", "None", ")", ":", "fh_", ",", "tmp_", "=", "tempfile", ".", "mkstemp", "(", "suffix", ",", "prefix", ",", "parent", ")", "os", ".", "close", "(", "fh_", ")", "return", "tmp_" ]

[ "Create", "a", "temporary", "file" ]

[ "def", "get_metric_group_definitions", "(", "self", ")", ":", "group_names", "=", "self", ".", "properties", ".", "get", "(", "'metric-groups'", ",", "None", ")", "if", "not", "group_names", ":", "group_names", "=", "self", ".", "manager", ".", "get_metric_group_definition_names", "(", ")", "mg_defs", "=", "[", "]", "for", "group_name", "in", "group_names", ":", "try", ":", "mg_def", "=", "self", ".", "manager", ".", "get_metric_group_definition", "(", "group_name", ")", "mg_defs", ".", "append", "(", "mg_def", ")", "except", "ValueError", ":", "pass", "# ignore metric groups without metric group defs", "return", "mg_defs" ]

[ "Get", "the", "faked", "metric", "group", "definitions", "for", "this", "context", "object", "that", "are", "to", "be", "returned", "from", "its", "create", "operation", "." ]

[ "def", "generate_null_timeseries", "(", "self", ",", "ts", ",", "mu", ",", "sigma", ")", ":", "l", "=", "len", "(", "ts", ")", "return", "np", ".", "random", ".", "normal", "(", "mu", ",", "sigma", ",", "l", ")" ]

[ "Generate", "a", "time", "series", "with", "a", "given", "mu", "and", "sigma", ".", "This", "serves", "as", "the", "NULL", "distribution", "." ]

[ "def", "snake", "(", "s", ")", ":", "if", "len", "(", "s", ")", "<", "2", ":", "return", "s", ".", "lower", "(", ")", "out", "=", "s", "[", "0", "]", ".", "lower", "(", ")", "for", "c", "in", "s", "[", "1", ":", "]", ":", "if", "c", ".", "isupper", "(", ")", ":", "out", "+=", "\"_\"", "c", "=", "c", ".", "lower", "(", ")", "out", "+=", "c", "return", "out" ]

[ "Convert", "from", "title", "or", "camelCase", "to", "snake_case", "." ]

[ "def", "parametric_function_api", "(", "scope_name", "=", "None", ",", "param_desc", "=", "None", ")", ":", "if", "scope_name", "is", "None", ":", "scope_name", "=", "name", "def", "parametric_function_api_inside", "(", "func", ")", ":", "from", "nnabla", ".", "utils", ".", "py23_compatible", "import", "getargspec", "import", "inspect", "name", "=", "func", ".", "__name__", "doc", "=", "func", ".", "__doc__", "if", "param_desc", ":", "indent", "=", "8", "try", ":", "desc", "=", "map", "(", "lambda", "d", ":", "' '", "*", "indent", "+", "'* {} (``need_grad={}``) : {}. (shape: ``{}``)'", ".", "format", "(", "d", "[", "0", "]", ",", "d", "[", "3", "]", ",", "d", "[", "1", "]", ",", "d", "[", "2", "]", ")", ",", "param_desc", ")", "except", ":", "ValueError", "(", "'param_desc argument of parametric_function_api must be '", "'None or a list of tuple with three elements composed of '", "'(name(str), description(str), need_grad(bool)).'", ")", "doc", "+=", "'''\n Parameters to be registered\n The following variables are registered in a parameter scope ``\"{}\"``;\n\n{}\n\n '''", ".", "format", "(", "scope_name", ",", "'\\n'", ".", "join", "(", "desc", ")", ")", "doc", "+=", "\"\"\"\n Note:\n\n If the ``name`` option is passed, the parameters become wrapped inside the parameter scope\n with the specified name, yielding the same results as the following code.\n This can be used to simplify the code.\n\n .. code-block:: python\n\n with parametric_scope(name):\n output = {name}(<args>)\n\n \"\"\"", ".", "format", "(", "name", "=", "name", ")", "spec", "=", "getargspec", "(", "func", ")", "defaults", "=", "spec", ".", "defaults", "if", "defaults", "is", "None", ":", "defaults", "=", "tuple", "(", ")", "# None will be appended later", "signature", "=", "inspect", ".", "formatargspec", "(", "spec", ".", "args", "+", "[", "'name'", "]", ",", "spec", ".", "varargs", ",", "spec", ".", "keywords", ",", "defaults", "+", "(", "None", ",", ")", ")", "shortsignature", "=", "inspect", ".", "formatargspec", "(", "spec", ".", "args", ",", "spec", ".", "varargs", ",", "spec", ".", "keywords", ",", "None", ")", "# Check required argument", "assert", "'fix_parameters'", "in", "spec", ".", "args", ",", "\"A parametric function must take `fix_parameters` as an argument.\"", "\" `{}{}` doesn't have it.\"", ".", "format", "(", "name", ",", "signature", ")", "code", "=", "\"\"\"\ndef {name}{signature}:\n if name is None:\n with parameter_scope(scope_name):\n return func{shortsignature}\n with parameter_scope(name):\n with parameter_scope(scope_name):\n return func{shortsignature}\n \"\"\"", ".", "format", "(", "*", "*", "locals", "(", ")", ")", "execdict", "=", "dict", "(", "func", "=", "func", ",", "parameter_scope", "=", "nn", ".", "parameter_scope", ",", "scope_name", "=", "scope_name", ")", "exec_", "(", "code", ",", "execdict", ")", "newfunc", "=", "execdict", "[", "name", "]", "newfunc", ".", "__doc__", "=", "doc", "newfunc", ".", "__parametric_function_api_base__", "=", "func", "newfunc", ".", "__scope_name__", "=", "scope_name", "newfunc", ".", "__module__", "=", "__name__", "return", "newfunc", "return", "parametric_function_api_inside" ]

[ "Decorator", "for", "parametric", "functions", "." ]

[ "def", "enter_fullscreen", "(", "self", ")", ":", "self", ".", "term", ".", "stream", ".", "write", "(", "self", ".", "term", ".", "enter_fullscreen", ")", "self", ".", "term", ".", "stream", ".", "write", "(", "self", ".", "term", ".", "hide_cursor", ")" ]

[ "Invoke", "before", "printing", "out", "anything", ".", "This", "method", "should", "be", "replaced", "by", "or", "merged", "to", "blessings", "package" ]

[ "def", "mavlink_packet", "(", "self", ",", "m", ")", ":", "if", "m", ".", "get_type", "(", ")", "==", "'SERIAL_CONTROL'", ":", "data", "=", "m", ".", "data", "[", ":", "m", ".", "count", "]", "if", "m", ".", "count", ">", "0", ":", "s", "=", "''", ".", "join", "(", "str", "(", "chr", "(", "x", ")", ")", "for", "x", "in", "data", ")", "if", "self", ".", "mpstate", ".", "system", "==", "'Windows'", ":", "# strip nsh ansi codes", "s", "=", "s", ".", "replace", "(", "\"\\033[K\"", ",", "\"\"", ")", "sys", ".", "stdout", ".", "write", "(", "s", ")", "self", ".", "last_packet", "=", "time", ".", "time", "(", ")" ]

[ "handle", "an", "incoming", "mavlink", "packet" ]

[ "def", "move", "(", "self", ",", "state", ")", ":", "if", "state", "==", "tuple", "(", "[", "BEGIN", "]", "*", "self", ".", "state_size", ")", ":", "choices", "=", "self", ".", "begin_choices", "cumdist", "=", "self", ".", "begin_cumdist", "else", ":", "choices", ",", "weights", "=", "zip", "(", "*", "self", ".", "model", "[", "state", "]", ".", "items", "(", ")", ")", "cumdist", "=", "list", "(", "accumulate", "(", "weights", ")", ")", "r", "=", "random", ".", "random", "(", ")", "*", "cumdist", "[", "-", "1", "]", "selection", "=", "choices", "[", "bisect", ".", "bisect", "(", "cumdist", ",", "r", ")", "]", "return", "selection" ]

[ "Given", "a", "state", "choose", "the", "next", "item", "at", "random", "." ]

[ "def", "load", "(", "self", ",", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'transform_name'", "]", "=", "True", "kwargs", "=", "self", ".", "_mutate_name", "(", "kwargs", ")", "return", "self", ".", "_load", "(", "*", "*", "kwargs", ")" ]

[ "Loads", "a", "given", "resource" ]

[ "def", "_asQuartusTcl", "(", "self", ",", "buff", ":", "List", "[", "str", "]", ",", "version", ":", "str", ",", "intfName", ":", "str", ",", "component", ":", "\"Component\"", ",", "packager", ":", "\"IpPackager\"", ",", "thisIf", ":", "'Interface'", ",", "intfMapOrName", ":", "Dict", "[", "str", ",", "Union", "[", "Dict", ",", "str", "]", "]", ")", ":", "if", "isinstance", "(", "intfMapOrName", ",", "str", ")", ":", "self", ".", "quartus_add_interface_port", "(", "buff", ",", "intfName", ",", "thisIf", ",", "intfMapOrName", ",", "packager", ")", "else", ":", "for", "thisIf_", "in", "thisIf", ".", "_interfaces", ":", "v", "=", "intfMapOrName", "[", "thisIf_", ".", "_name", "]", "self", ".", "_asQuartusTcl", "(", "buff", ",", "version", ",", "intfName", ",", "component", ",", "packager", ",", "thisIf_", ",", "v", ")" ]

[ "Add", "interface", "to", "Quartus", "tcl", "by", "specified", "name", "map" ]

[ "def", "check_password", "(", "self", ",", "raw_password", ")", ":", "bcrypt", "=", "self", ".", "get_bcrypt", "(", ")", "return", "bcrypt", ".", "hashpw", "(", "raw_password", ",", "self", ".", "value", ")", "==", "self", ".", "value" ]

[ "Validates", "the", "given", "raw", "password", "against", "the", "intance", "s", "encrypted", "one", "." ]

[ "def", "get_option_default", "(", "self", ",", "key", ",", "subkey", ")", ":", "key", ",", "subkey", "=", "_lower_keys", "(", "key", ",", "subkey", ")", "_entry_must_exist", "(", "self", ".", "gc", ",", "key", ",", "subkey", ")", "df", "=", "self", ".", "gc", "[", "(", "self", ".", "gc", "[", "\"k1\"", "]", "==", "key", ")", "&", "(", "self", ".", "gc", "[", "\"k2\"", "]", "==", "subkey", ")", "]", "if", "df", "[", "\"type\"", "]", ".", "values", "[", "0", "]", "==", "\"bool\"", ":", "return", "bool", "(", "df", "[", "\"default\"", "]", ".", "values", "[", "0", "]", ")", "elif", "df", "[", "\"type\"", "]", ".", "values", "[", "0", "]", "==", "\"int\"", ":", "return", "int", "(", "df", "[", "\"default\"", "]", ".", "values", "[", "0", "]", ")", "else", ":", "return", "df", "[", "\"default\"", "]", ".", "values", "[", "0", "]" ]

[ "Get", "the", "default", "value", "of", "the", "option", "." ]

[ "def", "toggle_pawn_cfg", "(", "self", ")", ":", "if", "self", ".", "app", ".", "manager", ".", "current", "==", "'pawncfg'", ":", "dummything", "=", "self", ".", "app", ".", "dummything", "self", ".", "ids", ".", "thingtab", ".", "remove_widget", "(", "dummything", ")", "dummything", ".", "clear", "(", ")", "if", "self", ".", "app", ".", "pawncfg", ".", "prefix", ":", "dummything", ".", "prefix", "=", "self", ".", "app", ".", "pawncfg", ".", "prefix", "dummything", ".", "num", "=", "dummynum", "(", "self", ".", "app", ".", "character", ",", "dummything", ".", "prefix", ")", "+", "1", "if", "self", ".", "app", ".", "pawncfg", ".", "imgpaths", ":", "dummything", ".", "paths", "=", "self", ".", "app", ".", "pawncfg", ".", "imgpaths", "else", ":", "dummything", ".", "paths", "=", "[", "'atlas://rltiles/base/unseen'", "]", "self", ".", "ids", ".", "thingtab", ".", "add_widget", "(", "dummything", ")", "else", ":", "self", ".", "app", ".", "pawncfg", ".", "prefix", "=", "self", ".", "ids", ".", "dummything", ".", "prefix", "self", ".", "app", ".", "pawncfg", ".", "toggle", "(", ")" ]

[ "Show", "or", "hide", "the", "pop", "-", "over", "where", "you", "can", "configure", "the", "dummy", "pawn" ]

[ "def", "store_many", "(", "self", ",", "items", ")", ":", "with", "self", ".", "walrus", ".", "atomic", "(", ")", ":", "for", "item", "in", "items", ":", "self", ".", "store", "(", "*", "item", ")" ]

[ "Store", "multiple", "subject", "-", "predicate", "-", "object", "triples", "in", "the", "database", "." ]

[ "def", "_get_f2rx", "(", "self", ",", "C", ",", "r_x", ",", "r_1", ",", "r_2", ")", ":", "drx", "=", "(", "r_x", "-", "r_1", ")", "/", "(", "r_2", "-", "r_1", ")", "return", "self", ".", "CONSTS", "[", "\"h4\"", "]", "+", "(", "C", "[", "\"h5\"", "]", "*", "drx", ")", "+", "(", "C", "[", "\"h6\"", "]", "*", "(", "drx", "**", "2.", ")", ")" ]

[ "Defines", "the", "f2", "scaling", "coefficient", "defined", "in", "equation", "10" ]

[ "def", "filter_from_import", "(", "line", ",", "unused_module", ")", ":", "(", "indentation", ",", "imports", ")", "=", "re", ".", "split", "(", "pattern", "=", "r'\\bimport\\b'", ",", "string", "=", "line", ",", "maxsplit", "=", "1", ")", "base_module", "=", "re", ".", "search", "(", "pattern", "=", "r'\\bfrom\\s+([^ ]+)'", ",", "string", "=", "indentation", ")", ".", "group", "(", "1", ")", "# Create an imported module list with base module name", "# ex ``from a import b, c as d`` -> ``['a.b', 'a.c as d']``", "imports", "=", "re", ".", "split", "(", "pattern", "=", "r','", ",", "string", "=", "imports", ".", "strip", "(", ")", ")", "imports", "=", "[", "base_module", "+", "'.'", "+", "x", ".", "strip", "(", ")", "for", "x", "in", "imports", "]", "# We compare full module name (``a.module`` not `module`) to", "# guarantee the exact same module as detected from pyflakes.", "filtered_imports", "=", "[", "x", ".", "replace", "(", "base_module", "+", "'.'", ",", "''", ")", "for", "x", "in", "imports", "if", "x", "not", "in", "unused_module", "]", "# All of the import in this statement is unused", "if", "not", "filtered_imports", ":", "return", "get_indentation", "(", "line", ")", "+", "'pass'", "+", "get_line_ending", "(", "line", ")", "indentation", "+=", "'import '", "return", "(", "indentation", "+", "', '", ".", "join", "(", "sorted", "(", "filtered_imports", ")", ")", "+", "get_line_ending", "(", "line", ")", ")" ]

[ "Parse", "and", "filter", "from", "something", "import", "a", "b", "c", "." ]

[ "def", "_get_edges", "(", "self", ")", ":", "if", "self", ".", "_edges", "is", "None", ":", "self", ".", "_edges", "=", "self", ".", "_compute_edges", "(", ")", "return", "self", ".", "_edges" ]

[ "Get", "the", "edges", "for", "the", "current", "surface", "." ]

[ "def", "_register", "(", "self", ",", "cls", ")", ":", "if", "not", "inspect", ".", "isclass", "(", "cls", ")", ":", "raise", "ValueError", "(", "'Only classes may be registered.'", ")", "elif", "not", "issubclass", "(", "cls", ",", "self", ".", "_registerable_class", ")", ":", "raise", "ValueError", "(", "'Only %s classes or subclasses may be registered.'", "%", "self", ".", "_registerable_class", ".", "__name__", ")", "if", "cls", "not", "in", "self", ".", "_registry", ":", "cls", ".", "_registered_with", "=", "self", "self", ".", "_registry", "[", "cls", "]", "=", "cls", "(", ")", "return", "self", ".", "_registry", "[", "cls", "]" ]

[ "Registers", "the", "given", "class", "." ]

[ "def", "valid_configs", "(", "self", ")", ":", "if", "self", ".", "ykver", "(", ")", "<", "(", "2", ",", "1", ",", "0", ")", ":", "raise", "YubiKeyUSBHIDError", "(", "'Valid configs unsupported in firmware %s'", "%", "(", "self", ".", "version", "(", ")", ")", ")", "res", "=", "[", "]", "if", "self", ".", "touch_level", "&", "self", ".", "CONFIG1_VALID", "==", "self", ".", "CONFIG1_VALID", ":", "res", ".", "append", "(", "1", ")", "if", "self", ".", "touch_level", "&", "self", ".", "CONFIG2_VALID", "==", "self", ".", "CONFIG2_VALID", ":", "res", ".", "append", "(", "2", ")", "return", "res" ]

[ "Return", "a", "list", "of", "slots", "having", "a", "valid", "configurtion", ".", "Requires", "firmware", "2", ".", "1", "." ]

[ "def", "get_all_results_from_jobs", "(", "user", ",", "j_id", ")", ":", "job", "=", "v1_utils", ".", "verify_existence_and_get", "(", "j_id", ",", "_TABLE", ")", "if", "not", "user", ".", "is_in_team", "(", "job", "[", "'team_id'", "]", ")", "and", "not", "user", ".", "is_read_only_user", "(", ")", ":", "raise", "dci_exc", ".", "Unauthorized", "(", ")", "# get testscases from tests_results", "query", "=", "sql", ".", "select", "(", "[", "models", ".", "TESTS_RESULTS", "]", ")", ".", "where", "(", "models", ".", "TESTS_RESULTS", ".", "c", ".", "job_id", "==", "job", "[", "'id'", "]", ")", "all_tests_results", "=", "flask", ".", "g", ".", "db_conn", ".", "execute", "(", "query", ")", ".", "fetchall", "(", ")", "results", "=", "[", "]", "for", "test_result", "in", "all_tests_results", ":", "test_result", "=", "dict", "(", "test_result", ")", "results", ".", "append", "(", "{", "'filename'", ":", "test_result", "[", "'name'", "]", ",", "'name'", ":", "test_result", "[", "'name'", "]", ",", "'total'", ":", "test_result", "[", "'total'", "]", ",", "'failures'", ":", "test_result", "[", "'failures'", "]", ",", "'errors'", ":", "test_result", "[", "'errors'", "]", ",", "'skips'", ":", "test_result", "[", "'skips'", "]", ",", "'time'", ":", "test_result", "[", "'time'", "]", ",", "'regressions'", ":", "test_result", "[", "'regressions'", "]", ",", "'successfixes'", ":", "test_result", "[", "'successfixes'", "]", ",", "'success'", ":", "test_result", "[", "'success'", "]", ",", "'file_id'", ":", "test_result", "[", "'file_id'", "]", "}", ")", "return", "flask", ".", "jsonify", "(", "{", "'results'", ":", "results", ",", "'_meta'", ":", "{", "'count'", ":", "len", "(", "results", ")", "}", "}", ")" ]

[ "Get", "all", "results", "from", "job", "." ]

[ "def", "_fake_references", "(", "self", ",", "namespace", ",", "*", "*", "params", ")", ":", "rc", "=", "None", "if", "params", "[", "'ResultClass'", "]", "is", "None", "else", "params", "[", "'ResultClass'", "]", ".", "classname", "role", "=", "params", "[", "'Role'", "]", "obj_name", "=", "params", "[", "'ObjectName'", "]", "classname", "=", "obj_name", ".", "classname", "pl", "=", "params", "[", "'PropertyList'", "]", "ico", "=", "params", "[", "'IncludeClassOrigin'", "]", "iq", "=", "params", "[", "'IncludeQualifiers'", "]", "if", "isinstance", "(", "obj_name", ",", "CIMClassName", ")", ":", "rtn_classnames", "=", "self", ".", "_get_reference_classnames", "(", "classname", ",", "namespace", ",", "rc", ",", "role", ")", "# returns list of tuples of (CIMClassname, CIMClass)", "return", "self", ".", "_return_assoc_class_tuples", "(", "rtn_classnames", ",", "namespace", ",", "iq", ",", "ico", ",", "pl", ")", "assert", "isinstance", "(", "obj_name", ",", "CIMInstanceName", ")", "ref_paths", "=", "self", ".", "_get_reference_instnames", "(", "obj_name", ",", "namespace", ",", "rc", ",", "role", ")", "rtn_insts", "=", "[", "]", "for", "path", "in", "ref_paths", ":", "rtn_insts", ".", "append", "(", "self", ".", "_get_instance", "(", "path", ",", "namespace", ",", "None", ",", "params", "[", "'PropertyList'", "]", ",", "params", "[", "'IncludeClassOrigin'", "]", ",", "params", "[", "'IncludeQualifiers'", "]", ")", ")", "for", "inst", "in", "rtn_insts", ":", "if", "inst", ".", "path", ".", "host", "is", "None", ":", "inst", ".", "path", ".", "host", "=", "self", ".", "host", "return", "self", ".", "_return_assoc_tuple", "(", "rtn_insts", ")" ]

[ "Implements", "a", "mock", "WBEM", "server", "responder", "for", ":", "meth", ":", "~pywbem", ".", "WBEMConnection", ".", "References" ]

[ "def", "as_curl", "(", "self", ",", "endpoint", ",", "encoded_data", ",", "headers", ")", ":", "header_list", "=", "[", "'-H \"{}: {}\" \\\\ \\n'", ".", "format", "(", "key", ".", "lower", "(", ")", ",", "val", ")", "for", "key", ",", "val", "in", "headers", ".", "items", "(", ")", "]", "data", "=", "\"\"", "if", "encoded_data", ":", "with", "open", "(", "\"encrypted.data\"", ",", "\"wb\"", ")", "as", "f", ":", "f", ".", "write", "(", "encoded_data", ")", "data", "=", "\"--data-binary @encrypted.data\"", "if", "'content-length'", "not", "in", "headers", ":", "header_list", ".", "append", "(", "'-H \"content-length: {}\" \\\\ \\n'", ".", "format", "(", "len", "(", "encoded_data", ")", ")", ")", "return", "(", "\"\"\"curl -vX POST {url} \\\\\\n{headers}{data}\"\"\"", ".", "format", "(", "url", "=", "endpoint", ",", "headers", "=", "\"\"", ".", "join", "(", "header_list", ")", ",", "data", "=", "data", ")", ")" ]

[ "Return", "the", "send", "as", "a", "curl", "command", "." ]

[ "def", "append_dist_to_shapes", "(", "feed", ":", "\"Feed\"", ")", "->", "\"Feed\"", ":", "if", "feed", ".", "shapes", "is", "None", ":", "raise", "ValueError", "(", "\"This function requires the feed to have a shapes.txt file\"", ")", "feed", "=", "feed", ".", "copy", "(", ")", "f", "=", "feed", ".", "shapes", "m_to_dist", "=", "hp", ".", "get_convert_dist", "(", "\"m\"", ",", "feed", ".", "dist_units", ")", "def", "compute_dist", "(", "group", ")", ":", "# Compute the distances of the stops along this trip", "group", "=", "group", ".", "sort_values", "(", "\"shape_pt_sequence\"", ")", "shape", "=", "group", "[", "\"shape_id\"", "]", ".", "iat", "[", "0", "]", "if", "not", "isinstance", "(", "shape", ",", "str", ")", ":", "group", "[", "\"shape_dist_traveled\"", "]", "=", "np", ".", "nan", "return", "group", "points", "=", "[", "sg", ".", "Point", "(", "utm", ".", "from_latlon", "(", "lat", ",", "lon", ")", "[", ":", "2", "]", ")", "for", "lon", ",", "lat", "in", "group", "[", "[", "\"shape_pt_lon\"", ",", "\"shape_pt_lat\"", "]", "]", ".", "values", "]", "p_prev", "=", "points", "[", "0", "]", "d", "=", "0", "distances", "=", "[", "0", "]", "for", "p", "in", "points", "[", "1", ":", "]", ":", "d", "+=", "p", ".", "distance", "(", "p_prev", ")", "distances", ".", "append", "(", "d", ")", "p_prev", "=", "p", "group", "[", "\"shape_dist_traveled\"", "]", "=", "distances", "return", "group", "g", "=", "f", ".", "groupby", "(", "\"shape_id\"", ",", "group_keys", "=", "False", ")", ".", "apply", "(", "compute_dist", ")", "# Convert from meters", "g", "[", "\"shape_dist_traveled\"", "]", "=", "g", "[", "\"shape_dist_traveled\"", "]", ".", "map", "(", "m_to_dist", ")", "feed", ".", "shapes", "=", "g", "return", "feed" ]

[ "Calculate", "and", "append", "the", "optional", "shape_dist_traveled", "field", "in", "feed", ".", "shapes", "in", "terms", "of", "the", "distance", "units", "feed", ".", "dist_units", ".", "Return", "the", "resulting", "Feed", "." ]

[ "def", "call_git_branch", "(", ")", ":", "try", ":", "with", "open", "(", "devnull", ",", "\"w\"", ")", "as", "fnull", ":", "arguments", "=", "[", "GIT_COMMAND", ",", "'rev-parse'", ",", "'--abbrev-ref'", ",", "'HEAD'", "]", "return", "check_output", "(", "arguments", ",", "cwd", "=", "CURRENT_DIRECTORY", ",", "stderr", "=", "fnull", ")", ".", "decode", "(", "\"ascii\"", ")", ".", "strip", "(", ")", "except", "(", "OSError", ",", "CalledProcessError", ")", ":", "return", "None" ]

[ "return", "the", "string", "output", "of", "git", "desribe" ]

[ "def", "pixel_wise_softmax", "(", "x", ",", "name", "=", "'pixel_wise_softmax'", ")", ":", "with", "tf", ".", "name_scope", "(", "name", ")", ":", "return", "tf", ".", "nn", ".", "softmax", "(", "x", ")" ]

[ "Return", "the", "softmax", "outputs", "of", "images", "every", "pixels", "have", "multiple", "label", "the", "sum", "of", "a", "pixel", "is", "1", "." ]

[ "def", "split", "(", "self", ",", "k", ")", ":", "if", "not", "1", "<=", "k", "<=", "self", ".", "num_rows", "-", "1", ":", "raise", "ValueError", "(", "\"Invalid value of k. k must be between 1 and the\"", "\"number of rows - 1\"", ")", "rows", "=", "np", ".", "random", ".", "permutation", "(", "self", ".", "num_rows", ")", "first", "=", "self", ".", "take", "(", "rows", "[", ":", "k", "]", ")", "rest", "=", "self", ".", "take", "(", "rows", "[", "k", ":", "]", ")", "for", "column_label", "in", "self", ".", "_formats", ":", "first", ".", "_formats", "[", "column_label", "]", "=", "self", ".", "_formats", "[", "column_label", "]", "rest", ".", "_formats", "[", "column_label", "]", "=", "self", ".", "_formats", "[", "column_label", "]", "return", "first", ",", "rest" ]

[ "Return", "a", "tuple", "of", "two", "tables", "where", "the", "first", "table", "contains", "k", "rows", "randomly", "sampled", "and", "the", "second", "contains", "the", "remaining", "rows", "." ]

[ "def", "pushAwayFrom", "(", "self", ",", "otherPositions", ",", "rng", ")", ":", "# Get the count of how many in each position", "positions", "=", "[", "self", ".", "choices", ".", "index", "(", "x", ")", "for", "x", "in", "otherPositions", "]", "positionCounts", "=", "[", "0", "]", "*", "len", "(", "self", ".", "choices", ")", "for", "pos", "in", "positions", ":", "positionCounts", "[", "pos", "]", "+=", "1", "self", ".", "_positionIdx", "=", "numpy", ".", "array", "(", "positionCounts", ")", ".", "argmin", "(", ")", "self", ".", "_bestPositionIdx", "=", "self", ".", "_positionIdx" ]

[ "See", "comments", "in", "base", "class", "." ]

[ "def", "get_enabled_references", "(", "self", ",", "datas", ",", "meta_references", ")", ":", "references", "=", "OrderedDict", "(", ")", "for", "section", "in", "meta_references", ":", "references", "[", "section", "]", "=", "self", ".", "get_reference", "(", "datas", ",", "section", ")", "return", "references" ]

[ "Get", "enabled", "manifest", "references", "declarations", "." ]

[ "def", "prepare_to_run", "(", "self", ",", "clock", ",", "period_count", ")", ":", "super", "(", "BasicLoanActivity", ",", "self", ")", ".", "prepare_to_run", "(", "clock", ",", "period_count", ")", "self", ".", "_months_executed", "=", "0", "self", ".", "_amount_left", "=", "self", ".", "amount" ]

[ "Prepare", "the", "activity", "for", "execution", "." ]

[ "def", "bind", "(", "self", ",", "family", ",", "type", ",", "proto", "=", "0", ")", ":", "self", ".", "socket", "=", "sockets", ".", "Socket", "(", "family", ",", "type", ",", "proto", ")", "self", ".", "socket", ".", "setsockopt", "(", "socket", ".", "SOL_SOCKET", ",", "socket", ".", "SO_REUSEADDR", ",", "1", ")", "self", ".", "socket", ".", "setblocking", "(", "0", ")", "#~ self.socket.setsockopt(socket.SOL_SOCKET, socket.TCP_NODELAY, 1)\r", "self", ".", "socket", ".", "bind", "(", "self", ".", "bind_addr", ")" ]

[ "Create", "(", "or", "recreate", ")", "the", "actual", "socket", "object", "." ]

[ "def", "ack", "(", "self", ",", "message", ",", "subscription_id", "=", "None", ",", "*", "*", "kwargs", ")", ":", "if", "isinstance", "(", "message", ",", "dict", ")", ":", "message_id", "=", "message", ".", "get", "(", "\"message-id\"", ")", "if", "not", "subscription_id", ":", "subscription_id", "=", "message", ".", "get", "(", "\"subscription\"", ")", "else", ":", "message_id", "=", "message", "if", "not", "message_id", ":", "raise", "workflows", ".", "Error", "(", "\"Cannot acknowledge message without \"", "+", "\"message ID\"", ")", "if", "not", "subscription_id", ":", "raise", "workflows", ".", "Error", "(", "\"Cannot acknowledge message without \"", "+", "\"subscription ID\"", ")", "self", ".", "log", ".", "debug", "(", "\"Acknowledging message %s on subscription %s\"", ",", "message_id", ",", "subscription_id", ")", "self", ".", "_ack", "(", "message_id", ",", "subscription_id", ",", "*", "*", "kwargs", ")" ]

[ "Acknowledge", "receipt", "of", "a", "message", ".", "This", "only", "makes", "sense", "when", "the", "acknowledgement", "flag", "was", "set", "for", "the", "relevant", "subscription", ".", ":", "param", "message", ":", "ID", "of", "the", "message", "to", "be", "acknowledged", "OR", "a", "dictionary", "containing", "a", "field", "message", "-", "id", ".", ":", "param", "subscription_id", ":", "ID", "of", "the", "associated", "subscription", ".", "Optional", "when", "a", "dictionary", "is", "passed", "as", "first", "parameter", "and", "that", "dictionary", "contains", "field", "subscription", ".", ":", "param", "**", "kwargs", ":", "Further", "parameters", "for", "the", "transport", "layer", ".", "For", "example", "transaction", ":", "Transaction", "ID", "if", "acknowledgement", "should", "be", "part", "of", "a", "transaction" ]

[ "def", "parse_filename", "(", "filename", ")", ":", "_patterns", "=", "patterns", ".", "get_expressions", "(", ")", "result", "=", "{", "}", "for", "cmatcher", "in", "_patterns", ":", "match", "=", "cmatcher", ".", "match", "(", "filename", ")", "if", "match", ":", "namedgroups", "=", "match", ".", "groupdict", "(", ")", ".", "keys", "(", ")", "result", "[", "'pattern'", "]", "=", "cmatcher", ".", "pattern", "result", "[", "'series_name'", "]", "=", "match", ".", "group", "(", "'seriesname'", ")", "result", "[", "'season_number'", "]", "=", "_get_season_no", "(", "match", ",", "namedgroups", ")", "result", "[", "'episode_numbers'", "]", "=", "_get_episodes", "(", "match", ",", "namedgroups", ")", "break", "else", ":", "result", "=", "None", "return", "result" ]

[ "Parse", "media", "filename", "for", "metadata", "." ]

[ "def", "design_stat_cooling", "(", "self", ",", "value", "=", "\"Cooling\"", ")", ":", "if", "value", "is", "not", "None", ":", "try", ":", "value", "=", "str", "(", "value", ")", "except", "ValueError", ":", "raise", "ValueError", "(", "'value {} need to be of type str '", "'for field `design_stat_cooling`'", ".", "format", "(", "value", ")", ")", "if", "','", "in", "value", ":", "raise", "ValueError", "(", "'value should not contain a comma '", "'for field `design_stat_cooling`'", ")", "vals", "=", "set", "(", ")", "vals", ".", "add", "(", "\"Cooling\"", ")", "if", "value", "not", "in", "vals", ":", "raise", "ValueError", "(", "'value {} is not an accepted value for '", "'field `design_stat_cooling`'", ".", "format", "(", "value", ")", ")", "self", ".", "_design_stat_cooling", "=", "value" ]

[ "Corresponds", "to", "IDD", "Field", "design_stat_cooling" ]

[ "def", "set_log_channel", "(", "self", ",", "name", ")", ":", "self", ".", "log_name", "=", "name", "self", ".", "logger", "=", "util", ".", "get_logger", "(", "name", ")", "self", ".", "packetizer", ".", "set_log", "(", "self", ".", "logger", ")" ]

[ "Set", "the", "channel", "for", "this", "transport", "s", "logging", ".", "The", "default", "is", "paramiko", ".", "transport", "but", "it", "can", "be", "set", "to", "anything", "you", "want", ".", "(", "See", "the", ".", "logging", "module", "for", "more", "info", ".", ")", "SSH", "Channels", "will", "log", "to", "a", "sub", "-", "channel", "of", "the", "one", "specified", "." ]

[ "def", "execute_xpath", "(", "xpath_string", ",", "sql_function", ",", "uuid", ",", "version", ")", ":", "settings", "=", "get_current_registry", "(", ")", ".", "settings", "with", "db_connect", "(", ")", "as", "db_connection", ":", "with", "db_connection", ".", "cursor", "(", ")", "as", "cursor", ":", "try", ":", "cursor", ".", "execute", "(", "SQL", "[", "sql_function", "]", ",", "{", "'document_uuid'", ":", "uuid", ",", "'document_version'", ":", "version", ",", "'xpath_string'", ":", "xpath_string", "}", ")", "except", "psycopg2", ".", "Error", "as", "e", ":", "exc", "=", "httpexceptions", ".", "HTTPBadRequest", "(", ")", "exc", ".", "explanation", "=", "e", ".", "pgerror", "raise", "exc", "for", "res", "in", "cursor", ".", "fetchall", "(", ")", ":", "yield", "{", "'name'", ":", "res", "[", "0", "]", ",", "'uuid'", ":", "res", "[", "1", "]", ",", "'version'", ":", "res", "[", "2", "]", ",", "'xpath_results'", ":", "res", "[", "3", "]", "}" ]

[ "Executes", "either", "xpath", "or", "xpath", "-", "module", "SQL", "function", "with", "given", "input", "params", "." ]

[ "def", "json", "(", "self", ")", ":", "if", "self", ".", "search_results", "is", "None", ":", "return", "None", "result", "=", "[", "]", "for", "row", "in", "self", ".", "search_results", "[", "'rows'", "]", ":", "obj", "=", "{", "}", "for", "index", "in", "range", "(", "0", ",", "len", "(", "self", ".", "search_results", "[", "'fields'", "]", ")", ")", ":", "obj", "[", "self", ".", "search_results", "[", "'fields'", "]", "[", "index", "]", "]", "=", "row", "[", "index", "]", "result", ".", "append", "(", "obj", ")", "return", "result" ]

[ "Returns", "the", "search", "results", "as", "a", "list", "of", "JSON", "objects", "." ]

[ "def", "get_statements", "(", "self", ")", ":", "for", "k", ",", "v", "in", "self", ".", "reader_output", ".", "items", "(", ")", ":", "for", "interaction", "in", "v", "[", "'interactions'", "]", ":", "self", ".", "_process_interaction", "(", "k", ",", "interaction", ",", "v", "[", "'text'", "]", ",", "self", ".", "pmid", ",", "self", ".", "extra_annotations", ")" ]

[ "Process", "reader", "output", "to", "produce", "INDRA", "Statements", "." ]

[ "def", "cached_instance", "(", "model", ",", "timeout", "=", "None", ",", "*", "*", "filters", ")", ":", "if", "isinstance", "(", "model", ",", "basestring", ")", ":", "model", "=", "_str_to_model", "(", "model", ")", "cache_key", "=", "generate_cache_key", "(", "model", ",", "*", "*", "filters", ")", "return", "get_cached", "(", "cache_key", ",", "model", ".", "objects", ".", "select_related", "(", ")", ".", "get", ",", "kwargs", "=", "filters", ")" ]

[ "Auto", "cached", "model", "instance", "." ]

[ "def", "get_metadata", "(", "url", ",", "validate_cert", "=", "True", ")", ":", "valid", "=", "False", "if", "validate_cert", ":", "response", "=", "urllib2", ".", "urlopen", "(", "url", ")", "else", ":", "ctx", "=", "ssl", ".", "create_default_context", "(", ")", "ctx", ".", "check_hostname", "=", "False", "ctx", ".", "verify_mode", "=", "ssl", ".", "CERT_NONE", "response", "=", "urllib2", ".", "urlopen", "(", "url", ",", "context", "=", "ctx", ")", "xml", "=", "response", ".", "read", "(", ")", "if", "xml", ":", "try", ":", "dom", "=", "fromstring", "(", "xml", ",", "forbid_dtd", "=", "True", ")", "idp_descriptor_nodes", "=", "OneLogin_Saml2_Utils", ".", "query", "(", "dom", ",", "'//md:IDPSSODescriptor'", ")", "if", "idp_descriptor_nodes", ":", "valid", "=", "True", "except", "Exception", ":", "pass", "if", "not", "valid", ":", "raise", "Exception", "(", "'Not valid IdP XML found from URL: %s'", "%", "(", "url", ")", ")", "return", "xml" ]

[ "Gets", "the", "metadata", "XML", "from", "the", "provided", "URL" ]

[ "def", "cellbrowser", "(", "adata", ",", "data_dir", ",", "data_name", ",", "embedding_keys", "=", "None", ",", "annot_keys", "=", "[", "\"louvain\"", ",", "\"percent_mito\"", ",", "\"n_genes\"", ",", "\"n_counts\"", "]", ",", "cluster_field", "=", "\"louvain\"", ",", "nb_marker", "=", "50", ",", "skip_matrix", "=", "False", ",", "html_dir", "=", "None", ",", "port", "=", "None", ",", "do_debug", "=", "False", ")", ":", "try", ":", "import", "cellbrowser", ".", "cellbrowser", "as", "cb", "except", "ImportError", ":", "print", "(", "\"The package cellbrowser is not installed. Install with 'pip \"", "\"install cellbrowser' and retry.\"", ")", "cb", ".", "setDebug", "(", "do_debug", ")", "cb", ".", "scanpyToCellbrowser", "(", "adata", ",", "data_dir", ",", "data_name", ",", "coordFields", "=", "embedding_keys", ",", "metaFields", "=", "annot_keys", ",", "clusterField", "=", "cluster_field", ",", "nb_marker", "=", "nb_marker", ",", "skipMatrix", "=", "skip_matrix", ",", "doDebug", "=", "None", ")", "if", "html_dir", ":", "cb", ".", "build", "(", "data_dir", ",", "html_dir", ",", "doDebug", "=", "None", ")", "if", "port", ":", "cb", ".", "serve", "(", "html_dir", ",", "port", ")" ]

[ "Export", "adata", "to", "a", "UCSC", "Cell", "Browser", "project", "directory", ".", "If", "html_dir", "is", "set", "subsequently", "build", "the", "html", "files", "from", "the", "project", "directory", "into", "html_dir", ".", "If", "port", "is", "set", "start", "an", "HTTP", "server", "in", "the", "background", "and", "serve", "html_dir", "on", "port", "." ]

[ "def", "_parse_contract_wages", "(", "self", ",", "table", ")", ":", "wages", "=", "[", "i", ".", "text", "(", ")", "if", "i", ".", "text", "(", ")", ".", "startswith", "(", "'$'", ")", "else", "''", "for", "i", "in", "table", "(", "'td'", ")", ".", "items", "(", ")", "]", "wages", ".", "remove", "(", "''", ")", "return", "wages" ]

[ "Parse", "the", "wages", "on", "the", "contract", "." ]

[ "def", "_perform_update_steps", "(", "self", ",", "observ", ",", "action", ",", "old_policy_params", ",", "reward", ",", "length", ")", ":", "return_", "=", "utility", ".", "discounted_return", "(", "reward", ",", "length", ",", "self", ".", "_config", ".", "discount", ")", "value", "=", "self", ".", "_network", "(", "observ", ",", "length", ")", ".", "value", "if", "self", ".", "_config", ".", "gae_lambda", ":", "advantage", "=", "utility", ".", "lambda_advantage", "(", "reward", ",", "value", ",", "length", ",", "self", ".", "_config", ".", "discount", ",", "self", ".", "_config", ".", "gae_lambda", ")", "else", ":", "advantage", "=", "return_", "-", "value", "mean", ",", "variance", "=", "tf", ".", "nn", ".", "moments", "(", "advantage", ",", "axes", "=", "[", "0", ",", "1", "]", ",", "keep_dims", "=", "True", ")", "advantage", "=", "(", "advantage", "-", "mean", ")", "/", "(", "tf", ".", "sqrt", "(", "variance", ")", "+", "1e-8", ")", "advantage", "=", "tf", ".", "Print", "(", "advantage", ",", "[", "tf", ".", "reduce_mean", "(", "return_", ")", ",", "tf", ".", "reduce_mean", "(", "value", ")", "]", ",", "'return and value: '", ")", "advantage", "=", "tf", ".", "Print", "(", "advantage", ",", "[", "tf", ".", "reduce_mean", "(", "advantage", ")", "]", ",", "'normalized advantage: '", ")", "episodes", "=", "(", "observ", ",", "action", ",", "old_policy_params", ",", "reward", ",", "advantage", ")", "value_loss", ",", "policy_loss", ",", "summary", "=", "parts", ".", "iterate_sequences", "(", "self", ".", "_update_step", ",", "[", "0.", ",", "0.", ",", "''", "]", ",", "episodes", ",", "length", ",", "self", ".", "_config", ".", "chunk_length", ",", "self", ".", "_config", ".", "batch_size", ",", "self", ".", "_config", ".", "update_epochs", ",", "padding_value", "=", "1", ")", "print_losses", "=", "tf", ".", "group", "(", "tf", ".", "Print", "(", "0", ",", "[", "tf", ".", "reduce_mean", "(", "value_loss", ")", "]", ",", "'value loss: '", ")", ",", "tf", ".", "Print", "(", "0", ",", "[", "tf", ".", "reduce_mean", "(", "policy_loss", ")", "]", ",", "'policy loss: '", ")", ")", "with", "tf", ".", "control_dependencies", "(", "[", "value_loss", ",", "policy_loss", ",", "print_losses", "]", ")", ":", "return", "summary", "[", "self", ".", "_config", ".", "update_epochs", "//", "2", "]" ]

[ "Perform", "multiple", "update", "steps", "of", "value", "function", "and", "policy", "." ]

[ "def", "rsa_init", "(", "spec", ")", ":", "try", ":", "size", "=", "spec", "[", "'size'", "]", "except", "KeyError", ":", "size", "=", "2048", "kb", "=", "KeyBundle", "(", "keytype", "=", "\"RSA\"", ")", "if", "'use'", "in", "spec", ":", "for", "use", "in", "harmonize_usage", "(", "spec", "[", "\"use\"", "]", ")", ":", "_key", "=", "new_rsa_key", "(", "use", "=", "use", ",", "key_size", "=", "size", ")", "kb", ".", "append", "(", "_key", ")", "else", ":", "_key", "=", "new_rsa_key", "(", "key_size", "=", "size", ")", "kb", ".", "append", "(", "_key", ")", "return", "kb" ]

[ "Initiates", "a", ":", "py", ":", "class", ":", "oidcmsg", ".", "keybundle", ".", "KeyBundle", "instance", "containing", "newly", "minted", "RSA", "keys", "according", "to", "a", "spec", ".", "Example", "of", "specification", "::", "{", "size", ":", "2048", "use", ":", "[", "enc", "sig", "]", "}", "Using", "the", "spec", "above", "2", "RSA", "keys", "would", "be", "minted", "one", "for", "encryption", "and", "one", "for", "signing", ".", ":", "param", "spec", ":", ":", "return", ":", "KeyBundle" ]

[ "def", "show_fig_outline_in_viewer", "(", "self", ",", "state", ")", ":", "if", "state", "is", "True", ":", "self", ".", "figviewer", ".", "figcanvas", ".", "setStyleSheet", "(", "\"FigureCanvas{border: 1px solid lightgrey;}\"", ")", "else", ":", "self", ".", "figviewer", ".", "figcanvas", ".", "setStyleSheet", "(", "\"FigureCanvas{}\"", ")", "self", ".", "option_changed", "(", "'show_plot_outline'", ",", "state", ")" ]

[ "Draw", "a", "frame", "around", "the", "figure", "viewer", "if", "state", "is", "True", "." ]

[ "def", "get_decomposition_energy", "(", "self", ",", "entry", ",", "pH", ",", "V", ")", ":", "# Find representative multientry", "if", "self", ".", "_multielement", "and", "not", "isinstance", "(", "entry", ",", "MultiEntry", ")", ":", "possible_entries", "=", "self", ".", "_generate_multielement_entries", "(", "self", ".", "_filtered_entries", ",", "forced_include", "=", "[", "entry", "]", ")", "# Filter to only include materials where the entry is only solid", "if", "entry", ".", "phase_type", "==", "\"solid\"", ":", "possible_entries", "=", "[", "e", "for", "e", "in", "possible_entries", "if", "e", ".", "phase_type", ".", "count", "(", "\"Solid\"", ")", "==", "1", "]", "possible_energies", "=", "[", "e", ".", "normalized_energy_at_conditions", "(", "pH", ",", "V", ")", "for", "e", "in", "possible_entries", "]", "else", ":", "possible_energies", "=", "[", "entry", ".", "normalized_energy_at_conditions", "(", "pH", ",", "V", ")", "]", "min_energy", "=", "np", ".", "min", "(", "possible_energies", ",", "axis", "=", "0", ")", "# Find entry and take the difference", "hull", "=", "self", ".", "get_hull_energy", "(", "pH", ",", "V", ")", "return", "min_energy", "-", "hull" ]

[ "Finds", "decomposition", "to", "most", "stable", "entry" ]

[ "def", "install", "(", "self", ",", "host", ")", ":", "print", "(", "\"Installing..\"", ")", "if", "self", ".", "_state", "[", "\"installed\"", "]", ":", "return", "if", "self", ".", "is_headless", "(", ")", ":", "log", ".", "info", "(", "\"Headless host\"", ")", "return", "print", "(", "\"aboutToQuit..\"", ")", "self", ".", "app", ".", "aboutToQuit", ".", "connect", "(", "self", ".", "_on_application_quit", ")", "if", "host", "==", "\"Maya\"", ":", "print", "(", "\"Maya host..\"", ")", "window", "=", "{", "widget", ".", "objectName", "(", ")", ":", "widget", "for", "widget", "in", "self", ".", "app", ".", "topLevelWidgets", "(", ")", "}", "[", "\"MayaWindow\"", "]", "else", ":", "window", "=", "self", ".", "find_window", "(", ")", "# Install event filter", "print", "(", "\"event filter..\"", ")", "event_filter", "=", "self", ".", "EventFilter", "(", "window", ")", "window", ".", "installEventFilter", "(", "event_filter", ")", "for", "signal", "in", "SIGNALS_TO_REMOVE_EVENT_FILTER", ":", "pyblish", ".", "api", ".", "register_callback", "(", "signal", ",", "self", ".", "uninstall", ")", "log", ".", "info", "(", "\"Installed event filter\"", ")", "self", ".", "window", "=", "window", "self", ".", "_state", "[", "\"installed\"", "]", "=", "True", "self", ".", "_state", "[", "\"eventFilter\"", "]", "=", "event_filter" ]

[ "Setup", "common", "to", "all", "Qt", "-", "based", "hosts" ]

[ "def", "send_backspace", "(", "self", ",", "count", ")", ":", "for", "i", "in", "range", "(", "count", ")", ":", "self", ".", "interface", ".", "send_key", "(", "Key", ".", "BACKSPACE", ")" ]

[ "Sends", "the", "given", "number", "of", "backspace", "key", "presses", "." ]

[ "def", "watch", "(", "self", ",", "path", ",", "flags", ",", "*", ",", "alias", "=", "None", ")", ":", "if", "alias", "is", "None", ":", "alias", "=", "path", "if", "alias", "in", "self", ".", "requests", ":", "raise", "ValueError", "(", "\"A watch request is already scheduled for alias %s\"", "%", "alias", ")", "self", ".", "requests", "[", "alias", "]", "=", "(", "path", ",", "flags", ")", "if", "self", ".", "_fd", "is", "not", "None", ":", "# We've started, register the watch immediately.", "self", ".", "_setup_watch", "(", "alias", ",", "path", ",", "flags", ")" ]

[ "Add", "a", "new", "watching", "rule", "." ]

[ "def", "_rows_differ", "(", "row", ",", "_row", ")", ":", "row_copy", "=", "copy", ".", "deepcopy", "(", "row", ")", "_row_copy", "=", "copy", ".", "deepcopy", "(", "_row", ")", "# Strip id from all panels in both rows, since they are always generated.", "for", "panel", "in", "row_copy", "[", "'panels'", "]", ":", "if", "'id'", "in", "panel", ":", "del", "panel", "[", "'id'", "]", "for", "_panel", "in", "_row_copy", "[", "'panels'", "]", ":", "if", "'id'", "in", "_panel", ":", "del", "_panel", "[", "'id'", "]", "diff", "=", "DictDiffer", "(", "row_copy", ",", "_row_copy", ")", "return", "diff", ".", "changed", "(", ")", "or", "diff", ".", "added", "(", ")", "or", "diff", ".", "removed", "(", ")" ]

[ "Check", "if", "grafana", "dashboard", "row", "and", "_row", "differ" ]

[ "def", "show", "(", "self", ",", "resolve_mac", "=", "True", ")", ":", "print", "(", "\"%s %s %s %s\"", "%", "(", "\"INDEX\"", ".", "ljust", "(", "5", ")", ",", "\"IFACE\"", ".", "ljust", "(", "35", ")", ",", "\"IP\"", ".", "ljust", "(", "15", ")", ",", "\"MAC\"", ")", ")", "for", "iface_name", "in", "sorted", "(", "self", ".", "data", ".", "keys", "(", ")", ")", ":", "dev", "=", "self", ".", "data", "[", "iface_name", "]", "mac", "=", "dev", ".", "mac", "if", "resolve_mac", "and", "iface_name", "!=", "LOOPBACK_NAME", ":", "mac", "=", "conf", ".", "manufdb", ".", "_resolve_MAC", "(", "mac", ")", "print", "(", "\"%s %s %s %s\"", "%", "(", "str", "(", "dev", ".", "win_index", ")", ".", "ljust", "(", "5", ")", ",", "str", "(", "dev", ".", "name", ")", ".", "ljust", "(", "35", ")", ",", "str", "(", "dev", ".", "ip", ")", ".", "ljust", "(", "15", ")", ",", "mac", ")", ")" ]

[ "Print", "list", "of", "available", "network", "interfaces", "in", "human", "readable", "form" ]

[ "def", "namedb_get_all_namespace_ids", "(", "cur", ")", ":", "query", "=", "\"SELECT namespace_id FROM namespaces WHERE op = ?;\"", "args", "=", "(", "NAMESPACE_READY", ",", ")", "namespace_rows", "=", "namedb_query_execute", "(", "cur", ",", "query", ",", "args", ")", "ret", "=", "[", "]", "for", "namespace_row", "in", "namespace_rows", ":", "ret", ".", "append", "(", "namespace_row", "[", "'namespace_id'", "]", ")", "return", "ret" ]

[ "Get", "a", "list", "of", "all", "READY", "namespace", "IDs", "." ]

[ "def", "language_file_exists", "(", "language_code", ")", ":", "filename", "=", "'{0}.js'", ".", "format", "(", "language_code", ")", "path", "=", "os", ".", "path", ".", "join", "(", "'tinymce'", ",", "'js'", ",", "'tinymce'", ",", "'langs'", ",", "filename", ")", "return", "finders", ".", "find", "(", "path", ")", "is", "not", "None" ]

[ "Check", "if", "TinyMCE", "has", "a", "language", "file", "for", "the", "specified", "lang", "code" ]

[ "def", "And", "(", "*", "predicates", ",", "*", "*", "kwargs", ")", ":", "if", "kwargs", ":", "predicates", "+=", "Query", "(", "*", "*", "kwargs", ")", ",", "return", "_flatten", "(", "_And", ",", "*", "predicates", ")" ]

[ "And", "predicate", ".", "Returns", "False", "at", "the", "first", "sub", "-", "predicate", "that", "returns", "False", "." ]

[ "def", "wigner_d", "(", "J", ",", "alpha", ",", "beta", ",", "gamma", ")", ":", "d", "=", "wigner_d_small", "(", "J", ",", "beta", ")", "M", "=", "[", "J", "-", "i", "for", "i", "in", "range", "(", "2", "*", "J", "+", "1", ")", "]", "D", "=", "[", "[", "exp", "(", "I", "*", "Mi", "*", "alpha", ")", "*", "d", "[", "i", ",", "j", "]", "*", "exp", "(", "I", "*", "Mj", "*", "gamma", ")", "for", "j", ",", "Mj", "in", "enumerate", "(", "M", ")", "]", "for", "i", ",", "Mi", "in", "enumerate", "(", "M", ")", "]", "return", "Matrix", "(", "D", ")" ]

[ "u", "Return", "the", "Wigner", "D", "matrix", "for", "angular", "momentum", "J", "." ]

[ "def", "timeseries_subplot", "(", "X", ",", "time", "=", "None", ",", "color", "=", "None", ",", "var_names", "=", "(", ")", ",", "highlightsX", "=", "(", ")", ",", "xlabel", "=", "''", ",", "ylabel", "=", "'gene expression'", ",", "yticks", "=", "None", ",", "xlim", "=", "None", ",", "legend", "=", "True", ",", "palette", "=", "None", ",", "color_map", "=", "'viridis'", ")", ":", "if", "color", "is", "not", "None", ":", "use_color_map", "=", "isinstance", "(", "color", "[", "0", "]", ",", "float", ")", "or", "isinstance", "(", "color", "[", "0", "]", ",", "np", ".", "float32", ")", "palette", "=", "default_palette", "(", "palette", ")", "x_range", "=", "np", ".", "arange", "(", "X", ".", "shape", "[", "0", "]", ")", "if", "time", "is", "None", "else", "time", "if", "X", ".", "ndim", "==", "1", ":", "X", "=", "X", "[", ":", ",", "None", "]", "if", "X", ".", "shape", "[", "1", "]", ">", "1", ":", "colors", "=", "palette", "[", ":", "X", ".", "shape", "[", "1", "]", "]", ".", "by_key", "(", ")", "[", "'color'", "]", "subsets", "=", "[", "(", "x_range", ",", "X", "[", ":", ",", "i", "]", ")", "for", "i", "in", "range", "(", "X", ".", "shape", "[", "1", "]", ")", "]", "elif", "use_color_map", ":", "colors", "=", "[", "color", "]", "subsets", "=", "[", "(", "x_range", ",", "X", "[", ":", ",", "0", "]", ")", "]", "else", ":", "levels", ",", "_", "=", "np", ".", "unique", "(", "color", ",", "return_inverse", "=", "True", ")", "colors", "=", "np", ".", "array", "(", "palette", "[", ":", "len", "(", "levels", ")", "]", ".", "by_key", "(", ")", "[", "'color'", "]", ")", "subsets", "=", "[", "(", "x_range", "[", "color", "==", "l", "]", ",", "X", "[", "color", "==", "l", ",", ":", "]", ")", "for", "l", "in", "levels", "]", "for", "i", ",", "(", "x", ",", "y", ")", "in", "enumerate", "(", "subsets", ")", ":", "pl", ".", "scatter", "(", "x", ",", "y", ",", "marker", "=", "'.'", ",", "edgecolor", "=", "'face'", ",", "s", "=", "rcParams", "[", "'lines.markersize'", "]", ",", "c", "=", "colors", "[", "i", "]", ",", "label", "=", "var_names", "[", "i", "]", "if", "len", "(", "var_names", ")", ">", "0", "else", "''", ",", "cmap", "=", "color_map", ",", "rasterized", "=", "settings", ".", "_vector_friendly", ")", "ylim", "=", "pl", ".", "ylim", "(", ")", "for", "ih", ",", "h", "in", "enumerate", "(", "highlightsX", ")", ":", "pl", ".", "plot", "(", "[", "h", ",", "h", "]", ",", "[", "ylim", "[", "0", "]", ",", "ylim", "[", "1", "]", "]", ",", "'--'", ",", "color", "=", "'black'", ")", "pl", ".", "ylim", "(", "ylim", ")", "if", "xlim", "is", "not", "None", ":", "pl", ".", "xlim", "(", "xlim", ")", "pl", ".", "xlabel", "(", "xlabel", ")", "pl", ".", "ylabel", "(", "ylabel", ")", "if", "yticks", "is", "not", "None", ":", "pl", ".", "yticks", "(", "yticks", ")", "if", "len", "(", "var_names", ")", ">", "0", "and", "legend", ":", "pl", ".", "legend", "(", "frameon", "=", "False", ")" ]

[ "Plot", "X", "." ]

[ "def", "delete_by_id", "(", "self", ",", "del_id", ")", ":", "if", "self", ".", "check_post_role", "(", ")", "[", "'DELETE'", "]", ":", "pass", "else", ":", "return", "False", "if", "self", ".", "is_p", ":", "if", "MLink", ".", "delete", "(", "del_id", ")", ":", "output", "=", "{", "'del_link'", ":", "1", "}", "else", ":", "output", "=", "{", "'del_link'", ":", "0", "}", "return", "json", ".", "dump", "(", "output", ",", "self", ")", "else", ":", "is_deleted", "=", "MLink", ".", "delete", "(", "del_id", ")", "if", "is_deleted", ":", "self", ".", "redirect", "(", "'/link/list'", ")" ]

[ "Delete", "a", "link", "by", "id", "." ]

[ "def", "getreadergroups", "(", "self", ")", ":", "innerreadergroups", ".", "getreadergroups", "(", "self", ")", "hresult", ",", "hcontext", "=", "SCardEstablishContext", "(", "SCARD_SCOPE_USER", ")", "if", "hresult", "!=", "0", ":", "raise", "EstablishContextException", "(", "hresult", ")", "hresult", ",", "readers", "=", "SCardListReaderGroups", "(", "hcontext", ")", "if", "hresult", "!=", "0", ":", "raise", "ListReadersException", "(", "hresult", ")", "hresult", "=", "SCardReleaseContext", "(", "hcontext", ")", "if", "hresult", "!=", "0", ":", "raise", "ReleaseContextException", "(", "hresult", ")", "return", "readers" ]

[ "Returns", "the", "list", "of", "smartcard", "reader", "groups", "." ]

[ "def", "visible_to_user", "(", "self", ",", "user", ")", ":", "return", "(", "Event", ".", "objects", ".", "filter", "(", "approved", "=", "True", ")", ".", "filter", "(", "Q", "(", "groups__in", "=", "user", ".", "groups", ".", "all", "(", ")", ")", "|", "Q", "(", "groups__isnull", "=", "True", ")", "|", "Q", "(", "user", "=", "user", ")", ")", ")" ]

[ "Get", "a", "list", "of", "visible", "events", "for", "a", "given", "user", "(", "usually", "request", ".", "user", ")", "." ]

[ "def", "add_output_path", "(", "path", ":", "str", "=", "None", ")", "->", "str", ":", "cleaned", "=", "paths", ".", "clean", "(", "path", "or", "os", ".", "getcwd", "(", ")", ")", "if", "cleaned", "not", "in", "_logging_paths", ":", "_logging_paths", ".", "append", "(", "cleaned", ")", "return", "cleaned" ]

[ "Adds", "the", "specified", "path", "to", "the", "output", "logging", "paths", "if", "it", "is", "not", "already", "in", "the", "listed", "paths", "." ]

[ "def", "get_voronoi_nodes", "(", "structure", ",", "rad_dict", "=", "None", ",", "probe_rad", "=", "0.1", ")", ":", "with", "ScratchDir", "(", "'.'", ")", ":", "name", "=", "\"temp_zeo1\"", "zeo_inp_filename", "=", "name", "+", "\".cssr\"", "ZeoCssr", "(", "structure", ")", ".", "write_file", "(", "zeo_inp_filename", ")", "rad_file", "=", "None", "rad_flag", "=", "False", "if", "rad_dict", ":", "rad_file", "=", "name", "+", "\".rad\"", "rad_flag", "=", "True", "with", "open", "(", "rad_file", ",", "'w+'", ")", "as", "fp", ":", "for", "el", "in", "rad_dict", ".", "keys", "(", ")", ":", "fp", ".", "write", "(", "\"{} {}\\n\"", ".", "format", "(", "el", ",", "rad_dict", "[", "el", "]", ".", "real", ")", ")", "atmnet", "=", "AtomNetwork", ".", "read_from_CSSR", "(", "zeo_inp_filename", ",", "rad_flag", "=", "rad_flag", ",", "rad_file", "=", "rad_file", ")", "vornet", ",", "vor_edge_centers", ",", "vor_face_centers", "=", "atmnet", ".", "perform_voronoi_decomposition", "(", ")", "vornet", ".", "analyze_writeto_XYZ", "(", "name", ",", "probe_rad", ",", "atmnet", ")", "voro_out_filename", "=", "name", "+", "'_voro.xyz'", "voro_node_mol", "=", "ZeoVoronoiXYZ", ".", "from_file", "(", "voro_out_filename", ")", ".", "molecule", "species", "=", "[", "\"X\"", "]", "*", "len", "(", "voro_node_mol", ".", "sites", ")", "coords", "=", "[", "]", "prop", "=", "[", "]", "for", "site", "in", "voro_node_mol", ".", "sites", ":", "coords", ".", "append", "(", "list", "(", "site", ".", "coords", ")", ")", "prop", ".", "append", "(", "site", ".", "properties", "[", "'voronoi_radius'", "]", ")", "lattice", "=", "Lattice", ".", "from_lengths_and_angles", "(", "structure", ".", "lattice", ".", "abc", ",", "structure", ".", "lattice", ".", "angles", ")", "vor_node_struct", "=", "Structure", "(", "lattice", ",", "species", ",", "coords", ",", "coords_are_cartesian", "=", "True", ",", "to_unit_cell", "=", "True", ",", "site_properties", "=", "{", "\"voronoi_radius\"", ":", "prop", "}", ")", "# PMG-Zeo c<->a transformation for voronoi face centers", "rot_face_centers", "=", "[", "(", "center", "[", "1", "]", ",", "center", "[", "2", "]", ",", "center", "[", "0", "]", ")", "for", "center", "in", "vor_face_centers", "]", "rot_edge_centers", "=", "[", "(", "center", "[", "1", "]", ",", "center", "[", "2", "]", ",", "center", "[", "0", "]", ")", "for", "center", "in", "vor_edge_centers", "]", "species", "=", "[", "\"X\"", "]", "*", "len", "(", "rot_face_centers", ")", "prop", "=", "[", "0.0", "]", "*", "len", "(", "rot_face_centers", ")", "# Vor radius not evaluated for fc", "vor_facecenter_struct", "=", "Structure", "(", "lattice", ",", "species", ",", "rot_face_centers", ",", "coords_are_cartesian", "=", "True", ",", "to_unit_cell", "=", "True", ",", "site_properties", "=", "{", "\"voronoi_radius\"", ":", "prop", "}", ")", "species", "=", "[", "\"X\"", "]", "*", "len", "(", "rot_edge_centers", ")", "prop", "=", "[", "0.0", "]", "*", "len", "(", "rot_edge_centers", ")", "# Vor radius not evaluated for fc", "vor_edgecenter_struct", "=", "Structure", "(", "lattice", ",", "species", ",", "rot_edge_centers", ",", "coords_are_cartesian", "=", "True", ",", "to_unit_cell", "=", "True", ",", "site_properties", "=", "{", "\"voronoi_radius\"", ":", "prop", "}", ")", "return", "vor_node_struct", ",", "vor_edgecenter_struct", ",", "vor_facecenter_struct" ]

[ "Analyze", "the", "void", "space", "in", "the", "input", "structure", "using", "voronoi", "decomposition", "Calls", "Zeo", "++", "for", "Voronoi", "decomposition", "." ]

[ "def", "is_default", "(", "self", ")", ":", "envvar_value", "=", "self", ".", "_get_envvar_value", "(", ")", "if", "envvar_value", "is", "not", "not_set", ":", "return", "envvar_value", "==", "self", ".", "default", "else", ":", "return", "self", ".", "_value", "is", "not_set", "or", "self", ".", "_value", "==", "self", ".", "default" ]

[ "True", "if", "the", "item", "s", "value", "is", "its", "default", "value", "or", "if", "no", "value", "and", "no", "default", "value", "are", "set", "." ]

[ "def", "_process_ortholog_classes", "(", "self", ",", "limit", "=", "None", ")", ":", "LOG", ".", "info", "(", "\"Processing ortholog classes\"", ")", "if", "self", ".", "test_mode", ":", "graph", "=", "self", ".", "testgraph", "else", ":", "graph", "=", "self", ".", "graph", "model", "=", "Model", "(", "graph", ")", "line_counter", "=", "0", "raw", "=", "'/'", ".", "join", "(", "(", "self", ".", "rawdir", ",", "self", ".", "files", "[", "'ortholog_classes'", "]", "[", "'file'", "]", ")", ")", "with", "open", "(", "raw", ",", "'r'", ",", "encoding", "=", "\"iso-8859-1\"", ")", "as", "csvfile", ":", "filereader", "=", "csv", ".", "reader", "(", "csvfile", ",", "delimiter", "=", "'\\t'", ",", "quotechar", "=", "'\\\"'", ")", "for", "row", "in", "filereader", ":", "line_counter", "+=", "1", "(", "orthology_class_id", ",", "orthology_class_name", ")", "=", "row", "if", "self", ".", "test_mode", "and", "orthology_class_id", "not", "in", "self", ".", "test_ids", "[", "'orthology_classes'", "]", ":", "continue", "# The orthology class is essentially a KEGG gene ID", "# that is species agnostic.", "# Add the ID and label as a gene family class", "other_labels", "=", "re", ".", "split", "(", "r'[;,]'", ",", "orthology_class_name", ")", "# the first one is the label we'll use", "orthology_label", "=", "other_labels", "[", "0", "]", "orthology_class_id", "=", "'KEGG-'", "+", "orthology_class_id", ".", "strip", "(", ")", "orthology_type", "=", "self", ".", "globaltt", "[", "'gene_family'", "]", "model", ".", "addClassToGraph", "(", "orthology_class_id", ",", "orthology_label", ",", "orthology_type", ")", "if", "len", "(", "other_labels", ")", ">", "1", ":", "# add the rest as synonyms", "# todo skip the first", "for", "s", "in", "other_labels", ":", "model", ".", "addSynonym", "(", "orthology_class_id", ",", "s", ".", "strip", "(", ")", ")", "# add the last one as the description", "d", "=", "other_labels", "[", "len", "(", "other_labels", ")", "-", "1", "]", "model", ".", "addDescription", "(", "orthology_class_id", ",", "d", ")", "# add the enzyme commission number (EC:1.2.99.5)as an xref", "# sometimes there's two, like [EC:1.3.5.1 1.3.5.4]", "# can also have a dash, like EC:1.10.3.-", "ec_matches", "=", "re", ".", "findall", "(", "r'((?:\\d+|\\.|-){5,7})'", ",", "d", ")", "if", "ec_matches", "is", "not", "None", ":", "for", "ecm", "in", "ec_matches", ":", "model", ".", "addXref", "(", "orthology_class_id", ",", "'EC:'", "+", "ecm", ")", "if", "not", "self", ".", "test_mode", "and", "limit", "is", "not", "None", "and", "line_counter", ">", "limit", ":", "break", "LOG", ".", "info", "(", "\"Done with ortholog classes\"", ")", "return" ]

[ "This", "method", "add", "the", "KEGG", "orthology", "classes", "to", "the", "graph", "." ]

[ "def", "register_field", "(", "cls", ",", "field", ")", ":", "FieldRegistry", ".", "add_field", "(", "cls", ",", "field", ")", "signals", ".", "post_save", ".", "connect", "(", "handle_save_embeds", ",", "sender", "=", "cls", ",", "dispatch_uid", "=", "'%s.%s.%s'", "%", "(", "cls", ".", "_meta", ".", "app_label", ",", "cls", ".", "_meta", ".", "module_name", ",", "field", ".", "name", ")", ")" ]

[ "Handles", "registering", "the", "fields", "with", "the", "FieldRegistry", "and", "creating", "a", "post", "-", "save", "signal", "for", "the", "model", "." ]

[ "def", "decode_message", "(", "self", ",", "message_type", ",", "encoded_message", ")", ":", "encoded_message", "=", "six", ".", "ensure_str", "(", "encoded_message", ")", "if", "not", "encoded_message", ".", "strip", "(", ")", ":", "return", "message_type", "(", ")", "dictionary", "=", "json", ".", "loads", "(", "encoded_message", ")", "message", "=", "self", ".", "__decode_dictionary", "(", "message_type", ",", "dictionary", ")", "message", ".", "check_initialized", "(", ")", "return", "message" ]

[ "Merge", "JSON", "structure", "to", "Message", "instance", "." ]

[ "def", "get_default_config_file", "(", "argparser", ",", "suppress", "=", "None", ",", "default_override", "=", "None", ")", ":", "if", "not", "suppress", ":", "suppress", "=", "[", "]", "if", "not", "default_override", ":", "default_override", "=", "{", "}", "lines", "=", "[", "]", "seen_arguments", "=", "[", "]", "for", "arg", "in", "argparser", ".", "_actions", ":", "if", "arg", ".", "dest", "in", "suppress", ":", "continue", "if", "arg", ".", "dest", "in", "seen_arguments", ":", "continue", "default", "=", "arg", ".", "default", "if", "arg", ".", "dest", "in", "default_override", ".", "keys", "(", ")", ":", "default", "=", "default_override", "[", "arg", ".", "dest", "]", "lines", ".", "append", "(", "\"# {0}\\n{1}={2}\\n\"", ".", "format", "(", "arg", ".", "help", ",", "arg", ".", "dest", ",", "default", ")", ")", "seen_arguments", ".", "append", "(", "arg", ".", "dest", ")", "return", "\"\"", ".", "join", "(", "lines", ")" ]

[ "Turn", "an", "ArgumentParser", "into", "a", "ConfigObj", "compatible", "configuration", "file", "." ]

[ "def", "hash_from_func", "(", "cls", ",", "func", ")", ":", "new", "=", "cls", ".", "_func_hash", "[", "func", "]", ".", "new", "return", "new", "(", ")", "if", "new", "else", "None" ]

[ "Return", "a", "hashlib", "-", "compatible", "object", "for", "the", "multihash", "func", "." ]

[ "def", "connect_handler", "(", "self", ",", "their_unl", ",", "events", ",", "force_master", ",", "hairpin", ",", "nonce", ")", ":", "# Figure out who should make the connection.\r", "our_unl", "=", "self", ".", "value", ".", "encode", "(", "\"ascii\"", ")", "their_unl", "=", "their_unl", ".", "encode", "(", "\"ascii\"", ")", "master", "=", "self", ".", "is_master", "(", "their_unl", ")", "if", "force_master", ":", "master", "=", "1", "# Deconstruct binary UNLs into dicts.\r", "our_unl", "=", "self", ".", "deconstruct", "(", "our_unl", ")", "their_unl", "=", "self", ".", "deconstruct", "(", "their_unl", ")", "if", "our_unl", "is", "None", ":", "raise", "Exception", "(", "\"Unable to deconstruct our UNL.\"", ")", "if", "their_unl", "is", "None", ":", "raise", "Exception", "(", "\"Unable to deconstruct their UNL.\"", ")", "# This means the nodes are behind the same router.\r", "if", "our_unl", "[", "\"wan_ip\"", "]", "==", "their_unl", "[", "\"wan_ip\"", "]", ":", "# Connect to LAN IP.\r", "our_unl", "[", "\"wan_ip\"", "]", "=", "our_unl", "[", "\"lan_ip\"", "]", "their_unl", "[", "\"wan_ip\"", "]", "=", "their_unl", "[", "\"lan_ip\"", "]", "# Already behind NAT so no forwarding needed.\r", "if", "hairpin", ":", "our_unl", "[", "\"node_type\"", "]", "=", "\"passive\"", "their_unl", "[", "\"node_type\"", "]", "=", "\"passive\"", "# Generate con ID.\r", "if", "nonce", "!=", "\"0\"", "*", "64", ":", "# Convert nonce to bytes.\r", "if", "sys", ".", "version_info", ">=", "(", "3", ",", "0", ",", "0", ")", ":", "if", "type", "(", "nonce", ")", "==", "str", ":", "nonce", ".", "encode", "(", "\"ascii\"", ")", "else", ":", "if", "type", "(", "nonce", ")", "==", "unicode", ":", "nonce", "=", "str", "(", "nonce", ")", "# Check nonce length.\r", "assert", "(", "len", "(", "nonce", ")", "==", "64", ")", "# Create con ID.\r", "con_id", "=", "self", ".", "net", ".", "generate_con_id", "(", "nonce", ",", "our_unl", "[", "\"wan_ip\"", "]", ",", "their_unl", "[", "\"wan_ip\"", "]", ")", "else", ":", "con_id", "=", "None", "# Acquire mutex.\r", "self", ".", "mutex", ".", "acquire", "(", ")", "# Wait for other UNLs to finish.\r", "end_time", "=", "time", ".", "time", "(", ")", "end_time", "+=", "len", "(", "self", ".", "pending_unls", ")", "*", "60", "self", ".", "debug_print", "(", "\"Waiting for other unls to finish\"", ")", "while", "their_unl", "in", "self", ".", "pending_unls", "and", "time", ".", "time", "(", ")", "<", "end_time", ":", "# This is an undifferentiated duplicate.\r", "if", "events", "is", "None", ":", "self", ".", "mutex", ".", "release", "(", ")", "return", "time", ".", "sleep", "(", "1", ")", "self", ".", "debug_print", "(", "\"Other unl finished\"", ")", "is_exception", "=", "0", "try", ":", "# Wait for any other hole punches to finish.\r", "if", "(", "their_unl", "[", "\"node_type\"", "]", "==", "\"simultaneous\"", "and", "our_unl", "[", "\"node_type\"", "]", "!=", "\"passive\"", ")", ":", "self", ".", "pending_sim_open", ".", "append", "(", "their_unl", "[", "\"value\"", "]", ")", "end_time", "=", "time", ".", "time", "(", ")", "end_time", "+=", "len", "(", "self", ".", "pending_unls", ")", "*", "60", "self", ".", "debug_print", "(", "\"wait for other hole punches to finish\"", ")", "while", "len", "(", "self", ".", "pending_sim_open", ")", "and", "time", ".", "time", "(", ")", "<", "end_time", ":", "if", "self", ".", "pending_sim_open", "[", "0", "]", "==", "their_unl", "[", "\"value\"", "]", ":", "break", "time", ".", "sleep", "(", "1", ")", "self", ".", "debug_print", "(", "\"other hole punches finished\"", ")", "# Set pending UNL.\r", "self", ".", "pending_unls", ".", "append", "(", "their_unl", ")", "# Release mutex.\r", "self", ".", "mutex", ".", "release", "(", ")", "# Get connection.\r", "con", "=", "self", ".", "get_connection", "(", "our_unl", ",", "their_unl", ",", "master", ",", "nonce", ",", "force_master", ",", "con_id", ")", "except", "Exception", "as", "e", ":", "is_exception", "=", "1", "print", "(", "e", ")", "print", "(", "\"EXCEPTION IN UNL.GET_CONNECTION\"", ")", "log_exception", "(", "\"error.log\"", ",", "parse_exception", "(", "e", ")", ")", "finally", ":", "# Release mutex.\r", "if", "self", ".", "mutex", ".", "locked", "(", ")", "and", "is_exception", ":", "self", ".", "mutex", ".", "release", "(", ")", "# Undo pending connect state.\r", "if", "their_unl", "in", "self", ".", "pending_unls", ":", "self", ".", "pending_unls", ".", "remove", "(", "their_unl", ")", "# Undo pending sim open.\r", "if", "len", "(", "self", ".", "pending_sim_open", ")", ":", "if", "self", ".", "pending_sim_open", "[", "0", "]", "==", "their_unl", "[", "\"value\"", "]", ":", "self", ".", "pending_sim_open", "=", "self", ".", "pending_sim_open", "[", "1", ":", "]", "# Only execute events if this function was called manually.\r", "if", "events", "is", "not", "None", ":", "# Success.\r", "if", "con", "is", "not", "None", ":", "if", "\"success\"", "in", "events", ":", "events", "[", "\"success\"", "]", "(", "con", ")", "# Failure.\r", "if", "con", "is", "None", ":", "if", "\"failure\"", "in", "events", ":", "events", "[", "\"failure\"", "]", "(", "con", ")" ]

[ "Master", "defines", "who", "connects", "if", "either", "side", "can", ".", "It", "s", "used", "to", "eliminate", "having", "multiple", "connections", "with", "the", "same", "host", "." ]

[ "def", "delete_image", "(", "self", ",", "image_id", ")", ":", "title", "=", "'%s.delete_image'", "%", "self", ".", "__class__", ".", "__name__", "# validate inputs", "input_fields", "=", "{", "'image_id'", ":", "image_id", "}", "for", "key", ",", "value", "in", "input_fields", ".", "items", "(", ")", ":", "object_title", "=", "'%s(%s=%s)'", "%", "(", "title", ",", "key", ",", "str", "(", "value", ")", ")", "self", ".", "fields", ".", "validate", "(", "value", ",", "'.%s'", "%", "key", ",", "object_title", ")", "# report query", "self", ".", "iam", ".", "printer", "(", "'Removing image %s from AWS region %s.'", "%", "(", "image_id", ",", "self", ".", "iam", ".", "region_name", ")", ")", "# retrieve state", "old_state", "=", "self", ".", "check_image_state", "(", "image_id", ")", "# discover snapshot id and tags associated with instance id", "image_details", "=", "self", ".", "read_image", "(", "image_id", ")", "tag_list", "=", "image_details", "[", "'tags'", "]", "snapshot_id", "=", "image_details", "[", "'snapshot_id'", "]", "# remove tags from instance", "try", ":", "delete_kwargs", "=", "{", "'Resources'", ":", "[", "image_id", "]", ",", "'Tags'", ":", "self", ".", "iam", ".", "prepare", "(", "tag_list", ")", "}", "self", ".", "connection", ".", "delete_tags", "(", "*", "*", "delete_kwargs", ")", "self", ".", "iam", ".", "printer", "(", "'Tags have been deleted from %s.'", "%", "image_id", ")", "except", ":", "raise", "AWSConnectionError", "(", "title", ")", "# deregister image", "try", ":", "self", ".", "connection", ".", "deregister_image", "(", "ImageId", "=", "image_id", ")", "except", ":", "raise", "AWSConnectionError", "(", "title", ")", "self", ".", "iam", ".", "printer", "(", "'Image %s has been deregistered.'", "%", "image_id", ")", "# delete snapshot", "try", ":", "response", "=", "self", ".", "connection", ".", "delete_snapshot", "(", "SnapshotId", "=", "snapshot_id", ")", "except", ":", "raise", "AWSConnectionError", "(", "title", ")", "self", ".", "iam", ".", "printer", "(", "'Snapshot %s associated with image %s has been deleted.'", "%", "(", "snapshot_id", ",", "image_id", ")", ")", "return", "response" ]

[ "method", "for", "removing", "an", "image", "from", "AWS", "EC2" ]

[ "def", "get_cardinality", "(", "self", ",", "node", "=", "None", ")", ":", "if", "node", ":", "for", "factor", "in", "self", ".", "factors", ":", "for", "variable", ",", "cardinality", "in", "zip", "(", "factor", ".", "scope", "(", ")", ",", "factor", ".", "cardinality", ")", ":", "if", "node", "==", "variable", ":", "return", "cardinality", "else", ":", "cardinalities", "=", "defaultdict", "(", "int", ")", "for", "factor", "in", "self", ".", "factors", ":", "for", "variable", ",", "cardinality", "in", "zip", "(", "factor", ".", "scope", "(", ")", ",", "factor", ".", "cardinality", ")", ":", "cardinalities", "[", "variable", "]", "=", "cardinality", "return", "cardinalities" ]

[ "Returns", "the", "cardinality", "of", "the", "node" ]

[ "def", "add_tag", "(", "self", ",", "tag", ")", ":", "if", "tag", "not", "in", "self", ".", "_tags", ":", "self", ".", "_tags", "[", "tag", "]", "=", "dict", "(", ")" ]

[ "add", "a", "tag", "to", "the", "tag", "list" ]

[ "def", "start", "(", "self", ",", "start_loop", "=", "True", ")", ":", "self", ".", "start_alerts", "(", ")", "if", "self", ".", "options", ".", "get", "(", "'pidfile'", ")", ":", "with", "open", "(", "self", ".", "options", ".", "get", "(", "'pidfile'", ")", ",", "'w'", ")", "as", "fpid", ":", "fpid", ".", "write", "(", "str", "(", "os", ".", "getpid", "(", ")", ")", ")", "self", ".", "callback", ".", "start", "(", ")", "LOGGER", ".", "info", "(", "'Reactor starts'", ")", "if", "start_loop", ":", "self", ".", "loop", ".", "start", "(", ")" ]

[ "Start", "all", "the", "things", "." ]

[ "def", "concatenate", "(", "arrays", ",", "axis", "=", "0", ",", "always_copy", "=", "True", ")", ":", "assert", "isinstance", "(", "arrays", ",", "list", ")", "assert", "len", "(", "arrays", ")", ">", "0", "assert", "isinstance", "(", "arrays", "[", "0", "]", ",", "NDArray", ")", "if", "not", "always_copy", "and", "len", "(", "arrays", ")", "==", "1", ":", "return", "arrays", "[", "0", "]", "shape_axis", "=", "arrays", "[", "0", "]", ".", "shape", "[", "axis", "]", "shape_rest1", "=", "arrays", "[", "0", "]", ".", "shape", "[", "0", ":", "axis", "]", "shape_rest2", "=", "arrays", "[", "0", "]", ".", "shape", "[", "axis", "+", "1", ":", "]", "dtype", "=", "arrays", "[", "0", "]", ".", "dtype", "for", "arr", "in", "arrays", "[", "1", ":", "]", ":", "shape_axis", "+=", "arr", ".", "shape", "[", "axis", "]", "assert", "shape_rest1", "==", "arr", ".", "shape", "[", "0", ":", "axis", "]", "assert", "shape_rest2", "==", "arr", ".", "shape", "[", "axis", "+", "1", ":", "]", "assert", "dtype", "==", "arr", ".", "dtype", "ret_shape", "=", "shape_rest1", "+", "(", "shape_axis", ",", ")", "+", "shape_rest2", "ret", "=", "empty", "(", "ret_shape", ",", "ctx", "=", "arrays", "[", "0", "]", ".", "context", ",", "dtype", "=", "dtype", ")", "idx", "=", "0", "begin", "=", "[", "0", "for", "_", "in", "ret_shape", "]", "end", "=", "list", "(", "ret_shape", ")", "for", "arr", "in", "arrays", ":", "if", "axis", "==", "0", ":", "ret", "[", "idx", ":", "idx", "+", "arr", ".", "shape", "[", "0", "]", "]", "=", "arr", "else", ":", "begin", "[", "axis", "]", "=", "idx", "end", "[", "axis", "]", "=", "idx", "+", "arr", ".", "shape", "[", "axis", "]", "# pylint: disable=no-member,protected-access", "_internal", ".", "_crop_assign", "(", "ret", ",", "arr", ",", "out", "=", "ret", ",", "begin", "=", "tuple", "(", "begin", ")", ",", "end", "=", "tuple", "(", "end", ")", ")", "# pylint: enable=no-member,protected-access", "idx", "+=", "arr", ".", "shape", "[", "axis", "]", "return", "ret" ]

[ "DEPRECATED", "use", "concat", "instead" ]

[ "def", "get_limits", "(", "self", ",", "limit_sum", "=", "None", ")", ":", "with", "self", ".", "limit_lock", ":", "# Any changes?", "if", "limit_sum", "and", "self", ".", "limit_sum", "==", "limit_sum", ":", "raise", "NoChangeException", "(", ")", "# Return a tuple of the limits and limit sum", "return", "(", "self", ".", "limit_sum", ",", "self", ".", "limit_data", ")" ]

[ "Gets", "the", "current", "limit", "data", "if", "it", "is", "different", "from", "the", "data", "indicated", "by", "limit_sum", ".", "The", "db", "argument", "is", "used", "for", "hydrating", "the", "limit", "objects", ".", "Raises", "a", "NoChangeException", "if", "the", "limit_sum", "represents", "no", "change", "otherwise", "returns", "a", "tuple", "consisting", "of", "the", "current", "limit_sum", "and", "a", "list", "of", "Limit", "objects", "." ]

[ "def", "_fromdata", "(", "self", ",", "code", ",", "dtype", ",", "count", ",", "value", ",", "name", "=", "None", ")", ":", "self", ".", "code", "=", "int", "(", "code", ")", "self", ".", "name", "=", "name", "if", "name", "else", "str", "(", "code", ")", "self", ".", "dtype", "=", "TIFF_DATA_TYPES", "[", "dtype", "]", "self", ".", "count", "=", "int", "(", "count", ")", "self", ".", "value", "=", "value" ]

[ "Initialize", "instance", "from", "arguments", "." ]

[ "def", "_get_fields_info", "(", "self", ",", "cols", ",", "model_schema", ",", "filter_rel_fields", ",", "*", "*", "kwargs", ")", ":", "ret", "=", "list", "(", ")", "for", "col", "in", "cols", ":", "page", "=", "page_size", "=", "None", "col_args", "=", "kwargs", ".", "get", "(", "col", ",", "{", "}", ")", "if", "col_args", ":", "page", "=", "col_args", ".", "get", "(", "API_PAGE_INDEX_RIS_KEY", ",", "None", ")", "page_size", "=", "col_args", ".", "get", "(", "API_PAGE_SIZE_RIS_KEY", ",", "None", ")", "ret", ".", "append", "(", "self", ".", "_get_field_info", "(", "model_schema", ".", "fields", "[", "col", "]", ",", "filter_rel_fields", ".", "get", "(", "col", ",", "[", "]", ")", ",", "page", "=", "page", ",", "page_size", "=", "page_size", ",", ")", ")", "return", "ret" ]

[ "Returns", "a", "dict", "with", "fields", "detail", "from", "a", "marshmallow", "schema" ]

[ "def", "predictions", "(", "args", ")", ":", "logger", ".", "info", "(", "args", ")", "logger", ".", "info", "(", "\"reading sequeces\"", ")", "out_file", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "splitext", "(", "args", ".", "json", ")", "[", "0", "]", "+", "\"_prediction.json\"", ")", "data", "=", "load_data", "(", "args", ".", "json", ")", "out_dir", "=", "os", ".", "path", ".", "abspath", "(", "safe_dirs", "(", "os", ".", "path", ".", "join", "(", "args", ".", "out", ",", "\"predictions\"", ")", ")", ")", "logger", ".", "info", "(", "\"make predictions\"", ")", "data", "=", "is_tRNA", "(", "data", ",", "out_dir", ",", "args", ")", "if", "args", ".", "coral", ":", "logger", ".", "info", "(", "\"make CoRaL predictions\"", ")", "run_coral", "(", "data", ",", "out_dir", ",", "args", ")", "write_data", "(", "data", "[", "0", "]", ",", "out_file", ")", "logger", ".", "info", "(", "\"Done\"", ")" ]

[ "Create", "predictions", "of", "clusters" ]

[ "def", "get_dex_names", "(", "self", ")", ":", "dexre", "=", "re", ".", "compile", "(", "r\"classes(\\d*).dex\"", ")", "return", "filter", "(", "lambda", "x", ":", "dexre", ".", "match", "(", "x", ")", ",", "self", ".", "get_files", "(", ")", ")" ]

[ "Return", "the", "names", "of", "all", "DEX", "files", "found", "in", "the", "APK", ".", "This", "method", "only", "accounts", "for", "offical", "dex", "files", "i", ".", "e", ".", "all", "files", "in", "the", "root", "directory", "of", "the", "APK", "named", "classes", ".", "dex", "or", "classes", "[", "0", "-", "9", "]", "+", ".", "dex" ]

[ "def", "pint2cfunits", "(", "value", ")", ":", "# Print units using abbreviations (millimeter -> mm)", "s", "=", "\"{:~}\"", ".", "format", "(", "value", ")", "# Search and replace patterns", "pat", "=", "r'(?P<inverse>/ )?(?P<unit>\\w+)(?: \\*\\* (?P<pow>\\d))?'", "def", "repl", "(", "m", ")", ":", "i", ",", "u", ",", "p", "=", "m", ".", "groups", "(", ")", "p", "=", "p", "or", "(", "1", "if", "i", "else", "''", ")", "neg", "=", "'-'", "if", "i", "else", "(", "'^'", "if", "p", "else", "''", ")", "return", "\"{}{}{}\"", ".", "format", "(", "u", ",", "neg", ",", "p", ")", "out", ",", "n", "=", "re", ".", "subn", "(", "pat", ",", "repl", ",", "s", ")", "return", "out" ]

[ "Return", "a", "CF", "-", "Convention", "unit", "string", "from", "a", "pint", "unit", "." ]

[ "def", "restore_values", "(", "self", ")", ":", "if", "self", ".", "convergence", "is", "True", ":", "return", "dae", "=", "self", ".", "system", ".", "dae", "system", "=", "self", ".", "system", "inc_g", "=", "self", ".", "inc", "[", "dae", ".", "n", ":", "dae", ".", "m", "+", "dae", ".", "n", "]", "max_g_err_sign", "=", "1", "if", "abs", "(", "max", "(", "inc_g", ")", ")", ">", "abs", "(", "min", "(", "inc_g", ")", ")", "else", "-", "1", "if", "max_g_err_sign", "==", "1", ":", "max_g_err_idx", "=", "list", "(", "inc_g", ")", ".", "index", "(", "max", "(", "inc_g", ")", ")", "else", ":", "max_g_err_idx", "=", "list", "(", "inc_g", ")", ".", "index", "(", "min", "(", "inc_g", ")", ")", "logger", ".", "debug", "(", "'Maximum mismatch = {:.4g} at equation <{}>'", ".", "format", "(", "max", "(", "abs", "(", "inc_g", ")", ")", ",", "system", ".", "varname", ".", "unamey", "[", "max_g_err_idx", "]", ")", ")", "logger", ".", "debug", "(", "'Reducing time step h={:.4g}s for t={:.4g}'", ".", "format", "(", "self", ".", "h", ",", "self", ".", "t", ")", ")", "# restore initial variable data", "dae", ".", "x", "=", "matrix", "(", "self", ".", "x0", ")", "dae", ".", "y", "=", "matrix", "(", "self", ".", "y0", ")", "dae", ".", "f", "=", "matrix", "(", "self", ".", "f0", ")" ]

[ "Restore", "x", "y", "and", "f", "values", "if", "not", "converged" ]

[ "def", "expand_user", "(", "path", ")", ":", "# Default values", "tilde_expand", "=", "False", "tilde_val", "=", "''", "newpath", "=", "path", "if", "path", ".", "startswith", "(", "'~'", ")", ":", "tilde_expand", "=", "True", "rest", "=", "len", "(", "path", ")", "-", "1", "newpath", "=", "os", ".", "path", ".", "expanduser", "(", "path", ")", "if", "rest", ":", "tilde_val", "=", "newpath", "[", ":", "-", "rest", "]", "else", ":", "tilde_val", "=", "newpath", "return", "newpath", ",", "tilde_expand", ",", "tilde_val" ]

[ "Expand", "~", "-", "style", "usernames", "in", "strings", "." ]

[ "def", "from_filename", "(", "cls", ",", "filename", ")", ":", "if", "not", "filename", ":", "logger", ".", "error", "(", "'No filename specified'", ")", "return", "None", "if", "not", "os", ".", "path", ".", "exists", "(", "filename", ")", ":", "logger", ".", "error", "(", "\"Err: File '%s' does not exist\"", ",", "filename", ")", "return", "None", "if", "os", ".", "path", ".", "isdir", "(", "filename", ")", ":", "logger", ".", "error", "(", "\"Err: File '%s' is a directory\"", ",", "filename", ")", "return", "None", "try", ":", "audiofile", "=", "eyed3", ".", "load", "(", "filename", ")", "except", "Exception", "as", "error", ":", "print", "(", "type", "(", "error", ")", ",", "error", ")", "return", "None", "# Sometimes eyed3 may return a null object and not raise any exceptions", "if", "audiofile", "is", "None", ":", "return", "None", "tags", "=", "audiofile", ".", "tag", "album", "=", "tags", ".", "album", "title", "=", "tags", ".", "title", "lyrics", "=", "''", ".", "join", "(", "[", "l", ".", "text", "for", "l", "in", "tags", ".", "lyrics", "]", ")", "artist", "=", "tags", ".", "album_artist", "if", "not", "artist", ":", "artist", "=", "tags", ".", "artist", "song", "=", "cls", "(", "artist", ",", "title", ",", "album", ",", "lyrics", ")", "song", ".", "filename", "=", "filename", "return", "song" ]

[ "Class", "constructor", "using", "the", "path", "to", "the", "corresponding", "mp3", "file", ".", "The", "metadata", "will", "be", "read", "from", "this", "file", "to", "create", "the", "song", "object", "so", "it", "must", "at", "least", "contain", "valid", "ID3", "tags", "for", "artist", "and", "title", "." ]

[ "def", "_to_int", "(", "self", ",", "val_str", ")", ":", "val", "=", "_integerValue_to_int", "(", "val_str", ")", "if", "val", "is", "None", ":", "raise", "ValueError", "(", "_format", "(", "\"The value-mapped {0} has an invalid integer \"", "\"representation in a ValueMap entry: {1!A}\"", ",", "self", ".", "_element_str", "(", ")", ",", "val_str", ")", ")", "return", "val" ]

[ "Conver", "val_str", "to", "an", "integer", "or", "raise", "ValueError" ]

[ "def", "_find_remote_bundle", "(", "self", ",", "ref", ",", "remote_service_type", "=", "'s3'", ")", ":", "for", "r", "in", "self", ".", "remotes", ":", "if", "remote_service_type", "and", "r", ".", "service", "!=", "remote_service_type", ":", "continue", "if", "'list'", "not", "in", "r", ".", "data", ":", "continue", "for", "k", ",", "v", "in", "r", ".", "data", "[", "'list'", "]", ".", "items", "(", ")", ":", "if", "ref", "in", "v", ".", "values", "(", ")", ":", "return", "(", "r", ",", "v", "[", "'vname'", "]", ")", "return", "None", ",", "None" ]

[ "Locate", "a", "bundle", "by", "any", "reference", "among", "the", "configured", "remotes", ".", "The", "routine", "will", "only", "look", "in", "the", "cache", "directory", "lists", "stored", "in", "the", "remotes", "which", "must", "be", "updated", "to", "be", "current", "." ]

[ "def", "move_application", "(", "self", ",", "app_id", ",", "queue", ")", ":", "self", ".", "_call", "(", "'moveApplication'", ",", "proto", ".", "MoveRequest", "(", "id", "=", "app_id", ",", "queue", "=", "queue", ")", ")" ]

[ "Move", "an", "application", "to", "a", "different", "queue", "." ]

[ "def", "find_all_item_classes", "(", "self", ")", ":", "# This is a circular import, but performed after the class is defined and an object is instatiated.", "# We do this in order to get references to any objects definitions in the redmine.py file", "# without requiring anyone editing the file to do anything other than create a class with the proper name.", "import", "redmine", "as", "public_classes", "item_class", "=", "{", "}", "for", "key", ",", "value", "in", "public_classes", ".", "__dict__", ".", "items", "(", ")", ":", "try", ":", "if", "issubclass", "(", "value", ",", "Redmine_Item", ")", ":", "item_class", "[", "key", ".", "lower", "(", ")", "]", "=", "value", "except", ":", "continue", "self", ".", "item_class", "=", "item_class" ]

[ "Finds", "and", "stores", "a", "reference", "to", "all", "Redmine_Item", "subclasses", "for", "later", "use", "." ]

[ "def", "convert_widgets", "(", "self", ")", ":", "for", "field", "in", "self", ".", "base_fields", ".", "values", "(", ")", ":", "try", ":", "new_widget", "=", "field", ".", "get_converted_widget", "(", ")", "except", "AttributeError", ":", "pass", "else", ":", "if", "new_widget", ":", "field", ".", "widget", "=", "new_widget" ]

[ "During", "form", "initialization", "some", "widgets", "have", "to", "be", "replaced", "by", "a", "counterpart", "suitable", "to", "be", "rendered", "the", "AngularJS", "way", "." ]

[ "def", "read_electrostatic_potential", "(", "self", ")", ":", "pattern", "=", "{", "\"ngf\"", ":", "r\"\\s+dimension x,y,z NGXF=\\s+([\\.\\-\\d]+)\\sNGYF=\\s+([\\.\\-\\d]+)\\sNGZF=\\s+([\\.\\-\\d]+)\"", "}", "self", ".", "read_pattern", "(", "pattern", ",", "postprocess", "=", "int", ")", "self", ".", "ngf", "=", "self", ".", "data", ".", "get", "(", "\"ngf\"", ",", "[", "[", "]", "]", ")", "[", "0", "]", "pattern", "=", "{", "\"radii\"", ":", "r\"the test charge radii are((?:\\s+[\\.\\-\\d]+)+)\"", "}", "self", ".", "read_pattern", "(", "pattern", ",", "reverse", "=", "True", ",", "terminate_on_match", "=", "True", ",", "postprocess", "=", "str", ")", "self", ".", "sampling_radii", "=", "[", "float", "(", "f", ")", "for", "f", "in", "self", ".", "data", "[", "\"radii\"", "]", "[", "0", "]", "[", "0", "]", ".", "split", "(", ")", "]", "header_pattern", "=", "r\"\\(the norm of the test charge is\\s+[\\.\\-\\d]+\\)\"", "table_pattern", "=", "r\"((?:\\s+\\d+\\s*[\\.\\-\\d]+)+)\"", "footer_pattern", "=", "r\"\\s+E-fermi :\"", "pots", "=", "self", ".", "read_table_pattern", "(", "header_pattern", ",", "table_pattern", ",", "footer_pattern", ")", "pots", "=", "\"\"", ".", "join", "(", "itertools", ".", "chain", ".", "from_iterable", "(", "pots", ")", ")", "pots", "=", "re", ".", "findall", "(", "r\"\\s+\\d+\\s?([\\.\\-\\d]+)+\"", ",", "pots", ")", "pots", "=", "[", "float", "(", "f", ")", "for", "f", "in", "pots", "]", "self", ".", "electrostatic_potential", "=", "pots" ]

[ "Parses", "the", "eletrostatic", "potential", "for", "the", "last", "ionic", "step" ]

[ "def", "get_bytes", "(", "self", ")", ":", "ret", "=", "struct", ".", "pack", "(", "\"<I16s16sQ\"", ",", "client_DH_inner_data", ".", "constructor", ",", "self", ".", "nonce", ",", "self", ".", "server_nonce", ",", "self", ".", "retry_id", ")", "bytes_io", "=", "BytesIO", "(", ")", "bytes_io", ".", "write", "(", "ret", ")", "serialize_string", "(", "bytes_io", ",", "self", ".", "g_b", ")", "return", "bytes_io", ".", "getvalue", "(", ")" ]

[ "client_DH_inner_data#6643b654", "nonce", ":", "int128", "server_nonce", ":", "int128", "retry_id", ":", "long", "g_b", ":", "string", "=", "Client_DH_Inner_Data" ]

[ "def", "put", "(", "self", ",", "id", ",", "name", ",", "description", ",", "private", ",", "runs_executable_tasks", ",", "runs_docker_container_tasks", ",", "runs_singularity_container_tasks", ",", "active", ",", "whitelists", ",", ")", ":", "# Update the object", "request_url", "=", "self", ".", "_client", ".", "base_api_url", "+", "self", ".", "detail_url", ".", "format", "(", "id", "=", "id", ")", "data_to_put", "=", "{", "\"name\"", ":", "name", ",", "\"description\"", ":", "description", ",", "\"private\"", ":", "private", ",", "\"runs_executable_tasks\"", ":", "runs_executable_tasks", ",", "\"runs_docker_container_tasks\"", ":", "runs_docker_container_tasks", ",", "\"runs_singularity_container_tasks\"", ":", "runs_singularity_container_tasks", ",", "\"active\"", ":", "active", ",", "\"whitelists\"", ":", "whitelists", ",", "}", "response", "=", "self", ".", "_client", ".", "session", ".", "put", "(", "request_url", ",", "data", "=", "data_to_put", ")", "# Validate that the request was successful", "self", ".", "validate_request_success", "(", "response_text", "=", "response", ".", "text", ",", "request_url", "=", "request_url", ",", "status_code", "=", "response", ".", "status_code", ",", "expected_status_code", "=", "HTTP_200_OK", ",", ")", "# Return a model instance representing the task instance", "return", "self", ".", "response_data_to_model_instance", "(", "response", ".", "json", "(", ")", ")" ]

[ "Updates", "a", "task", "queue", "on", "the", "saltant", "server", "." ]

[ "def", "phenograph", "(", "adata", ",", "k", "=", "30", ",", "directed", "=", "False", ",", "prune", "=", "False", ",", "min_cluster_size", "=", "10", ",", "jaccard", "=", "True", ",", "primary_metric", "=", "'euclidean'", ",", "n_jobs", "=", "-", "1", ",", "q_tol", "=", "1e-3", ",", "louvain_time_limit", "=", "2000", ",", "nn_method", "=", "'kdtree'", ")", ":", "logg", ".", "info", "(", "'PhenoGraph clustering'", ",", "r", "=", "True", ")", "try", ":", "import", "phenograph", "except", "ImportError", ":", "raise", "ImportError", "(", "'please install phenograph: '", "'pip3 install git+https://github.com/jacoblevine/phenograph.git'", ")", "communities", ",", "graph", ",", "Q", "=", "phenograph", ".", "cluster", "(", "data", "=", "adata", ",", "k", "=", "k", ",", "directed", "=", "directed", ",", "prune", "=", "prune", ",", "min_cluster_size", "=", "min_cluster_size", ",", "jaccard", "=", "jaccard", ",", "primary_metric", "=", "primary_metric", ",", "n_jobs", "=", "n_jobs", ",", "q_tol", "=", "q_tol", ",", "louvain_time_limit", "=", "louvain_time_limit", ",", "nn_method", "=", "nn_method", ")", "logg", ".", "info", "(", "' finished'", ",", "time", "=", "True", ")", "return", "communities", ",", "graph", ",", "Q" ]

[ "PhenoGraph", "clustering", "[", "Levine15", "]", "_", "." ]

[ "def", "search_function", "(", "encoding", ")", ":", "if", "encoding", "in", "_CACHE", ":", "return", "_CACHE", "[", "encoding", "]", "norm_encoding", "=", "normalize_encoding", "(", "encoding", ")", "codec", "=", "None", "if", "norm_encoding", "in", "UTF8_VAR_NAMES", ":", "from", "ftfy", ".", "bad_codecs", ".", "utf8_variants", "import", "CODEC_INFO", "codec", "=", "CODEC_INFO", "elif", "norm_encoding", ".", "startswith", "(", "'sloppy_'", ")", ":", "from", "ftfy", ".", "bad_codecs", ".", "sloppy", "import", "CODECS", "codec", "=", "CODECS", ".", "get", "(", "norm_encoding", ")", "if", "codec", "is", "not", "None", ":", "_CACHE", "[", "encoding", "]", "=", "codec", "return", "codec" ]

[ "Register", "our", "bad", "codecs", "with", "Python", "s", "codecs", "API", ".", "This", "involves", "adding", "a", "search", "function", "that", "takes", "in", "an", "encoding", "name", "and", "returns", "a", "codec", "for", "that", "encoding", "if", "it", "knows", "one", "or", "None", "if", "it", "doesn", "t", "." ]

[ "def", "simxAuxiliaryConsoleOpen", "(", "clientID", ",", "title", ",", "maxLines", ",", "mode", ",", "position", ",", "size", ",", "textColor", ",", "backgroundColor", ",", "operationMode", ")", ":", "consoleHandle", "=", "ct", ".", "c_int", "(", ")", "if", "(", "sys", ".", "version_info", "[", "0", "]", "==", "3", ")", "and", "(", "type", "(", "title", ")", "is", "str", ")", ":", "title", "=", "title", ".", "encode", "(", "'utf-8'", ")", "if", "position", "!=", "None", ":", "c_position", "=", "(", "ct", ".", "c_int", "*", "2", ")", "(", "*", "position", ")", "else", ":", "c_position", "=", "None", "if", "size", "!=", "None", ":", "c_size", "=", "(", "ct", ".", "c_int", "*", "2", ")", "(", "*", "size", ")", "else", ":", "c_size", "=", "None", "if", "textColor", "!=", "None", ":", "c_textColor", "=", "(", "ct", ".", "c_float", "*", "3", ")", "(", "*", "textColor", ")", "else", ":", "c_textColor", "=", "None", "if", "backgroundColor", "!=", "None", ":", "c_backgroundColor", "=", "(", "ct", ".", "c_float", "*", "3", ")", "(", "*", "backgroundColor", ")", "else", ":", "c_backgroundColor", "=", "None", "return", "c_AuxiliaryConsoleOpen", "(", "clientID", ",", "title", ",", "maxLines", ",", "mode", ",", "c_position", ",", "c_size", ",", "c_textColor", ",", "c_backgroundColor", ",", "ct", ".", "byref", "(", "consoleHandle", ")", ",", "operationMode", ")", ",", "consoleHandle", ".", "value" ]

[ "Please", "have", "a", "look", "at", "the", "function", "description", "/", "documentation", "in", "the", "V", "-", "REP", "user", "manual" ]

[ "def", "wait_gone", "(", "self", ",", "timeout", "=", "None", ",", "raise_error", "=", "True", ")", ":", "start_time", "=", "time", ".", "time", "(", ")", "if", "timeout", "is", "None", "or", "timeout", "<=", "0", ":", "timeout", "=", "self", ".", "timeout", "while", "start_time", "+", "timeout", ">", "time", ".", "time", "(", ")", ":", "if", "not", "self", ".", "exists", ":", "return", "True", "if", "not", "raise_error", ":", "return", "False", "raise", "WDAElementNotDisappearError", "(", "\"element not gone\"", ")" ]

[ "Args", ":", "timeout", "(", "float", ")", ":", "default", "timeout", "raise_error", "(", "bool", ")", ":", "return", "bool", "or", "raise", "error", "Returns", ":", "bool", ":", "works", "when", "raise_error", "is", "False" ]

[ "def", "serialize", "(", "self", ",", "content", ")", ":", "content", "=", "super", "(", "JSONPEmitter", ",", "self", ")", ".", "serialize", "(", "content", ")", "callback", "=", "self", ".", "request", ".", "GET", ".", "get", "(", "'callback'", ",", "'callback'", ")", "return", "u'%s(%s)'", "%", "(", "callback", ",", "content", ")" ]

[ "Serialize", "to", "JSONP", "." ]

[ "def", "get_objects_or_children_by_type", "(", "self", ",", "*", "types", ")", ":", "objects", "=", "self", ".", "get_objects_by_type", "(", "*", "types", ")", "return", "objects", "if", "objects", "else", "self", ".", "get_children", "(", "*", "types", ")" ]

[ "Get", "objects", "if", "children", "already", "been", "read", "or", "get", "children", "." ]

[ "def", "unpack_classical_reg", "(", "c", ")", ":", "if", "isinstance", "(", "c", ",", "list", ")", "or", "isinstance", "(", "c", ",", "tuple", ")", ":", "if", "len", "(", "c", ")", ">", "2", "or", "len", "(", "c", ")", "==", "0", ":", "raise", "ValueError", "(", "\"if c is a list/tuple, it should be of length <= 2\"", ")", "if", "len", "(", "c", ")", "==", "1", ":", "c", "=", "(", "c", "[", "0", "]", ",", "0", ")", "if", "not", "isinstance", "(", "c", "[", "0", "]", ",", "str", ")", ":", "raise", "ValueError", "(", "\"if c is a list/tuple, its first member should be a string\"", ")", "if", "not", "isinstance", "(", "c", "[", "1", "]", ",", "int", ")", ":", "raise", "ValueError", "(", "\"if c is a list/tuple, its second member should be an int\"", ")", "return", "MemoryReference", "(", "c", "[", "0", "]", ",", "c", "[", "1", "]", ")", "if", "isinstance", "(", "c", ",", "MemoryReference", ")", ":", "return", "c", "elif", "isinstance", "(", "c", ",", "str", ")", ":", "return", "MemoryReference", "(", "c", ",", "0", ")", "else", ":", "raise", "TypeError", "(", "\"c should be a list of length 2, a pair, a string, or a MemoryReference\"", ")" ]

[ "Get", "the", "address", "for", "a", "classical", "register", "." ]

[ "def", "decode_step", "(", "self", ",", "step", ":", "int", ",", "target_embed_prev", ":", "mx", ".", "sym", ".", "Symbol", ",", "source_encoded_max_length", ":", "int", ",", "*", "states", ":", "mx", ".", "sym", ".", "Symbol", ")", "->", "Tuple", "[", "mx", ".", "sym", ".", "Symbol", ",", "mx", ".", "sym", ".", "Symbol", ",", "List", "[", "mx", ".", "sym", ".", "Symbol", "]", "]", ":", "pass" ]

[ "Decodes", "a", "single", "time", "step", "given", "the", "current", "step", "the", "previous", "embedded", "target", "word", "and", "previous", "decoder", "states", ".", "Returns", "decoder", "representation", "for", "the", "next", "prediction", "attention", "probabilities", "and", "next", "decoder", "states", ".", "Implementations", "can", "maintain", "an", "arbitrary", "number", "of", "states", "." ]

[ "def", "create_simulated_env", "(", "output_dir", ",", "grayscale", ",", "resize_width_factor", ",", "resize_height_factor", ",", "frame_stack_size", ",", "generative_model", ",", "generative_model_params", ",", "random_starts", "=", "True", ",", "which_epoch_data", "=", "\"last\"", ",", "*", "*", "other_hparams", ")", ":", "# We need these, to initialize T2TGymEnv, but these values (hopefully) have", "# no effect on player.", "a_bit_risky_defaults", "=", "{", "\"game\"", ":", "\"pong\"", ",", "# assumes that T2TGymEnv has always reward_range (-1,1)", "\"real_batch_size\"", ":", "1", ",", "\"rl_env_max_episode_steps\"", ":", "-", "1", ",", "\"max_num_noops\"", ":", "0", "}", "for", "key", "in", "a_bit_risky_defaults", ":", "if", "key", "not", "in", "other_hparams", ":", "other_hparams", "[", "key", "]", "=", "a_bit_risky_defaults", "[", "key", "]", "hparams", "=", "hparam", ".", "HParams", "(", "grayscale", "=", "grayscale", ",", "resize_width_factor", "=", "resize_width_factor", ",", "resize_height_factor", "=", "resize_height_factor", ",", "frame_stack_size", "=", "frame_stack_size", ",", "generative_model", "=", "generative_model", ",", "generative_model_params", "=", "generative_model_params", ",", "*", "*", "other_hparams", ")", "return", "load_data_and_make_simulated_env", "(", "output_dir", ",", "wm_dir", "=", "None", ",", "hparams", "=", "hparams", ",", "which_epoch_data", "=", "which_epoch_data", ",", "random_starts", "=", "random_starts", ")" ]

[ "Create", "SimulatedEnv", "with", "minimal", "subset", "of", "hparams", "." ]

[ "def", "get_permissions", "(", "self", ")", ":", "path", "=", "Client", ".", "urls", "[", "'all_permissions'", "]", "conns", "=", "self", ".", "_call", "(", "path", ",", "'GET'", ")", "return", "conns" ]

[ ":", "returns", ":", "list", "of", "dicts", "or", "an", "empty", "list", "if", "there", "are", "no", "permissions", "." ]