Datasets:

---

kejian

/

codesearchnet-python-raw

like 1

[ "def", "np_lst_sq", "(", "vecMdl", ",", "aryFuncChnk", ")", ":", "aryTmpBts", ",", "vecTmpRes", "=", "np", ".", "linalg", ".", "lstsq", "(", "vecMdl", ",", "aryFuncChnk", ",", "rcond", "=", "-", "1", ")", "[", ":", "2", "]", "return", "aryTmpBts", ",", "vecTmpRes" ]

[ "Least", "squares", "fitting", "in", "numpy", "without", "cross", "-", "validation", "." ]

[ "def", "value_interval", "(", "ol", ",", "value", ")", ":", "si", ",", "ei", "=", "where", "(", "ol", ",", "value", ")", "if", "(", "si", "==", "None", ")", ":", "sv", "=", "None", "else", ":", "sv", "=", "ol", "[", "si", "]", "if", "(", "ei", "==", "None", ")", ":", "ev", "=", "None", "else", ":", "ev", "=", "ol", "[", "ei", "]", "return", "(", "(", "sv", ",", "ev", ")", ")" ]

[ "ol", "=", "[", "0", "4", "6", "8", "10", "14", "]", "value_interval", "(", "ol", "-", "1", ")", "value_interval", "(", "ol", "1", ")", "value_interval", "(", "ol", "2", ")", "value_interval", "(", "ol", "3", ")", "value_interval", "(", "ol", "4", ")", "value_interval", "(", "ol", "9", ")", "value_interval", "(", "ol", "14", ")", "value_interval", "(", "ol", "17", ")" ]

[ "def", "get_probes_results", "(", "self", ")", ":", "probes_results", "=", "{", "}", "probes_results_table", "=", "junos_views", ".", "junos_rpm_probes_results_table", "(", "self", ".", "device", ")", "probes_results_table", ".", "get", "(", ")", "probes_results_items", "=", "probes_results_table", ".", "items", "(", ")", "for", "probe_result", "in", "probes_results_items", ":", "probe_name", "=", "py23_compat", ".", "text_type", "(", "probe_result", "[", "0", "]", ")", "test_results", "=", "{", "p", "[", "0", "]", ":", "p", "[", "1", "]", "for", "p", "in", "probe_result", "[", "1", "]", "}", "test_results", "[", "'last_test_loss'", "]", "=", "napalm_base", ".", "helpers", ".", "convert", "(", "int", ",", "test_results", ".", "pop", "(", "'last_test_loss'", ")", ",", "0", ")", "for", "test_param_name", ",", "test_param_value", "in", "test_results", ".", "items", "(", ")", ":", "if", "isinstance", "(", "test_param_value", ",", "float", ")", ":", "test_results", "[", "test_param_name", "]", "=", "test_param_value", "*", "1e-3", "# convert from useconds to mseconds", "test_name", "=", "test_results", ".", "pop", "(", "'test_name'", ",", "''", ")", "source", "=", "test_results", ".", "get", "(", "'source'", ",", "u''", ")", "if", "source", "is", "None", ":", "test_results", "[", "'source'", "]", "=", "u''", "if", "probe_name", "not", "in", "probes_results", ".", "keys", "(", ")", ":", "probes_results", "[", "probe_name", "]", "=", "{", "}", "probes_results", "[", "probe_name", "]", "[", "test_name", "]", "=", "test_results", "return", "probes_results" ]

[ "Return", "the", "results", "of", "the", "RPM", "probes", "." ]

[ "async", "def", "getTempCoreCmdr", "(", "mods", "=", "None", ",", "outp", "=", "None", ")", ":", "acm", "=", "genTempCoreProxy", "(", "mods", ")", "prox", "=", "await", "acm", ".", "__aenter__", "(", ")", "cmdrcore", "=", "await", "CmdrCore", ".", "anit", "(", "prox", ",", "outp", "=", "outp", ")", "cmdrcore", ".", "acm", "=", "acm", "return", "cmdrcore" ]

[ "Get", "a", "CmdrCore", "instance", "which", "is", "backed", "by", "a", "temporary", "Cortex", "." ]

[ "def", "build_kernel", "(", "self", ")", ":", "if", "self", ".", "precomputed", "==", "\"affinity\"", ":", "# already done", "# TODO: should we check that precomputed matrices look okay?", "# e.g. check the diagonal", "K", "=", "self", ".", "data_nu", "elif", "self", ".", "precomputed", "==", "\"adjacency\"", ":", "# need to set diagonal to one to make it an affinity matrix", "K", "=", "self", ".", "data_nu", "if", "sparse", ".", "issparse", "(", "K", ")", "and", "not", "(", "isinstance", "(", "K", ",", "sparse", ".", "dok_matrix", ")", "or", "isinstance", "(", "K", ",", "sparse", ".", "lil_matrix", ")", ")", ":", "K", "=", "K", ".", "tolil", "(", ")", "K", "=", "set_diagonal", "(", "K", ",", "1", ")", "else", ":", "tasklogger", ".", "log_start", "(", "\"affinities\"", ")", "if", "sparse", ".", "issparse", "(", "self", ".", "data_nu", ")", ":", "self", ".", "data_nu", "=", "self", ".", "data_nu", ".", "toarray", "(", ")", "if", "self", ".", "precomputed", "==", "\"distance\"", ":", "pdx", "=", "self", ".", "data_nu", "elif", "self", ".", "precomputed", "is", "None", ":", "pdx", "=", "pdist", "(", "self", ".", "data_nu", ",", "metric", "=", "self", ".", "distance", ")", "if", "np", ".", "any", "(", "pdx", "==", "0", ")", ":", "pdx", "=", "squareform", "(", "pdx", ")", "duplicate_ids", "=", "np", ".", "array", "(", "[", "i", "for", "i", "in", "np", ".", "argwhere", "(", "pdx", "==", "0", ")", "if", "i", "[", "1", "]", ">", "i", "[", "0", "]", "]", ")", "duplicate_names", "=", "\", \"", ".", "join", "(", "[", "\"{} and {}\"", ".", "format", "(", "i", "[", "0", "]", ",", "i", "[", "1", "]", ")", "for", "i", "in", "duplicate_ids", "]", ")", "warnings", ".", "warn", "(", "\"Detected zero distance between samples {}. \"", "\"Consider removing duplicates to avoid errors in \"", "\"downstream processing.\"", ".", "format", "(", "duplicate_names", ")", ",", "RuntimeWarning", ")", "else", ":", "pdx", "=", "squareform", "(", "pdx", ")", "else", ":", "raise", "ValueError", "(", "\"precomputed='{}' not recognized. \"", "\"Choose from ['affinity', 'adjacency', 'distance', \"", "\"None]\"", ".", "format", "(", "self", ".", "precomputed", ")", ")", "if", "self", ".", "bandwidth", "is", "None", ":", "knn_dist", "=", "np", ".", "partition", "(", "pdx", ",", "self", ".", "knn", "+", "1", ",", "axis", "=", "1", ")", "[", ":", ",", ":", "self", ".", "knn", "+", "1", "]", "bandwidth", "=", "np", ".", "max", "(", "knn_dist", ",", "axis", "=", "1", ")", "elif", "callable", "(", "self", ".", "bandwidth", ")", ":", "bandwidth", "=", "self", ".", "bandwidth", "(", "pdx", ")", "else", ":", "bandwidth", "=", "self", ".", "bandwidth", "bandwidth", "=", "bandwidth", "*", "self", ".", "bandwidth_scale", "pdx", "=", "(", "pdx", ".", "T", "/", "bandwidth", ")", ".", "T", "K", "=", "np", ".", "exp", "(", "-", "1", "*", "np", ".", "power", "(", "pdx", ",", "self", ".", "decay", ")", ")", "# handle nan", "K", "=", "np", ".", "where", "(", "np", ".", "isnan", "(", "K", ")", ",", "1", ",", "K", ")", "tasklogger", ".", "log_complete", "(", "\"affinities\"", ")", "# truncate", "if", "sparse", ".", "issparse", "(", "K", ")", ":", "if", "not", "(", "isinstance", "(", "K", ",", "sparse", ".", "csr_matrix", ")", "or", "isinstance", "(", "K", ",", "sparse", ".", "csc_matrix", ")", "or", "isinstance", "(", "K", ",", "sparse", ".", "bsr_matrix", ")", ")", ":", "K", "=", "K", ".", "tocsr", "(", ")", "K", ".", "data", "[", "K", ".", "data", "<", "self", ".", "thresh", "]", "=", "0", "K", "=", "K", ".", "tocoo", "(", ")", "K", ".", "eliminate_zeros", "(", ")", "K", "=", "K", ".", "tocsr", "(", ")", "else", ":", "K", "[", "K", "<", "self", ".", "thresh", "]", "=", "0", "return", "K" ]

[ "Build", "the", "KNN", "kernel", "." ]

[ "def", "get_urls", "(", "self", ")", ":", "urls", "=", "super", "(", "TreeAdmin", ",", "self", ")", ".", "get_urls", "(", ")", "if", "django", ".", "VERSION", "<", "(", "1", ",", "10", ")", ":", "from", "django", ".", "views", ".", "i18n", "import", "javascript_catalog", "jsi18n_url", "=", "url", "(", "r'^jsi18n/$'", ",", "javascript_catalog", ",", "{", "'packages'", ":", "(", "'treebeard'", ",", ")", "}", ")", "else", ":", "from", "django", ".", "views", ".", "i18n", "import", "JavaScriptCatalog", "jsi18n_url", "=", "url", "(", "r'^jsi18n/$'", ",", "JavaScriptCatalog", ".", "as_view", "(", "packages", "=", "[", "'treebeard'", "]", ")", ",", "name", "=", "'javascript-catalog'", ")", "new_urls", "=", "[", "url", "(", "'^move/$'", ",", "self", ".", "admin_site", ".", "admin_view", "(", "self", ".", "move_node", ")", ",", ")", ",", "jsi18n_url", ",", "]", "return", "new_urls", "+", "urls" ]

[ "Adds", "a", "url", "to", "move", "nodes", "to", "this", "admin" ]

[ "def", "as_tensorflow_layer", "(", "odl_op", ",", "name", "=", "'ODLOperator'", ",", "differentiable", "=", "True", ")", ":", "default_name", "=", "name", "def", "py_func", "(", "func", ",", "inp", ",", "Tout", ",", "stateful", "=", "True", ",", "name", "=", "None", ",", "grad", "=", "None", ")", ":", "\"\"\"Define custom py_func which takes also a grad op as argument.\n\n We need to overwrite this function since the default tensorflow\n `tf.py_func` does not support custom gradients.\n\n See tensorflow `issue #1095`_ for more information.\n\n Parameters\n ----------\n func : callable\n Python function that takes and returns numpy arrays.\n inp : sequence of `tensorflow.Tensor`\n Input tensors for the function\n Tout : sequence of `tensorflow.dtype`\n Datatype of the output(s).\n stateful : bool, optional\n If the function has internal state, i.e. if calling the function\n with a given input repeatedly could give different output.\n name : string, optional\n Name of the python function.\n grad : callbable, optional\n Gradient of the function.\n\n References\n ----------\n .. _issue #1095: https://github.com/tensorflow/tensorflow/issues/1095\n \"\"\"", "if", "grad", "is", "None", ":", "return", "tf", ".", "py_func", "(", "func", ",", "inp", ",", "Tout", ",", "stateful", "=", "stateful", ",", "name", "=", "name", ")", "else", ":", "if", "stateful", ":", "override_name", "=", "'PyFunc'", "else", ":", "override_name", "=", "'PyFuncStateless'", "# Need to generate a unique name to avoid duplicates:", "rnd_name", "=", "override_name", "+", "'Grad'", "+", "str", "(", "uuid", ".", "uuid4", "(", ")", ")", "tf", ".", "RegisterGradient", "(", "rnd_name", ")", "(", "grad", ")", "g", "=", "tf", ".", "get_default_graph", "(", ")", "with", "g", ".", "gradient_override_map", "(", "{", "override_name", ":", "rnd_name", "}", ")", ":", "return", "tf", ".", "py_func", "(", "func", ",", "inp", ",", "Tout", ",", "stateful", "=", "stateful", ",", "name", "=", "name", ")", "def", "tensorflow_layer_grad_impl", "(", "x", ",", "dy", ",", "name", ")", ":", "\"\"\"Implementation of the tensorflow gradient.\n\n Gradient in tensorflow is equivalent to the adjoint of the derivative\n in ODL.\n\n Returns a `tensorflow.Tensor` that represents a lazy application of ::\n\n odl_op.derivative(x).adjoint(dy)\n\n Parameters\n ----------\n x : `numpy.ndarray`\n Point(s) in which the derivative should be taken.\n If ``odl_op`` is an `Operator` the axes are:\n 0 : batch id. This is a constant if ``fixed_size`` is\n ``True``, otherwise it is dynamic.\n 1, ..., n-2 : spatial dimensions of data.\n n-1 : (currently) unused data channel.\n If ``odl_op`` is a `Functional` the axes are:\n 0 : batch id.\n dy : `tensorflow.Tensor`\n Point(s) in which the adjoint of the derivative of the\n operator should be evaluated.\n The axes are:\n 0 : batch id. Should be pairwise matched with ``x``.\n 1, ..., m-2 : spatial dimensions of data.\n m-1 : (currently) unused data channel.\n name : string\n Name of the tensor.\n\n Returns\n -------\n result : `tensorflow.Tensor`\n Lazy result of the computation.\n If ``odl_op`` is an `Operator` the axes are:\n 0 : batch id.\n 1, ..., n-2 : spatial dimensions of data.\n n-1 : (currently) unused data channel.\n If ``odl_op`` is a `Functional` the axes are:\n 0 : batch id.\n \"\"\"", "with", "tf", ".", "name_scope", "(", "name", ")", ":", "# Validate the input/output shape", "x_shape", "=", "x", ".", "get_shape", "(", ")", "dy_shape", "=", "dy", ".", "get_shape", "(", ")", "try", ":", "# Lazy check if the first dimension is dynamic", "n_x", "=", "int", "(", "x_shape", "[", "0", "]", ")", "fixed_size", "=", "True", "except", "TypeError", ":", "n_x", "=", "x_shape", "[", "0", "]", "fixed_size", "=", "False", "if", "odl_op", ".", "is_functional", ":", "in_shape", "=", "(", "n_x", ",", ")", "else", ":", "in_shape", "=", "(", "n_x", ",", ")", "+", "space_shape", "(", "odl_op", ".", "range", ")", "+", "(", "1", ",", ")", "out_shape", "=", "(", "n_x", ",", ")", "+", "space_shape", "(", "odl_op", ".", "domain", ")", "+", "(", "1", ",", ")", "assert", "x_shape", "[", "1", ":", "]", "==", "space_shape", "(", "odl_op", ".", "domain", ")", "+", "(", "1", ",", ")", "if", "odl_op", ".", "is_functional", ":", "assert", "dy_shape", "[", "1", ":", "]", "==", "(", ")", "else", ":", "assert", "dy_shape", "[", "1", ":", "]", "==", "space_shape", "(", "odl_op", ".", "range", ")", "+", "(", "1", ",", ")", "def", "_impl", "(", "x", ",", "dy", ")", ":", "\"\"\"Implementation of the adjoint of the derivative.\n\n Returns ::\n\n odl_op.derivative(x).adjoint(dy)\n\n Parameters\n ----------\n x : `numpy.ndarray`\n Point(s) in which the derivative should be taken.\n If ``odl_op`` is an `Operator` the axes are:\n 0 : batch id. This is a constant if ``fixed_size`` is\n true, otherwise it is dynamic.\n 1, ..., n-2 : spatial dimensions of data.\n n-1 : (currently) unused data channel.\n If ``odl_op`` is a `Functional` the axes are:\n 0 : batch id.\n dy : `numpy.ndarray`\n Point(s) in which the adjoint of the derivative of the\n operator should be evaluated.\n The axes are:\n 0 : batch id. Should be pairwise matched with ``x``.\n 1, ..., m-2 : spatial dimensions of data.\n m-1 : (currently) unused data channel.\n\n Returns\n -------\n result : `numpy.ndarray`\n Result of the computation.\n\n If ``odl_op`` is an `Operator` the axes are:\n 0 : batch id.\n 1, ..., n-2 : spatial dimensions of data.\n n-1 : (currently) unused data channel.\n If ``odl_op`` is a `Functional` the axes are:\n 0 : batch id.\n \"\"\"", "# Validate the shape of the given input", "if", "fixed_size", ":", "x_out_shape", "=", "out_shape", "assert", "x", ".", "shape", "==", "out_shape", "assert", "dy", ".", "shape", "==", "in_shape", "else", ":", "x_out_shape", "=", "(", "x", ".", "shape", "[", "0", "]", ",", ")", "+", "out_shape", "[", "1", ":", "]", "assert", "x", ".", "shape", "[", "1", ":", "]", "==", "out_shape", "[", "1", ":", "]", "assert", "dy", ".", "shape", "[", "1", ":", "]", "==", "in_shape", "[", "1", ":", "]", "# Evaluate the operator on all inputs in the batch.", "out", "=", "np", ".", "empty", "(", "x_out_shape", ",", "odl_op", ".", "domain", ".", "dtype", ")", "out_element", "=", "odl_op", ".", "domain", ".", "element", "(", ")", "for", "i", "in", "range", "(", "x_out_shape", "[", "0", "]", ")", ":", "if", "odl_op", ".", "is_functional", ":", "xi", "=", "x", "[", "i", ",", "...", ",", "0", "]", "dyi", "=", "dy", "[", "i", "]", "out", "[", "i", ",", "...", ",", "0", "]", "=", "np", ".", "asarray", "(", "odl_op", ".", "gradient", "(", "xi", ")", ")", "*", "dyi", "else", ":", "xi", "=", "x", "[", "i", ",", "...", ",", "0", "]", "dyi", "=", "dy", "[", "i", ",", "...", ",", "0", "]", "odl_op", ".", "derivative", "(", "xi", ")", ".", "adjoint", "(", "dyi", ",", "out", "=", "out_element", ")", "out", "[", "i", ",", "...", ",", "0", "]", "=", "np", ".", "asarray", "(", "out_element", ")", "# Rescale the domain/range according to the weighting since", "# tensorflow does not have weighted spaces.", "try", ":", "dom_weight", "=", "odl_op", ".", "domain", ".", "weighting", ".", "const", "except", "AttributeError", ":", "dom_weight", "=", "1.0", "try", ":", "ran_weight", "=", "odl_op", ".", "range", ".", "weighting", ".", "const", "except", "AttributeError", ":", "ran_weight", "=", "1.0", "scale", "=", "dom_weight", "/", "ran_weight", "out", "*=", "scale", "return", "out", "with", "ops", ".", "name_scope", "(", "name", "+", "'_pyfunc'", ",", "values", "=", "[", "x", ",", "dy", "]", ")", "as", "name_call", ":", "result", "=", "py_func", "(", "_impl", ",", "[", "x", ",", "dy", "]", ",", "[", "odl_op", ".", "domain", ".", "dtype", "]", ",", "name", "=", "name_call", ",", "stateful", "=", "False", ")", "# We must manually set the output shape since tensorflow cannot", "# figure it out", "result", "=", "result", "[", "0", "]", "result", ".", "set_shape", "(", "out_shape", ")", "return", "result", "def", "tensorflow_layer", "(", "x", ",", "name", "=", "None", ")", ":", "\"\"\"Implementation of the tensorflow call.\n\n Returns a `tensorflow.Tensor` that represents a lazy application of\n ``odl_op`` to ``x``.\n\n Parameters\n ----------\n x : `tensorflow.Tensor`\n Point(s) to which the layer should be applied.\n The axes are:\n 0 : batch id. Can be fixed or dynamic.\n 1, ..., n-2 : spatial dimensions of data.\n n-1 : (currently) unused data channel.\n name : string\n Name of the tensor. Default: Defaultname.\n\n Returns\n -------\n result : `tensorflow.Tensor`\n Lazy result of the computation.\n If ``odl_op`` is an `Operator` the axes are:\n 0 : batch id.\n 1, ..., m-2 : spatial dimensions of data.\n m-1 : (currently) unused data channel.\n If ``odl_op`` is a `Functional` the axes are:\n 0 : batch id.\n \"\"\"", "if", "name", "is", "None", ":", "name", "=", "default_name", "with", "tf", ".", "name_scope", "(", "name", ")", ":", "# Validate input shape", "x_shape", "=", "x", ".", "get_shape", "(", ")", "try", ":", "# Lazy check if the first dimension is dynamic", "n_x", "=", "int", "(", "x_shape", "[", "0", "]", ")", "fixed_size", "=", "True", "except", "TypeError", ":", "n_x", "=", "x_shape", "[", "0", "]", "fixed_size", "=", "False", "in_shape", "=", "(", "n_x", ",", ")", "+", "space_shape", "(", "odl_op", ".", "domain", ")", "+", "(", "1", ",", ")", "if", "odl_op", ".", "is_functional", ":", "out_shape", "=", "(", "n_x", ",", ")", "else", ":", "out_shape", "=", "(", "n_x", ",", ")", "+", "space_shape", "(", "odl_op", ".", "range", ")", "+", "(", "1", ",", ")", "assert", "x_shape", "[", "1", ":", "]", "==", "space_shape", "(", "odl_op", ".", "domain", ")", "+", "(", "1", ",", ")", "out_dtype", "=", "getattr", "(", "odl_op", ".", "range", ",", "'dtype'", ",", "odl_op", ".", "domain", ".", "dtype", ")", "def", "_impl", "(", "x", ")", ":", "\"\"\"Implementation of the tensorflow layer.\n\n Parameters\n ----------\n x : `numpy.ndarray`\n Point(s) in which the operator should be evaluated.\n The axes are:\n 0 : batch id. This is a constant if ``fixed_size`` is\n true, otherwise it is dynamic.\n 1, ..., n-2 : spatial dimensions of data.\n n-1 : (currently) unused data channel.\n\n Returns\n -------\n result : `numpy.ndarray`\n Result of the computation.\n The axes are:\n 0 : batch id. Data is pairwise matched with ``x``.\n 1, ..., m-2 : spatial dimensions of data.\n m-1 : (currently) unused data channel.\n \"\"\"", "# Validate input shape", "if", "fixed_size", ":", "x_out_shape", "=", "out_shape", "assert", "x", ".", "shape", "==", "in_shape", "else", ":", "x_out_shape", "=", "(", "x", ".", "shape", "[", "0", "]", ",", ")", "+", "out_shape", "[", "1", ":", "]", "assert", "x", ".", "shape", "[", "1", ":", "]", "==", "in_shape", "[", "1", ":", "]", "# Evaluate the operator on all inputs in the batch.", "out", "=", "np", ".", "empty", "(", "x_out_shape", ",", "out_dtype", ")", "out_element", "=", "odl_op", ".", "range", ".", "element", "(", ")", "for", "i", "in", "range", "(", "x_out_shape", "[", "0", "]", ")", ":", "if", "odl_op", ".", "is_functional", ":", "out", "[", "i", "]", "=", "odl_op", "(", "x", "[", "i", ",", "...", ",", "0", "]", ")", "else", ":", "odl_op", "(", "x", "[", "i", ",", "...", ",", "0", "]", ",", "out", "=", "out_element", ")", "out", "[", "i", ",", "...", ",", "0", "]", "=", "np", ".", "asarray", "(", "out_element", ")", "return", "out", "if", "differentiable", ":", "def", "tensorflow_layer_grad", "(", "op", ",", "grad", ")", ":", "\"\"\"Thin wrapper for the gradient.\"\"\"", "x", "=", "op", ".", "inputs", "[", "0", "]", "return", "tensorflow_layer_grad_impl", "(", "x", ",", "grad", ",", "name", "=", "name", "+", "'_grad'", ")", "else", ":", "tensorflow_layer_grad", "=", "None", "with", "ops", ".", "name_scope", "(", "name", "+", "'_pyfunc'", ",", "values", "=", "[", "x", "]", ")", "as", "name_call", ":", "result", "=", "py_func", "(", "_impl", ",", "[", "x", "]", ",", "[", "out_dtype", "]", ",", "name", "=", "name_call", ",", "stateful", "=", "False", ",", "grad", "=", "tensorflow_layer_grad", ")", "# We must manually set the output shape since tensorflow cannot", "# figure it out", "result", "=", "result", "[", "0", "]", "result", ".", "set_shape", "(", "out_shape", ")", "return", "result", "return", "tensorflow_layer" ]

[ "Convert", "Operator", "or", "Functional", "to", "a", "tensorflow", "layer", "." ]

[ "def", "set_breakpoint", "(", "self", ",", "file_name", ",", "line_number", ",", "condition", "=", "None", ",", "enabled", "=", "True", ")", ":", "c_file_name", "=", "self", ".", "canonic", "(", "file_name", ")", "import", "linecache", "line", "=", "linecache", ".", "getline", "(", "c_file_name", ",", "line_number", ")", "if", "not", "line", ":", "return", "\"Line %s:%d does not exist.\"", "%", "(", "c_file_name", ",", "line_number", ")", ",", "None", "bp", "=", "IKBreakpoint", "(", "c_file_name", ",", "line_number", ",", "condition", ",", "enabled", ")", "if", "self", ".", "pending_stop", "or", "IKBreakpoint", ".", "any_active_breakpoint", ":", "self", ".", "enable_tracing", "(", ")", "else", ":", "self", ".", "disable_tracing", "(", ")", "return", "None", ",", "bp", ".", "number" ]

[ "Create", "a", "breakpoint", "register", "it", "in", "the", "class", "s", "lists", "and", "returns", "a", "tuple", "of", "(", "error_message", "break_number", ")" ]

[ "def", "example_delete_topics", "(", "a", ",", "topics", ")", ":", "# Call delete_topics to asynchronously delete topics, a future is returned.", "# By default this operation on the broker returns immediately while", "# topics are deleted in the background. But here we give it some time (30s)", "# to propagate in the cluster before returning.", "#", "# Returns a dict of <topic,future>.", "fs", "=", "a", ".", "delete_topics", "(", "topics", ",", "operation_timeout", "=", "30", ")", "# Wait for operation to finish.", "for", "topic", ",", "f", "in", "fs", ".", "items", "(", ")", ":", "try", ":", "f", ".", "result", "(", ")", "# The result itself is None", "print", "(", "\"Topic {} deleted\"", ".", "format", "(", "topic", ")", ")", "except", "Exception", "as", "e", ":", "print", "(", "\"Failed to delete topic {}: {}\"", ".", "format", "(", "topic", ",", "e", ")", ")" ]

[ "delete", "topics" ]

[ "def", "condition_to_lambda", "(", "condition", ",", "default", "=", "False", ")", ":", "if", "condition", "is", "None", ":", "condition_function", "=", "lambda", "state", ":", "default", "static_addrs", "=", "set", "(", ")", "elif", "isinstance", "(", "condition", ",", "int", ")", ":", "return", "condition_to_lambda", "(", "(", "condition", ",", ")", ")", "elif", "isinstance", "(", "condition", ",", "(", "tuple", ",", "set", ",", "list", ")", ")", ":", "static_addrs", "=", "set", "(", "condition", ")", "def", "condition_function", "(", "state", ")", ":", "if", "state", ".", "addr", "in", "static_addrs", ":", "# returning {state.addr} instead of True to properly handle find/avoid conflicts", "return", "{", "state", ".", "addr", "}", "if", "not", "isinstance", "(", "state", ".", "project", ".", "engines", ".", "default_engine", ",", "engines", ".", "SimEngineVEX", ")", ":", "return", "False", "try", ":", "# If the address is not in the set (which could mean it is", "# not at the top of a block), check directly in the blocks", "# (Blocks are repeatedly created for every check, but with", "# the IRSB cache in angr lifter it should be OK.)", "return", "static_addrs", ".", "intersection", "(", "set", "(", "state", ".", "block", "(", ")", ".", "instruction_addrs", ")", ")", "except", "(", "AngrError", ",", "SimError", ")", ":", "return", "False", "elif", "hasattr", "(", "condition", ",", "'__call__'", ")", ":", "condition_function", "=", "condition", "static_addrs", "=", "None", "else", ":", "raise", "AngrExplorationTechniqueError", "(", "\"ExplorationTechnique is unable to convert given type (%s) to a callable condition function.\"", "%", "condition", ".", "__class__", ")", "return", "condition_function", ",", "static_addrs" ]

[ "Translates", "an", "integer", "set", "list", "or", "function", "into", "a", "lambda", "that", "checks", "if", "state", "s", "current", "basic", "block", "matches", "some", "condition", "." ]

[ "def", "_le_circle", "(", "self", ",", "annot", ",", "p1", ",", "p2", ",", "lr", ")", ":", "m", ",", "im", ",", "L", ",", "R", ",", "w", ",", "scol", ",", "fcol", ",", "opacity", "=", "self", ".", "_le_annot_parms", "(", "annot", ",", "p1", ",", "p2", ")", "shift", "=", "2.5", "# 2*shift*width = length of square edge", "d", "=", "shift", "*", "max", "(", "1", ",", "w", ")", "M", "=", "R", "-", "(", "d", "/", "2.", ",", "0", ")", "if", "lr", "else", "L", "+", "(", "d", "/", "2.", ",", "0", ")", "r", "=", "Rect", "(", "M", ",", "M", ")", "+", "(", "-", "d", ",", "-", "d", ",", "d", ",", "d", ")", "# the square", "ap", "=", "\"q\\n\"", "+", "opacity", "+", "self", ".", "_oval_string", "(", "r", ".", "tl", "*", "im", ",", "r", ".", "tr", "*", "im", ",", "r", ".", "br", "*", "im", ",", "r", ".", "bl", "*", "im", ")", "ap", "+=", "\"%g w\\n\"", "%", "w", "ap", "+=", "scol", "+", "fcol", "+", "\"b\\nQ\\n\"", "return", "ap" ]

[ "Make", "stream", "commands", "for", "circle", "line", "end", "symbol", ".", "lr", "denotes", "left", "(", "False", ")", "or", "right", "point", "." ]

[ "def", "display_boxes", "(", "self", ",", "pdf_file", ",", "boxes", ",", "alternate_colors", "=", "False", ")", ":", "imgs", "=", "[", "]", "colors", "=", "[", "Color", "(", "\"blue\"", ")", ",", "Color", "(", "\"red\"", ")", "]", "boxes_per_page", "=", "defaultdict", "(", "int", ")", "boxes_by_page", "=", "defaultdict", "(", "list", ")", "for", "i", ",", "(", "page", ",", "top", ",", "left", ",", "bottom", ",", "right", ")", "in", "enumerate", "(", "boxes", ")", ":", "boxes_per_page", "[", "page", "]", "+=", "1", "boxes_by_page", "[", "page", "]", ".", "append", "(", "(", "top", ",", "left", ",", "bottom", ",", "right", ")", ")", "for", "i", ",", "page_num", "in", "enumerate", "(", "boxes_per_page", ".", "keys", "(", ")", ")", ":", "img", "=", "pdf_to_img", "(", "pdf_file", ",", "page_num", ")", "draw", "=", "Drawing", "(", ")", "draw", ".", "fill_color", "=", "Color", "(", "\"rgba(0, 0, 0, 0.0)\"", ")", "for", "j", ",", "(", "top", ",", "left", ",", "bottom", ",", "right", ")", "in", "enumerate", "(", "boxes_by_page", "[", "page_num", "]", ")", ":", "draw", ".", "stroke_color", "=", "colors", "[", "j", "%", "2", "]", "if", "alternate_colors", "else", "colors", "[", "0", "]", "draw", ".", "rectangle", "(", "left", "=", "left", ",", "top", "=", "top", ",", "right", "=", "right", ",", "bottom", "=", "bottom", ")", "draw", "(", "img", ")", "imgs", ".", "append", "(", "img", ")", "return", "imgs" ]

[ "Displays", "each", "of", "the", "bounding", "boxes", "passed", "in", "boxes", "on", "images", "of", "the", "pdf", "pointed", "to", "by", "pdf_file", "boxes", "is", "a", "list", "of", "5", "-", "tuples", "(", "page", "top", "left", "bottom", "right", ")" ]

[ "def", "pack", "(", "self", ",", "data", ")", ":", "try", ":", "return", "self", ".", "pack_any", "(", "data", ")", "except", "KeyError", "as", "e", ":", "raise", "Error", "(", "'{} not found in data dictionary'", ".", "format", "(", "str", "(", "e", ")", ")", ")" ]

[ "See", ":", "func", ":", "~bitstruct", ".", "pack_dict", "()", "." ]

[ "def", "_decode_step", "(", "self", ",", "prev_word", ":", "mx", ".", "nd", ".", "NDArray", ",", "step", ":", "int", ",", "source_length", ":", "int", ",", "states", ":", "List", "[", "ModelState", "]", ",", "models_output_layer_w", ":", "List", "[", "mx", ".", "nd", ".", "NDArray", "]", ",", "models_output_layer_b", ":", "List", "[", "mx", ".", "nd", ".", "NDArray", "]", ")", "->", "Tuple", "[", "mx", ".", "nd", ".", "NDArray", ",", "mx", ".", "nd", ".", "NDArray", ",", "List", "[", "ModelState", "]", "]", ":", "bucket_key", "=", "(", "source_length", ",", "step", ")", "model_outs", ",", "model_attention_probs", ",", "model_states", "=", "[", "]", ",", "[", "]", ",", "[", "]", "# We use zip_longest here since we'll have empty lists when not using restrict_lexicon", "for", "model", ",", "out_w", ",", "out_b", ",", "state", "in", "itertools", ".", "zip_longest", "(", "self", ".", "models", ",", "models_output_layer_w", ",", "models_output_layer_b", ",", "states", ")", ":", "decoder_out", ",", "attention_probs", ",", "state", "=", "model", ".", "run_decoder", "(", "prev_word", ",", "bucket_key", ",", "state", ")", "# Compute logits and softmax with restricted vocabulary", "if", "self", ".", "restrict_lexicon", ":", "# Apply output layer outside decoder module.", "logits", "=", "model", ".", "output_layer", "(", "decoder_out", ",", "out_w", ",", "out_b", ")", "if", "model", ".", "skip_softmax", ":", "model_out", "=", "logits", "# raw logits", "else", ":", "model_out", "=", "mx", ".", "nd", ".", "softmax", "(", "logits", ")", "# normalized probabilities", "else", ":", "# Output layer is applied inside decoder module.", "# if model.skip_softmax decoder_out represents logits, normalized probabilities else.", "model_out", "=", "decoder_out", "model_outs", ".", "append", "(", "model_out", ")", "model_attention_probs", ".", "append", "(", "attention_probs", ")", "model_states", ".", "append", "(", "state", ")", "scores", ",", "attention_probs", "=", "self", ".", "_combine_predictions", "(", "model_outs", ",", "model_attention_probs", ")", "return", "scores", ",", "attention_probs", ",", "model_states" ]

[ "Returns", "decoder", "predictions", "(", "combined", "from", "all", "models", ")", "attention", "scores", "and", "updated", "states", "." ]

[ "def", "do_folder_create", "(", "client", ",", "args", ")", ":", "for", "folder_uri", "in", "args", ".", "uris", ":", "client", ".", "create_folder", "(", "folder_uri", ",", "recursive", "=", "True", ")", "return", "True" ]

[ "Create", "directory" ]

[ "def", "user_return", "(", "self", ",", "frame", ",", "return_value", ")", ":", "# This is useful when debugging in an active interpreter (otherwise,", "# the debugger will stop before reaching the target file)", "if", "self", ".", "_wait_for_mainpyfile", ":", "if", "(", "self", ".", "mainpyfile", "!=", "self", ".", "canonic", "(", "frame", ".", "f_code", ".", "co_filename", ")", "or", "frame", ".", "f_lineno", "<=", "0", ")", ":", "return", "self", ".", "_wait_for_mainpyfile", "=", "0", "self", ".", "_old_Pdb_user_return", "(", "frame", ",", "return_value", ")" ]

[ "This", "function", "is", "called", "when", "a", "return", "trap", "is", "set", "here", "." ]

[ "def", "_read_neuralev", "(", "filename", ",", "read_markers", "=", "False", ",", "trigger_bits", "=", "16", ",", "trigger_zero", "=", "True", ")", ":", "hdr", "=", "{", "}", "with", "open", "(", "filename", ",", "'rb'", ")", "as", "f", ":", "BasicHdr", "=", "f", ".", "read", "(", "336", ")", "i1", "=", "8", "hdr", "[", "'FileTypeID'", "]", "=", "BasicHdr", "[", ":", "i1", "]", ".", "decode", "(", "'utf-8'", ")", "assert", "hdr", "[", "'FileTypeID'", "]", "==", "'NEURALEV'", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "filespec", "=", "unpack", "(", "'bb'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "hdr", "[", "'FileSpec'", "]", "=", "str", "(", "filespec", "[", "0", "]", ")", "+", "'.'", "+", "str", "(", "filespec", "[", "1", "]", ")", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "hdr", "[", "'Flags'", "]", "=", "unpack", "(", "'<H'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "hdr", "[", "'HeaderOffset'", "]", "=", "unpack", "(", "'<I'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "hdr", "[", "'PacketBytes'", "]", "=", "unpack", "(", "'<I'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "hdr", "[", "'TimeRes'", "]", "=", "unpack", "(", "'<I'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "hdr", "[", "'SampleRes'", "]", "=", "unpack", "(", "'<I'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "16", "time", "=", "unpack", "(", "'<'", "+", "'H'", "*", "8", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "hdr", "[", "'DateTimeRaw'", "]", "=", "time", "lg", ".", "warning", "(", "'DateTime is in local time with Central version <= 6.03'", "' and in UTC with Central version > 6.05'", ")", "hdr", "[", "'DateTime'", "]", "=", "datetime", "(", "time", "[", "0", "]", ",", "time", "[", "1", "]", ",", "time", "[", "3", "]", ",", "time", "[", "4", "]", ",", "time", "[", "5", "]", ",", "time", "[", "6", "]", ",", "time", "[", "7", "]", "*", "1000", ")", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "32", "# hdr['Application'] = _str(BasicHdr[i0:i1].decode('utf-8'))", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "256", "hdr", "[", "'Comment'", "]", "=", "_str", "(", "BasicHdr", "[", "i0", ":", "i1", "]", ".", "decode", "(", "'utf-8'", ",", "errors", "=", "'replace'", ")", ")", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "countExtHeader", "=", "unpack", "(", "'<I'", ",", "BasicHdr", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "# you can read subject name from sif", "# Check data duration", "f", ".", "seek", "(", "-", "hdr", "[", "'PacketBytes'", "]", ",", "SEEK_END", ")", "hdr", "[", "'DataDuration'", "]", "=", "unpack", "(", "'<I'", ",", "f", ".", "read", "(", "4", ")", ")", "[", "0", "]", "hdr", "[", "'DataDurationSec'", "]", "=", "hdr", "[", "'DataDuration'", "]", "/", "hdr", "[", "'SampleRes'", "]", "# Read the Extended Header", "f", ".", "seek", "(", "336", ")", "ElectrodesInfo", "=", "[", "]", "IOLabels", "=", "[", "]", "for", "i", "in", "range", "(", "countExtHeader", ")", ":", "ExtendedHeader", "=", "f", ".", "read", "(", "32", ")", "i1", "=", "8", "PacketID", "=", "ExtendedHeader", "[", ":", "i1", "]", ".", "decode", "(", "'utf-8'", ")", "if", "PacketID", "==", "'NEUEVWAV'", ":", "elec", "=", "{", "}", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "elec", "[", "'ElectrodeID'", "]", "=", "unpack", "(", "'<H'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "1", "elec", "[", "'ConnectorBank'", "]", "=", "chr", "(", "ExtendedHeader", "[", "i0", "]", "+", "64", ")", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "1", "elec", "[", "'ConnectorPin'", "]", "=", "ExtendedHeader", "[", "i0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "df", "=", "unpack", "(", "'<h'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "# This is a workaround for the DigitalFactor overflow", "if", "df", "==", "21516", ":", "elec", "[", "'DigitalFactor'", "]", "=", "152592.547", "else", ":", "elec", "[", "'DigitalFactor'", "]", "=", "df", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "elec", "[", "'EnergyThreshold'", "]", "=", "unpack", "(", "'<H'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "elec", "[", "'HighThreshold'", "]", "=", "unpack", "(", "'<h'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "elec", "[", "'LowThreshold'", "]", "=", "unpack", "(", "'<h'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "1", "elec", "[", "'Units'", "]", "=", "ExtendedHeader", "[", "i0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "1", "elec", "[", "'WaveformBytes'", "]", "=", "ExtendedHeader", "[", "i0", "]", "ElectrodesInfo", ".", "append", "(", "elec", ")", "elif", "PacketID", "==", "'NEUEVLBL'", ":", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "ElectrodeID", "=", "unpack", "(", "'<H'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "-", "1", "s", "=", "_str", "(", "ExtendedHeader", "[", "i1", ":", "]", ".", "decode", "(", "'utf-8'", ")", ")", "ElectrodesInfo", "[", "ElectrodeID", "]", "[", "'ElectrodeLabel'", "]", "=", "s", "elif", "PacketID", "==", "'NEUEVFLT'", ":", "elec", "=", "{", "}", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "ElectrodeID", "=", "unpack", "(", "'<H'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "-", "1", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "elec", "[", "'HighFreqCorner'", "]", "=", "unpack", "(", "'<I'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "elec", "[", "'HighFreqOrder'", "]", "=", "unpack", "(", "'<I'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "elec", "[", "'HighFilterType'", "]", "=", "unpack", "(", "'<H'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "elec", "[", "'LowFreqCorner'", "]", "=", "unpack", "(", "'<I'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "4", "elec", "[", "'LowFreqOrder'", "]", "=", "unpack", "(", "'<I'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "i0", ",", "i1", "=", "i1", ",", "i1", "+", "2", "elec", "[", "'LowFilterType'", "]", "=", "unpack", "(", "'<H'", ",", "ExtendedHeader", "[", "i0", ":", "i1", "]", ")", "[", "0", "]", "ElectrodesInfo", "[", "ElectrodeID", "]", ".", "update", "(", "elec", ")", "elif", "PacketID", "==", "'DIGLABEL'", ":", "# TODO: the order is not taken into account and probably wrong!", "iolabel", "=", "{", "}", "iolabel", "[", "'mode'", "]", "=", "ExtendedHeader", "[", "24", "]", "+", "1", "s", "=", "_str", "(", "ExtendedHeader", "[", "8", ":", "25", "]", ".", "decode", "(", "'utf-8'", ")", ")", "iolabel", "[", "'label'", "]", "=", "s", "IOLabels", ".", "append", "(", "iolabel", ")", "else", ":", "raise", "NotImplementedError", "(", "PacketID", "+", "' not implemented yet'", ")", "hdr", "[", "'ChannelID'", "]", "=", "[", "x", "[", "'ElectrodeID'", "]", "for", "x", "in", "ElectrodesInfo", "]", "fExtendedHeader", "=", "f", ".", "tell", "(", ")", "fData", "=", "f", ".", "seek", "(", "0", ",", "SEEK_END", ")", "countDataPacket", "=", "int", "(", "(", "fData", "-", "fExtendedHeader", ")", "/", "hdr", "[", "'PacketBytes'", "]", ")", "markers", "=", "[", "]", "if", "read_markers", "and", "countDataPacket", ":", "f", ".", "seek", "(", "fExtendedHeader", ")", "x", "=", "f", ".", "read", "(", "countDataPacket", "*", "hdr", "[", "'PacketBytes'", "]", ")", "DigiValues", "=", "[", "]", "for", "j", "in", "range", "(", "countDataPacket", ")", ":", "i", "=", "j", "*", "hdr", "[", "'PacketBytes'", "]", "if", "trigger_bits", "==", "16", ":", "tempDigiVals", "=", "unpack", "(", "'<H'", ",", "x", "[", "8", "+", "i", ":", "10", "+", "i", "]", ")", "[", "0", "]", "else", ":", "tempDigiVals", "=", "unpack", "(", "'<H'", ",", "x", "[", "8", "+", "i", ":", "9", "+", "i", "]", "+", "b'\\x00'", ")", "[", "0", "]", "val", "=", "{", "'timestamp'", ":", "unpack", "(", "'<I'", ",", "x", "[", "0", "+", "i", ":", "4", "+", "i", "]", ")", "[", "0", "]", ",", "'packetID'", ":", "unpack", "(", "'<H'", ",", "x", "[", "4", "+", "i", ":", "6", "+", "i", "]", ")", "[", "0", "]", ",", "'tempClassOrReason'", ":", "unpack", "(", "'<B'", ",", "x", "[", "6", "+", "i", ":", "7", "+", "i", "]", ")", "[", "0", "]", ",", "'tempDigiVals'", ":", "tempDigiVals", "}", "if", "tempDigiVals", "!=", "0", "or", "False", ":", "DigiValues", ".", "append", "(", "val", ")", "digserPacketID", "=", "0", "not_serialdigital", "=", "[", "x", "for", "x", "in", "DigiValues", "if", "not", "x", "[", "'packetID'", "]", "==", "digserPacketID", "]", "if", "not_serialdigital", ":", "lg", ".", "debug", "(", "'Code not implemented to read PacketID '", "+", "str", "(", "not_serialdigital", "[", "0", "]", "[", "'packetID'", "]", ")", ")", "# convert to markers", "for", "val", "in", "DigiValues", ":", "m", "=", "{", "'name'", ":", "str", "(", "val", "[", "'tempDigiVals'", "]", ")", ",", "'start'", ":", "val", "[", "'timestamp'", "]", "/", "hdr", "[", "'SampleRes'", "]", ",", "'end'", ":", "val", "[", "'timestamp'", "]", "/", "hdr", "[", "'SampleRes'", "]", ",", "'chan'", ":", "[", "''", "]", ",", "}", "markers", ".", "append", "(", "m", ")", "if", "read_markers", ":", "return", "markers", "else", ":", "return", "hdr" ]

[ "Read", "some", "information", "from", "NEV" ]

[ "def", "relative_bin_deviation", "(", "h1", ",", "h2", ")", ":", "# 79 us @array, 104 us @list \\w 100 bins", "h1", ",", "h2", "=", "__prepare_histogram", "(", "h1", ",", "h2", ")", "numerator", "=", "scipy", ".", "sqrt", "(", "scipy", ".", "square", "(", "h1", "-", "h2", ")", ")", "denominator", "=", "(", "scipy", ".", "sqrt", "(", "scipy", ".", "square", "(", "h1", ")", ")", "+", "scipy", ".", "sqrt", "(", "scipy", ".", "square", "(", "h2", ")", ")", ")", "/", "2.", "old_err_state", "=", "scipy", ".", "seterr", "(", "invalid", "=", "'ignore'", ")", "# divide through zero only occurs when the bin is zero in both histograms, in which case the division is 0/0 and leads to (and should lead to) 0", "result", "=", "numerator", "/", "denominator", "scipy", ".", "seterr", "(", "*", "*", "old_err_state", ")", "result", "[", "scipy", ".", "isnan", "(", "result", ")", "]", "=", "0", "# faster than scipy.nan_to_num, which checks for +inf and -inf also", "return", "scipy", ".", "sum", "(", "result", ")" ]

[ "r", "Calculate", "the", "bin", "-", "wise", "deviation", "between", "two", "histograms", ".", "The", "relative", "bin", "deviation", "between", "two", "histograms", ":", "math", ":", "H", "and", ":", "math", ":", "H", "of", "size", ":", "math", ":", "m", "is", "defined", "as", ":", "..", "math", "::", "d_", "{", "rbd", "}", "(", "H", "H", ")", "=", "\\", "sum_", "{", "m", "=", "1", "}", "^M", "\\", "frac", "{", "\\", "sqrt", "{", "(", "H_m", "-", "H", "_m", ")", "^2", "}", "}", "{", "\\", "frac", "{", "1", "}", "{", "2", "}", "\\", "left", "(", "\\", "sqrt", "{", "H_m^2", "}", "+", "\\", "sqrt", "{{", "H", "}", "_m^2", "}", "\\", "right", ")", "}", "*", "Attributes", ":", "*" ]

[ "def", "possible_params", "(", "self", ")", ":", "return", "self", ".", "params", "if", "isinstance", "(", "self", ".", "params", ",", "list", ")", "else", "[", "self", ".", "params", "]" ]

[ "Used", "when", "assuming", "params", "is", "a", "list", "." ]

[ "def", "on", "(", "self", ",", "eventName", ",", "cb", ")", ":", "self", ".", "eventHandlers", "[", "eventName", "]", "=", "cb", "return", "self", ".", "_send", "(", "{", "\"id\"", ":", "self", ".", "igv_id", ",", "\"command\"", ":", "\"on\"", ",", "\"eventName\"", ":", "eventName", "}", ")" ]

[ "Subscribe", "to", "an", "igv", ".", "js", "event", "." ]

[ "async", "def", "find", "(", "self", ",", "seq_set", ":", "SequenceSet", ",", "selected", ":", "SelectedMailbox", ",", "requirement", ":", "FetchRequirement", "=", "FetchRequirement", ".", "METADATA", ")", "->", "AsyncIterable", "[", "Tuple", "[", "int", ",", "MessageT", "]", "]", ":", "for", "seq", ",", "cached_msg", "in", "selected", ".", "messages", ".", "get_all", "(", "seq_set", ")", ":", "msg", "=", "await", "self", ".", "get", "(", "cached_msg", ".", "uid", ",", "cached_msg", ",", "requirement", ")", "if", "msg", "is", "not", "None", ":", "yield", "(", "seq", ",", "msg", ")" ]

[ "Find", "the", "active", "message", "UID", "and", "message", "pairs", "in", "the", "mailbox", "that", "are", "contained", "in", "the", "given", "sequences", "set", ".", "Message", "sequence", "numbers", "are", "resolved", "by", "the", "selected", "mailbox", "session", "." ]

[ "def", "set_border_type", "(", "self", ",", "clazz", ",", "weight", "=", "DefaultWeight", ",", "color", "=", "None", ",", "cap", "=", "None", ",", "dashes", "=", "None", ",", "join", "=", "None", ",", "count", "=", "None", ",", "space", "=", "None", ")", ":", "args", "=", "locals", "(", ")", "args", ".", "pop", "(", "'clazz'", ")", "args", ".", "pop", "(", "'self'", ")", "clazz", "(", "*", "*", "args", ")", ".", "apply", "(", "self", ")" ]

[ "example", ":", "set_border_type", "(", "BorderTypePartialRows", ")", "would", "set", "a", "border", "above", "and", "below", "each", "row", "in", "the", "range" ]

[ "def", "to_underscore", "(", "s", ")", ":", "return", "re", ".", "sub", "(", "r'(?!^)([A-Z]+)'", ",", "lambda", "m", ":", "\"_{0}\"", ".", "format", "(", "m", ".", "group", "(", "1", ")", ".", "lower", "(", ")", ")", ",", "re", ".", "sub", "(", "r'(?!^)([A-Z]{1}[a-z]{1})'", ",", "lambda", "m", ":", "\"_{0}\"", ".", "format", "(", "m", ".", "group", "(", "1", ")", ".", "lower", "(", ")", ")", ",", "s", ")", ")", ".", "lower", "(", ")" ]

[ "Transform", "camel", "or", "pascal", "case", "to", "underscore", "separated", "string" ]

[ "def", "ifind_first_object", "(", "self", ",", "ObjectClass", ",", "*", "*", "kwargs", ")", ":", "# Call regular find() if USER_IFIND_MODE is nocase_collation", "if", "self", ".", "user_manager", ".", "USER_IFIND_MODE", "==", "'nocase_collation'", ":", "return", "self", ".", "find_first_object", "(", "ObjectClass", ",", "*", "*", "kwargs", ")", "# Convert each name/value pair in 'kwargs' into a filter", "query", "=", "ObjectClass", ".", "query", "for", "field_name", ",", "field_value", "in", "kwargs", ".", "items", "(", ")", ":", "# Make sure that ObjectClass has a 'field_name' property", "field", "=", "getattr", "(", "ObjectClass", ",", "field_name", ",", "None", ")", "if", "field", "is", "None", ":", "raise", "KeyError", "(", "\"BaseAlchemyAdapter.find_first_object(): Class '%s' has no field '%s'.\"", "%", "(", "ObjectClass", ",", "field_name", ")", ")", "# Add a case sensitive filter to the query", "query", "=", "query", ".", "filter", "(", "field", ".", "ifind", "(", "field_value", ")", ")", "# case insensitive!!", "# Execute query", "return", "query", ".", "first", "(", ")" ]

[ "Retrieve", "the", "first", "object", "of", "type", "ObjectClass", "matching", "the", "specified", "filters", "in", "**", "kwargs", "--", "case", "insensitive", "." ]

[ "def", "keep_indels", "(", "mut_df", ",", "indel_len_col", "=", "True", ",", "indel_type_col", "=", "True", ")", ":", "# keep only frameshifts", "mut_df", "=", "mut_df", "[", "is_indel_annotation", "(", "mut_df", ")", "]", "if", "indel_len_col", ":", "# calculate length", "mut_df", ".", "loc", "[", ":", ",", "'indel len'", "]", "=", "compute_indel_length", "(", "mut_df", ")", "if", "indel_type_col", ":", "is_ins", "=", "mut_df", "[", "'Reference_Allele'", "]", "==", "'-'", "is_del", "=", "mut_df", "[", "'Tumor_Allele'", "]", "==", "'-'", "mut_df", "[", "'indel type'", "]", "=", "''", "mut_df", ".", "loc", "[", "is_ins", ",", "'indel type'", "]", "=", "'INS'", "mut_df", ".", "loc", "[", "is_del", ",", "'indel type'", "]", "=", "'DEL'", "return", "mut_df" ]

[ "Filters", "out", "all", "mutations", "that", "are", "not", "indels", "." ]

[ "def", "approve", "(", "self", ",", "allowed_address", ":", "Address", ",", "allowance", ":", "TokenAmount", ",", ")", ":", "# Note that given_block_identifier is not used here as there", "# are no preconditions to check before sending the transaction", "log_details", "=", "{", "'node'", ":", "pex", "(", "self", ".", "node_address", ")", ",", "'contract'", ":", "pex", "(", "self", ".", "address", ")", ",", "'allowed_address'", ":", "pex", "(", "allowed_address", ")", ",", "'allowance'", ":", "allowance", ",", "}", "checking_block", "=", "self", ".", "client", ".", "get_checking_block", "(", ")", "error_prefix", "=", "'Call to approve will fail'", "gas_limit", "=", "self", ".", "proxy", ".", "estimate_gas", "(", "checking_block", ",", "'approve'", ",", "to_checksum_address", "(", "allowed_address", ")", ",", "allowance", ",", ")", "if", "gas_limit", ":", "error_prefix", "=", "'Call to approve failed'", "log", ".", "debug", "(", "'approve called'", ",", "*", "*", "log_details", ")", "transaction_hash", "=", "self", ".", "proxy", ".", "transact", "(", "'approve'", ",", "safe_gas_limit", "(", "gas_limit", ")", ",", "to_checksum_address", "(", "allowed_address", ")", ",", "allowance", ",", ")", "self", ".", "client", ".", "poll", "(", "transaction_hash", ")", "receipt_or_none", "=", "check_transaction_threw", "(", "self", ".", "client", ",", "transaction_hash", ")", "transaction_executed", "=", "gas_limit", "is", "not", "None", "if", "not", "transaction_executed", "or", "receipt_or_none", ":", "if", "transaction_executed", ":", "block", "=", "receipt_or_none", "[", "'blockNumber'", "]", "else", ":", "block", "=", "checking_block", "self", ".", "proxy", ".", "jsonrpc_client", ".", "check_for_insufficient_eth", "(", "transaction_name", "=", "'approve'", ",", "transaction_executed", "=", "transaction_executed", ",", "required_gas", "=", "GAS_REQUIRED_FOR_APPROVE", ",", "block_identifier", "=", "block", ",", ")", "msg", "=", "self", ".", "_check_why_approved_failed", "(", "allowance", ",", "block", ")", "error_msg", "=", "f'{error_prefix}. {msg}'", "log", ".", "critical", "(", "error_msg", ",", "*", "*", "log_details", ")", "raise", "RaidenUnrecoverableError", "(", "error_msg", ")", "log", ".", "info", "(", "'approve successful'", ",", "*", "*", "log_details", ")" ]

[ "Aprove", "allowed_address", "to", "transfer", "up", "to", "deposit", "amount", "of", "token", "." ]

[ "def", "add_nodes", "(", "self", ",", "nodes", ")", ":", "# noqa: D302", "self", ".", "_validate_nodes_with_data", "(", "nodes", ")", "nodes", "=", "nodes", "if", "isinstance", "(", "nodes", ",", "list", ")", "else", "[", "nodes", "]", "# Create root node (if needed)", "if", "not", "self", ".", "root_name", ":", "self", ".", "_set_root_name", "(", "nodes", "[", "0", "]", "[", "\"name\"", "]", ".", "split", "(", "self", ".", "_node_separator", ")", "[", "0", "]", ".", "strip", "(", ")", ")", "self", ".", "_root_hierarchy_length", "=", "len", "(", "self", ".", "root_name", ".", "split", "(", "self", ".", "_node_separator", ")", ")", "self", ".", "_create_node", "(", "name", "=", "self", ".", "root_name", ",", "parent", "=", "\"\"", ",", "children", "=", "[", "]", ",", "data", "=", "[", "]", ")", "# Process new data", "for", "node_dict", "in", "nodes", ":", "name", ",", "data", "=", "node_dict", "[", "\"name\"", "]", ",", "node_dict", "[", "\"data\"", "]", "if", "name", "not", "in", "self", ".", "_db", ":", "# Validate node name (root of new node same as tree root)", "if", "not", "name", ".", "startswith", "(", "self", ".", "root_name", "+", "self", ".", "_node_separator", ")", ":", "raise", "ValueError", "(", "\"Illegal node name: {0}\"", ".", "format", "(", "name", ")", ")", "self", ".", "_create_intermediate_nodes", "(", "name", ")", "self", ".", "_db", "[", "name", "]", "[", "\"data\"", "]", "+=", "copy", ".", "deepcopy", "(", "data", "if", "isinstance", "(", "data", ",", "list", ")", "and", "data", "else", "(", "[", "]", "if", "isinstance", "(", "data", ",", "list", ")", "else", "[", "data", "]", ")", ")" ]

[ "r", "Add", "nodes", "to", "tree", "." ]

[ "def", "check_child_friendly", "(", "self", ",", "name", ")", ":", "name", "=", "name", ".", "split", "(", ")", "[", "0", "]", "if", "name", "in", "self", ".", "container_modules", ":", "return", "root", "=", "os", ".", "path", ".", "dirname", "(", "os", ".", "path", ".", "realpath", "(", "__file__", ")", ")", "module_path", "=", "os", ".", "path", ".", "join", "(", "root", ",", "\"modules\"", ")", "try", ":", "info", "=", "imp", ".", "find_module", "(", "name", ",", "[", "module_path", "]", ")", "except", "ImportError", ":", "return", "if", "not", "info", ":", "return", "(", "file", ",", "pathname", ",", "description", ")", "=", "info", "try", ":", "py_mod", "=", "imp", ".", "load_module", "(", "name", ",", "file", ",", "pathname", ",", "description", ")", "except", "Exception", ":", "# We cannot load the module! We could error out here but then the", "# user gets informed that the problem is with their config. This", "# is not correct. Better to say that all is well and then the", "# config can get parsed and py3status loads. The error about the", "# failing module load is better handled at that point, and will be.", "return", "try", ":", "container", "=", "py_mod", ".", "Py3status", ".", "Meta", ".", "container", "except", "AttributeError", ":", "container", "=", "False", "# delete the module", "del", "py_mod", "if", "container", ":", "self", ".", "container_modules", ".", "append", "(", "name", ")", "else", ":", "self", ".", "error", "(", "\"Module `{}` cannot contain others\"", ".", "format", "(", "name", ")", ")" ]

[ "Check", "if", "a", "module", "is", "a", "container", "and", "so", "can", "have", "children" ]

[ "def", "make_interactive_tree", "(", "matrix", "=", "None", ",", "labels", "=", "None", ")", ":", "from", "scipy", ".", "cluster", ".", "hierarchy", "import", "(", "dendrogram", ",", "linkage", ",", "to_tree", ")", "d3", "=", "None", "from", "scipy", ".", "cluster", ".", "hierarchy", "import", "cophenet", "from", "scipy", ".", "spatial", ".", "distance", "import", "pdist", "if", "isinstance", "(", "matrix", ",", "pandas", ".", "DataFrame", ")", ":", "Z", "=", "linkage", "(", "matrix", ",", "'ward'", ")", "# clusters", "T", "=", "to_tree", "(", "Z", ",", "rd", "=", "False", ")", "if", "labels", "==", "None", ":", "labels", "=", "matrix", ".", "index", ".", "tolist", "(", ")", "lookup", "=", "dict", "(", "zip", "(", "range", "(", "len", "(", "labels", ")", ")", ",", "labels", ")", ")", "# Create a dendrogram object without plotting", "dend", "=", "dendrogram", "(", "Z", ",", "no_plot", "=", "True", ",", "orientation", "=", "\"right\"", ",", "leaf_rotation", "=", "90.", ",", "# rotates the x axis labels", "leaf_font_size", "=", "8.", ",", "# font size for the x axis labels", "labels", "=", "labels", ")", "d3", "=", "dict", "(", "children", "=", "[", "]", ",", "name", "=", "\"root\"", ")", "add_node", "(", "T", ",", "d3", ")", "label_tree", "(", "d3", "[", "\"children\"", "]", "[", "0", "]", ",", "lookup", ")", "else", ":", "bot", ".", "warning", "(", "'Please provide data as pandas Data Frame.'", ")", "return", "d3" ]

[ "make", "interactive", "tree", "will", "return", "complete", "html", "for", "an", "interactive", "tree", ":", "param", "title", ":", "a", "title", "for", "the", "plot", "if", "not", "defined", "will", "be", "left", "out", "." ]

[ "def", "lreg", "(", "self", ",", "xcol", ",", "ycol", ",", "name", "=", "\"Regression\"", ")", ":", "try", ":", "x", "=", "self", ".", "df", "[", "xcol", "]", ".", "values", ".", "reshape", "(", "-", "1", ",", "1", ")", "y", "=", "self", ".", "df", "[", "ycol", "]", "lm", "=", "linear_model", ".", "LinearRegression", "(", ")", "lm", ".", "fit", "(", "x", ",", "y", ")", "predictions", "=", "lm", ".", "predict", "(", "x", ")", "self", ".", "df", "[", "name", "]", "=", "predictions", "except", "Exception", "as", "e", ":", "self", ".", "err", "(", "e", ",", "\"Can not calculate linear regression\"", ")" ]

[ "Add", "a", "column", "to", "the", "main", "dataframe", "populted", "with", "the", "model", "s", "linear", "regression", "for", "a", "column" ]

[ "def", "formatBitData", "(", "self", ",", "pos", ",", "width1", ",", "width2", "=", "0", ")", ":", "result", "=", "[", "]", "#make empty prefix code explicit", "if", "width1", "==", "0", ":", "result", "=", "[", "'()'", ",", "','", "]", "for", "width", "in", "width1", ",", "width2", ":", "#skip empty width2", "if", "width", "==", "0", ":", "continue", "#build result backwards in a list", "while", "width", ">", "0", ":", "availableBits", "=", "8", "-", "(", "pos", "&", "7", ")", "if", "width", "<", "availableBits", ":", "#read partial byte, beginning nor ending at boundary", "data", "=", "self", ".", "stream", ".", "data", "[", "pos", ">>", "3", "]", ">>", "(", "pos", "&", "7", ")", "&", "(", "1", "<<", "width", ")", "-", "1", "result", ".", "append", "(", "'{:0{}b}'", ".", "format", "(", "data", ",", "width", ")", ")", "elif", "availableBits", "<", "8", ":", "#read rest of byte, ending at boundary", "data", "=", "self", ".", "stream", ".", "data", "[", "pos", ">>", "3", "]", ">>", "(", "pos", "&", "7", ")", "result", ".", "append", "(", "'|{:0{}b}'", ".", "format", "(", "data", ",", "availableBits", ")", ")", "else", ":", "#read whole byte (in hex), beginning and ending at boundary", "data", "=", "self", ".", "stream", ".", "data", "[", "pos", ">>", "3", "]", "result", ".", "append", "(", "'|{:02X}h'", ".", "format", "(", "data", ")", ")", "width", "-=", "availableBits", "pos", "+=", "availableBits", "#if width overshot from the availableBits subtraction, fix it", "pos", "+=", "width", "#add comma to separate fields", "result", ".", "append", "(", "','", ")", "#concatenate pieces, reversed, skipping the last space", "return", "''", ".", "join", "(", "result", "[", "-", "2", ":", ":", "-", "1", "]", ")" ]

[ "Show", "formatted", "bit", "data", ":", "Bytes", "are", "separated", "by", "commas", "whole", "bytes", "are", "displayed", "in", "hex", ">>>", "Layout", "(", "olleke", ")", ".", "formatBitData", "(", "6", "2", "16", ")", "|00h|2Eh", "|00", ">>>", "Layout", "(", "olleke", ")", ".", "formatBitData", "(", "4", "1", "0", ")", "1" ]

[ "def", "paramsarray", "(", "self", ",", "value", ")", ":", "nparams", "=", "len", "(", "self", ".", "_index_to_param", ")", "assert", "(", "isinstance", "(", "value", ",", "scipy", ".", "ndarray", ")", "and", "value", ".", "ndim", "==", "1", ")", ",", "(", "\"paramsarray must be 1-dim ndarray\"", ")", "assert", "len", "(", "value", ")", "==", "nparams", ",", "(", "\"Assigning paramsarray to ndarray \"", "\"of the wrong length.\"", ")", "if", "(", "self", ".", "_paramsarray", "is", "not", "None", ")", "and", "all", "(", "value", "==", "self", ".", "_paramsarray", ")", ":", "return", "# do not need to do anything if value has not changed", "# build `newvalues` to pass to `updateParams`", "newvalues", "=", "{", "}", "vectorized_params", "=", "{", "}", "for", "(", "i", ",", "param", ")", "in", "self", ".", "_index_to_param", ".", "items", "(", ")", ":", "if", "isinstance", "(", "param", ",", "str", ")", ":", "newvalues", "[", "param", "]", "=", "float", "(", "value", "[", "i", "]", ")", "elif", "isinstance", "(", "param", ",", "tuple", ")", ":", "(", "iparam", ",", "iparamindex", ")", "=", "param", "if", "iparam", "in", "vectorized_params", ":", "assert", "iparamindex", "not", "in", "vectorized_params", "[", "iparam", "]", "vectorized_params", "[", "iparam", "]", "[", "iparamindex", "]", "=", "float", "(", "value", "[", "i", "]", ")", "else", ":", "vectorized_params", "[", "iparam", "]", "=", "{", "iparamindex", ":", "float", "(", "value", "[", "i", "]", ")", "}", "else", ":", "raise", "ValueError", "(", "\"Invalid param type\"", ")", "for", "(", "param", ",", "paramd", ")", "in", "vectorized_params", ".", "items", "(", ")", ":", "assert", "set", "(", "paramd", ".", "keys", "(", ")", ")", "==", "set", "(", "range", "(", "len", "(", "paramd", ")", ")", ")", "newvalues", "[", "param", "]", "=", "scipy", ".", "array", "(", "[", "paramd", "[", "i", "]", "for", "i", "in", "range", "(", "len", "(", "paramd", ")", ")", "]", ",", "dtype", "=", "'float'", ")", "self", ".", "updateParams", "(", "newvalues", ")", "self", ".", "_paramsarray", "=", "self", ".", "paramsarray" ]

[ "Set", "new", "paramsarray", "and", "update", "via", "updateParams", "." ]

[ "def", "execute_command_in_message", "(", "controller", ",", "cliargs", ",", "clioptions", ",", "message", ")", ":", "SUPPORTED_COMMANDS", "=", "[", "'start'", "]", "# , 'stop'] # TODO", "print", "(", "message", ")", "# args and options from SushiBar overrride command line args and options", "args", "=", "cliargs", "options", "=", "clioptions", "if", "'args'", "in", "message", ":", "args", ".", "update", "(", "message", "[", "'args'", "]", ")", "if", "'options'", "in", "message", ":", "options", ".", "update", "(", "message", "[", "'options'", "]", ")", "if", "message", "[", "'command'", "]", "==", "'start'", ":", "if", "not", "controller", ".", "thread", "or", "not", "controller", ".", "thread", ".", "isAlive", "(", ")", ":", "controller", ".", "thread", "=", "threading", ".", "Thread", "(", "target", "=", "controller", ".", "chef", ".", "run", ",", "args", "=", "(", "args", ",", "options", ")", ",", ")", "controller", ".", "thread", ".", "start", "(", ")", "else", ":", "config", ".", "LOGGER", ".", "info", "(", "'Not starting because chef is already running.'", ")", "else", ":", "config", ".", "LOGGER", ".", "info", "(", "'Command not supported: %s'", "%", "message", "[", "'command'", "]", ")" ]

[ "Runs", "the", "command", "in", "message", "[", "command", "]", "which", "is", "one", "of", ":", "start", "/", "stop", ".", "Updates", "the", "chef", "s", "initial", "command", "line", "args", "and", "options", "with", "args", "and", "options", "provided", "in", "message", "[", "args", "]", "and", "message", "[", "options", "]", "." ]

[ "def", "mongodb_ensure_index", "(", "database_name", ",", "collection_name", ",", "key", ")", ":", "try", ":", "mongodb_client_url", "=", "getattr", "(", "settings", ",", "'MONGODB_CLIENT'", ",", "'mongodb://localhost:27017/'", ")", "mc", "=", "MongoClient", "(", "mongodb_client_url", ",", "document_class", "=", "OrderedDict", ")", "dbs", "=", "mc", "[", "database_name", "]", "dbc", "=", "dbs", "[", "collection_name", "]", "dbc", ".", "ensure_index", "(", "key", ")", "# print \"success\"", "return", "key", "except", ":", "# error connecting to mongodb", "# print str(sys.exc_info())", "return", "str", "(", "sys", ".", "exc_info", "(", ")", ")" ]

[ "Ensure", "Index" ]

[ "def", "iterate", "(", "self", ",", "func", ",", "args", "=", "None", ",", "filter", "=", "[", "]", ")", ":", "with", "self", ".", "_mutex", ":", "result", "=", "[", "]", "if", "filter", ":", "filters_passed", "=", "True", "for", "f", "in", "filter", ":", "if", "type", "(", "f", ")", "==", "str", ":", "if", "not", "eval", "(", "'self.'", "+", "f", ")", ":", "filters_passed", "=", "False", "break", "else", ":", "if", "not", "f", "(", "self", ")", ":", "filters_passed", "=", "False", "break", "if", "filters_passed", ":", "result", "=", "[", "func", "(", "self", ",", "args", ")", "]", "else", ":", "result", "=", "[", "func", "(", "self", ",", "args", ")", "]", "for", "child", "in", "self", ".", "_children", ":", "result", "+=", "self", ".", "_children", "[", "child", "]", ".", "iterate", "(", "func", ",", "args", ",", "filter", ")", "return", "result" ]

[ "Call", "a", "function", "on", "this", "node", "and", "recursively", "all", "its", "children", "." ]

[ "def", "get_host", "(", "environ", ")", ":", "scheme", "=", "environ", ".", "get", "(", "'wsgi.url_scheme'", ")", "if", "'HTTP_X_FORWARDED_HOST'", "in", "environ", ":", "result", "=", "environ", "[", "'HTTP_X_FORWARDED_HOST'", "]", "elif", "'HTTP_HOST'", "in", "environ", ":", "result", "=", "environ", "[", "'HTTP_HOST'", "]", "else", ":", "result", "=", "environ", "[", "'SERVER_NAME'", "]", "if", "(", "scheme", ",", "str", "(", "environ", "[", "'SERVER_PORT'", "]", ")", ")", "not", "in", "(", "(", "'https'", ",", "'443'", ")", ",", "(", "'http'", ",", "'80'", ")", ")", ":", "result", "+=", "':'", "+", "environ", "[", "'SERVER_PORT'", "]", "if", "result", ".", "endswith", "(", "':80'", ")", "and", "scheme", "==", "'http'", ":", "result", "=", "result", "[", ":", "-", "3", "]", "elif", "result", ".", "endswith", "(", "':443'", ")", "and", "scheme", "==", "'https'", ":", "result", "=", "result", "[", ":", "-", "4", "]", "return", "result" ]

[ "Return", "the", "real", "host", "for", "the", "given", "WSGI", "environment", ".", "This", "takes", "care", "of", "the", "X", "-", "Forwarded", "-", "Host", "header", "." ]

[ "def", "create_hit", "(", "self", ",", "hit_type", "=", "None", ",", "question", "=", "None", ",", "lifetime", "=", "datetime", ".", "timedelta", "(", "days", "=", "7", ")", ",", "max_assignments", "=", "1", ",", "title", "=", "None", ",", "description", "=", "None", ",", "keywords", "=", "None", ",", "reward", "=", "None", ",", "duration", "=", "datetime", ".", "timedelta", "(", "days", "=", "7", ")", ",", "approval_delay", "=", "None", ",", "annotation", "=", "None", ",", "questions", "=", "None", ",", "qualifications", "=", "None", ",", "response_groups", "=", "None", ")", ":", "# handle single or multiple questions", "neither", "=", "question", "is", "None", "and", "questions", "is", "None", "both", "=", "question", "is", "not", "None", "and", "questions", "is", "not", "None", "if", "neither", "or", "both", ":", "raise", "ValueError", "(", "\"Must specify either question (single Question instance) or questions (list or QuestionForm instance), but not both\"", ")", "if", "question", ":", "questions", "=", "[", "question", "]", "question_param", "=", "QuestionForm", "(", "questions", ")", "if", "isinstance", "(", "question", ",", "QuestionForm", ")", ":", "question_param", "=", "question", "elif", "isinstance", "(", "question", ",", "ExternalQuestion", ")", ":", "question_param", "=", "question", "# Handle basic required arguments and set up params dict", "params", "=", "{", "'Question'", ":", "question_param", ".", "get_as_xml", "(", ")", ",", "'LifetimeInSeconds'", ":", "self", ".", "duration_as_seconds", "(", "lifetime", ")", ",", "'MaxAssignments'", ":", "max_assignments", ",", "}", "# if hit type specified then add it", "# else add the additional required parameters", "if", "hit_type", ":", "params", "[", "'HITTypeId'", "]", "=", "hit_type", "else", ":", "# Handle keywords", "final_keywords", "=", "MTurkConnection", ".", "get_keywords_as_string", "(", "keywords", ")", "# Handle price argument", "final_price", "=", "MTurkConnection", ".", "get_price_as_price", "(", "reward", ")", "final_duration", "=", "self", ".", "duration_as_seconds", "(", "duration", ")", "additional_params", "=", "dict", "(", "Title", "=", "title", ",", "Description", "=", "description", ",", "Keywords", "=", "final_keywords", ",", "AssignmentDurationInSeconds", "=", "final_duration", ",", ")", "additional_params", ".", "update", "(", "final_price", ".", "get_as_params", "(", "'Reward'", ")", ")", "if", "approval_delay", "is", "not", "None", ":", "d", "=", "self", ".", "duration_as_seconds", "(", "approval_delay", ")", "additional_params", "[", "'AutoApprovalDelayInSeconds'", "]", "=", "d", "# add these params to the others", "params", ".", "update", "(", "additional_params", ")", "# add the annotation if specified", "if", "annotation", "is", "not", "None", ":", "params", "[", "'RequesterAnnotation'", "]", "=", "annotation", "# Add the Qualifications if specified", "if", "qualifications", "is", "not", "None", ":", "params", ".", "update", "(", "qualifications", ".", "get_as_params", "(", ")", ")", "# Handle optional response groups argument", "if", "response_groups", ":", "self", ".", "build_list_params", "(", "params", ",", "response_groups", ",", "'ResponseGroup'", ")", "# Submit", "return", "self", ".", "_process_request", "(", "'CreateHIT'", ",", "params", ",", "[", "(", "'HIT'", ",", "HIT", ")", ",", "]", ")" ]

[ "Creates", "a", "new", "HIT", ".", "Returns", "a", "ResultSet", "See", ":", "http", ":", "//", "docs", ".", "amazonwebservices", ".", "com", "/", "AWSMechanicalTurkRequester", "/", "2006", "-", "10", "-", "31", "/", "ApiReference_CreateHITOperation", ".", "html" ]

[ "def", "_plt_gogrouped", "(", "self", ",", "goids", ",", "go2color_usr", ",", "*", "*", "kws", ")", ":", "fout_img", "=", "self", ".", "get_outfile", "(", "kws", "[", "'outfile'", "]", ",", "goids", ")", "sections", "=", "read_sections", "(", "kws", "[", "'sections'", "]", ",", "exclude_ungrouped", "=", "True", ")", "# print (\"KWWSSSSSSSS\", kws)", "# kws_plt = {k:v for k, v in kws.items if k in self.kws_plt}", "grprobj_cur", "=", "self", ".", "_get_grprobj", "(", "goids", ",", "sections", ")", "# GO: purple=hdr-only, green=hdr&usr, yellow=usr-only", "# BORDER: Black=hdr Blu=hdr&usr", "grpcolor", "=", "GrouperColors", "(", "grprobj_cur", ")", "# get_bordercolor get_go2color_users", "grp_go2color", "=", "grpcolor", ".", "get_go2color_users", "(", ")", "grp_go2bordercolor", "=", "grpcolor", ".", "get_bordercolor", "(", ")", "for", "goid", ",", "color", "in", "go2color_usr", ".", "items", "(", ")", ":", "grp_go2color", "[", "goid", "]", "=", "color", "objcolor", "=", "Go2Color", "(", "self", ".", "gosubdag", ",", "objgoea", "=", "None", ",", "go2color", "=", "grp_go2color", ",", "go2bordercolor", "=", "grp_go2bordercolor", ")", "go2txt", "=", "GrouperPlot", ".", "get_go2txt", "(", "grprobj_cur", ",", "grp_go2color", ",", "grp_go2bordercolor", ")", "objplt", "=", "GoSubDagPlot", "(", "self", ".", "gosubdag", ",", "Go2Color", "=", "objcolor", ",", "go2txt", "=", "go2txt", ",", "*", "*", "kws", ")", "objplt", ".", "prt_goids", "(", "sys", ".", "stdout", ")", "objplt", ".", "plt_dag", "(", "fout_img", ")", "sys", ".", "stdout", ".", "write", "(", "\"{N:>6} sections read\\n\"", ".", "format", "(", "N", "=", "\"NO\"", "if", "sections", "is", "None", "else", "len", "(", "sections", ")", ")", ")", "return", "fout_img" ]

[ "Plot", "grouped", "GO", "IDs", "." ]

[ "def", "camel_case", "(", "string", ")", ":", "if", "not", "string", ":", "return", "string", "parts", "=", "snake_case", "(", "string", ")", ".", "split", "(", "'_'", ")", "rv", "=", "''", "while", "parts", ":", "part", "=", "parts", ".", "pop", "(", "0", ")", "rv", "+=", "part", "or", "'_'", "if", "part", ":", "break", "return", "rv", "+", "''", ".", "join", "(", "x", ".", "title", "(", ")", "for", "x", "in", "parts", ")" ]

[ "Converts", "a", "string", "to", "camel", "case", ".", "For", "example", "::" ]

[ "def", "copy_file_if_modified", "(", "src_path", ",", "dest_path", ")", ":", "# if the destination path is a directory, delete it completely - we assume here we are", "# writing a file to the filesystem", "if", "os", ".", "path", ".", "isdir", "(", "dest_path", ")", ":", "shutil", ".", "rmtree", "(", "dest_path", ")", "must_copy", "=", "False", "if", "not", "os", ".", "path", ".", "exists", "(", "dest_path", ")", ":", "must_copy", "=", "True", "else", ":", "src_stat", "=", "os", ".", "stat", "(", "src_path", ")", "dest_stat", "=", "os", ".", "stat", "(", "dest_path", ")", "# if the size or last modified timestamp are different", "if", "(", "(", "src_stat", "[", "stat", ".", "ST_SIZE", "]", "!=", "dest_stat", "[", "stat", ".", "ST_SIZE", "]", ")", "or", "(", "src_stat", "[", "stat", ".", "ST_MTIME", "]", "!=", "dest_stat", "[", "stat", ".", "ST_MTIME", "]", ")", ")", ":", "must_copy", "=", "True", "if", "must_copy", ":", "shutil", ".", "copy2", "(", "src_path", ",", "dest_path", ")" ]

[ "Only", "copies", "the", "file", "from", "the", "source", "path", "to", "the", "destination", "path", "if", "it", "doesn", "t", "exist", "yet", "or", "it", "has", "been", "modified", ".", "Intended", "to", "provide", "something", "of", "an", "optimisation", "when", "a", "project", "has", "large", "trees", "of", "assets", "." ]

[ "def", "sphinx_make", "(", "*", "targets", ")", ":", "sh", "(", "'make %s'", "%", "' '", ".", "join", "(", "targets", ")", ",", "cwd", "=", "options", ".", "paved", ".", "docs", ".", "path", ")" ]

[ "Call", "the", "Sphinx", "Makefile", "with", "the", "specified", "targets", "." ]

[ "def", "verify_response_time", "(", "self", ",", "expected_below", ")", ":", "if", "self", ".", "timedelta", ">", "expected_below", ":", "raise", "ValueError", "(", "\"Response time is more (%f) than expected (%f)!\"", "%", "(", "self", ".", "timedelta", ",", "expected_below", ")", ")" ]

[ "Verify", "that", "response", "time", "(", "time", "span", "between", "request", "-", "response", ")", "is", "reasonable", "." ]

[ "def", "clear_lock", "(", "self", ",", "abspath", "=", "True", ")", ":", "cmd_list", "=", "[", "'clean'", ",", "'--lock'", ",", "'--json'", "]", "return", "self", ".", "_call_and_parse", "(", "cmd_list", ",", "abspath", "=", "abspath", ")" ]

[ "Clean", "any", "conda", "lock", "in", "the", "system", "." ]

[ "def", "parse_rpm_output", "(", "output", ",", "tags", "=", "None", ",", "separator", "=", "';'", ")", ":", "if", "tags", "is", "None", ":", "tags", "=", "image_component_rpm_tags", "def", "field", "(", "tag", ")", ":", "\"\"\"\n Get a field value by name\n \"\"\"", "try", ":", "value", "=", "fields", "[", "tags", ".", "index", "(", "tag", ")", "]", "except", "ValueError", ":", "return", "None", "if", "value", "==", "'(none)'", ":", "return", "None", "return", "value", "components", "=", "[", "]", "sigmarker", "=", "'Key ID '", "for", "rpm", "in", "output", ":", "fields", "=", "rpm", ".", "rstrip", "(", "'\\n'", ")", ".", "split", "(", "separator", ")", "if", "len", "(", "fields", ")", "<", "len", "(", "tags", ")", ":", "continue", "signature", "=", "field", "(", "'SIGPGP:pgpsig'", ")", "or", "field", "(", "'SIGGPG:pgpsig'", ")", "if", "signature", ":", "parts", "=", "signature", ".", "split", "(", "sigmarker", ",", "1", ")", "if", "len", "(", "parts", ")", ">", "1", ":", "signature", "=", "parts", "[", "1", "]", "component_rpm", "=", "{", "'type'", ":", "'rpm'", ",", "'name'", ":", "field", "(", "'NAME'", ")", ",", "'version'", ":", "field", "(", "'VERSION'", ")", ",", "'release'", ":", "field", "(", "'RELEASE'", ")", ",", "'arch'", ":", "field", "(", "'ARCH'", ")", ",", "'sigmd5'", ":", "field", "(", "'SIGMD5'", ")", ",", "'signature'", ":", "signature", ",", "}", "# Special handling for epoch as it must be an integer or None", "epoch", "=", "field", "(", "'EPOCH'", ")", "if", "epoch", "is", "not", "None", ":", "epoch", "=", "int", "(", "epoch", ")", "component_rpm", "[", "'epoch'", "]", "=", "epoch", "if", "component_rpm", "[", "'name'", "]", "!=", "'gpg-pubkey'", ":", "components", ".", "append", "(", "component_rpm", ")", "return", "components" ]

[ "Parse", "output", "of", "the", "rpm", "query", "." ]

[ "def", "check_incoming", "(", "self", ",", "message", ",", "addr", ",", "protocol", ")", ":", "component", "=", "protocol", ".", "local_candidate", ".", "component", "# find remote candidate", "remote_candidate", "=", "None", "for", "c", "in", "self", ".", "_remote_candidates", ":", "if", "c", ".", "host", "==", "addr", "[", "0", "]", "and", "c", ".", "port", "==", "addr", "[", "1", "]", ":", "remote_candidate", "=", "c", "assert", "remote_candidate", ".", "component", "==", "component", "break", "if", "remote_candidate", "is", "None", ":", "# 7.2.1.3. Learning Peer Reflexive Candidates", "remote_candidate", "=", "Candidate", "(", "foundation", "=", "random_string", "(", "10", ")", ",", "component", "=", "component", ",", "transport", "=", "'udp'", ",", "priority", "=", "message", ".", "attributes", "[", "'PRIORITY'", "]", ",", "host", "=", "addr", "[", "0", "]", ",", "port", "=", "addr", "[", "1", "]", ",", "type", "=", "'prflx'", ")", "self", ".", "_remote_candidates", ".", "append", "(", "remote_candidate", ")", "self", ".", "__log_info", "(", "'Discovered peer reflexive candidate %s'", ",", "remote_candidate", ")", "# find pair", "pair", "=", "self", ".", "_find_pair", "(", "protocol", ",", "remote_candidate", ")", "if", "pair", "is", "None", ":", "pair", "=", "CandidatePair", "(", "protocol", ",", "remote_candidate", ")", "pair", ".", "state", "=", "CandidatePair", ".", "State", ".", "WAITING", "self", ".", "_check_list", ".", "append", "(", "pair", ")", "self", ".", "sort_check_list", "(", ")", "# triggered check", "if", "pair", ".", "state", "in", "[", "CandidatePair", ".", "State", ".", "WAITING", ",", "CandidatePair", ".", "State", ".", "FAILED", "]", ":", "pair", ".", "handle", "=", "asyncio", ".", "ensure_future", "(", "self", ".", "check_start", "(", "pair", ")", ")", "# 7.2.1.5. Updating the Nominated Flag", "if", "'USE-CANDIDATE'", "in", "message", ".", "attributes", "and", "not", "self", ".", "ice_controlling", ":", "pair", ".", "remote_nominated", "=", "True", "if", "pair", ".", "state", "==", "CandidatePair", ".", "State", ".", "SUCCEEDED", ":", "pair", ".", "nominated", "=", "True", "self", ".", "check_complete", "(", "pair", ")" ]

[ "Handle", "a", "succesful", "incoming", "check", "." ]

[ "def", "parse_headers", "(", "self", ",", "req", ",", "name", ",", "field", ")", ":", "# Use req.get_headers rather than req.headers for performance", "return", "req", ".", "get_header", "(", "name", ",", "required", "=", "False", ")", "or", "core", ".", "missing" ]

[ "Pull", "a", "header", "value", "from", "the", "request", "." ]

[ "def", "get_template_id", "(", "template_name", ",", "auth", ",", "url", ")", ":", "object_list", "=", "get_cfg_template", "(", "auth", "=", "auth", ",", "url", "=", "url", ")", "for", "object", "in", "object_list", ":", "if", "object", "[", "'confFileName'", "]", "==", "template_name", ":", "return", "object", "[", "'confFileId'", "]", "return", "\"template not found\"" ]

[ "Helper", "function", "takes", "str", "input", "of", "folder", "name", "and", "returns", "str", "numerical", "id", "of", "the", "folder", ".", ":", "param", "folder_name", ":", "str", "name", "of", "the", "folder" ]

[ "def", "hms2dec", "(", "hms", ")", ":", "DEGREE", "=", "360.", "HOUR", "=", "24.", "MINUTE", "=", "60.", "SECOND", "=", "3600.", "if", "isstring", "(", "hms", ")", ":", "hour", ",", "minute", ",", "second", "=", "np", ".", "array", "(", "re", ".", "split", "(", "'[hms]'", ",", "hms", ")", ")", "[", ":", "3", "]", ".", "astype", "(", "float", ")", "else", ":", "hour", ",", "minute", ",", "second", "=", "hms", ".", "T", "decimal", "=", "(", "hour", "+", "minute", "*", "1.", "/", "MINUTE", "+", "second", "*", "1.", "/", "SECOND", ")", "*", "(", "DEGREE", "/", "HOUR", ")", "return", "decimal" ]

[ "Convert", "longitude", "from", "hours", "minutes", "seconds", "in", "string", "or", "3", "-", "array", "format", "to", "decimal", "degrees", "." ]

[ "def", "_download", "(", "url", ",", "dest", ")", ":", "print", "(", "'Downloading %s'", "%", "url", ")", "filename", "=", "os", ".", "path", ".", "basename", "(", "url", ")", "dest_path", "=", "os", ".", "path", ".", "join", "(", "dest", ",", "filename", ")", "if", "sys", ".", "platform", "==", "'win32'", ":", "powershell_exe", "=", "os", ".", "path", ".", "join", "(", "'system32\\\\WindowsPowerShell\\\\v1.0\\\\powershell.exe'", ")", "code", "=", "\"[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12;\"", "code", "+=", "\"(New-Object Net.WebClient).DownloadFile('%s', '%s');\"", "%", "(", "url", ",", "dest_path", ")", "_execute", "(", "[", "powershell_exe", ",", "'-Command'", ",", "code", "]", ",", "dest", ")", "else", ":", "_execute", "(", "[", "'curl'", ",", "'-L'", ",", "'--silent'", ",", "'--show-error'", ",", "'-O'", ",", "url", "]", ",", "dest", ")", "return", "dest_path" ]

[ "Downloads", "a", "URL", "to", "a", "directory" ]

[ "def", "get_invocation_command_nodefault", "(", "toolset", ",", "tool", ",", "user_provided_command", "=", "[", "]", ",", "additional_paths", "=", "[", "]", ",", "path_last", "=", "False", ")", ":", "assert", "isinstance", "(", "toolset", ",", "basestring", ")", "assert", "isinstance", "(", "tool", ",", "basestring", ")", "assert", "is_iterable_typed", "(", "user_provided_command", ",", "basestring", ")", "assert", "is_iterable_typed", "(", "additional_paths", ",", "basestring", ")", "or", "additional_paths", "is", "None", "assert", "isinstance", "(", "path_last", ",", "(", "int", ",", "bool", ")", ")", "if", "not", "user_provided_command", ":", "command", "=", "find_tool", "(", "tool", ",", "additional_paths", ",", "path_last", ")", "if", "not", "command", "and", "__debug_configuration", ":", "print", "\"warning: toolset\"", ",", "toolset", ",", "\"initialization: can't find tool, tool\"", "#FIXME", "#print \"warning: initialized from\" [ errors.nearest-user-location ] ;", "else", ":", "command", "=", "check_tool", "(", "user_provided_command", ")", "if", "not", "command", "and", "__debug_configuration", ":", "print", "\"warning: toolset\"", ",", "toolset", ",", "\"initialization:\"", "print", "\"warning: can't find user-provided command\"", ",", "user_provided_command", "#FIXME", "#ECHO \"warning: initialized from\" [ errors.nearest-user-location ]", "command", "=", "[", "]", "if", "command", ":", "command", "=", "' '", ".", "join", "(", "command", ")", "return", "command" ]

[ "A", "helper", "rule", "to", "get", "the", "command", "to", "invoke", "some", "tool", ".", "If", "user", "-", "provided", "-", "command", "is", "not", "given", "tries", "to", "find", "binary", "named", "tool", "in", "PATH", "and", "in", "the", "passed", "additional", "-", "path", ".", "Otherwise", "verifies", "that", "the", "first", "element", "of", "user", "-", "provided", "-", "command", "is", "an", "existing", "program", "." ]

[ "def", "kernels_list_cli", "(", "self", ",", "mine", "=", "False", ",", "page", "=", "1", ",", "page_size", "=", "20", ",", "search", "=", "None", ",", "csv_display", "=", "False", ",", "parent", "=", "None", ",", "competition", "=", "None", ",", "dataset", "=", "None", ",", "user", "=", "None", ",", "language", "=", "None", ",", "kernel_type", "=", "None", ",", "output_type", "=", "None", ",", "sort_by", "=", "None", ")", ":", "kernels", "=", "self", ".", "kernels_list", "(", "page", "=", "page", ",", "page_size", "=", "page_size", ",", "search", "=", "search", ",", "mine", "=", "mine", ",", "dataset", "=", "dataset", ",", "competition", "=", "competition", ",", "parent_kernel", "=", "parent", ",", "user", "=", "user", ",", "language", "=", "language", ",", "kernel_type", "=", "kernel_type", ",", "output_type", "=", "output_type", ",", "sort_by", "=", "sort_by", ")", "fields", "=", "[", "'ref'", ",", "'title'", ",", "'author'", ",", "'lastRunTime'", ",", "'totalVotes'", "]", "if", "kernels", ":", "if", "csv_display", ":", "self", ".", "print_csv", "(", "kernels", ",", "fields", ")", "else", ":", "self", ".", "print_table", "(", "kernels", ",", "fields", ")", "else", ":", "print", "(", "'No kernels found'", ")" ]

[ "client", "wrapper", "for", "kernels_list", "see", "this", "function", "for", "arguments", ".", "Additional", "arguments", "are", "provided", "here", ".", "Parameters", "==========", "csv_display", ":", "if", "True", "print", "comma", "separated", "values", "instead", "of", "table" ]

[ "def", "_node_add_with_peer_list", "(", "self", ",", "child_self", ",", "child_other", ")", ":", "parent_self", "=", "child_self", ".", "getparent", "(", ")", "s_node", "=", "self", ".", "device", ".", "get_schema_node", "(", "child_self", ")", "if", "child_other", ".", "get", "(", "operation_tag", ")", "!=", "'delete'", "and", "child_other", ".", "get", "(", "operation_tag", ")", "!=", "'remove'", "and", "s_node", ".", "get", "(", "'ordered-by'", ")", "==", "'user'", "and", "child_other", ".", "get", "(", "insert_tag", ")", "is", "not", "None", ":", "if", "child_other", ".", "get", "(", "insert_tag", ")", "==", "'first'", ":", "scope", "=", "parent_self", ".", "getchildren", "(", ")", "siblings", "=", "self", ".", "_get_sequence", "(", "scope", ",", "child_other", ".", "tag", ",", "parent_self", ")", "if", "siblings", "[", "0", "]", "!=", "child_self", ":", "siblings", "[", "0", "]", ".", "addprevious", "(", "child_self", ")", "elif", "child_other", ".", "get", "(", "insert_tag", ")", "==", "'last'", ":", "scope", "=", "parent_self", ".", "getchildren", "(", ")", "siblings", "=", "self", ".", "_get_sequence", "(", "scope", ",", "child_other", ".", "tag", ",", "parent_self", ")", "if", "siblings", "[", "-", "1", "]", "!=", "child_self", ":", "siblings", "[", "-", "1", "]", ".", "addnext", "(", "child_self", ")", "elif", "child_other", ".", "get", "(", "insert_tag", ")", "==", "'before'", ":", "if", "child_other", ".", "get", "(", "key_tag", ")", "is", "None", ":", "_inserterror", "(", "'before'", ",", "self", ".", "device", ".", "get_xpath", "(", "child_other", ")", ",", "'key'", ")", "sibling", "=", "parent_self", ".", "find", "(", "child_other", ".", "tag", "+", "child_other", ".", "get", "(", "key_tag", ")", ",", "namespaces", "=", "child_other", ".", "nsmap", ")", "if", "sibling", "is", "None", ":", "path", "=", "self", ".", "device", ".", "get_xpath", "(", "child_other", ")", "key", "=", "child_other", ".", "get", "(", "key_tag", ")", "_inserterror", "(", "'before'", ",", "path", ",", "'key'", ",", "key", ")", "if", "sibling", "!=", "child_self", ":", "sibling", ".", "addprevious", "(", "child_self", ")", "elif", "child_other", ".", "get", "(", "insert_tag", ")", "==", "'after'", ":", "if", "child_other", ".", "get", "(", "key_tag", ")", "is", "None", ":", "_inserterror", "(", "'after'", ",", "self", ".", "device", ".", "get_xpath", "(", "child_other", ")", ",", "'key'", ")", "sibling", "=", "parent_self", ".", "find", "(", "child_other", ".", "tag", "+", "child_other", ".", "get", "(", "key_tag", ")", ",", "namespaces", "=", "child_other", ".", "nsmap", ")", "if", "sibling", "is", "None", ":", "path", "=", "self", ".", "device", ".", "get_xpath", "(", "child_other", ")", "key", "=", "child_other", ".", "get", "(", "key_tag", ")", "_inserterror", "(", "'after'", ",", "path", ",", "'key'", ",", "key", ")", "if", "sibling", "!=", "child_self", ":", "sibling", ".", "addnext", "(", "child_self", ")", "if", "child_other", ".", "get", "(", "operation_tag", ")", "is", "None", "or", "child_other", ".", "get", "(", "operation_tag", ")", "==", "'merge'", ":", "self", ".", "node_add", "(", "child_self", ",", "child_other", ")", "elif", "child_other", ".", "get", "(", "operation_tag", ")", "==", "'replace'", ":", "e", "=", "deepcopy", "(", "child_other", ")", "parent_self", ".", "replace", "(", "child_self", ",", "self", ".", "_del_attrib", "(", "e", ")", ")", "elif", "child_other", ".", "get", "(", "operation_tag", ")", "==", "'create'", ":", "raise", "ConfigDeltaError", "(", "'data-exists: try to create node {} but '", "'it already exists'", ".", "format", "(", "self", ".", "device", ".", "get_xpath", "(", "child_other", ")", ")", ")", "elif", "child_other", ".", "get", "(", "operation_tag", ")", "==", "'delete'", "or", "child_other", ".", "get", "(", "operation_tag", ")", "==", "'remove'", ":", "parent_self", ".", "remove", "(", "child_self", ")", "else", ":", "raise", "ConfigDeltaError", "(", "\"unknown operation: node {} contains \"", "\"operation '{}'\"", ".", "format", "(", "self", ".", "device", ".", "get_xpath", "(", "child_other", ")", ",", "child_other", ".", "get", "(", "operation_tag", ")", ")", ")" ]

[ "_node_add_with_peer_list" ]

[ "def", "embed_code_links", "(", "app", ",", "exception", ")", ":", "if", "exception", "is", "not", "None", ":", "return", "# No need to waste time embedding hyperlinks when not running the examples", "# XXX: also at the time of writing this fixes make html-noplot", "# for some reason I don't fully understand", "if", "not", "app", ".", "builder", ".", "config", ".", "plot_gallery", ":", "return", "# XXX: Whitelist of builders for which it makes sense to embed", "# hyperlinks inside the example html. Note that the link embedding", "# require searchindex.js to exist for the links to the local doc", "# and there does not seem to be a good way of knowing which", "# builders creates a searchindex.js.", "if", "app", ".", "builder", ".", "name", "not", "in", "[", "'html'", ",", "'readthedocs'", "]", ":", "return", "print", "(", "'Embedding documentation hyperlinks in examples..'", ")", "gallery_conf", "=", "app", ".", "config", ".", "sphinx_gallery_conf", "gallery_dirs", "=", "gallery_conf", "[", "'gallery_dirs'", "]", "if", "not", "isinstance", "(", "gallery_dirs", ",", "list", ")", ":", "gallery_dirs", "=", "[", "gallery_dirs", "]", "for", "gallery_dir", "in", "gallery_dirs", ":", "_embed_code_links", "(", "app", ",", "gallery_conf", ",", "gallery_dir", ")" ]

[ "Embed", "hyperlinks", "to", "documentation", "into", "example", "code" ]

[ "def", "all_nets", "(", "transform_func", ")", ":", "@", "functools", ".", "wraps", "(", "transform_func", ")", "def", "t_res", "(", "*", "*", "kwargs", ")", ":", "net_transform", "(", "transform_func", ",", "*", "*", "kwargs", ")", "return", "t_res" ]

[ "Decorator", "that", "wraps", "a", "net", "transform", "function" ]

[ "def", "ssa", "(", "n", ",", "h", ",", "K", ",", "f", ",", "T", ")", ":", "model", "=", "Model", "(", "\"safety stock allocation\"", ")", "# calculate endpoints for linear segments", "a", ",", "b", "=", "{", "}", ",", "{", "}", "for", "i", "in", "range", "(", "1", ",", "n", "+", "1", ")", ":", "a", "[", "i", "]", "=", "[", "k", "for", "k", "in", "range", "(", "K", ")", "]", "b", "[", "i", "]", "=", "[", "f", "(", "i", ",", "k", ")", "for", "k", "in", "range", "(", "K", ")", "]", "# x: net replenishment time for stage i", "# y: corresponding cost", "# s: piecewise linear segment of variable x", "x", ",", "y", ",", "s", "=", "{", "}", ",", "{", "}", ",", "{", "}", "L", "=", "{", "}", "# service time of stage i", "for", "i", "in", "range", "(", "1", ",", "n", "+", "1", ")", ":", "x", "[", "i", "]", ",", "y", "[", "i", "]", ",", "s", "[", "i", "]", "=", "convex_comb_sos", "(", "model", ",", "a", "[", "i", "]", ",", "b", "[", "i", "]", ")", "if", "i", "==", "1", ":", "L", "[", "i", "]", "=", "model", ".", "addVar", "(", "ub", "=", "0", ",", "vtype", "=", "\"C\"", ",", "name", "=", "\"L[%s]\"", "%", "i", ")", "else", ":", "L", "[", "i", "]", "=", "model", ".", "addVar", "(", "vtype", "=", "\"C\"", ",", "name", "=", "\"L[%s]\"", "%", "i", ")", "L", "[", "n", "+", "1", "]", "=", "model", ".", "addVar", "(", "ub", "=", "0", ",", "vtype", "=", "\"C\"", ",", "name", "=", "\"L[%s]\"", "%", "(", "n", "+", "1", ")", ")", "for", "i", "in", "range", "(", "1", ",", "n", "+", "1", ")", ":", "# net replenishment time for each stage i", "model", ".", "addCons", "(", "x", "[", "i", "]", "+", "L", "[", "i", "]", "==", "T", "[", "i", "]", "+", "L", "[", "i", "+", "1", "]", ")", "model", ".", "setObjective", "(", "quicksum", "(", "h", "[", "i", "]", "*", "y", "[", "i", "]", "for", "i", "in", "range", "(", "1", ",", "n", "+", "1", ")", ")", ",", "\"minimize\"", ")", "model", ".", "data", "=", "x", ",", "s", ",", "L", "return", "model" ]

[ "ssa", "--", "multi", "-", "stage", "(", "serial", ")", "safety", "stock", "allocation", "model", "Parameters", ":", "-", "n", ":", "number", "of", "stages", "-", "h", "[", "i", "]", ":", "inventory", "cost", "on", "stage", "i", "-", "K", ":", "number", "of", "linear", "segments", "-", "f", ":", "(", "non", "-", "linear", ")", "cost", "function", "-", "T", "[", "i", "]", ":", "production", "lead", "time", "on", "stage", "i", "Returns", "the", "model", "with", "the", "piecewise", "linear", "relation", "on", "added", "variables", "x", "f", "and", "z", "." ]

[ "def", "setup_module_dev", "(", "destdir", ")", ":", "if", "not", "nav", ":", "sys", ".", "exit", "(", "1", ")", "ecode", "=", "0", "try", ":", "anchore_print", "(", "\"Anchore Module Development Environment\\n\"", ")", "helpstr", "=", "\"This tool has set up an environment that represents what anchore will normally set up before running an analyzer, gate and/or query module. Each section below includes some information along with a string that you can use to help develop your own anchore modules.\\n\"", "anchore_print", "(", "fill", "(", "helpstr", ",", "80", ")", ")", "anchore_print", "(", "\"\"", ")", "anchore_print", "(", "\"Setting up environment...\"", ")", "anchore_print", "(", "\"\"", ")", "result", "=", "nav", ".", "unpack", "(", "destdir", "=", "destdir", ")", "if", "not", "result", ":", "raise", "Exception", "(", "\"unable to unpack input image\"", ")", "for", "imageId", "in", "result", ":", "unpackdir", "=", "result", "[", "imageId", "]", "# copy anchore imageDB dir into unpacked environment", "imgdir", "=", "'/'", ".", "join", "(", "[", "config", ".", "data", "[", "'image_data_store'", "]", ",", "imageId", "]", ")", "tmpdatastore", "=", "'/'", ".", "join", "(", "[", "unpackdir", ",", "'data'", "]", ")", "dstimgdir", "=", "'/'", ".", "join", "(", "[", "tmpdatastore", ",", "imageId", "]", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "imgdir", ")", ":", "anchore_print_err", "(", "\"Image must exist and have been analyzed before being used for module development.\"", ")", "break", "if", "not", "os", ".", "path", ".", "exists", "(", "tmpdatastore", ")", ":", "os", ".", "makedirs", "(", "tmpdatastore", ")", "shutil", ".", "copytree", "(", "imgdir", ",", "dstimgdir", ",", "symlinks", "=", "True", ")", "# copy examples into the unpacked environment ", "examples", "=", "{", "}", "basedir", "=", "'/'", ".", "join", "(", "[", "unpackdir", ",", "\"anchore-modules\"", "]", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "basedir", ")", ":", "os", ".", "makedirs", "(", "basedir", ")", "# copy the shell-utils", "os", ".", "makedirs", "(", "'/'", ".", "join", "(", "[", "basedir", ",", "'shell-utils'", "]", ")", ")", "for", "s", "in", "os", ".", "listdir", "(", "'/'", ".", "join", "(", "[", "config", ".", "data", "[", "'scripts_dir'", "]", ",", "'shell-utils'", "]", ")", ")", ":", "shutil", ".", "copy", "(", "'/'", ".", "join", "(", "[", "config", ".", "data", "[", "'scripts_dir'", "]", ",", "'shell-utils'", ",", "s", "]", ")", ",", "'/'", ".", "join", "(", "[", "basedir", ",", "'shell-utils'", ",", "s", "]", ")", ")", "# copy any examples that exist in the anchore egg into the unpack dir", "for", "d", "in", "os", ".", "listdir", "(", "config", ".", "data", "[", "'scripts_dir'", "]", ")", ":", "scriptdir", "=", "'/'", ".", "join", "(", "[", "basedir", ",", "d", "]", ")", "if", "os", ".", "path", ".", "exists", "(", "config", ".", "data", "[", "'scripts_dir'", "]", "+", "\"/examples/\"", "+", "d", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "scriptdir", ")", ":", "os", ".", "makedirs", "(", "scriptdir", ")", "for", "s", "in", "os", ".", "listdir", "(", "config", ".", "data", "[", "'scripts_dir'", "]", "+", "\"/examples/\"", "+", "d", ")", ":", "thefile", "=", "'/'", ".", "join", "(", "[", "config", ".", "data", "[", "'scripts_dir'", "]", ",", "\"examples\"", ",", "d", ",", "s", "]", ")", "thefiledst", "=", "'/'", ".", "join", "(", "[", "scriptdir", ",", "s", "]", ")", "if", "re", ".", "match", "(", "\".*(\\.sh)$\"", ",", "thefile", ")", ":", "examples", "[", "d", "]", "=", "thefiledst", "shutil", ".", "copy", "(", "thefile", ",", "thefiledst", ")", "# all set, show how to use them", "anchore_print", "(", "\"\\tImage: \"", "+", "imageId", "[", "0", ":", "12", "]", ")", "anchore_print", "(", "\"\\tUnpack Directory: \"", "+", "result", "[", "imageId", "]", ")", "anchore_print", "(", "\"\"", ")", "analyzer_string", "=", "' '", ".", "join", "(", "[", "examples", "[", "'analyzers'", "]", ",", "imageId", ",", "tmpdatastore", ",", "dstimgdir", ",", "result", "[", "imageId", "]", "]", ")", "anchore_print", "(", "\"\\tAnalyzer Command:\\n\\n\\t\"", "+", "analyzer_string", ")", "anchore_print", "(", "\"\"", ")", "anchore_utils", ".", "write_plainfile_fromstr", "(", "result", "[", "imageId", "]", "+", "\"/queryimages\"", ",", "imageId", "+", "\"\\n\"", ")", "queryoutput", "=", "'/'", ".", "join", "(", "[", "result", "[", "imageId", "]", ",", "\"querytmp/\"", "]", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "queryoutput", ")", ":", "os", ".", "makedirs", "(", "queryoutput", ")", "query_string", "=", "' '", ".", "join", "(", "[", "examples", "[", "'queries'", "]", ",", "result", "[", "imageId", "]", "+", "\"/queryimages\"", ",", "tmpdatastore", ",", "queryoutput", ",", "\"passwd\"", "]", ")", "anchore_print", "(", "\"Query Command:\\n\\n\\t\"", "+", "query_string", ")", "anchore_print", "(", "\"\"", ")", "anchore_print", "(", "\"Next Steps: \"", ")", "anchore_print", "(", "\"\\tFirst: run the above analyzer command and note the RESULT output\"", ")", "anchore_print", "(", "\"\\tSecond: run the above query command and note the RESULT output, checking that the query was able to use the analyzer data to perform its search\"", ")", "anchore_print", "(", "\"\\tThird: modify the analyzer/query modules as you wish, including renaming them and continue running/inspecting output until you are satisfied\"", ")", "anchore_print", "(", "\"\\tFinally: when you're happy with the analyzer/query, copy them to next to existing anchore analyzer/query modules and anchore will start calling them as part of container analysis/query:\\n\"", ")", "anchore_print", "(", "\"\\tcp \"", "+", "examples", "[", "'analyzers'", "]", "+", "\" \"", "+", "config", ".", "data", "[", "'scripts_dir'", "]", "+", "\"/analyzers/99_analyzer-example.sh\"", ")", "anchore_print", "(", "\"\\tcp \"", "+", "examples", "[", "'queries'", "]", "+", "\" \"", "+", "config", ".", "data", "[", "'scripts_dir'", "]", "+", "\"/queries/\"", ")", "anchore_print", "(", "\"\\tanchore analyze --force --image \"", "+", "imageId", "+", "\" --imagetype none\"", ")", "anchore_print", "(", "\"\\tanchore query --image \"", "+", "imageId", "+", "\" query-example\"", ")", "anchore_print", "(", "\"\\tanchore query --image \"", "+", "imageId", "+", "\" query-example passwd\"", ")", "anchore_print", "(", "\"\\tanchore query --image \"", "+", "imageId", "+", "\" query-example pdoesntexist\"", ")", "except", ":", "anchore_print_err", "(", "\"operation failed\"", ")", "ecode", "=", "1", "contexts", "[", "'anchore_allimages'", "]", ".", "clear", "(", ")", "sys", ".", "exit", "(", "ecode", ")" ]

[ "Sets", "up", "a", "development", "environment", "suitable", "for", "working", "on", "anchore", "modules", "(", "queries", "etc", ")", "in", "the", "specified", "directory", ".", "Creates", "a", "copied", "environment", "in", "the", "destination", "containing", "the", "module", "scripts", "unpacked", "image", "(", "s", ")", "and", "helper", "scripts", "such", "that", "a", "module", "script", "that", "works", "in", "the", "environment", "can", "be", "copied", "into", "the", "correct", "installation", "environment", "and", "run", "with", "anchore", "explore", "<modulename", ">", "invocation", "and", "should", "work", "." ]

[ "def", "route_create", "(", "credential_file", "=", "None", ",", "project_id", "=", "None", ",", "name", "=", "None", ",", "dest_range", "=", "None", ",", "next_hop_instance", "=", "None", ",", "instance_zone", "=", "None", ",", "tags", "=", "None", ",", "network", "=", "None", ",", "priority", "=", "None", ")", ":", "credentials", "=", "oauth2client", ".", "service_account", ".", "ServiceAccountCredentials", ".", "from_json_keyfile_name", "(", "credential_file", ")", "service", "=", "googleapiclient", ".", "discovery", ".", "build", "(", "'compute'", ",", "'v1'", ",", "credentials", "=", "credentials", ")", "routes", "=", "service", ".", "routes", "(", ")", "routes_config", "=", "{", "'name'", ":", "six", ".", "text_type", "(", "name", ")", ",", "'network'", ":", "_get_network", "(", "project_id", ",", "six", ".", "text_type", "(", "network", ")", ",", "service", "=", "service", ")", "[", "'selfLink'", "]", ",", "'destRange'", ":", "six", ".", "text_type", "(", "dest_range", ")", ",", "'nextHopInstance'", ":", "_get_instance", "(", "project_id", ",", "instance_zone", ",", "next_hop_instance", ",", "service", "=", "service", ")", "[", "'selfLink'", "]", ",", "'tags'", ":", "tags", ",", "'priority'", ":", "priority", "}", "route_create_request", "=", "routes", ".", "insert", "(", "project", "=", "project_id", ",", "body", "=", "routes_config", ")", "return", "route_create_request", ".", "execute", "(", ")" ]

[ "Create", "a", "route", "to", "send", "traffic", "destined", "to", "the", "Internet", "through", "your", "gateway", "instance" ]

[ "def", "textFromHTML", "(", "html", ")", ":", "cleaner", "=", "lxml", ".", "html", ".", "clean", ".", "Cleaner", "(", "scripts", "=", "True", ")", "cleaned", "=", "cleaner", ".", "clean_html", "(", "html", ")", "return", "lxml", ".", "html", ".", "fromstring", "(", "cleaned", ")", ".", "text_content", "(", ")" ]

[ "Cleans", "and", "parses", "text", "from", "the", "given", "HTML", "." ]

[ "def", "find_match_command", "(", "self", ",", "rule", ")", ":", "command_string", "=", "rule", "[", "'command'", "]", "command_list", "=", "command_string", ".", "split", "(", ")", "self", ".", "logdebug", "(", "'comparing \"%s\" to \"%s\"\\n'", "%", "(", "command_list", ",", "self", ".", "original_command_list", ")", ")", "if", "rule", ".", "get", "(", "'allow_trailing_args'", ")", ":", "self", ".", "logdebug", "(", "'allow_trailing_args is true - comparing initial '", "'list.\\n'", ")", "# Verify the initial arguments are all the same", "if", "(", "self", ".", "original_command_list", "[", ":", "len", "(", "command_list", ")", "]", "==", "command_list", ")", ":", "self", ".", "logdebug", "(", "'initial list is same\\n'", ")", "return", "{", "'command'", ":", "self", ".", "original_command_list", "}", "else", ":", "self", ".", "logdebug", "(", "'initial list is not same\\n'", ")", "elif", "rule", ".", "get", "(", "'pcre_match'", ")", ":", "if", "re", ".", "search", "(", "command_string", ",", "self", ".", "original_command_string", ")", ":", "return", "{", "'command'", ":", "self", ".", "original_command_list", "}", "elif", "command_list", "==", "self", ".", "original_command_list", ":", "return", "{", "'command'", ":", "command_list", "}" ]

[ "Return", "a", "matching", "(", "possibly", "munged", ")", "command", "if", "found", "in", "rule", "." ]

[ "def", "show_fabric_trunk_info_output_show_trunk_list_trunk_list_groups_trunk_list_member_trunk_list_nbr_wwn", "(", "self", ",", "*", "*", "kwargs", ")", ":", "config", "=", "ET", ".", "Element", "(", "\"config\"", ")", "show_fabric_trunk_info", "=", "ET", ".", "Element", "(", "\"show_fabric_trunk_info\"", ")", "config", "=", "show_fabric_trunk_info", "output", "=", "ET", ".", "SubElement", "(", "show_fabric_trunk_info", ",", "\"output\"", ")", "show_trunk_list", "=", "ET", ".", "SubElement", "(", "output", ",", "\"show-trunk-list\"", ")", "trunk_list_groups", "=", "ET", ".", "SubElement", "(", "show_trunk_list", ",", "\"trunk-list-groups\"", ")", "trunk_list_member", "=", "ET", ".", "SubElement", "(", "trunk_list_groups", ",", "\"trunk-list-member\"", ")", "trunk_list_nbr_wwn", "=", "ET", ".", "SubElement", "(", "trunk_list_member", ",", "\"trunk-list-nbr-wwn\"", ")", "trunk_list_nbr_wwn", ".", "text", "=", "kwargs", ".", "pop", "(", "'trunk_list_nbr_wwn'", ")", "callback", "=", "kwargs", ".", "pop", "(", "'callback'", ",", "self", ".", "_callback", ")", "return", "callback", "(", "config", ")" ]

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

[ "def", "prefix", "(", "self", ",", "sign", ":", "Optional", "[", "PrefixSign", "]", "=", "None", ",", "symbol", ":", "bool", "=", "False", ")", "->", "str", ":", "prefixes", "=", "SI_PREFIXES_SYM", "if", "symbol", "else", "SI_PREFIXES", "key", "=", "self", ".", "_validate_enum", "(", "item", "=", "sign", ",", "enum", "=", "PrefixSign", ")", "return", "self", ".", "random", ".", "choice", "(", "prefixes", "[", "key", "]", ")" ]

[ "Get", "a", "random", "prefix", "for", "the", "International", "System", "of", "Units", "." ]

[ "def", "_check_data_port_id", "(", "self", ",", "data_port", ")", ":", "# First check inputs and outputs", "valid", ",", "message", "=", "super", "(", "ContainerState", ",", "self", ")", ".", "_check_data_port_id", "(", "data_port", ")", "if", "not", "valid", ":", "return", "False", ",", "message", "# Container state also has scoped variables", "for", "scoped_variable_id", ",", "scoped_variable", "in", "self", ".", "scoped_variables", ".", "items", "(", ")", ":", "if", "data_port", ".", "data_port_id", "==", "scoped_variable_id", "and", "data_port", "is", "not", "scoped_variable", ":", "return", "False", ",", "\"data port id already existing in state\"", "return", "True", ",", "message" ]

[ "Checks", "the", "validity", "of", "a", "data", "port", "id" ]

[ "def", "toggle_service", "(", "self", ")", ":", "self", ".", "monitoring_disabled", ".", "emit", "(", "not", "self", ".", "service", ".", "is_running", "(", ")", ")", "if", "self", ".", "service", ".", "is_running", "(", ")", ":", "self", ".", "pause_service", "(", ")", "else", ":", "self", ".", "unpause_service", "(", ")" ]

[ "Convenience", "method", "for", "toggling", "the", "expansion", "service", "on", "or", "off", ".", "This", "is", "called", "by", "the", "global", "hotkey", "." ]

[ "def", "_validate_ports_low_level", "(", "ports", ")", ":", "if", "not", "isinstance", "(", "ports", ",", "(", "list", ",", "tuple", ")", ")", ":", "raise", "ValueError", "(", "\"'ports' must be a list of strings\"", ")", "if", "any", "(", "[", "not", "isinstance", "(", "x", ",", "(", "six", ".", "text_type", ",", "str", ")", ")", "for", "x", "in", "ports", "]", ")", ":", "raise", "ValueError", "(", "\"'ports' must be a list of strings\"", ")", "for", "port", "in", "ports", ":", "_validate_single_port_string", "(", "port", ")" ]

[ "Internal", "helper", "." ]

[ "def", "load_mo", "(", "self", ",", "state", ",", "page_idx", ")", ":", "try", ":", "key", "=", "next", "(", "self", ".", "_storage", ".", "irange", "(", "maximum", "=", "page_idx", ",", "reverse", "=", "True", ")", ")", "except", "StopIteration", ":", "return", "None", "else", ":", "return", "self", ".", "_storage", "[", "key", "]" ]

[ "Loads", "a", "memory", "object", "from", "memory", "." ]

[ "def", "avail_locations", "(", "call", "=", "None", ")", ":", "if", "call", "==", "'action'", ":", "raise", "SaltCloudSystemExit", "(", "'The avail_locations function must be called with '", "'-f or --function, or with the --list-locations option'", ")", "params", "=", "{", "'Action'", ":", "'DescribeRegions'", "}", "items", "=", "query", "(", "params", "=", "params", ")", "ret", "=", "{", "}", "for", "region", "in", "items", "[", "'Regions'", "]", "[", "'Region'", "]", ":", "ret", "[", "region", "[", "'RegionId'", "]", "]", "=", "{", "}", "for", "item", "in", "region", ":", "ret", "[", "region", "[", "'RegionId'", "]", "]", "[", "item", "]", "=", "six", ".", "text_type", "(", "region", "[", "item", "]", ")", "return", "ret" ]

[ "Return", "a", "dict", "of", "all", "available", "VM", "locations", "on", "the", "cloud", "provider", "with", "relevant", "data" ]

[ "def", "_process_if", "(", "self", ",", "node", ")", ":", "creg_name", "=", "node", ".", "children", "[", "0", "]", ".", "name", "creg", "=", "self", ".", "dag", ".", "cregs", "[", "creg_name", "]", "cval", "=", "node", ".", "children", "[", "1", "]", ".", "value", "self", ".", "condition", "=", "(", "creg", ",", "cval", ")", "self", ".", "_process_node", "(", "node", ".", "children", "[", "2", "]", ")", "self", ".", "condition", "=", "None" ]

[ "Process", "an", "if", "node", "." ]

[ "def", "create_custom_trees", "(", "cls", ",", "obj", ",", "options", "=", "None", ")", ":", "clones", ",", "id_mapping", "=", "{", "}", ",", "[", "]", "obj_ids", "=", "cls", ".", "get_object_ids", "(", "obj", ")", "offset", "=", "cls", ".", "id_offset", "(", ")", "obj_ids", "=", "[", "None", "]", "if", "len", "(", "obj_ids", ")", "==", "0", "else", "obj_ids", "for", "tree_id", "in", "obj_ids", ":", "if", "tree_id", "is", "not", "None", "and", "tree_id", "in", "Store", ".", "custom_options", "(", ")", ":", "original", "=", "Store", ".", "custom_options", "(", ")", "[", "tree_id", "]", "clone", "=", "OptionTree", "(", "items", "=", "original", ".", "items", "(", ")", ",", "groups", "=", "original", ".", "groups", ")", "clones", "[", "tree_id", "+", "offset", "+", "1", "]", "=", "clone", "id_mapping", ".", "append", "(", "(", "tree_id", ",", "tree_id", "+", "offset", "+", "1", ")", ")", "else", ":", "clone", "=", "OptionTree", "(", "groups", "=", "Store", ".", "options", "(", ")", ".", "groups", ")", "clones", "[", "offset", "]", "=", "clone", "id_mapping", ".", "append", "(", "(", "tree_id", ",", "offset", ")", ")", "# Nodes needed to ensure allowed_keywords is respected", "for", "k", "in", "Store", ".", "options", "(", ")", ":", "if", "k", "in", "[", "(", "opt", ".", "split", "(", "'.'", ")", "[", "0", "]", ",", ")", "for", "opt", "in", "options", "]", ":", "group", "=", "{", "grp", ":", "Options", "(", "allowed_keywords", "=", "opt", ".", "allowed_keywords", ")", "for", "(", "grp", ",", "opt", ")", "in", "Store", ".", "options", "(", ")", "[", "k", "]", ".", "groups", ".", "items", "(", ")", "}", "clone", "[", "k", "]", "=", "group", "return", "{", "k", ":", "cls", ".", "apply_customizations", "(", "options", ",", "t", ")", "if", "options", "else", "t", "for", "k", ",", "t", "in", "clones", ".", "items", "(", ")", "}", ",", "id_mapping" ]

[ "Returns", "the", "appropriate", "set", "of", "customized", "subtree", "clones", "for", "an", "object", "suitable", "for", "merging", "with", "Store", ".", "custom_options", "(", "i", ".", "e", "with", "the", "ids", "appropriately", "offset", ")", ".", "Note", "if", "an", "object", "has", "no", "integer", "ids", "a", "new", "OptionTree", "is", "built", "." ]

[ "def", "mfds2multimfd", "(", "mfds", ")", ":", "_", ",", "kind", "=", "mfds", "[", "0", "]", ".", "tag", ".", "split", "(", "'}'", ")", "node", "=", "Node", "(", "'multiMFD'", ",", "dict", "(", "kind", "=", "kind", ",", "size", "=", "len", "(", "mfds", ")", ")", ")", "lengths", "=", "None", "for", "field", "in", "mfd", ".", "multi_mfd", ".", "ASSOC", "[", "kind", "]", "[", "1", ":", "]", ":", "alias", "=", "mfd", ".", "multi_mfd", ".", "ALIAS", ".", "get", "(", "field", ",", "field", ")", "if", "field", "in", "(", "'magnitudes'", ",", "'occurRates'", ")", ":", "data", "=", "[", "~", "getattr", "(", "m", ",", "field", ")", "for", "m", "in", "mfds", "]", "lengths", "=", "[", "len", "(", "d", ")", "for", "d", "in", "data", "]", "data", "=", "sum", "(", "data", ",", "[", "]", ")", "# list of lists", "else", ":", "try", ":", "data", "=", "[", "m", "[", "alias", "]", "for", "m", "in", "mfds", "]", "except", "KeyError", ":", "if", "alias", "==", "'binWidth'", ":", "# missing bindWidth in GR MDFs is ok", "continue", "else", ":", "raise", "node", ".", "append", "(", "Node", "(", "field", ",", "text", "=", "collapse", "(", "data", ")", ")", ")", "if", "lengths", ":", "# this is the last field if present", "node", ".", "append", "(", "Node", "(", "'lengths'", ",", "text", "=", "collapse", "(", "lengths", ")", ")", ")", "return", "node" ]

[ "Convert", "a", "list", "of", "MFD", "nodes", "into", "a", "single", "MultiMFD", "node" ]

[ "def", "ensure_proper_casing", "(", "self", ")", ":", "pfile", "=", "self", ".", "parsed_pipfile", "casing_changed", "=", "self", ".", "proper_case_section", "(", "pfile", ".", "get", "(", "\"packages\"", ",", "{", "}", ")", ")", "casing_changed", "|=", "self", ".", "proper_case_section", "(", "pfile", ".", "get", "(", "\"dev-packages\"", ",", "{", "}", ")", ")", "return", "casing_changed" ]

[ "Ensures", "proper", "casing", "of", "Pipfile", "packages" ]

[ "def", "watch", "(", "filenames", ",", "callback", ",", "use_sudo", "=", "False", ")", ":", "filenames", "=", "[", "filenames", "]", "if", "isinstance", "(", "filenames", ",", "basestring", ")", "else", "filenames", "old_md5", "=", "{", "fn", ":", "md5sum", "(", "fn", ",", "use_sudo", ")", "for", "fn", "in", "filenames", "}", "yield", "for", "filename", "in", "filenames", ":", "if", "md5sum", "(", "filename", ",", "use_sudo", ")", "!=", "old_md5", "[", "filename", "]", ":", "callback", "(", ")", "return" ]

[ "Call", "callback", "if", "any", "of", "filenames", "change", "during", "the", "context" ]

[ "def", "_analyze_txt_config", "(", "self", ",", "config_string", "=", "None", ")", ":", "self", ".", "log", "(", "u\"Analyzing container with TXT config string\"", ")", "if", "config_string", "is", "None", ":", "self", ".", "log", "(", "u\"Analyzing container with TXT config file\"", ")", "config_entry", "=", "self", ".", "container", ".", "entry_config_txt", "self", ".", "log", "(", "[", "u\"Found TXT config entry '%s'\"", ",", "config_entry", "]", ")", "config_dir", "=", "os", ".", "path", ".", "dirname", "(", "config_entry", ")", "self", ".", "log", "(", "[", "u\"Directory of TXT config entry: '%s'\"", ",", "config_dir", "]", ")", "self", ".", "log", "(", "[", "u\"Reading TXT config entry: '%s'\"", ",", "config_entry", "]", ")", "config_contents", "=", "self", ".", "container", ".", "read_entry", "(", "config_entry", ")", "self", ".", "log", "(", "u\"Converting config contents to config string\"", ")", "config_contents", "=", "gf", ".", "safe_unicode", "(", "config_contents", ")", "config_string", "=", "gf", ".", "config_txt_to_string", "(", "config_contents", ")", "else", ":", "self", ".", "log", "(", "[", "u\"Analyzing container with TXT config string '%s'\"", ",", "config_string", "]", ")", "config_dir", "=", "\"\"", "self", ".", "log", "(", "u\"Creating the Job object\"", ")", "job", "=", "Job", "(", "config_string", ")", "self", ".", "log", "(", "u\"Getting entries\"", ")", "entries", "=", "self", ".", "container", ".", "entries", "self", ".", "log", "(", "u\"Converting config string into config dict\"", ")", "parameters", "=", "gf", ".", "config_string_to_dict", "(", "config_string", ")", "self", ".", "log", "(", "u\"Calculating the path of the tasks root directory\"", ")", "tasks_root_directory", "=", "gf", ".", "norm_join", "(", "config_dir", ",", "parameters", "[", "gc", ".", "PPN_JOB_IS_HIERARCHY_PREFIX", "]", ")", "self", ".", "log", "(", "[", "u\"Path of the tasks root directory: '%s'\"", ",", "tasks_root_directory", "]", ")", "self", ".", "log", "(", "u\"Calculating the path of the sync map root directory\"", ")", "sync_map_root_directory", "=", "gf", ".", "norm_join", "(", "config_dir", ",", "parameters", "[", "gc", ".", "PPN_JOB_OS_HIERARCHY_PREFIX", "]", ")", "job_os_hierarchy_type", "=", "parameters", "[", "gc", ".", "PPN_JOB_OS_HIERARCHY_TYPE", "]", "self", ".", "log", "(", "[", "u\"Path of the sync map root directory: '%s'\"", ",", "sync_map_root_directory", "]", ")", "text_file_relative_path", "=", "parameters", "[", "gc", ".", "PPN_JOB_IS_TEXT_FILE_RELATIVE_PATH", "]", "self", ".", "log", "(", "[", "u\"Relative path for text file: '%s'\"", ",", "text_file_relative_path", "]", ")", "text_file_name_regex", "=", "re", ".", "compile", "(", "r\"\"", "+", "parameters", "[", "gc", ".", "PPN_JOB_IS_TEXT_FILE_NAME_REGEX", "]", ")", "self", ".", "log", "(", "[", "u\"Regex for text file: '%s'\"", ",", "parameters", "[", "gc", ".", "PPN_JOB_IS_TEXT_FILE_NAME_REGEX", "]", "]", ")", "audio_file_relative_path", "=", "parameters", "[", "gc", ".", "PPN_JOB_IS_AUDIO_FILE_RELATIVE_PATH", "]", "self", ".", "log", "(", "[", "u\"Relative path for audio file: '%s'\"", ",", "audio_file_relative_path", "]", ")", "audio_file_name_regex", "=", "re", ".", "compile", "(", "r\"\"", "+", "parameters", "[", "gc", ".", "PPN_JOB_IS_AUDIO_FILE_NAME_REGEX", "]", ")", "self", ".", "log", "(", "[", "u\"Regex for audio file: '%s'\"", ",", "parameters", "[", "gc", ".", "PPN_JOB_IS_AUDIO_FILE_NAME_REGEX", "]", "]", ")", "if", "parameters", "[", "gc", ".", "PPN_JOB_IS_HIERARCHY_TYPE", "]", "==", "HierarchyType", ".", "FLAT", ":", "self", ".", "log", "(", "u\"Looking for text/audio pairs in flat hierarchy\"", ")", "text_files", "=", "self", ".", "_find_files", "(", "entries", ",", "tasks_root_directory", ",", "text_file_relative_path", ",", "text_file_name_regex", ")", "self", ".", "log", "(", "[", "u\"Found text files: '%s'\"", ",", "text_files", "]", ")", "audio_files", "=", "self", ".", "_find_files", "(", "entries", ",", "tasks_root_directory", ",", "audio_file_relative_path", ",", "audio_file_name_regex", ")", "self", ".", "log", "(", "[", "u\"Found audio files: '%s'\"", ",", "audio_files", "]", ")", "self", ".", "log", "(", "u\"Matching files in flat hierarchy...\"", ")", "matched_tasks", "=", "self", ".", "_match_files_flat_hierarchy", "(", "text_files", ",", "audio_files", ")", "self", ".", "log", "(", "u\"Matching files in flat hierarchy... done\"", ")", "for", "task_info", "in", "matched_tasks", ":", "self", ".", "log", "(", "[", "u\"Creating task: '%s'\"", ",", "str", "(", "task_info", ")", "]", ")", "task", "=", "self", ".", "_create_task", "(", "task_info", ",", "config_string", ",", "sync_map_root_directory", ",", "job_os_hierarchy_type", ")", "job", ".", "add_task", "(", "task", ")", "if", "parameters", "[", "gc", ".", "PPN_JOB_IS_HIERARCHY_TYPE", "]", "==", "HierarchyType", ".", "PAGED", ":", "self", ".", "log", "(", "u\"Looking for text/audio pairs in paged hierarchy\"", ")", "# find all subdirectories of tasks_root_directory", "# that match gc.PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX", "matched_directories", "=", "self", ".", "_match_directories", "(", "entries", ",", "tasks_root_directory", ",", "parameters", "[", "gc", ".", "PPN_JOB_IS_TASK_DIRECTORY_NAME_REGEX", "]", ")", "for", "matched_directory", "in", "matched_directories", ":", "# rebuild the full path", "matched_directory_full_path", "=", "gf", ".", "norm_join", "(", "tasks_root_directory", ",", "matched_directory", ")", "self", ".", "log", "(", "[", "u\"Looking for text/audio pairs in directory '%s'\"", ",", "matched_directory_full_path", "]", ")", "# look for text and audio files there", "text_files", "=", "self", ".", "_find_files", "(", "entries", ",", "matched_directory_full_path", ",", "text_file_relative_path", ",", "text_file_name_regex", ")", "self", ".", "log", "(", "[", "u\"Found text files: '%s'\"", ",", "text_files", "]", ")", "audio_files", "=", "self", ".", "_find_files", "(", "entries", ",", "matched_directory_full_path", ",", "audio_file_relative_path", ",", "audio_file_name_regex", ")", "self", ".", "log", "(", "[", "u\"Found audio files: '%s'\"", ",", "audio_files", "]", ")", "# if we have found exactly one text and one audio file,", "# create a Task", "if", "(", "len", "(", "text_files", ")", "==", "1", ")", "and", "(", "len", "(", "audio_files", ")", "==", "1", ")", ":", "self", ".", "log", "(", "[", "u\"Exactly one text file and one audio file in '%s'\"", ",", "matched_directory", "]", ")", "task_info", "=", "[", "matched_directory", ",", "text_files", "[", "0", "]", ",", "audio_files", "[", "0", "]", "]", "self", ".", "log", "(", "[", "u\"Creating task: '%s'\"", ",", "str", "(", "task_info", ")", "]", ")", "task", "=", "self", ".", "_create_task", "(", "task_info", ",", "config_string", ",", "sync_map_root_directory", ",", "job_os_hierarchy_type", ")", "job", ".", "add_task", "(", "task", ")", "elif", "len", "(", "text_files", ")", ">", "1", ":", "self", ".", "log", "(", "[", "u\"More than one text file in '%s'\"", ",", "matched_directory", "]", ")", "elif", "len", "(", "audio_files", ")", ">", "1", ":", "self", ".", "log", "(", "[", "u\"More than one audio file in '%s'\"", ",", "matched_directory", "]", ")", "else", ":", "self", ".", "log", "(", "[", "u\"No text nor audio file in '%s'\"", ",", "matched_directory", "]", ")", "return", "job" ]

[ "Analyze", "the", "given", "container", "and", "return", "the", "corresponding", "job", "." ]

[ "def", "columns", "(", "table", ",", "missing", "=", "None", ")", ":", "cols", "=", "OrderedDict", "(", ")", "it", "=", "iter", "(", "table", ")", "hdr", "=", "next", "(", "it", ")", "flds", "=", "list", "(", "map", "(", "text_type", ",", "hdr", ")", ")", "for", "f", "in", "flds", ":", "cols", "[", "f", "]", "=", "list", "(", ")", "for", "row", "in", "it", ":", "for", "f", ",", "v", "in", "izip_longest", "(", "flds", ",", "row", ",", "fillvalue", "=", "missing", ")", ":", "if", "f", "in", "cols", ":", "cols", "[", "f", "]", ".", "append", "(", "v", ")", "return", "cols" ]

[ "Construct", "a", ":", "class", ":", "dict", "mapping", "field", "names", "to", "lists", "of", "values", ".", "E", ".", "g", ".", "::" ]

[ "def", "next_frame_basic_stochastic", "(", ")", ":", "hparams", "=", "basic_deterministic_params", ".", "next_frame_basic_deterministic", "(", ")", "hparams", ".", "stochastic_model", "=", "True", "hparams", ".", "add_hparam", "(", "\"latent_channels\"", ",", "1", ")", "hparams", ".", "add_hparam", "(", "\"latent_std_min\"", ",", "-", "5.0", ")", "hparams", ".", "add_hparam", "(", "\"num_iterations_1st_stage\"", ",", "15000", ")", "hparams", ".", "add_hparam", "(", "\"num_iterations_2nd_stage\"", ",", "15000", ")", "hparams", ".", "add_hparam", "(", "\"latent_loss_multiplier\"", ",", "1e-3", ")", "hparams", ".", "add_hparam", "(", "\"latent_loss_multiplier_dynamic\"", ",", "False", ")", "hparams", ".", "add_hparam", "(", "\"latent_loss_multiplier_alpha\"", ",", "1e-5", ")", "hparams", ".", "add_hparam", "(", "\"latent_loss_multiplier_epsilon\"", ",", "1.0", ")", "hparams", ".", "add_hparam", "(", "\"latent_loss_multiplier_schedule\"", ",", "\"constant\"", ")", "hparams", ".", "add_hparam", "(", "\"latent_num_frames\"", ",", "0", ")", "# 0 means use all frames.", "hparams", ".", "add_hparam", "(", "\"anneal_end\"", ",", "50000", ")", "hparams", ".", "add_hparam", "(", "\"information_capacity\"", ",", "0.0", ")", "return", "hparams" ]

[ "Basic", "2", "-", "frame", "conv", "model", "with", "stochastic", "tower", "." ]

[ "def", "fullConn", "(", "self", ",", "preCellsTags", ",", "postCellsTags", ",", "connParam", ")", ":", "from", ".", ".", "import", "sim", "if", "sim", ".", "cfg", ".", "verbose", ":", "print", "(", "'Generating set of all-to-all connections (rule: %s) ...'", "%", "(", "connParam", "[", "'label'", "]", ")", ")", "# get list of params that have a lambda function", "paramsStrFunc", "=", "[", "param", "for", "param", "in", "[", "p", "+", "'Func'", "for", "p", "in", "self", ".", "connStringFuncParams", "]", "if", "param", "in", "connParam", "]", "for", "paramStrFunc", "in", "paramsStrFunc", ":", "# replace lambda function (with args as dict of lambda funcs) with list of values", "connParam", "[", "paramStrFunc", "[", ":", "-", "4", "]", "+", "'List'", "]", "=", "{", "(", "preGid", ",", "postGid", ")", ":", "connParam", "[", "paramStrFunc", "]", "(", "*", "*", "{", "k", ":", "v", "if", "isinstance", "(", "v", ",", "Number", ")", "else", "v", "(", "preCellTags", ",", "postCellTags", ")", "for", "k", ",", "v", "in", "connParam", "[", "paramStrFunc", "+", "'Vars'", "]", ".", "items", "(", ")", "}", ")", "for", "preGid", ",", "preCellTags", "in", "preCellsTags", ".", "items", "(", ")", "for", "postGid", ",", "postCellTags", "in", "postCellsTags", ".", "items", "(", ")", "}", "for", "postCellGid", "in", "postCellsTags", ":", "# for each postsyn cell", "if", "postCellGid", "in", "self", ".", "gid2lid", ":", "# check if postsyn is in this node's list of gids", "for", "preCellGid", ",", "preCellTags", "in", "preCellsTags", ".", "items", "(", ")", ":", "# for each presyn cell", "self", ".", "_addCellConn", "(", "connParam", ",", "preCellGid", ",", "postCellGid", ")" ]

[ "Generates", "connections", "between", "all", "pre", "and", "post", "-", "syn", "cells" ]

[ "def", "funnel_rebuild", "(", "psg_trm_spec", ")", ":", "param_score_gen", ",", "top_result_model", ",", "specification", "=", "psg_trm_spec", "params", ",", "score", ",", "gen", "=", "param_score_gen", "model", "=", "specification", "(", "*", "params", ")", "rmsd", "=", "top_result_model", ".", "rmsd", "(", "model", ")", "return", "rmsd", ",", "score", ",", "gen" ]

[ "Rebuilds", "a", "model", "and", "compares", "it", "to", "a", "reference", "model", "." ]

[ "def", "rank_member_if_in", "(", "self", ",", "leaderboard_name", ",", "rank_conditional", ",", "member", ",", "score", ",", "member_data", "=", "None", ")", ":", "current_score", "=", "self", ".", "redis_connection", ".", "zscore", "(", "leaderboard_name", ",", "member", ")", "if", "current_score", "is", "not", "None", ":", "current_score", "=", "float", "(", "current_score", ")", "if", "rank_conditional", "(", "self", ",", "member", ",", "current_score", ",", "score", ",", "member_data", ",", "{", "'reverse'", ":", "self", ".", "order", "}", ")", ":", "self", ".", "rank_member_in", "(", "leaderboard_name", ",", "member", ",", "score", ",", "member_data", ")" ]

[ "Rank", "a", "member", "in", "the", "named", "leaderboard", "based", "on", "execution", "of", "the", "+", "rank_conditional", "+", "." ]

[ "def", "get_share_url_with_dirname", "(", "uk", ",", "shareid", ",", "dirname", ")", ":", "return", "''", ".", "join", "(", "[", "const", ".", "PAN_URL", ",", "'wap/link'", ",", "'?shareid='", ",", "shareid", ",", "'&uk='", ",", "uk", ",", "'&dir='", ",", "encoder", ".", "encode_uri_component", "(", "dirname", ")", ",", "'&third=0'", ",", "]", ")" ]

[ "得到共享目录的链接" ]

[ "def", "_Resample", "(", "self", ",", "stats", ",", "target_size", ")", ":", "t_first", "=", "stats", "[", "0", "]", "[", "0", "]", "t_last", "=", "stats", "[", "-", "1", "]", "[", "0", "]", "interval", "=", "(", "t_last", "-", "t_first", ")", "/", "target_size", "result", "=", "[", "]", "current_t", "=", "t_first", "current_v", "=", "0", "i", "=", "0", "while", "i", "<", "len", "(", "stats", ")", ":", "stat_t", "=", "stats", "[", "i", "]", "[", "0", "]", "stat_v", "=", "stats", "[", "i", "]", "[", "1", "]", "if", "stat_t", "<=", "(", "current_t", "+", "interval", ")", ":", "# Always add the last value in an interval to the result.", "current_v", "=", "stat_v", "i", "+=", "1", "else", ":", "result", ".", "append", "(", "[", "current_t", "+", "interval", ",", "current_v", "]", ")", "current_t", "+=", "interval", "result", ".", "append", "(", "[", "current_t", "+", "interval", ",", "current_v", "]", ")", "return", "result" ]

[ "Resamples", "the", "stats", "to", "have", "a", "specific", "number", "of", "data", "points", "." ]

[ "def", "on_connect", "(", "self", ",", "connection", ")", ":", "self", ".", "_sock", "=", "connection", ".", "_sock", "self", ".", "_buffer", "=", "SocketBuffer", "(", "self", ".", "_sock", ",", "self", ".", "socket_read_size", ")", "if", "connection", ".", "decode_responses", ":", "self", ".", "encoding", "=", "connection", ".", "encoding" ]

[ "Called", "when", "the", "socket", "connects" ]

[ "def", "remove_chain", "(", "self", ",", "chain", "=", "-", "1", ")", ":", "if", "isinstance", "(", "chain", ",", "str", ")", "or", "isinstance", "(", "chain", ",", "int", ")", ":", "chain", "=", "[", "chain", "]", "chain", "=", "sorted", "(", "[", "i", "for", "c", "in", "chain", "for", "i", "in", "self", ".", "_get_chain", "(", "c", ")", "]", ")", "[", ":", ":", "-", "1", "]", "assert", "len", "(", "chain", ")", "==", "len", "(", "list", "(", "set", "(", "chain", ")", ")", ")", ",", "\"Error, you are trying to remove a chain more than once.\"", "for", "index", "in", "chain", ":", "del", "self", ".", "chains", "[", "index", "]", "seen", "=", "set", "(", ")", "self", ".", "_all_parameters", "=", "[", "p", "for", "c", "in", "self", ".", "chains", "for", "p", "in", "c", ".", "parameters", "if", "not", "(", "p", "in", "seen", "or", "seen", ".", "add", "(", "p", ")", ")", "]", "# Need to reconfigure", "self", ".", "_init_params", "(", ")", "return", "self" ]

[ "Removes", "a", "chain", "from", "ChainConsumer", ".", "Calling", "this", "will", "require", "any", "configurations", "set", "to", "be", "redone!" ]

[ "def", "get_proxies_from_environ", "(", ")", ":", "proxies", "=", "{", "}", "http_proxy", "=", "os", ".", "getenv", "(", "'http_proxy'", ")", "or", "os", ".", "getenv", "(", "'HTTP_PROXY'", ")", "https_proxy", "=", "os", ".", "getenv", "(", "'https_proxy'", ")", "or", "os", ".", "getenv", "(", "'HTTPS_PROXY'", ")", "if", "http_proxy", ":", "proxies", "[", "'http'", "]", "=", "http_proxy", "if", "https_proxy", ":", "proxies", "[", "'https'", "]", "=", "https_proxy", "return", "proxies" ]

[ "Get", "proxies", "from", "os", ".", "environ", "." ]

[ "def", "cert", "(", "name", ",", "aliases", "=", "None", ",", "email", "=", "None", ",", "webroot", "=", "None", ",", "test_cert", "=", "False", ",", "renew", "=", "None", ",", "keysize", "=", "None", ",", "server", "=", "None", ",", "owner", "=", "'root'", ",", "group", "=", "'root'", ",", "mode", "=", "'0640'", ",", "certname", "=", "None", ",", "preferred_challenges", "=", "None", ",", "tls_sni_01_port", "=", "None", ",", "tls_sni_01_address", "=", "None", ",", "http_01_port", "=", "None", ",", "http_01_address", "=", "None", ",", "dns_plugin", "=", "None", ",", "dns_plugin_credentials", "=", "None", ",", "dns_plugin_propagate_seconds", "=", "10", ")", ":", "cmd", "=", "[", "LEA", ",", "'certonly'", ",", "'--non-interactive'", ",", "'--agree-tos'", "]", "supported_dns_plugins", "=", "[", "'cloudflare'", ",", "'digitalocean'", "]", "cert_file", "=", "_cert_file", "(", "name", ",", "'cert'", ")", "if", "not", "__salt__", "[", "'file.file_exists'", "]", "(", "cert_file", ")", ":", "log", ".", "debug", "(", "'Certificate %s does not exist (yet)'", ",", "cert_file", ")", "renew", "=", "False", "elif", "needs_renewal", "(", "name", ",", "renew", ")", ":", "log", ".", "debug", "(", "'Certificate %s will be renewed'", ",", "cert_file", ")", "cmd", ".", "append", "(", "'--renew-by-default'", ")", "renew", "=", "True", "if", "server", ":", "cmd", ".", "append", "(", "'--server {0}'", ".", "format", "(", "server", ")", ")", "if", "certname", ":", "cmd", ".", "append", "(", "'--cert-name {0}'", ".", "format", "(", "certname", ")", ")", "if", "test_cert", ":", "if", "server", ":", "return", "{", "'result'", ":", "False", ",", "'comment'", ":", "'Use either server or test_cert, not both'", "}", "cmd", ".", "append", "(", "'--test-cert'", ")", "if", "webroot", ":", "cmd", ".", "append", "(", "'--authenticator webroot'", ")", "if", "webroot", "is", "not", "True", ":", "cmd", ".", "append", "(", "'--webroot-path {0}'", ".", "format", "(", "webroot", ")", ")", "elif", "dns_plugin", "in", "supported_dns_plugins", ":", "if", "dns_plugin", "==", "'cloudflare'", ":", "cmd", ".", "append", "(", "'--dns-cloudflare'", ")", "cmd", ".", "append", "(", "'--dns-cloudflare-credentials {0}'", ".", "format", "(", "dns_plugin_credentials", ")", ")", "cmd", ".", "append", "(", "'--dns-cloudflare-propagation-seconds {0}'", ".", "format", "(", "dns_plugin_propagate_seconds", ")", ")", "elif", "dns_plugin", "==", "'digitalocean'", ":", "cmd", ".", "append", "(", "'--dns-digitalocean'", ")", "cmd", ".", "append", "(", "'--dns-digitalocean-credentials {0}'", ".", "format", "(", "dns_plugin_credentials", ")", ")", "cmd", ".", "append", "(", "'--dns-digitalocean-propagation-seconds {0}'", ".", "format", "(", "dns_plugin_propagate_seconds", ")", ")", "else", ":", "return", "{", "'result'", ":", "False", ",", "'comment'", ":", "'DNS plugin \\'{0}\\' is not supported'", ".", "format", "(", "dns_plugin", ")", "}", "else", ":", "cmd", ".", "append", "(", "'--authenticator standalone'", ")", "if", "email", ":", "cmd", ".", "append", "(", "'--email {0}'", ".", "format", "(", "email", ")", ")", "if", "keysize", ":", "cmd", ".", "append", "(", "'--rsa-key-size {0}'", ".", "format", "(", "keysize", ")", ")", "cmd", ".", "append", "(", "'--domains {0}'", ".", "format", "(", "name", ")", ")", "if", "aliases", "is", "not", "None", ":", "for", "dns", "in", "aliases", ":", "cmd", ".", "append", "(", "'--domains {0}'", ".", "format", "(", "dns", ")", ")", "if", "preferred_challenges", ":", "cmd", ".", "append", "(", "'--preferred-challenges {}'", ".", "format", "(", "preferred_challenges", ")", ")", "if", "tls_sni_01_port", ":", "cmd", ".", "append", "(", "'--tls-sni-01-port {}'", ".", "format", "(", "tls_sni_01_port", ")", ")", "if", "tls_sni_01_address", ":", "cmd", ".", "append", "(", "'--tls-sni-01-address {}'", ".", "format", "(", "tls_sni_01_address", ")", ")", "if", "http_01_port", ":", "cmd", ".", "append", "(", "'--http-01-port {}'", ".", "format", "(", "http_01_port", ")", ")", "if", "http_01_address", ":", "cmd", ".", "append", "(", "'--http-01-address {}'", ".", "format", "(", "http_01_address", ")", ")", "res", "=", "__salt__", "[", "'cmd.run_all'", "]", "(", "' '", ".", "join", "(", "cmd", ")", ")", "if", "res", "[", "'retcode'", "]", "!=", "0", ":", "if", "'expand'", "in", "res", "[", "'stderr'", "]", ":", "cmd", ".", "append", "(", "'--expand'", ")", "res", "=", "__salt__", "[", "'cmd.run_all'", "]", "(", "' '", ".", "join", "(", "cmd", ")", ")", "if", "res", "[", "'retcode'", "]", "!=", "0", ":", "return", "{", "'result'", ":", "False", ",", "'comment'", ":", "'Certificate {0} renewal failed with:\\n{1}'", ".", "format", "(", "name", ",", "res", "[", "'stderr'", "]", ")", "}", "else", ":", "return", "{", "'result'", ":", "False", ",", "'comment'", ":", "'Certificate {0} renewal failed with:\\n{1}'", ".", "format", "(", "name", ",", "res", "[", "'stderr'", "]", ")", "}", "if", "'no action taken'", "in", "res", "[", "'stdout'", "]", ":", "comment", "=", "'Certificate {0} unchanged'", ".", "format", "(", "cert_file", ")", "result", "=", "None", "elif", "renew", ":", "comment", "=", "'Certificate {0} renewed'", ".", "format", "(", "name", ")", "result", "=", "True", "else", ":", "comment", "=", "'Certificate {0} obtained'", ".", "format", "(", "name", ")", "result", "=", "True", "ret", "=", "{", "'comment'", ":", "comment", ",", "'not_after'", ":", "expires", "(", "name", ")", ",", "'changes'", ":", "{", "}", ",", "'result'", ":", "result", "}", "ret", ",", "_", "=", "__salt__", "[", "'file.check_perms'", "]", "(", "_cert_file", "(", "name", ",", "'privkey'", ")", ",", "ret", ",", "owner", ",", "group", ",", "mode", ",", "follow_symlinks", "=", "True", ")", "return", "ret" ]

[ "Obtain", "/", "renew", "a", "certificate", "from", "an", "ACME", "CA", "probably", "Let", "s", "Encrypt", "." ]

[ "def", "_ensure_tf_install", "(", ")", ":", "# pylint: disable=g-statement-before-imports", "try", ":", "import", "tensorflow", "as", "tf", "except", "ImportError", ":", "# Print more informative error message, then reraise.", "print", "(", "\"\\n\\nFailed to import TensorFlow. Please note that TensorFlow is not \"", "\"installed by default when you install TensorFlow Probability. This \"", "\"is so that users can decide whether to install the GPU-enabled \"", "\"TensorFlow package. To use TensorFlow Probability, please install \"", "\"the most recent version of TensorFlow, by following instructions at \"", "\"https://tensorflow.org/install.\\n\\n\"", ")", "raise", "import", "distutils", ".", "version", "#", "# Update this whenever we need to depend on a newer TensorFlow release.", "#", "required_tensorflow_version", "=", "\"1.13\"", "if", "(", "distutils", ".", "version", ".", "LooseVersion", "(", "tf", ".", "__version__", ")", "<", "distutils", ".", "version", ".", "LooseVersion", "(", "required_tensorflow_version", ")", ")", ":", "raise", "ImportError", "(", "\"This version of TensorFlow Probability requires TensorFlow \"", "\"version >= {required}; Detected an installation of version {present}. \"", "\"Please upgrade TensorFlow to proceed.\"", ".", "format", "(", "required", "=", "required_tensorflow_version", ",", "present", "=", "tf", ".", "__version__", ")", ")" ]

[ "Attempt", "to", "import", "tensorflow", "and", "ensure", "its", "version", "is", "sufficient", "." ]

[ "def", "unique", "(", "text", ")", ":", "# check if the text is correct", "correct", ",", "error", "=", "_is_correct", "(", "text", ")", "if", "not", "correct", ":", "raise", "Exception", "(", "error", ")", "s", "=", "[", "]", "_all_unique_texts", "(", "text", ",", "s", ")", "return", "s", "[", "0", "]" ]

[ "Return", "an", "unique", "text" ]

[ "def", "create_attachment", "(", "cls", ",", "session", ",", "attachment", ")", ":", "return", "super", "(", "Conversations", ",", "cls", ")", ".", "create", "(", "session", ",", "attachment", ",", "endpoint_override", "=", "'/attachments.json'", ",", "out_type", "=", "Attachment", ",", ")" ]

[ "Create", "an", "attachment", "." ]

[ "def", "xml", "(", "cls", ",", "res", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "parse_xml", "(", "res", ".", "text", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parses", "XML", "from", "a", "response", "." ]

[ "def", "files", "(", "self", ")", ":", "# try new file header format first, then fallback on old", "for", "header", "in", "(", "r\"(.*)\\t\\[\\[\\[1\\n\"", ",", "r\"^(\\d+)\\n$\"", ")", ":", "header", "=", "re", ".", "compile", "(", "header", ")", "filename", "=", "None", "self", ".", "fd", ".", "seek", "(", "0", ")", "line", "=", "self", ".", "readline", "(", ")", "while", "line", ":", "m", "=", "header", ".", "match", "(", "line", ")", "if", "m", "is", "not", "None", ":", "filename", "=", "m", ".", "group", "(", "1", ")", "try", ":", "filelines", "=", "int", "(", "self", ".", "readline", "(", ")", ".", "rstrip", "(", ")", ")", "except", "ValueError", ":", "raise", "ArchiveError", "(", "'invalid archive format'", ")", "filestart", "=", "self", ".", "fd", ".", "tell", "(", ")", "yield", "(", "filename", ",", "filelines", ",", "filestart", ")", "line", "=", "self", ".", "readline", "(", ")", "if", "filename", "is", "not", "None", ":", "break" ]

[ "Yields", "archive", "file", "information", "." ]

[ "def", "get_modules", "(", "paths", ",", "toplevel", "=", "True", ")", ":", "modules", "=", "[", "]", "for", "path", "in", "paths", ":", "path", "=", "os", ".", "path", ".", "abspath", "(", "path", ")", "if", "toplevel", "and", "path", ".", "endswith", "(", "'.pyc'", ")", ":", "sys", ".", "exit", "(", "'.pyc files are not supported: {0}'", ".", "format", "(", "path", ")", ")", "if", "os", ".", "path", ".", "isfile", "(", "path", ")", "and", "(", "path", ".", "endswith", "(", "'.py'", ")", "or", "toplevel", ")", ":", "modules", ".", "append", "(", "path", ")", "elif", "os", ".", "path", ".", "isdir", "(", "path", ")", ":", "subpaths", "=", "[", "os", ".", "path", ".", "join", "(", "path", ",", "filename", ")", "for", "filename", "in", "sorted", "(", "os", ".", "listdir", "(", "path", ")", ")", "]", "modules", ".", "extend", "(", "get_modules", "(", "subpaths", ",", "toplevel", "=", "False", ")", ")", "elif", "toplevel", ":", "sys", ".", "exit", "(", "'Error: {0} could not be found.'", ".", "format", "(", "path", ")", ")", "return", "modules" ]

[ "Take", "files", "from", "the", "command", "line", "even", "if", "they", "don", "t", "end", "with", ".", "py", "." ]

[ "def", "delete_api_deployment", "(", "restApiId", ",", "deploymentId", ",", "region", "=", "None", ",", "key", "=", "None", ",", "keyid", "=", "None", ",", "profile", "=", "None", ")", ":", "try", ":", "conn", "=", "_get_conn", "(", "region", "=", "region", ",", "key", "=", "key", ",", "keyid", "=", "keyid", ",", "profile", "=", "profile", ")", "conn", ".", "delete_deployment", "(", "restApiId", "=", "restApiId", ",", "deploymentId", "=", "deploymentId", ")", "return", "{", "'deleted'", ":", "True", "}", "except", "ClientError", "as", "e", ":", "return", "{", "'deleted'", ":", "False", ",", "'error'", ":", "__utils__", "[", "'boto3.get_error'", "]", "(", "e", ")", "}" ]

[ "Deletes", "API", "deployment", "for", "a", "given", "restApiId", "and", "deploymentID" ]

[ "def", "_direct_render", "(", "self", ",", "name", ",", "attrs", ")", ":", "context", "=", "{", "'image'", ":", "self", ".", "image_url", "(", ")", ",", "'name'", ":", "name", ",", "'key'", ":", "self", ".", "_key", ",", "'id'", ":", "u'%s_%s'", "%", "(", "self", ".", "id_prefix", ",", "attrs", ".", "get", "(", "'id'", ")", ")", "if", "self", ".", "id_prefix", "else", "attrs", ".", "get", "(", "'id'", ")", ",", "'audio'", ":", "self", ".", "audio_url", "(", ")", ",", "}", "self", ".", "image_and_audio", "=", "render_to_string", "(", "settings", ".", "CAPTCHA_IMAGE_TEMPLATE", ",", "context", ")", "self", ".", "hidden_field", "=", "render_to_string", "(", "settings", ".", "CAPTCHA_HIDDEN_FIELD_TEMPLATE", ",", "context", ")", "self", ".", "text_field", "=", "render_to_string", "(", "settings", ".", "CAPTCHA_TEXT_FIELD_TEMPLATE", ",", "context", ")", "return", "self", ".", "format_output", "(", "None", ")" ]

[ "Render", "the", "widget", "the", "old", "way", "-", "using", "field_template", "or", "output_format", "." ]

[ "def", "fromAddress", "(", "address", ")", ":", "validate_address", "(", "address", ")", "address_as_integer", "=", "int", "(", "address", ",", "16", ")", "address_as_base36", "=", "baseN", "(", "address_as_integer", ",", "36", ")", "padded", "=", "pad_left_hex", "(", "address_as_base36", ",", "15", ")", "return", "Iban", ".", "fromBban", "(", "padded", ".", "upper", "(", ")", ")" ]

[ "This", "method", "should", "be", "used", "to", "create", "an", "iban", "object", "from", "ethereum", "address" ]

[ "def", "strip_prefix_from_list", "(", "list", ",", "strip", ")", ":", "for", "i", "in", "range", "(", "len", "(", "list", ")", ")", ":", "list", "[", "i", "]", "=", "strip_prefix", "(", "list", "[", "i", "]", ",", "strip", ")" ]

[ "Goes", "through", "a", "list", "of", "strings", "and", "removes", "the", "specified", "prefix", "from", "the", "beginning", "of", "each", "string", "in", "place", "." ]

[ "def", "removeBiosample", "(", "self", ",", "biosample", ")", ":", "q", "=", "models", ".", "Biosample", ".", "delete", "(", ")", ".", "where", "(", "models", ".", "Biosample", ".", "id", "==", "biosample", ".", "getId", "(", ")", ")", "q", ".", "execute", "(", ")" ]

[ "Removes", "the", "specified", "biosample", "from", "this", "repository", "." ]

[ "def", "run", "(", "edges", ",", "iterations", "=", "1000", ",", "force_strength", "=", "5.0", ",", "dampening", "=", "0.01", ",", "max_velocity", "=", "2.0", ",", "max_distance", "=", "50", ",", "is_3d", "=", "True", ")", ":", "# Get a list of node ids from the edge data", "nodes", "=", "set", "(", "e", "[", "'source'", "]", "for", "e", "in", "edges", ")", "|", "set", "(", "e", "[", "'target'", "]", "for", "e", "in", "edges", ")", "# Convert to a data-storing object and initialize some values", "d", "=", "3", "if", "is_3d", "else", "2", "nodes", "=", "{", "n", ":", "{", "'velocity'", ":", "[", "0.0", "]", "*", "d", ",", "'force'", ":", "[", "0.0", "]", "*", "d", "}", "for", "n", "in", "nodes", "}", "# Repeat n times (is there a more Pythonic way to do this?)", "for", "_", "in", "repeat", "(", "None", ",", "iterations", ")", ":", "# Add in Coulomb-esque node-node repulsive forces", "for", "node1", ",", "node2", "in", "combinations", "(", "nodes", ".", "values", "(", ")", ",", "2", ")", ":", "_coulomb", "(", "node1", ",", "node2", ",", "force_strength", ",", "max_distance", ")", "# And Hooke-esque edge spring forces", "for", "edge", "in", "edges", ":", "_hooke", "(", "nodes", "[", "edge", "[", "'source'", "]", "]", ",", "nodes", "[", "edge", "[", "'target'", "]", "]", ",", "force_strength", "*", "edge", ".", "get", "(", "'size'", ",", "1", ")", ",", "max_distance", ")", "# Move by resultant force", "for", "node", "in", "nodes", ".", "values", "(", ")", ":", "# Constrain the force to the bounds specified by input parameter", "force", "=", "[", "_constrain", "(", "dampening", "*", "f", ",", "-", "max_velocity", ",", "max_velocity", ")", "for", "f", "in", "node", "[", "'force'", "]", "]", "# Update velocities and reset force", "node", "[", "'velocity'", "]", "=", "[", "v", "+", "dv", "for", "v", ",", "dv", "in", "zip", "(", "node", "[", "'velocity'", "]", ",", "force", ")", "]", "node", "[", "'force'", "]", "=", "[", "0", "]", "*", "d", "# Clean and return", "for", "node", "in", "nodes", ".", "values", "(", ")", ":", "del", "node", "[", "'force'", "]", "node", "[", "'location'", "]", "=", "node", "[", "'velocity'", "]", "del", "node", "[", "'velocity'", "]", "# Even if it's 2D, let's specify three dimensions", "if", "not", "is_3d", ":", "node", "[", "'location'", "]", "+=", "[", "0.0", "]", "return", "nodes" ]

[ "Runs", "a", "force", "-", "directed", "-", "layout", "algorithm", "on", "the", "input", "graph", "." ]

[ "def", "time_correlation_direct_by_mtx_vec_prod", "(", "P", ",", "mu", ",", "obs1", ",", "obs2", "=", "None", ",", "time", "=", "1", ",", "start_values", "=", "None", ",", "return_P_k_obs", "=", "False", ")", ":", "# input checks", "if", "not", "(", "type", "(", "time", ")", "==", "int", ")", ":", "if", "not", "(", "type", "(", "time", ")", "==", "np", ".", "int64", ")", ":", "raise", "TypeError", "(", "\"given time (%s) is not an integer, but has type: %s\"", "%", "(", "str", "(", "time", ")", ",", "type", "(", "time", ")", ")", ")", "if", "obs1", ".", "shape", "[", "0", "]", "!=", "P", ".", "shape", "[", "0", "]", ":", "raise", "ValueError", "(", "\"observable shape not compatible with given matrix\"", ")", "if", "obs2", "is", "None", ":", "obs2", "=", "obs1", "# multiply element-wise obs1 and pi. this is obs1' diag(pi)", "l", "=", "np", ".", "multiply", "(", "obs1", ",", "mu", ")", "# raise transition matrix to power of time by substituting dot product", "# <Pk, obs2> with something like <P, <P, obs2>>.", "# This saves a lot of matrix matrix multiplications.", "if", "start_values", ":", "# begin with a previous calculated val", "P_i_obs", "=", "start_values", "[", "1", "]", "# calculate difference properly!", "time_prev", "=", "start_values", "[", "0", "]", "t_diff", "=", "time", "-", "time_prev", "r", "=", "range", "(", "t_diff", ")", "else", ":", "if", "time", ">=", "2", ":", "P_i_obs", "=", "np", ".", "dot", "(", "P", ",", "np", ".", "dot", "(", "P", ",", "obs2", ")", ")", "# vector <P, <P, obs2> := P^2 * obs", "r", "=", "range", "(", "time", "-", "2", ")", "elif", "time", "==", "1", ":", "P_i_obs", "=", "np", ".", "dot", "(", "P", ",", "obs2", ")", "# P^1 = P*obs", "r", "=", "range", "(", "0", ")", "elif", "time", "==", "0", ":", "# P^0 = I => I*obs2 = obs2", "P_i_obs", "=", "obs2", "r", "=", "range", "(", "0", ")", "for", "k", "in", "r", ":", "# since we already substituted started with 0", "P_i_obs", "=", "np", ".", "dot", "(", "P", ",", "P_i_obs", ")", "corr", "=", "np", ".", "dot", "(", "l", ",", "P_i_obs", ")", "if", "return_P_k_obs", ":", "return", "corr", ",", "(", "time", ",", "P_i_obs", ")", "else", ":", "return", "corr" ]

[ "r", "Compute", "time", "-", "correlation", "of", "obs1", "or", "time", "-", "cross", "-", "correlation", "with", "obs2", "." ]

[ "def", "resolve", "(", "self", ")", ":", "# AWS_* variables must always be passed to the function, but user has the choice to override them", "result", "=", "self", ".", "_get_aws_variables", "(", ")", "# Default value for the variable gets lowest priority", "for", "name", ",", "value", "in", "self", ".", "variables", ".", "items", "(", ")", ":", "# Shell environment values, second priority", "if", "name", "in", "self", ".", "shell_env_values", ":", "value", "=", "self", ".", "shell_env_values", "[", "name", "]", "# Overridden values, highest priority", "if", "name", "in", "self", ".", "override_values", ":", "value", "=", "self", ".", "override_values", "[", "name", "]", "# Any value must be a string when passed to Lambda runtime.", "# Runtime expects a Map<String, String> for environment variables", "result", "[", "name", "]", "=", "self", ".", "_stringify_value", "(", "value", ")", "return", "result" ]

[ "Resolves", "the", "values", "from", "different", "sources", "and", "returns", "a", "dict", "of", "environment", "variables", "to", "use", "when", "running", "the", "function", "locally", "." ]

[ "def", "get_flanker", "(", "group", ",", "query", ")", ":", "group", ".", "sort", "(", ")", "pos", "=", "bisect_left", "(", "group", ",", "(", "query", ",", "0", ")", ")", "left_flanker", "=", "group", "[", "0", "]", "if", "pos", "==", "0", "else", "group", "[", "pos", "-", "1", "]", "right_flanker", "=", "group", "[", "-", "1", "]", "if", "pos", "==", "len", "(", "group", ")", "else", "group", "[", "pos", "]", "# pick the closest flanker", "if", "abs", "(", "query", "-", "left_flanker", "[", "0", "]", ")", "<", "abs", "(", "query", "-", "right_flanker", "[", "0", "]", ")", ":", "flanker", ",", "other", "=", "left_flanker", ",", "right_flanker", "else", ":", "flanker", ",", "other", "=", "right_flanker", ",", "left_flanker", "flanked", "=", "not", "(", "pos", "==", "0", "or", "pos", "==", "len", "(", "group", ")", "or", "flanker", "==", "query", ")", "return", "flanker", ",", "other", ",", "flanked" ]

[ ">>>", "get_flanker", "(", "[", "(", "370", "15184", ")", "(", "372", "15178", ")", "(", "373", "15176", ")", "(", "400", "15193", ")", "]", "385", ")", "((", "373", "15176", ")", "(", "400", "15193", ")", "True", ")" ]

[ "def", "list_dir", "(", "self", ")", ":", "bucket", "=", "self", ".", "blob", ".", "bucket", "prefix", "=", "self", ".", "blob", ".", "name", "if", "not", "prefix", ".", "endswith", "(", "'/'", ")", ":", "prefix", "+=", "'/'", "for", "blob", "in", "bucket", ".", "list_blobs", "(", "prefix", "=", "prefix", ",", "delimiter", "=", "'/'", ")", ":", "yield", "'gs://{}/{}'", ".", "format", "(", "blob", ".", "bucket", ".", "name", ",", "blob", ".", "name", ")" ]

[ "Non", "-", "recursive", "file", "listing", "." ]

[ "def", "isOpeningTag", "(", "self", ")", ":", "if", "self", ".", "isTag", "(", ")", "and", "not", "self", ".", "isComment", "(", ")", "and", "not", "self", ".", "isEndTag", "(", ")", "and", "not", "self", ".", "isNonPairTag", "(", ")", ":", "return", "True", "return", "False" ]

[ "Detect", "whether", "this", "tag", "is", "opening", "or", "not", "." ]