Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "IsOk", "(", "self", ")", "-", ">", "bool" ]

[ "def", "IsOk", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewItem_IsOk", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "If", "the", "given", "arithmetic", "operation", "fails", "attempt", "it", "again", "on", "only", "the", "non", "-", "null", "elements", "of", "the", "input", "array", "(", "s", ")", "." ]

[ "def", "masked_arith_op", "(", "x", ",", "y", ",", "op", ")", ":", "# For Series `x` is 1D so ravel() is a no-op; calling it anyway makes", "# the logic valid for both Series and DataFrame ops.", "xrav", "=", "x", ".", "ravel", "(", ")", "assert", "isinstance", "(", "x", ",", "(", "np", ".", "ndarray", ",", "ABCSeries", ")", ")", ",", "type", "(", "x", ")", "if", "isinstance", "(", "y", ",", "(", "np", ".", "ndarray", ",", "ABCSeries", ",", "ABCIndexClass", ")", ")", ":", "dtype", "=", "find_common_type", "(", "[", "x", ".", "dtype", ",", "y", ".", "dtype", "]", ")", "result", "=", "np", ".", "empty", "(", "x", ".", "size", ",", "dtype", "=", "dtype", ")", "# PeriodIndex.ravel() returns int64 dtype, so we have", "# to work around that case. See GH#19956", "yrav", "=", "y", "if", "is_period_dtype", "(", "y", ")", "else", "y", ".", "ravel", "(", ")", "mask", "=", "notna", "(", "xrav", ")", "&", "notna", "(", "yrav", ")", "if", "yrav", ".", "shape", "!=", "mask", ".", "shape", ":", "# FIXME: GH#5284, GH#5035, GH#19448", "# Without specifically raising here we get mismatched", "# errors in Py3 (TypeError) vs Py2 (ValueError)", "# Note: Only = an issue in DataFrame case", "raise", "ValueError", "(", "'Cannot broadcast operands together.'", ")", "if", "mask", ".", "any", "(", ")", ":", "with", "np", ".", "errstate", "(", "all", "=", "'ignore'", ")", ":", "result", "[", "mask", "]", "=", "op", "(", "xrav", "[", "mask", "]", ",", "com", ".", "values_from_object", "(", "yrav", "[", "mask", "]", ")", ")", "else", ":", "assert", "is_scalar", "(", "y", ")", ",", "type", "(", "y", ")", "assert", "isinstance", "(", "x", ",", "np", ".", "ndarray", ")", ",", "type", "(", "x", ")", "# mask is only meaningful for x", "result", "=", "np", ".", "empty", "(", "x", ".", "size", ",", "dtype", "=", "x", ".", "dtype", ")", "mask", "=", "notna", "(", "xrav", ")", "# 1 ** np.nan is 1. So we have to unmask those.", "if", "op", "==", "pow", ":", "mask", "=", "np", ".", "where", "(", "x", "==", "1", ",", "False", ",", "mask", ")", "elif", "op", "==", "rpow", ":", "mask", "=", "np", ".", "where", "(", "y", "==", "1", ",", "False", ",", "mask", ")", "if", "mask", ".", "any", "(", ")", ":", "with", "np", ".", "errstate", "(", "all", "=", "'ignore'", ")", ":", "result", "[", "mask", "]", "=", "op", "(", "xrav", "[", "mask", "]", ",", "y", ")", "result", ",", "changed", "=", "maybe_upcast_putmask", "(", "result", ",", "~", "mask", ",", "np", ".", "nan", ")", "result", "=", "result", ".", "reshape", "(", "x", ".", "shape", ")", "# 2D compat", "return", "result" ]

[ "Return", "a", "list", "of", "all", "parameter", "nodes", "for", "this", "module", "Multiple", "parameter", "nodes", "are", "useful", "for", "storing", "multiple", "parameter", "sets", "in", "a", "single", "scene", "." ]

[ "def", "getAllParameterNodes", "(", "self", ")", ":", "foundParameterNodes", "=", "[", "]", "numberOfScriptedModuleNodes", "=", "slicer", ".", "mrmlScene", ".", "GetNumberOfNodesByClass", "(", "\"vtkMRMLScriptedModuleNode\"", ")", "for", "nodeIndex", "in", "range", "(", "numberOfScriptedModuleNodes", ")", ":", "parameterNode", "=", "slicer", ".", "mrmlScene", ".", "GetNthNodeByClass", "(", "nodeIndex", ",", "\"vtkMRMLScriptedModuleNode\"", ")", "if", "parameterNode", ".", "GetAttribute", "(", "\"ModuleName\"", ")", "==", "self", ".", "moduleName", ":", "foundParameterNodes", ".", "append", "(", "parameterNode", ")", "return", "foundParameterNodes" ]

[ "Like", "processKill", "()", "but", "checks", "if", "the", "process", "name", "matches", "before", "killing", "it", ".", "This", "is", "intended", "for", "killing", "using", "potentially", "stale", "pid", "values", "." ]

[ "def", "processKillWithNameCheck", "(", "uPid", ",", "sName", ")", ":", "if", "processCheckPidAndName", "(", "uPid", ",", "sName", ")", "is", "not", "True", ":", "return", "False", "return", "processKill", "(", "uPid", ")" ]

[ "Check", "whether", "this", "is", "a", "fake", "forked", "process", "in", "a", "frozen", "executable", ".", "If", "so", "then", "run", "code", "specified", "by", "commandline", "and", "exit", "." ]

[ "def", "freeze_support", "(", ")", ":", "if", "sys", ".", "platform", "==", "'win32'", "and", "getattr", "(", "sys", ",", "'frozen'", ",", "False", ")", ":", "from", "multiprocessing", ".", "forking", "import", "freeze_support", "freeze_support", "(", ")" ]

[ "Equivalent", "to", "node", ".", "children", ".", "insert", "(", "i", "child", ")", ".", "This", "method", "also", "sets", "the", "child", "s", "parent", "attribute", "appropriately", "." ]

[ "def", "insert_child", "(", "self", ",", "i", ",", "child", ")", ":", "child", ".", "parent", "=", "self", "self", ".", "children", ".", "insert", "(", "i", ",", "child", ")", "self", ".", "changed", "(", ")" ]

[ "Extract", "all", "entities", "tagged", "with", "a", "physical", "marker", "in", "the", "gmsh", "model", "and", "collects", "the", "data", "per", "cell", "type", ".", "Returns", "a", "nested", "dictionary", "where", "the", "first", "key", "is", "the", "gmsh", "MSH", "element", "type", "integer", ".", "Each", "element", "type", "present", "in", "the", "model", "contains", "the", "cell", "topology", "of", "the", "elements", "and", "corresponding", "markers", "." ]

[ "def", "extract_gmsh_topology_and_markers", "(", "gmsh_model", ",", "model_name", "=", "None", ")", ":", "if", "model_name", "is", "not", "None", ":", "gmsh_model", ".", "setCurrent", "(", "model_name", ")", "# Get the physical groups from gmsh on the form [(dim1, tag1),(dim1,", "# tag2), (dim2, tag3),...]", "phys_grps", "=", "gmsh_model", ".", "getPhysicalGroups", "(", ")", "topologies", "=", "{", "}", "for", "dim", ",", "tag", "in", "phys_grps", ":", "# Get the entities for a given dimension:", "# dim=0->Points, dim=1->Lines, dim=2->Triangles/Quadrilaterals,", "# etc.", "entities", "=", "gmsh_model", ".", "getEntitiesForPhysicalGroup", "(", "dim", ",", "tag", ")", "for", "entity", "in", "entities", ":", "# Get data about the elements on a given entity:", "# NOTE: Assumes that each entity only have one cell-type", "element_data", "=", "gmsh_model", ".", "mesh", ".", "getElements", "(", "dim", ",", "tag", "=", "entity", ")", "element_types", ",", "element_tags", ",", "node_tags", "=", "element_data", "assert", "len", "(", "element_types", ")", "==", "1", "# The MSH type of the cells on the element", "element_type", "=", "element_types", "[", "0", "]", "num_el", "=", "len", "(", "element_tags", "[", "0", "]", ")", "# Determine number of local nodes per element to create the", "# topology of the elements", "properties", "=", "gmsh_model", ".", "mesh", ".", "getElementProperties", "(", "element_type", ")", "name", ",", "dim", ",", "order", ",", "num_nodes", ",", "local_coords", ",", "_", "=", "properties", "# 2D array of shape (num_elements,num_nodes_per_element)", "# containing the topology of the elements on this entity", "# NOTE: GMSH indexing starts with 1 and not zero", "element_topology", "=", "node_tags", "[", "0", "]", ".", "reshape", "(", "-", "1", ",", "num_nodes", ")", "-", "1", "# Gather data for each element type and the", "# corresponding physical markers", "if", "element_type", "in", "topologies", ".", "keys", "(", ")", ":", "topologies", "[", "element_type", "]", "[", "\"topology\"", "]", "=", "np", ".", "concatenate", "(", "(", "topologies", "[", "element_type", "]", "[", "\"topology\"", "]", ",", "element_topology", ")", ",", "axis", "=", "0", ")", "topologies", "[", "element_type", "]", "[", "\"cell_data\"", "]", "=", "np", ".", "concatenate", "(", "(", "topologies", "[", "element_type", "]", "[", "\"cell_data\"", "]", ",", "np", ".", "full", "(", "num_el", ",", "tag", ")", ")", ",", "axis", "=", "0", ")", "else", ":", "topologies", "[", "element_type", "]", "=", "{", "\"topology\"", ":", "element_topology", ",", "\"cell_data\"", ":", "np", ".", "full", "(", "num_el", ",", "tag", ")", "}", "return", "topologies" ]

[ "return", "the", "correct", "fill", "value", "for", "the", "dtype", "of", "the", "values" ]

[ "def", "_get_fill_value", "(", "dtype", ",", "fill_value", "=", "None", ",", "fill_value_typ", "=", "None", ")", ":", "if", "fill_value", "is", "not", "None", ":", "return", "fill_value", "if", "_na_ok_dtype", "(", "dtype", ")", ":", "if", "fill_value_typ", "is", "None", ":", "return", "np", ".", "nan", "else", ":", "if", "fill_value_typ", "==", "'+inf'", ":", "return", "np", ".", "inf", "else", ":", "return", "-", "np", ".", "inf", "else", ":", "if", "fill_value_typ", "is", "None", ":", "return", "tslibs", ".", "iNaT", "else", ":", "if", "fill_value_typ", "==", "'+inf'", ":", "# need the max int here", "return", "_int64_max", "else", ":", "return", "tslibs", ".", "iNaT" ]

[ "Undo", "(", "self", ")" ]

[ "def", "Undo", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "TextEntryBase_Undo", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "signature", "contents", "of", "this", "action", "s", "command", "line", "." ]

[ "def", "get_presig", "(", "self", ",", "target", ",", "source", ",", "env", ",", "executor", "=", "None", ")", ":", "return", "self", ".", "_generate", "(", "target", ",", "source", ",", "env", ",", "1", ",", "executor", ")", ".", "get_presig", "(", "target", ",", "source", ",", "env", ")" ]

[ "Parse", "a", "dictionary", "of", "declarations", "from", "text", "." ]

[ "def", "parse_decls", "(", "text", ")", ":", "decls", "=", "collections", ".", "OrderedDict", "(", ")", "idx", "=", "LIndex", "(", "text", ")", "for", "m", "in", "doc", ".", "finditer", "(", "text", ")", ":", "line", ",", "_", "=", "idx", ".", "linecol", "(", "m", ".", "span", "(", "'decl'", ")", "[", "0", "]", ")", "d", "=", "Decl", "(", "m", ".", "group", "(", "'text'", ")", ",", "m", ".", "group", "(", "'decl'", ")", ",", "line", ")", "decls", "[", "d", ".", "name", "]", "=", "d", "return", "decls" ]

[ "Set", "the", "input", "delimiter", ".", "Can", "be", "a", "fixed", "string", "of", "any", "length", "an", "integer", "or", "None" ]

[ "def", "set_terminator", "(", "self", ",", "term", ")", ":", "self", ".", "terminator", "=", "term" ]

[ "Set", "metadata", "." ]

[ "def", "setxattr", "(", "self", ",", "path", ",", "copy_kwargs", "=", "None", ",", "*", "*", "kw_args", ")", ":", "bucket", ",", "key", ",", "version_id", "=", "self", ".", "split_path", "(", "path", ")", "metadata", "=", "self", ".", "metadata", "(", "path", ")", "metadata", ".", "update", "(", "*", "*", "kw_args", ")", "copy_kwargs", "=", "copy_kwargs", "or", "{", "}", "# remove all keys that are None", "for", "kw_key", "in", "kw_args", ":", "if", "kw_args", "[", "kw_key", "]", "is", "None", ":", "metadata", ".", "pop", "(", "kw_key", ",", "None", ")", "src", "=", "{", "'Bucket'", ":", "bucket", ",", "'Key'", ":", "key", "}", "if", "version_id", ":", "src", "[", "'VersionId'", "]", "=", "version_id", "self", ".", "_call_s3", "(", "self", ".", "s3", ".", "copy_object", ",", "copy_kwargs", ",", "CopySource", "=", "src", ",", "Bucket", "=", "bucket", ",", "Key", "=", "key", ",", "Metadata", "=", "metadata", ",", "MetadataDirective", "=", "'REPLACE'", ",", ")", "# refresh metadata", "self", ".", "_metadata_cache", "[", "path", "]", "=", "metadata" ]

[ "Returns", "a", "Basic", "Auth", "string", "." ]

[ "def", "_basic_auth_str", "(", "username", ",", "password", ")", ":", "# \"I want us to put a big-ol' comment on top of it that", "# says that this behaviour is dumb but we need to preserve", "# it because people are relying on it.\"", "# - Lukasa", "#", "# These are here solely to maintain backwards compatibility", "# for things like ints. This will be removed in 3.0.0.", "if", "not", "isinstance", "(", "username", ",", "basestring", ")", ":", "warnings", ".", "warn", "(", "\"Non-string usernames will no longer be supported in Requests \"", "\"3.0.0. Please convert the object you've passed in ({!r}) to \"", "\"a string or bytes object in the near future to avoid \"", "\"problems.\"", ".", "format", "(", "username", ")", ",", "category", "=", "DeprecationWarning", ",", ")", "username", "=", "str", "(", "username", ")", "if", "not", "isinstance", "(", "password", ",", "basestring", ")", ":", "warnings", ".", "warn", "(", "\"Non-string passwords will no longer be supported in Requests \"", "\"3.0.0. Please convert the object you've passed in ({!r}) to \"", "\"a string or bytes object in the near future to avoid \"", "\"problems.\"", ".", "format", "(", "type", "(", "password", ")", ")", ",", "category", "=", "DeprecationWarning", ",", ")", "password", "=", "str", "(", "password", ")", "# -- End Removal --", "if", "isinstance", "(", "username", ",", "str", ")", ":", "username", "=", "username", ".", "encode", "(", "'latin1'", ")", "if", "isinstance", "(", "password", ",", "str", ")", ":", "password", "=", "password", ".", "encode", "(", "'latin1'", ")", "authstr", "=", "'Basic '", "+", "to_native_string", "(", "b64encode", "(", "b':'", ".", "join", "(", "(", "username", ",", "password", ")", ")", ")", ".", "strip", "(", ")", ")", "return", "authstr" ]

[ "Preprocess", "true", "boxes", "to", "training", "input", "format" ]

[ "def", "preprocess_true_boxes", "(", "true_boxes", ",", "input_shape", ",", "anchors", ",", "num_classes", ")", ":", "assert", "(", "true_boxes", "[", "...", ",", "4", "]", "<", "num_classes", ")", ".", "all", "(", ")", ",", "'class id must be less than num_classes'", "num_layers", "=", "len", "(", "anchors", ")", "//", "3", "# default setting", "anchor_mask", "=", "[", "[", "6", ",", "7", ",", "8", "]", ",", "[", "3", ",", "4", ",", "5", "]", ",", "[", "0", ",", "1", ",", "2", "]", "]", "if", "num_layers", "==", "3", "else", "[", "[", "3", ",", "4", ",", "5", "]", ",", "[", "1", ",", "2", ",", "3", "]", "]", "true_boxes", "=", "np", ".", "array", "(", "true_boxes", ",", "dtype", "=", "'float32'", ")", "input_shape", "=", "np", ".", "array", "(", "input_shape", ",", "dtype", "=", "'int32'", ")", "boxes_xy", "=", "(", "true_boxes", "[", "...", ",", "0", ":", "2", "]", "+", "true_boxes", "[", "...", ",", "2", ":", "4", "]", ")", "//", "2", "boxes_wh", "=", "true_boxes", "[", "...", ",", "2", ":", "4", "]", "-", "true_boxes", "[", "...", ",", "0", ":", "2", "]", "true_boxes", "[", "...", ",", "0", ":", "2", "]", "=", "boxes_xy", "/", "input_shape", "[", ":", ":", "-", "1", "]", "true_boxes", "[", "...", ",", "2", ":", "4", "]", "=", "boxes_wh", "/", "input_shape", "[", ":", ":", "-", "1", "]", "m", "=", "true_boxes", ".", "shape", "[", "0", "]", "grid_shapes", "=", "[", "input_shape", "//", "{", "0", ":", "32", ",", "1", ":", "16", ",", "2", ":", "8", "}", "[", "l", "]", "for", "l", "in", "range", "(", "num_layers", ")", "]", "y_true", "=", "[", "np", ".", "zeros", "(", "(", "m", ",", "grid_shapes", "[", "l", "]", "[", "0", "]", ",", "grid_shapes", "[", "l", "]", "[", "1", "]", ",", "len", "(", "anchor_mask", "[", "l", "]", ")", ",", "5", "+", "num_classes", ")", ",", "dtype", "=", "'float32'", ")", "for", "l", "in", "range", "(", "num_layers", ")", "]", "# Expand dim to apply broadcasting.", "anchors", "=", "np", ".", "expand_dims", "(", "anchors", ",", "0", ")", "anchor_maxes", "=", "anchors", "/", "2.", "anchor_mins", "=", "-", "anchor_maxes", "valid_mask", "=", "boxes_wh", "[", "...", ",", "0", "]", ">", "0", "for", "b", "in", "range", "(", "m", ")", ":", "# Discard zero rows.", "wh", "=", "boxes_wh", "[", "b", ",", "valid_mask", "[", "b", "]", "]", "if", "len", "(", "wh", ")", "==", "0", ":", "continue", "# Expand dim to apply broadcasting.", "wh", "=", "np", ".", "expand_dims", "(", "wh", ",", "-", "2", ")", "box_maxes", "=", "wh", "/", "2.", "box_mins", "=", "-", "box_maxes", "intersect_mins", "=", "np", ".", "maximum", "(", "box_mins", ",", "anchor_mins", ")", "intersect_maxes", "=", "np", ".", "minimum", "(", "box_maxes", ",", "anchor_maxes", ")", "intersect_wh", "=", "np", ".", "maximum", "(", "intersect_maxes", "-", "intersect_mins", ",", "0.", ")", "intersect_area", "=", "intersect_wh", "[", "...", ",", "0", "]", "*", "intersect_wh", "[", "...", ",", "1", "]", "box_area", "=", "wh", "[", "...", ",", "0", "]", "*", "wh", "[", "...", ",", "1", "]", "anchor_area", "=", "anchors", "[", "...", ",", "0", "]", "*", "anchors", "[", "...", ",", "1", "]", "iou", "=", "intersect_area", "/", "(", "box_area", "+", "anchor_area", "-", "intersect_area", ")", "# Find best anchor for each true box", "best_anchor", "=", "np", ".", "argmax", "(", "iou", ",", "axis", "=", "-", "1", ")", "for", "t", ",", "n", "in", "enumerate", "(", "best_anchor", ")", ":", "for", "l", "in", "range", "(", "num_layers", ")", ":", "if", "n", "in", "anchor_mask", "[", "l", "]", ":", "i", "=", "np", ".", "floor", "(", "true_boxes", "[", "b", ",", "t", ",", "0", "]", "*", "grid_shapes", "[", "l", "]", "[", "1", "]", ")", ".", "astype", "(", "'int32'", ")", "j", "=", "np", ".", "floor", "(", "true_boxes", "[", "b", ",", "t", ",", "1", "]", "*", "grid_shapes", "[", "l", "]", "[", "0", "]", ")", ".", "astype", "(", "'int32'", ")", "k", "=", "anchor_mask", "[", "l", "]", ".", "index", "(", "n", ")", "c", "=", "true_boxes", "[", "b", ",", "t", ",", "4", "]", ".", "astype", "(", "'int32'", ")", "y_true", "[", "l", "]", "[", "b", ",", "j", ",", "i", ",", "k", ",", "0", ":", "4", "]", "=", "true_boxes", "[", "b", ",", "t", ",", "0", ":", "4", "]", "y_true", "[", "l", "]", "[", "b", ",", "j", ",", "i", ",", "k", ",", "4", "]", "=", "1", "y_true", "[", "l", "]", "[", "b", ",", "j", ",", "i", ",", "k", ",", "5", "+", "c", "]", "=", "1", "return", "y_true" ]

[ "Open", "the", "underlying", "transport" ]

[ "def", "open", "(", "self", ")", ":", "self", ".", "_init_stats", "(", ")", "return", "self", ".", "__trans", ".", "open", "(", ")" ]

[ "Load", "information", "from", "an", "ExodusII", "file", "." ]

[ "def", "import_model", "(", "filename", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "model", "=", "ExodusModel", "(", ")", "model", ".", "import_model", "(", "filename", ",", "*", "args", ",", "*", "*", "kwargs", ")", "return", "model" ]

[ "Called", "when", "the", "notebook", "is", "idle", "and", "this", "instance", "is", "the", "active", "tab", "." ]

[ "def", "DoOnIdle", "(", "self", ")", ":", "pass" ]

[ "Emit", "a", "record", "." ]

[ "def", "emit", "(", "self", ",", "record", ")", ":", "try", ":", "s", "=", "self", ".", "makePickle", "(", "record", ")", "self", ".", "send", "(", "s", ")", "except", "Exception", ":", "self", ".", "handleError", "(", "record", ")" ]

[ "Create", "a", "new", "cell", "in", "the", "notebook", "that", "applies", "the", "tactic" ]

[ "def", "apply_goal_tactic", "(", "goal", ",", "tactic", ")", ":", "code", "=", "'''{}(goal({!r}))'''", ".", "format", "(", "tactic", ",", "goal", ".", "id", ")", "yield", "ExecuteNewCell", "(", "code", ")" ]

[ "Return", "path", "to", "an", "MSVC", "executable", "program", "." ]

[ "def", "find_exe", "(", "self", ",", "exe", ")", ":", "for", "p", "in", "self", ".", "__paths", ":", "fn", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "abspath", "(", "p", ")", ",", "exe", ")", "if", "os", ".", "path", ".", "isfile", "(", "fn", ")", ":", "return", "fn", "# didn't find it; try existing path", "for", "p", "in", "os", ".", "environ", "[", "'Path'", "]", ".", "split", "(", "';'", ")", ":", "fn", "=", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "abspath", "(", "p", ")", ",", "exe", ")", "if", "os", ".", "path", ".", "isfile", "(", "fn", ")", ":", "return", "fn", "return", "exe" ]

[ "r", "Overrides", "the", "default", "whitespace", "chars" ]

[ "def", "setDefaultWhitespaceChars", "(", "chars", ")", ":", "ParserElement", ".", "DEFAULT_WHITE_CHARS", "=", "chars" ]

[ "Return", "version", "of", "MSVC", "runtime", "library", "as", "defined", "by", "__MSC_VER__", "macro" ]

[ "def", "msvc_runtime_version", "(", ")", ":", "msc_pos", "=", "sys", ".", "version", ".", "find", "(", "'MSC v.'", ")", "if", "msc_pos", "!=", "-", "1", ":", "msc_ver", "=", "int", "(", "sys", ".", "version", "[", "msc_pos", "+", "6", ":", "msc_pos", "+", "10", "]", ")", "else", ":", "msc_ver", "=", "None", "return", "msc_ver" ]

[ ":", "param", "refeq", ":", "value", "of", "benchmark", "for", "equilibrium", "Reaction", ":", "param", "rrat", ":", "ratio", "of", "intermonomer", "separation", "for", "Reaction", "to", "equilibrium", "Reaction", ":", "param", "xi", ":", "parameter", ":", "return", ":", "weight", "for", "CURE" ]

[ "def", "cure_weight", "(", "refrxn", ",", "refeq", ",", "rrat", ",", "xi", "=", "0.2", ")", ":", "sigma", "=", "xi", "*", "abs", "(", "refeq", ")", "/", "(", "rrat", "**", "3", ")", "weight", "=", "max", "(", "abs", "(", "refrxn", ")", ",", "sigma", ")", "return", "weight" ]

[ "Write", "the", "ending", "of", "the", "block", "." ]

[ "def", "__exit__", "(", "self", ",", "*", "args", ")", ":", "# type: (*str) -> None", "self", ".", "_writer", ".", "write_unindented_line", "(", "self", ".", "_closing", ")" ]

[ "Deletes", "a", "layer", "from", "the", "network", "." ]

[ "def", "delete_layer", "(", "self", ",", "layer", ")", ":", "if", "type", "(", "layer", ")", "is", "str", ":", "self", ".", "_delete_layer", "(", "layer", ")", "elif", "isinstance", "(", "layer", ",", "Layer", ")", ":", "self", ".", "_delete_layer", "(", "layer", ".", "name", ")", "else", ":", "raise", "ValueError", "(", "'The `layer` is expected to be `str` or `neoml.Dnn.Layer`'", ")" ]

[ "initialize", "the", "serial", "port", "and", "default", "network", "parameters", "Args", ":", "**", "kwargs", ":", "Arbitrary", "keyword", "arguments", "Includes", "EUI", "and", "SerialPort" ]

[ "def", "__init__", "(", "self", ",", "*", "*", "kwargs", ")", ":", "self", ".", "intialize", "(", "kwargs", ")" ]

[ "Deprecated", "getter", "for", "the", "_ctypes", ".", "strides", "property", "." ]

[ "def", "get_strides", "(", "self", ")", ":", "warnings", ".", "warn", "(", "'\"get_strides\" is deprecated. Use \"strides\" instead'", ",", "DeprecationWarning", ",", "stacklevel", "=", "2", ")", "return", "self", ".", "strides" ]

[ "Construct", "the", "package", "for", "(", "arch", "distro", "spec", ")", "getting", "packaging", "files", "from", "srcdir", "and", "any", "user", "-", "specified", "suffix", "from", "suffixes" ]

[ "def", "make_package", "(", "distro", ",", "build_os", ",", "arch", ",", "spec", ",", "srcdir", ")", ":", "sdir", "=", "setupdir", "(", "distro", ",", "build_os", ",", "arch", ",", "spec", ")", "packager", ".", "ensure_dir", "(", "sdir", ")", "# Note that the RPM packages get their man pages from the debian", "# directory, so the debian directory is needed in all cases (and", "# innocuous in the debianoids' sdirs).", "for", "pkgdir", "in", "[", "\"debian\"", ",", "\"rpm\"", "]", ":", "print", "\"Copying packaging files from %s to %s\"", "%", "(", "\"%s/%s\"", "%", "(", "srcdir", ",", "pkgdir", ")", ",", "sdir", ")", "# FIXME: sh-dash-cee is bad. See if tarfile can do this.", "packager", ".", "sysassert", "(", "[", "\"sh\"", ",", "\"-c\"", ",", "\"(cd \\\"%s\\\" && git archive %s %s/ ) | (cd \\\"%s\\\" && tar xvf -)\"", "%", "(", "srcdir", ",", "spec", ".", "metadata_gitspec", "(", ")", ",", "pkgdir", ",", "sdir", ")", "]", ")", "# Splat the binaries and snmp files under sdir. The \"build\" stages of the", "# packaging infrastructure will move the files to wherever they", "# need to go.", "unpack_binaries_into", "(", "build_os", ",", "arch", ",", "spec", ",", "sdir", ")", "# Remove the mongoreplay binary due to libpcap dynamic", "# linkage.", "if", "os", ".", "path", ".", "exists", "(", "sdir", "+", "\"bin/mongoreplay\"", ")", ":", "os", ".", "unlink", "(", "sdir", "+", "\"bin/mongoreplay\"", ")", "return", "distro", ".", "make_pkg", "(", "build_os", ",", "arch", ",", "spec", ",", "srcdir", ")" ]

[ "Test", "a", "single", "line", "against", "multi", "-", "line", "change", "." ]

[ "def", "__call__", "(", "self", ",", "line", ")", ":", "if", "self", ".", "_tracked_lines", "[", "self", ".", "_current", "]", "in", "line", ":", "self", ".", "_current", "=", "self", ".", "_current", "+", "1", "if", "self", ".", "_current", "==", "len", "(", "self", ".", "_tracked_lines", ")", ":", "self", ".", "_current", "=", "0", "return", "True", "else", ":", "self", ".", "_current", "=", "0", "return", "False" ]

[ ":", "type", "root1", ":", "TreeNode", ":", "type", "root2", ":", "TreeNode", ":", "rtype", ":", "List", "[", "int", "]" ]

[ "def", "getAllElements", "(", "self", ",", "root1", ",", "root2", ")", ":", "def", "inorder_gen", "(", "root", ")", ":", "result", ",", "stack", "=", "[", "]", ",", "[", "(", "root", ",", "False", ")", "]", "while", "stack", ":", "root", ",", "is_visited", "=", "stack", ".", "pop", "(", ")", "if", "root", "is", "None", ":", "continue", "if", "is_visited", ":", "yield", "root", ".", "val", "else", ":", "stack", ".", "append", "(", "(", "root", ".", "right", ",", "False", ")", ")", "stack", ".", "append", "(", "(", "root", ",", "True", ")", ")", "stack", ".", "append", "(", "(", "root", ".", "left", ",", "False", ")", ")", "yield", "None", "result", "=", "[", "]", "left_gen", ",", "right_gen", "=", "inorder_gen", "(", "root1", ")", ",", "inorder_gen", "(", "root2", ")", "left", ",", "right", "=", "next", "(", "left_gen", ")", ",", "next", "(", "right_gen", ")", "while", "left", "is", "not", "None", "or", "right", "is", "not", "None", ":", "if", "right", "is", "None", "or", "(", "left", "is", "not", "None", "and", "left", "<", "right", ")", ":", "result", ".", "append", "(", "left", ")", "left", "=", "next", "(", "left_gen", ")", "else", ":", "result", ".", "append", "(", "right", ")", "right", "=", "next", "(", "right_gen", ")", "return", "result" ]

[ "Feed", "a", "block", "of", "data", "to", "the", "hash", "." ]

[ "def", "feed", "(", "self", ",", "block", ")", ":", "return" ]

[ "This", "function", "builds", "burnup", "matrix", "A", ".", "Decay", "only", "." ]

[ "def", "_build_matrix", "(", "N", ")", ":", "A", "=", "np", ".", "zeros", "(", "(", "len", "(", "N", ")", ",", "len", "(", "N", ")", ")", ")", "# convert N to id form", "N_id", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "N", ")", ")", ":", "if", "isinstance", "(", "N", "[", "i", "]", ",", "str", ")", ":", "ID", "=", "nucname", ".", "id", "(", "N", "[", "i", "]", ")", "else", ":", "ID", "=", "N", "[", "i", "]", "N_id", ".", "append", "(", "ID", ")", "sds", "=", "SimpleDataSource", "(", ")", "# Decay", "for", "i", "in", "range", "(", "len", "(", "N", ")", ")", ":", "A", "[", "i", ",", "i", "]", "-=", "decay_const", "(", "N_id", "[", "i", "]", ")", "# Find decay parents", "for", "k", "in", "range", "(", "len", "(", "N", ")", ")", ":", "if", "N_id", "[", "i", "]", "in", "decay_children", "(", "N_id", "[", "k", "]", ")", ":", "A", "[", "i", ",", "k", "]", "+=", "branch_ratio", "(", "N_id", "[", "k", "]", ",", "N_id", "[", "i", "]", ")", "*", "decay_const", "(", "N_id", "[", "k", "]", ")", "return", "A" ]

[ "Recursively", "search", "the", "the", "origin", "parent", "TreeItem", "in", "parents", "." ]

[ "def", "getWalterStandinItem", "(", "self", ")", ":", "parent", "=", "self", ".", "parent", "(", ")", "if", "not", "parent", ".", "parent", "(", ")", ":", "return", "self", "return", "parent", ".", "getWalterStandinItem", "(", ")" ]

[ "SetValueAsLong", "(", "self", "int", "row", "int", "col", "long", "value", ")" ]

[ "def", "SetValueAsLong", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "GridTableBase_SetValueAsLong", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "workspace", "indicies", "for", "the", "given", "ymin", "/", "ymax", "values", "on", "the", "given", "workspace", ":", "param", "workspace", ":", "A", "MatrixWorkspace", "object", "spectra", "Y", "Axis", ":", "param", "ymin", ":", "Minimum", "Y", "value", "in", "range", ":", "param", "ymax", ":", "Maximum", "Y", "value", "in", "range" ]

[ "def", "_index_range_spectraaxis", "(", "workspace", ":", "MatrixWorkspace", ",", "ymin", ":", "float", ",", "ymax", ":", "float", ")", ":", "if", "ymin", "is", "None", "or", "ymax", "is", "None", ":", "return", "0", ",", "workspace", ".", "getNumberHistograms", "(", ")", "-", "1", "else", ":", "spectra_axis", "=", "workspace", ".", "getAxis", "(", "1", ")", "return", "spectra_axis", ".", "indexOfValue", "(", "ymin", ")", ",", "spectra_axis", ".", "indexOfValue", "(", "ymax", ")" ]

[ "Handles", "when", "the", "normalisation", "line", "edit", "has", "been", "changed", "by", "the", "user", "." ]

[ "def", "handle_normalisation_changed", "(", "self", ")", "->", "None", ":", "self", ".", "model", ".", "set_current_normalisation", "(", "self", ".", "view", ".", "normalisation", ")", "self", ".", "update_plot_guess", "(", ")", "self", ".", "fit_parameter_changed_notifier", ".", "notify_subscribers", "(", ")" ]

[ "performs", "inference", "/", "evaluation", "Args", ":", "data_layer", ":", "data", "layer", "object", "that", "holds", "data", "loader", "audio_processor", ":", "data", "processing", "module", "greedy_decoder", ":", "greedy", "decoder", "labels", ":", "list", "of", "labels", "as", "output", "vocabulary", "args", ":", "script", "input", "arguments" ]

[ "def", "eval", "(", "data_layer", ",", "audio_processor", ",", "greedy_decoder", ",", "labels", ",", "args", ")", ":", "start_t", "=", "time", ".", "time", "(", ")", "if", "args", ".", "mode", "==", "1", "or", "args", ".", "mode", "==", "2", ":", "rnnt_hw_model", "=", "RNNT_infer_model", "(", ")", "else", ":", "rnnt_hw_model", "=", "None", "logits_save_to", "=", "args", ".", "logits_save_to", "with", "torch", ".", "no_grad", "(", ")", ":", "_global_var_dict", "=", "{", "'predictions'", ":", "[", "]", ",", "'transcripts'", ":", "[", "]", ",", "'logits'", ":", "[", "]", ",", "}", "Processnum", "=", "[", "]", "for", "it", ",", "data", "in", "enumerate", "(", "data_layer", ".", "data_iterator", ")", ":", "if", "args", ".", "mode", "==", "3", ":", "(", "t_audio_signal_e", ",", "t_a_sig_length_e", ",", "transcript_list", ",", "t_transcript_e", ",", "t_transcript_len_e", ")", "=", "audio_processor", "(", "data", ")", "h_rnns", "=", "(", "None", ",", "None", ")", "label", "=", "[", "]", "hidden", "=", "None", "#greedy decode on cpu ", "t_transcript_e", "=", "torch", ".", "nn", ".", "utils", ".", "rnn", ".", "pad_packed_sequence", "(", "t_transcript_e", ",", "batch_first", "=", "True", ")", "[", "0", "]", "t_predictions_e", ",", "h_pre_rnns", ",", "hidden_predict", ",", "decode_batch_length", "=", "greedy_decoder", ".", "decode", "(", "t_audio_signal_e", ",", "t_a_sig_length_e", ",", "h_rnns", ",", "label", ",", "hidden", ",", "None", ")", "else", ":", "Process_ver", "=", "MyProcess", "(", "data", ",", "audio_processor", ",", "_global_var_dict", ",", "labels", ",", "ver_Process", ",", "rnnt_hw_model", ",", "greedy_decoder", ")", "Process_ver", ".", "start", "(", ")", "Processnum", ".", "append", "(", "it", ")", "if", "args", ".", "steps", "is", "not", "None", "and", "it", "+", "1", ">=", "args", ".", "steps", ":", "break", "if", "args", ".", "mode", "!=", "3", ":", "for", "id", "in", "Processnum", ":", "Process_ver", ".", "join", "(", ")", "else", ":", "values_dict", "=", "dict", "(", "predictions", "=", "[", "t_predictions_e", "]", ",", "transcript", "=", "transcript_list", ",", "transcript_length", "=", "t_transcript_len_e", ",", ")", "process_evaluation_batch", "(", "values_dict", ",", "_global_var_dict", ",", "labels", "=", "labels", ")", "wer", "=", "process_evaluation_epoch", "(", "_global_var_dict", ")", "print", "(", "\"=================>Evaluation WER: {0}\\n\"", ".", "format", "(", "wer", ")", ")", "if", "args", ".", "save_prediction", "is", "not", "None", ":", "with", "open", "(", "args", ".", "save_prediction", ",", "'w'", ")", "as", "fp", ":", "fp", ".", "write", "(", "'\\n'", ".", "join", "(", "_global_var_dict", "[", "'predictions'", "]", ")", ")", "end_t", "=", "time", ".", "time", "(", ")", "if", "args", ".", "mode", "==", "1", ":", "print", "(", "'dpu computation time (lstm_run time)'", ",", "sum", "(", "lstm_run_time_t", ")", ")", "print", "(", "'e2e decode time:'", ",", "end_t", "-", "start_t", ")" ]

[ "Expand", "the", "given", "build", "request", "by", "combining", "all", "property_sets", "which", "don", "t", "specify", "conflicting", "non", "-", "free", "features", "." ]

[ "def", "expand_no_defaults", "(", "property_sets", ")", ":", "# First make all features and subfeatures explicit", "expanded_property_sets", "=", "[", "ps", ".", "expand_subfeatures", "(", ")", "for", "ps", "in", "property_sets", "]", "# Now combine all of the expanded property_sets", "product", "=", "__x_product", "(", "expanded_property_sets", ")", "return", "[", "property_set", ".", "create", "(", "p", ")", "for", "p", "in", "product", "]" ]

[ "Converts", "html", "numbers", "with", "exponents", "to", "floats" ]

[ "def", "parse_num", "(", "dst", ")", ":", "nums", "=", "dst", ".", "split", "(", "'x'", ")", "base", "=", "float", "(", "nums", "[", "0", "]", ")", "exp", "=", "(", "nums", "[", "1", "]", ".", "split", "(", "'^{'", ")", "[", "1", "]", ")", ".", "split", "(", "'}'", ")", "[", "0", "]", "return", "base", "*", "10", "**", "float", "(", "exp", ")" ]

[ "Returns", "the", "buildbot", "s", "equivalent", "value", "." ]

[ "def", "GetBuildbotValue", "(", "self", ")", ":", "raise", "NotImplementedError", "(", ")" ]

[ "GetNoCopies", "(", "self", ")", "-", ">", "int" ]

[ "def", "GetNoCopies", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PrintDialogData_GetNoCopies", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Register", "a", "new", "TokenKind", "enumeration", "." ]

[ "def", "register", "(", "value", ",", "name", ")", ":", "if", "value", "in", "TokenKind", ".", "_value_map", ":", "raise", "ValueError", "(", "'TokenKind already registered: %d'", "%", "value", ")", "kind", "=", "TokenKind", "(", "value", ",", "name", ")", "TokenKind", ".", "_value_map", "[", "value", "]", "=", "kind", "setattr", "(", "TokenKind", ",", "name", ",", "kind", ")" ]

[ "Adds", "files", "and", "/", "or", "filters", "to", "the", "parent", "node", "." ]

[ "def", "_AddFilesToNode", "(", "self", ",", "parent", ",", "files", ")", ":", "for", "f", "in", "files", ":", "if", "isinstance", "(", "f", ",", "Filter", ")", ":", "node", "=", "[", "'Filter'", ",", "{", "'Name'", ":", "f", ".", "name", "}", "]", "self", ".", "_AddFilesToNode", "(", "node", ",", "f", ".", "contents", ")", "else", ":", "node", "=", "[", "'File'", ",", "{", "'RelativePath'", ":", "f", "}", "]", "self", ".", "files_dict", "[", "f", "]", "=", "node", "parent", ".", "append", "(", "node", ")" ]

[ "Create", "a", "plot", "for", "a", "particular", "attribute", ".", "It", "will", "include", "data", "for", "all", "planners", "that", "have", "data", "for", "this", "attribute", "." ]

[ "def", "plotAttribute", "(", "cur", ",", "planners", ",", "attribute", ",", "typename", ")", ":", "labels", "=", "[", "]", "measurements", "=", "[", "]", "nanCounts", "=", "[", "]", "if", "typename", "==", "\"ENUM\"", ":", "cur", ".", "execute", "(", "'SELECT description FROM enums where name IS \"%s\"'", "%", "attribute", ")", "descriptions", "=", "[", "t", "[", "0", "]", "for", "t", "in", "cur", ".", "fetchall", "(", ")", "]", "numValues", "=", "len", "(", "descriptions", ")", "for", "planner", "in", "planners", ":", "cur", ".", "execute", "(", "\"SELECT %s FROM runs WHERE plannerid = %s AND %s IS NOT NULL\"", "%", "(", "attribute", ",", "planner", "[", "0", "]", ",", "attribute", ")", ")", "measurement", "=", "[", "t", "[", "0", "]", "for", "t", "in", "cur", ".", "fetchall", "(", ")", "if", "t", "[", "0", "]", "!=", "None", "]", "if", "len", "(", "measurement", ")", ">", "0", ":", "cur", ".", "execute", "(", "\"SELECT count(*) FROM runs WHERE plannerid = %s AND %s IS NULL\"", "%", "(", "planner", "[", "0", "]", ",", "attribute", ")", ")", "nanCounts", ".", "append", "(", "cur", ".", "fetchone", "(", ")", "[", "0", "]", ")", "labels", ".", "append", "(", "planner", "[", "1", "]", ")", "if", "typename", "==", "\"ENUM\"", ":", "scale", "=", "100.0", "/", "len", "(", "measurement", ")", "measurements", ".", "append", "(", "[", "measurement", ".", "count", "(", "i", ")", "*", "scale", "for", "i", "in", "range", "(", "numValues", ")", "]", ")", "else", ":", "measurements", ".", "append", "(", "measurement", ")", "if", "len", "(", "measurements", ")", "==", "0", ":", "print", "(", "'Skipping \"%s\": no available measurements'", "%", "attribute", ")", "return", "plt", ".", "clf", "(", ")", "ax", "=", "plt", ".", "gca", "(", ")", "if", "typename", "==", "\"ENUM\"", ":", "width", "=", "0.5", "measurements", "=", "np", ".", "transpose", "(", "np", ".", "vstack", "(", "measurements", ")", ")", "colsum", "=", "np", ".", "sum", "(", "measurements", ",", "axis", "=", "1", ")", "rows", "=", "np", ".", "where", "(", "colsum", "!=", "0", ")", "[", "0", "]", "heights", "=", "np", ".", "zeros", "(", "(", "1", ",", "measurements", ".", "shape", "[", "1", "]", ")", ")", "ind", "=", "range", "(", "measurements", ".", "shape", "[", "1", "]", ")", "legend_labels", "=", "[", "]", "for", "i", "in", "rows", ":", "plt", ".", "bar", "(", "ind", ",", "measurements", "[", "i", "]", ",", "width", ",", "bottom", "=", "heights", "[", "0", "]", ",", "color", "=", "matplotlib", ".", "cm", ".", "hot", "(", "int", "(", "floor", "(", "i", "*", "256", "/", "numValues", ")", ")", ")", ",", "label", "=", "descriptions", "[", "i", "]", ",", ")", "heights", "=", "heights", "+", "measurements", "[", "i", "]", "xtickNames", "=", "plt", ".", "xticks", "(", "[", "x", "+", "width", "/", "2.0", "for", "x", "in", "ind", "]", ",", "labels", ",", "rotation", "=", "30", ",", "fontsize", "=", "8", ",", "ha", "=", "\"right\"", ")", "ax", ".", "set_ylabel", "(", "attribute", ".", "replace", "(", "\"_\"", ",", "\" \"", ")", "+", "\" (%)\"", ")", "box", "=", "ax", ".", "get_position", "(", ")", "ax", ".", "set_position", "(", "[", "box", ".", "x0", ",", "box", ".", "y0", ",", "box", ".", "width", "*", "0.8", ",", "box", ".", "height", "]", ")", "props", "=", "matplotlib", ".", "font_manager", ".", "FontProperties", "(", ")", "props", ".", "set_size", "(", "\"small\"", ")", "ax", ".", "legend", "(", "loc", "=", "\"center left\"", ",", "bbox_to_anchor", "=", "(", "1", ",", "0.5", ")", ",", "prop", "=", "props", ")", "elif", "typename", "==", "\"BOOLEAN\"", ":", "width", "=", "0.5", "measurementsPercentage", "=", "[", "sum", "(", "m", ")", "*", "100.0", "/", "len", "(", "m", ")", "for", "m", "in", "measurements", "]", "ind", "=", "range", "(", "len", "(", "measurements", ")", ")", "plt", ".", "bar", "(", "ind", ",", "measurementsPercentage", ",", "width", ")", "### uncommenting this line will remove the term 'kConfigDefault' from the labels for OMPL Solvers.", "### Fits situations where you need more control in the plot, such as in an academic publication for example", "# labels = [l.replace('kConfigDefault', '') for l in labels]", "xtickNames", "=", "plt", ".", "xticks", "(", "[", "x", "+", "width", "/", "2.0", "for", "x", "in", "ind", "]", ",", "labels", ",", "rotation", "=", "30", ",", "fontsize", "=", "8", ",", "ha", "=", "\"right\"", ")", "ax", ".", "set_ylabel", "(", "attribute", ".", "replace", "(", "\"_\"", ",", "\" \"", ")", "+", "\" (%)\"", ")", "plt", ".", "subplots_adjust", "(", "bottom", "=", "0.3", ")", "# Squish the plot into the upper 2/3 of the page. Leave room for labels", "else", ":", "if", "int", "(", "matplotlibversion", ".", "split", "(", "\".\"", ")", "[", "0", "]", ")", "<", "1", ":", "plt", ".", "boxplot", "(", "measurements", ",", "notch", "=", "0", ",", "sym", "=", "\"k+\"", ",", "vert", "=", "1", ",", "whis", "=", "1.5", ")", "else", ":", "plt", ".", "boxplot", "(", "measurements", ",", "notch", "=", "0", ",", "sym", "=", "\"k+\"", ",", "vert", "=", "1", ",", "whis", "=", "1.5", ",", "bootstrap", "=", "1000", ")", "ax", ".", "set_ylabel", "(", "attribute", ".", "replace", "(", "\"_\"", ",", "\" \"", ")", ")", "# xtickNames = plt.xticks(labels, rotation=30, fontsize=10)", "# plt.subplots_adjust(bottom=0.3) # Squish the plot into the upper 2/3 of the page. Leave room for labels", "### uncommenting this line will remove the term 'kConfigDefault' from the labels for OMPL Solvers.", "### Fits situations where you need more control in the plot, such as in an academic publication for example", "# labels = [l.replace('kConfigDefault', '') for l in labels]", "xtickNames", "=", "plt", ".", "setp", "(", "ax", ",", "xticklabels", "=", "labels", ")", "plt", ".", "setp", "(", "xtickNames", ",", "rotation", "=", "30", ",", "fontsize", "=", "8", ",", "ha", "=", "\"right\"", ")", "for", "(", "tick", ")", "in", "ax", ".", "xaxis", ".", "get_major_ticks", "(", ")", ":", "# shrink the font size of the x tick labels", "tick", ".", "label", ".", "set_fontsize", "(", "8", ")", "plt", ".", "subplots_adjust", "(", "bottom", "=", "0.3", ")", "# Squish the plot into the upper 2/3 of the page. Leave room for labels", "ax", ".", "set_xlabel", "(", "\"Motion planning algorithm\"", ",", "fontsize", "=", "12", ")", "ax", ".", "yaxis", ".", "grid", "(", "True", ",", "linestyle", "=", "\"-\"", ",", "which", "=", "\"major\"", ",", "color", "=", "\"lightgrey\"", ",", "alpha", "=", "0.5", ")", "if", "max", "(", "nanCounts", ")", ">", "0", ":", "maxy", "=", "max", "(", "[", "max", "(", "y", ")", "for", "y", "in", "measurements", "]", ")", "for", "i", "in", "range", "(", "len", "(", "labels", ")", ")", ":", "x", "=", "i", "+", "width", "/", "2", "if", "typename", "==", "\"BOOLEAN\"", "else", "i", "+", "1", "### uncommenting the next line, the number of failed planning attempts will be added to each bar", "# ax.text(x, .95*maxy, str(nanCounts[i]), horizontalalignment='center', size='small')", "plt", ".", "show", "(", ")" ]

[ "Returns", "a", "list", "of", "supported", "formats", "for", "archiving", "and", "unarchiving", "." ]

[ "def", "get_archive_formats", "(", ")", ":", "formats", "=", "[", "(", "name", ",", "registry", "[", "2", "]", ")", "for", "name", ",", "registry", "in", "_ARCHIVE_FORMATS", ".", "items", "(", ")", "]", "formats", ".", "sort", "(", ")", "return", "formats" ]

[ "IsContainer", "(", "self", "DataViewItem", "item", ")", "-", ">", "bool" ]

[ "def", "IsContainer", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewModel_IsContainer", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Check", "whether", "a", "shape", "is", "completely", "known", "with", "or", "without", "np", "semantics", "." ]

[ "def", "shape_is_known", "(", "shape", ")", ":", "if", "shape", "is", "None", ":", "return", "False", "unknown_dim_size", "=", "-", "1", "if", "is_np_shape", "(", ")", "else", "0", "if", "len", "(", "shape", ")", "==", "0", ":", "return", "unknown_dim_size", "==", "-", "1", "for", "dim_size", "in", "shape", ":", "if", "dim_size", "==", "unknown_dim_size", ":", "return", "False", "assert", "dim_size", ">", "unknown_dim_size", ",", "\"shape dimension size cannot be less than {}, while \"", "\"received {}\"", ".", "format", "(", "unknown_dim_size", ",", "dim_size", ")", "return", "True" ]

[ "Lazy", "loading", "of", "brain", "function", "file" ]

[ "def", "func", "(", "self", ")", ":", "return", "self", ".", "_get_func", "(", ")" ]

[ "Given", "a", "node", "and", "a", "sequence", "of", "strings", "in", "names", "return", "a", "dictionary", "containing", "the", "names", "as", "keys", "and", "child", "ELEMENT_NODEs", "that", "have", "a", "tagName", "equal", "to", "the", "name", "." ]

[ "def", "get_specific_nodes", "(", "self", ",", "node", ",", "names", ")", ":", "nodes", "=", "[", "(", "x", ".", "tagName", ",", "x", ")", "for", "x", "in", "node", ".", "childNodes", "if", "x", ".", "nodeType", "==", "x", ".", "ELEMENT_NODE", "and", "x", ".", "tagName", "in", "names", "]", "return", "dict", "(", "nodes", ")" ]

[ "Convert", "list", "of", "tuples", "to", "MultiIndex", "." ]

[ "def", "from_tuples", "(", "cls", ",", "tuples", ",", "sortorder", "=", "None", ",", "names", "=", "None", ")", ":", "if", "not", "is_list_like", "(", "tuples", ")", ":", "raise", "TypeError", "(", "\"Input must be a list / sequence of tuple-likes.\"", ")", "elif", "is_iterator", "(", "tuples", ")", ":", "tuples", "=", "list", "(", "tuples", ")", "if", "len", "(", "tuples", ")", "==", "0", ":", "if", "names", "is", "None", ":", "raise", "TypeError", "(", "\"Cannot infer number of levels from empty list\"", ")", "arrays", "=", "[", "[", "]", "]", "*", "len", "(", "names", ")", "elif", "isinstance", "(", "tuples", ",", "(", "np", ".", "ndarray", ",", "Index", ")", ")", ":", "if", "isinstance", "(", "tuples", ",", "Index", ")", ":", "tuples", "=", "tuples", ".", "_values", "arrays", "=", "list", "(", "lib", ".", "tuples_to_object_array", "(", "tuples", ")", ".", "T", ")", "elif", "isinstance", "(", "tuples", ",", "list", ")", ":", "arrays", "=", "list", "(", "lib", ".", "to_object_array_tuples", "(", "tuples", ")", ".", "T", ")", "else", ":", "arrays", "=", "zip", "(", "*", "tuples", ")", "return", "MultiIndex", ".", "from_arrays", "(", "arrays", ",", "sortorder", "=", "sortorder", ",", "names", "=", "names", ")" ]

[ "List", "unique", "elements", "preserving", "order", ".", "Remember", "all", "elements", "ever", "seen", "." ]

[ "def", "unique_everseen", "(", "iterable", ",", "key", "=", "None", ")", ":", "# unique_everseen('AAAABBBCCDAABBB') --> A B C D", "# unique_everseen('ABBCcAD', str.lower) --> A B C D", "seen", "=", "set", "(", ")", "seen_add", "=", "seen", ".", "add", "if", "key", "is", "None", ":", "for", "element", "in", "six", ".", "moves", ".", "filterfalse", "(", "seen", ".", "__contains__", ",", "iterable", ")", ":", "seen_add", "(", "element", ")", "yield", "element", "else", ":", "for", "element", "in", "iterable", ":", "k", "=", "key", "(", "element", ")", "if", "k", "not", "in", "seen", ":", "seen_add", "(", "k", ")", "yield", "element" ]

[ "Return", "a", "list", "of", "tuples", "of", "the", "(", "attr", "formatted_value", ")", "." ]

[ "def", "_format_attrs", "(", "self", ")", ":", "return", "format_object_attrs", "(", "self", ",", "include_dtype", "=", "False", ")" ]

[ "Returns", "contents", "of", "a", "given", "file", "or", "None", "if", "not", "readable", "." ]

[ "def", "read_file", "(", "path", ")", ":", "assert", "isinstance", "(", "path", ",", "(", "list", ",", "tuple", ")", ")", "try", ":", "with", "open", "(", "os", ".", "path", ".", "join", "(", "*", "path", ")", ",", "'r'", ")", "as", "f", ":", "return", "f", ".", "read", "(", ")", "except", "IOError", ":", "return", "None" ]

[ "Substitutes", "variables", "in", "a", ".", "in", "file" ]

[ "def", "subst_func", "(", "tsk", ")", ":", "m4_re", "=", "re", ".", "compile", "(", "'@(\\w+)@'", ",", "re", ".", "M", ")", "code", "=", "tsk", ".", "inputs", "[", "0", "]", ".", "read", "(", ")", "#Utils.readf(infile)", "# replace all % by %% to prevent errors by % signs in the input file while string formatting", "code", "=", "code", ".", "replace", "(", "'%'", ",", "'%%'", ")", "s", "=", "m4_re", ".", "sub", "(", "r'%(\\1)s'", ",", "code", ")", "env", "=", "tsk", ".", "env", "di", "=", "getattr", "(", "tsk", ",", "'dict'", ",", "{", "}", ")", "or", "getattr", "(", "tsk", ".", "generator", ",", "'dict'", ",", "{", "}", ")", "if", "not", "di", ":", "names", "=", "m4_re", ".", "findall", "(", "code", ")", "for", "i", "in", "names", ":", "di", "[", "i", "]", "=", "env", ".", "get_flat", "(", "i", ")", "or", "env", ".", "get_flat", "(", "i", ".", "upper", "(", ")", ")", "tsk", ".", "outputs", "[", "0", "]", ".", "write", "(", "s", "%", "di", ")" ]

[ "This", "function", "prepares", "the", "ModelPart", "for", "being", "used", "by", "the", "PythonSolver" ]

[ "def", "PrepareModelPart", "(", "self", ")", ":", "pass" ]

[ "Generate", "bprop", "for", "Reshape" ]

[ "def", "get_bprop_reshape", "(", "self", ")", ":", "def", "bprop", "(", "x", ",", "shp", ",", "out", ",", "dout", ")", ":", "shapex", "=", "shape_op", "(", "x", ")", "if", "-", "1", "in", "shapex", ":", "shapex", "=", "dyn_shape_op", "(", "x", ")", "return", "reshape", "(", "dout", ",", "shapex", ")", ",", "zeros_like", "(", "shp", ")", "return", "bprop" ]

[ "Returns", ":", "string", "name", "of", "the", "module", "from", "which", "execution", "started", "." ]

[ "def", "_GetMainModule", "(", ")", ":", "# First, try to use the same logic used by _GetCallingModuleObjectAndName(),", "# i.e., call _GetModuleObjectAndName(). For that we first need to", "# find the dictionary that the main module uses to store the", "# globals.", "#", "# That's (normally) the same dictionary object that the deepest", "# (oldest) stack frame is using for globals.", "deepest_frame", "=", "sys", ".", "_getframe", "(", "0", ")", "while", "deepest_frame", ".", "f_back", "is", "not", "None", ":", "deepest_frame", "=", "deepest_frame", ".", "f_back", "globals_for_main_module", "=", "deepest_frame", ".", "f_globals", "main_module_name", "=", "_GetModuleObjectAndName", "(", "globals_for_main_module", ")", "[", "1", "]", "# The above strategy fails in some cases (e.g., tools that compute", "# code coverage by redefining, among other things, the main module).", "# If so, just use sys.argv[0]. We can probably always do this, but", "# it's safest to try to use the same logic as _GetCallingModuleObjectAndName()", "if", "main_module_name", "is", "None", ":", "main_module_name", "=", "sys", ".", "argv", "[", "0", "]", "return", "main_module_name" ]

[ "Fast", "persistence", "of", "an", "arbitrary", "Python", "object", "into", "a", "files", "with", "dedicated", "storage", "for", "numpy", "arrays", "." ]

[ "def", "dump", "(", "value", ",", "filename", ",", "compress", "=", "0", ",", "cache_size", "=", "100", ")", ":", "if", "not", "isinstance", "(", "filename", ",", "basestring", ")", ":", "# People keep inverting arguments, and the resulting error is", "# incomprehensible", "raise", "ValueError", "(", "'Second argument should be a filename, %s (type %s) was given'", "%", "(", "filename", ",", "type", "(", "filename", ")", ")", ")", "try", ":", "pickler", "=", "NumpyPickler", "(", "filename", ",", "compress", "=", "compress", ",", "cache_size", "=", "cache_size", ")", "pickler", ".", "dump", "(", "value", ")", "pickler", ".", "close", "(", ")", "finally", ":", "if", "'pickler'", "in", "locals", "(", ")", "and", "hasattr", "(", "pickler", ",", "'file'", ")", ":", "pickler", ".", "file", ".", "flush", "(", ")", "pickler", ".", "file", ".", "close", "(", ")", "return", "pickler", ".", "_filenames" ]

[ "Prepares", "a", "replacement", "AST", "that", "s", "safe", "to", "swap", "in", "for", "a", "node", "." ]

[ "def", "_prepare_replacement", "(", "self", ",", "replaced", ",", "key", ")", ":", "repl", "=", "self", ".", "replacements", "[", "key", "]", "new_nodes", "=", "ast_util", ".", "copy_clean", "(", "repl", ",", "preserve_annos", "=", "self", ".", "preserved_annos", ")", "if", "isinstance", "(", "new_nodes", ",", "gast", ".", "AST", ")", ":", "new_nodes", "=", "[", "new_nodes", "]", "return", "new_nodes" ]

[ "Encode", "the", "given", "object", "and", "yield", "each", "string", "representation", "as", "available", "." ]

[ "def", "iterencode", "(", "self", ",", "o", ",", "_one_shot", "=", "False", ")", ":", "if", "self", ".", "check_circular", ":", "markers", "=", "{", "}", "else", ":", "markers", "=", "None", "if", "self", ".", "ensure_ascii", ":", "_encoder", "=", "encode_basestring_ascii", "else", ":", "_encoder", "=", "encode_basestring", "if", "self", ".", "encoding", "!=", "'utf-8'", ":", "def", "_encoder", "(", "o", ",", "_orig_encoder", "=", "_encoder", ",", "_encoding", "=", "self", ".", "encoding", ")", ":", "if", "isinstance", "(", "o", ",", "str", ")", ":", "o", "=", "o", ".", "decode", "(", "_encoding", ")", "return", "_orig_encoder", "(", "o", ")", "def", "floatstr", "(", "o", ",", "allow_nan", "=", "self", ".", "allow_nan", ",", "_repr", "=", "FLOAT_REPR", ",", "_inf", "=", "INFINITY", ",", "_neginf", "=", "-", "INFINITY", ")", ":", "# Check for specials. Note that this type of test is processor- and/or", "# platform-specific, so do tests which don't depend on the internals.", "if", "o", "!=", "o", ":", "text", "=", "'NaN'", "elif", "o", "==", "_inf", ":", "text", "=", "'Infinity'", "elif", "o", "==", "_neginf", ":", "text", "=", "'-Infinity'", "else", ":", "return", "_repr", "(", "o", ")", "if", "not", "allow_nan", ":", "raise", "ValueError", "(", "\"Out of range float values are not JSON compliant: \"", "+", "repr", "(", "o", ")", ")", "return", "text", "if", "_one_shot", "and", "c_make_encoder", "is", "not", "None", "and", "not", "self", ".", "indent", "and", "not", "self", ".", "sort_keys", ":", "_iterencode", "=", "c_make_encoder", "(", "markers", ",", "self", ".", "default", ",", "_encoder", ",", "self", ".", "indent", ",", "self", ".", "key_separator", ",", "self", ".", "item_separator", ",", "self", ".", "sort_keys", ",", "self", ".", "skipkeys", ",", "self", ".", "allow_nan", ")", "else", ":", "_iterencode", "=", "_make_iterencode", "(", "markers", ",", "self", ".", "default", ",", "_encoder", ",", "self", ".", "indent", ",", "floatstr", ",", "self", ".", "key_separator", ",", "self", ".", "item_separator", ",", "self", ".", "sort_keys", ",", "self", ".", "skipkeys", ",", "_one_shot", ")", "return", "_iterencode", "(", "o", ",", "0", ")" ]

[ "Compute", "the", "delta", "in", "metric", "m", "between", "two", "metric", "snapshots", "." ]

[ "def", "delta", "(", "prev", ",", "cur", ",", "m", ")", ":", "if", "m", "not", "in", "prev", "or", "m", "not", "in", "cur", ":", "return", "0", "return", "cur", "[", "m", "]", "-", "prev", "[", "m", "]" ]

[ "Given", "a", "set", "of", "source", "files", "sets", "the", "given", "property", "on", "them", "." ]

[ "def", "SetFilesProperty", "(", "output", ",", "variable", ",", "property_name", ",", "values", ",", "sep", ")", ":", "output", ".", "write", "(", "'set_source_files_properties('", ")", "WriteVariable", "(", "output", ",", "variable", ")", "output", ".", "write", "(", "' PROPERTIES '", ")", "output", ".", "write", "(", "property_name", ")", "output", ".", "write", "(", "' \"'", ")", "for", "value", "in", "values", ":", "output", ".", "write", "(", "CMakeStringEscape", "(", "value", ")", ")", "output", ".", "write", "(", "sep", ")", "output", ".", "write", "(", "'\")\\n'", ")" ]

[ "Find", "the", "full", "path", "to", "a", "command", "using", "which", "." ]

[ "def", "_find_cmd", "(", "cmd", ")", ":", "path", "=", "sp", ".", "Popen", "(", "[", "'/usr/bin/env'", ",", "'which'", ",", "cmd", "]", ",", "stdout", "=", "sp", ".", "PIPE", ",", "stderr", "=", "sp", ".", "PIPE", ")", ".", "communicate", "(", ")", "[", "0", "]", "return", "py3compat", ".", "bytes_to_str", "(", "path", ")" ]

[ "Load", "a", "list", "of", "arrays", "into", "a", "list", "of", "arrays", "specified", "by", "slices", "." ]

[ "def", "_load_general", "(", "data", ",", "targets", ")", ":", "for", "d_src", ",", "d_targets", "in", "zip", "(", "data", ",", "targets", ")", ":", "if", "isinstance", "(", "d_targets", ",", "nd", ".", "NDArray", ")", ":", "d_src", ".", "copyto", "(", "d_targets", ")", "else", ":", "assert", "d_targets", "[", "-", "1", "]", "[", "0", "]", ".", "stop", "==", "d_src", ".", "shape", "[", "0", "]", ",", "\"Batch size miss match. Expected %d, got %d\"", "%", "(", "d_targets", "[", "-", "1", "]", "[", "0", "]", ".", "stop", ",", "d_src", ".", "shape", "[", "0", "]", ")", "for", "slice_idx", ",", "d_dst", "in", "d_targets", ":", "d_src", "[", "slice_idx", "]", ".", "copyto", "(", "d_dst", ")" ]

[ "Loading", "of", "client_secrets", "JSON", "file", "optionally", "backed", "by", "a", "cache", "." ]

[ "def", "loadfile", "(", "filename", ",", "cache", "=", "None", ")", ":", "_SECRET_NAMESPACE", "=", "'oauth2client:secrets#ns'", "if", "not", "cache", ":", "return", "_loadfile", "(", "filename", ")", "obj", "=", "cache", ".", "get", "(", "filename", ",", "namespace", "=", "_SECRET_NAMESPACE", ")", "if", "obj", "is", "None", ":", "client_type", ",", "client_info", "=", "_loadfile", "(", "filename", ")", "obj", "=", "{", "client_type", ":", "client_info", "}", "cache", ".", "set", "(", "filename", ",", "obj", ",", "namespace", "=", "_SECRET_NAMESPACE", ")", "return", "next", "(", "six", ".", "iteritems", "(", "obj", ")", ")" ]

[ "Copy", "the", "workload", "folder", "to", "a", "temporary", "directory", "and", "returns", "its", "name", "." ]

[ "def", "backup_workloads", "(", ")", ":", "temp_dir", "=", "mkdtemp", "(", ")", "sh", ".", "cp", "(", "os", ".", "path", ".", "join", "(", "IMPALA_HOME", ",", "\"testdata\"", ",", "\"workloads\"", ")", ",", "temp_dir", ",", "R", "=", "True", ",", "_out", "=", "sys", ".", "stdout", ",", "_err", "=", "sys", ".", "stderr", ")", "print", "\"Backed up workloads to {0}\"", ".", "format", "(", "temp_dir", ")", "return", "temp_dir" ]

[ "GetWindow", "(", "self", ")", "-", ">", "Window" ]

[ "def", "GetWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "Validator_GetWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "a", "concat_nd", "layer", "to", "the", "model", "that", "performs", "concatenation", "along", "the", "given", "axis", ".", "Refer", "to", "the", "**", "ConcatNDLayerParams", "**", "message", "in", "specification", "(", "NeuralNetwork", ".", "proto", ")", "for", "more", "details", "." ]

[ "def", "add_concat_nd", "(", "self", ",", "name", ",", "input_names", ",", "output_name", ",", "axis", ")", ":", "spec_layer", "=", "self", ".", "_add_generic_layer", "(", "name", ",", "input_names", ",", "[", "output_name", "]", ")", "spec_layer_params", "=", "spec_layer", ".", "concatND", "spec_layer_params", ".", "axis", "=", "axis", "return", "spec_layer" ]

[ "Returns", "the", "MACH_O_TYPE", "of", "this", "target", "." ]

[ "def", "GetMachOType", "(", "self", ")", ":", "# Weird, but matches Xcode.", "if", "not", "self", ".", "_IsBundle", "(", ")", "and", "self", ".", "spec", "[", "'type'", "]", "==", "'executable'", ":", "return", "''", "return", "{", "'executable'", ":", "'mh_execute'", ",", "'static_library'", ":", "'staticlib'", ",", "'shared_library'", ":", "'mh_dylib'", ",", "'loadable_module'", ":", "'mh_bundle'", ",", "}", "[", "self", ".", "spec", "[", "'type'", "]", "]" ]

[ "Returns", "the", "list", "of", "IRQ", "numbers", "for", "the", "given", "interface", "." ]

[ "def", "__get_irqs_one", "(", "self", ",", "iface", ")", ":", "return", "self", ".", "__nic2irqs", "[", "iface", "]" ]

[ "Assigns", "roles", ".", ":", "param", "flat_requests", ":", "The", "role", "requests", ".", ":", "param", "world_state", ":", "The", "current", "state", "of", "the", "world", ".", ":", "param", "prev_results", ":", "The", "previous", "results", ".", ":", "return", ":", "The", "results", "of", "the", "role", "assignment", "." ]

[ "def", "assign_roles", "(", "flat_requests", ":", "FlatRoleRequests", ",", "world_state", ":", "stp", ".", "rc", ".", "WorldState", ",", "prev_results", ":", "FlatRoleResults", ",", ")", "->", "FlatRoleResults", ":", "..." ]

[ "Determines", "C", "type" ]

[ "def", "getctype", "(", "var", ")", ":", "ctype", "=", "'void'", "if", "isfunction", "(", "var", ")", ":", "if", "'result'", "in", "var", ":", "a", "=", "var", "[", "'result'", "]", "else", ":", "a", "=", "var", "[", "'name'", "]", "if", "a", "in", "var", "[", "'vars'", "]", ":", "return", "getctype", "(", "var", "[", "'vars'", "]", "[", "a", "]", ")", "else", ":", "errmess", "(", "'getctype: function %s has no return value?!\\n'", "%", "a", ")", "elif", "issubroutine", "(", "var", ")", ":", "return", "ctype", "elif", "'typespec'", "in", "var", "and", "var", "[", "'typespec'", "]", ".", "lower", "(", ")", "in", "f2cmap_all", ":", "typespec", "=", "var", "[", "'typespec'", "]", ".", "lower", "(", ")", "f2cmap", "=", "f2cmap_all", "[", "typespec", "]", "ctype", "=", "f2cmap", "[", "''", "]", "# default type", "if", "'kindselector'", "in", "var", ":", "if", "'*'", "in", "var", "[", "'kindselector'", "]", ":", "try", ":", "ctype", "=", "f2cmap", "[", "var", "[", "'kindselector'", "]", "[", "'*'", "]", "]", "except", "KeyError", ":", "errmess", "(", "'getctype: \"%s %s %s\" not supported.\\n'", "%", "(", "var", "[", "'typespec'", "]", ",", "'*'", ",", "var", "[", "'kindselector'", "]", "[", "'*'", "]", ")", ")", "elif", "'kind'", "in", "var", "[", "'kindselector'", "]", ":", "if", "typespec", "+", "'kind'", "in", "f2cmap_all", ":", "f2cmap", "=", "f2cmap_all", "[", "typespec", "+", "'kind'", "]", "try", ":", "ctype", "=", "f2cmap", "[", "var", "[", "'kindselector'", "]", "[", "'kind'", "]", "]", "except", "KeyError", ":", "if", "typespec", "in", "f2cmap_all", ":", "f2cmap", "=", "f2cmap_all", "[", "typespec", "]", "try", ":", "ctype", "=", "f2cmap", "[", "str", "(", "var", "[", "'kindselector'", "]", "[", "'kind'", "]", ")", "]", "except", "KeyError", ":", "errmess", "(", "'getctype: \"%s(kind=%s)\" is mapped to C \"%s\" (to override define dict(%s = dict(%s=\"<C typespec>\")) in %s/.f2py_f2cmap file).\\n'", "%", "(", "typespec", ",", "var", "[", "'kindselector'", "]", "[", "'kind'", "]", ",", "ctype", ",", "typespec", ",", "var", "[", "'kindselector'", "]", "[", "'kind'", "]", ",", "os", ".", "getcwd", "(", ")", ")", ")", "else", ":", "if", "not", "isexternal", "(", "var", ")", ":", "errmess", "(", "'getctype: No C-type found in \"%s\", assuming void.\\n'", "%", "var", ")", "return", "ctype" ]

[ "Return", "the", "indices", "of", "unmasked", "elements", "that", "are", "not", "zero", "." ]

[ "def", "nonzero", "(", "self", ")", ":", "return", "narray", "(", "self", ".", "filled", "(", "0", ")", ",", "copy", "=", "False", ")", ".", "nonzero", "(", ")" ]

[ "Returns", "new", "TPM2_Startup_REQUEST", "object", "constructed", "from", "its", "marshaled", "representation", "in", "the", "given", "byte", "buffer" ]

[ "def", "fromBytes", "(", "buffer", ")", ":", "return", "TpmBuffer", "(", "buffer", ")", ".", "createObj", "(", "TPM2_Startup_REQUEST", ")" ]

[ "Unlock", "and", "close", "a", "file", "." ]

[ "def", "unlock_and_close", "(", "self", ")", ":", "self", ".", "_opener", ".", "unlock_and_close", "(", ")" ]

[ "Hides", "or", "shows", "the", "label", "of", "an", "item", "in", "the", "visualization" ]

[ "def", "hideLabel", "(", "name", ":", "ItemPath", ",", "hidden", "=", "True", ")", "->", "None", ":", "return", "scene", "(", ")", ".", "hideLabel", "(", "name", ",", "hidden", ")" ]

[ "Start", "profiling", "." ]

[ "def", "start", "(", ")", ":", "global", "_profiler", "with", "_profiler_lock", ":", "if", "_profiler", "is", "not", "None", ":", "raise", "ProfilerAlreadyRunningError", "(", "'Another profiler is running.'", ")", "if", "context", ".", "default_execution_mode", "==", "context", ".", "EAGER_MODE", ":", "context", ".", "ensure_initialized", "(", ")", "_profiler", "=", "pywrap_tensorflow", ".", "TFE_NewProfiler", "(", ")", "if", "not", "pywrap_tensorflow", ".", "TFE_ProfilerIsOk", "(", "_profiler", ")", ":", "logging", ".", "warning", "(", "'Another profiler session is running which is probably '", "'created by profiler server. Please avoid using profiler '", "'server and profiler APIs at the same time.'", ")" ]

[ "SetStyle", "(", "self", "RichTextRange", "range", "RichTextAttr", "style", "int", "flags", "=", "RICHTEXT_SETSTYLE_WITH_UNDO", ")", "-", ">", "bool" ]

[ "def", "SetStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextParagraphLayoutBox_SetStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "display", "name", "for", "the", "entity", "referenced", "by", "this", "cursor", "." ]

[ "def", "displayname", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_displayname'", ")", ":", "self", ".", "_displayname", "=", "conf", ".", "lib", ".", "clang_getCursorDisplayName", "(", "self", ")", "return", "self", ".", "_displayname" ]

[ "Get", "the", "language", "id", "@return", ":", "string" ]

[ "def", "GetLangId", "(", "self", ")", ":", "return", "self", ".", "langid" ]

[ "The", "Graph", "that", "contains", "the", "index", "value", "and", "dense_shape", "tensors", "." ]

[ "def", "graph", "(", "self", ")", ":", "return", "self", ".", "_indices", ".", "graph" ]

[ "!", "Draw", "Event" ]

[ "def", "draw_events", "(", "self", ",", "ctx", ",", "events", ",", "x", ",", "y", ",", "width", ",", "height", ")", ":", "if", "(", "self", ".", "grey_background", "%", "2", ")", "==", "0", ":", "ctx", ".", "rectangle", "(", "x", ",", "y", "-", "self", ".", "padding", "/", "2", ",", "width", ",", "height", "+", "self", ".", "padding", ")", "ctx", ".", "set_source_rgb", "(", "0.9", ",", "0.9", ",", "0.9", ")", "ctx", ".", "fill", "(", ")", "last_x_drawn", "=", "int", "(", "x", ")", "(", "lo", ",", "hi", ")", "=", "events", ".", "get_events_bounds", "(", "self", ".", "start", ",", "self", ".", "end", ")", "for", "event", "in", "events", ".", "events", "[", "lo", ":", "hi", "]", ":", "real_x", "=", "int", "(", "x", "+", "(", "event", ".", "at", "-", "self", ".", "start", ")", "*", "width", "/", "(", "self", ".", "end", "-", "self", ".", "start", ")", ")", "if", "real_x", ">", "last_x_drawn", "+", "2", ":", "ctx", ".", "rectangle", "(", "real_x", ",", "y", ",", "1", ",", "1", ")", "ctx", ".", "set_source_rgb", "(", "1", ",", "0", ",", "0", ")", "ctx", ".", "stroke", "(", ")", "ctx", ".", "move_to", "(", "real_x", ",", "y", "+", "self", ".", "max_text_height", ")", "ctx", ".", "set_source_rgb", "(", "0", ",", "0", ",", "0", ")", "ctx", ".", "show_text", "(", "str", "(", "event", ".", "value", ")", ")", "last_x_drawn", "=", "real_x", "self", ".", "grey_background", "+=", "1" ]

[ "错误应答" ]

[ "def", "onRspError", "(", "self", ",", "RspInfoField", ",", "requestId", ",", "final", ")", ":", "log", "=", "u'行情服务响应错误，错误码:[{0}], 错误信息:[{1}]'.format(", "", "", "", "RspInfoField", ".", "errorID", ",", "RspInfoField", ".", "errorMsg", ".", "decode", "(", "'gbk'", ")", ")", "logger", ".", "info", "(", "log", ")" ]

[ "Compute", "the", "inverse", "FFT", "of", "a", "signal", "whose", "spectrum", "has", "Hermitian", "symmetry", "." ]

[ "def", "ihfft", "(", "a", ",", "n", "=", "None", ",", "axis", "=", "-", "1", ")", ":", "a", "=", "asarray", "(", "a", ")", ".", "astype", "(", "float", ")", "if", "n", "is", "None", ":", "n", "=", "shape", "(", "a", ")", "[", "axis", "]", "return", "conjugate", "(", "rfft", "(", "a", ",", "n", ",", "axis", ")", ")", "/", "n" ]

[ "operator", "[]", "is", "only", "supported", "for", "shared_ptr<T", "[]", ">" ]

[ "def", "_supports", "(", "self", ",", "method_name", ")", ":", "return", "self", ".", "_is_array" ]

[ "Create", "a", "3D", "plot", "for", "data", "visualization" ]

[ "def", "visualize_data", "(", "data1", ",", "data2", ")", ":", "fig", "=", "plt", ".", "figure", "(", "figsize", "=", "(", "8", ",", "8", ")", ")", "ax", "=", "fig", ".", "add_subplot", "(", "111", ",", "projection", "=", "\"3d\"", ")", "plt", ".", "rcParams", "[", "\"legend.fontsize\"", "]", "=", "10", "ax", ".", "plot", "(", "data1", "[", "0", ",", ":", "]", ",", "data1", "[", "1", ",", ":", "]", ",", "data1", "[", "2", ",", ":", "]", ",", "\"o\"", ",", "markersize", "=", "8", ",", "color", "=", "\"blue\"", ",", "alpha", "=", "0.5", ",", "label", "=", "\"class1\"", ",", ")", "ax", ".", "plot", "(", "data2", "[", "0", ",", ":", "]", ",", "data2", "[", "1", ",", ":", "]", ",", "data2", "[", "2", ",", ":", "]", ",", "\"^\"", ",", "markersize", "=", "8", ",", "alpha", "=", "0.5", ",", "color", "=", "\"red\"", ",", "label", "=", "\"class2\"", ",", ")", "ax", ".", "set_xlabel", "(", "\"x_values\"", ")", "ax", ".", "set_ylabel", "(", "\"y_values\"", ")", "ax", ".", "set_zlabel", "(", "\"z_values\"", ")", "plt", ".", "title", "(", "\"Samples for class 1 and class 2\"", ")", "ax", ".", "legend", "(", "loc", "=", "\"upper right\"", ")", "plt", ".", "show", "(", ")" ]

[ "Create", "the", "source", "distribution", "(", "s", ")", ".", "First", "we", "create", "the", "release", "tree", "with", "make_release_tree", "()", ";", "then", "we", "create", "all", "required", "archive", "files", "(", "according", "to", "self", ".", "formats", ")", "from", "the", "release", "tree", ".", "Finally", "we", "clean", "up", "by", "blowing", "away", "the", "release", "tree", "(", "unless", "self", ".", "keep_temp", "is", "true", ")", ".", "The", "list", "of", "archive", "files", "created", "is", "stored", "so", "it", "can", "be", "retrieved", "later", "by", "get_archive_files", "()", "." ]

[ "def", "make_distribution", "(", "self", ")", ":", "# Don't warn about missing meta-data here -- should be (and is!)", "# done elsewhere.", "base_dir", "=", "self", ".", "distribution", ".", "get_fullname", "(", ")", "base_name", "=", "os", ".", "path", ".", "join", "(", "self", ".", "dist_dir", ",", "base_dir", ")", "self", ".", "make_release_tree", "(", "base_dir", ",", "self", ".", "filelist", ".", "files", ")", "archive_files", "=", "[", "]", "# remember names of files we create", "# tar archive must be created last to avoid overwrite and remove", "if", "'tar'", "in", "self", ".", "formats", ":", "self", ".", "formats", ".", "append", "(", "self", ".", "formats", ".", "pop", "(", "self", ".", "formats", ".", "index", "(", "'tar'", ")", ")", ")", "for", "fmt", "in", "self", ".", "formats", ":", "file", "=", "self", ".", "make_archive", "(", "base_name", ",", "fmt", ",", "base_dir", "=", "base_dir", ",", "owner", "=", "self", ".", "owner", ",", "group", "=", "self", ".", "group", ")", "archive_files", ".", "append", "(", "file", ")", "self", ".", "distribution", ".", "dist_files", ".", "append", "(", "(", "'sdist'", ",", "''", ",", "file", ")", ")", "self", ".", "archive_files", "=", "archive_files", "if", "not", "self", ".", "keep_temp", ":", "dir_util", ".", "remove_tree", "(", "base_dir", ",", "dry_run", "=", "self", ".", "dry_run", ")" ]

[ "Load", "cats", "with", "the", "specified", "ids", ".", ":", "param", "ids", "(", "int", "array", ")", ":", "integer", "ids", "specifying", "cats", ":", "return", ":", "cats", "(", "object", "array", ")", ":", "loaded", "cat", "objects" ]

[ "def", "loadCats", "(", "self", ",", "ids", "=", "[", "]", ")", ":", "if", "type", "(", "ids", ")", "==", "list", ":", "return", "[", "self", ".", "cats", "[", "id", "]", "for", "id", "in", "ids", "]", "elif", "type", "(", "ids", ")", "==", "int", ":", "return", "[", "self", ".", "cats", "[", "ids", "]", "]" ]

[ "Unbox", "argument", "and", "emit", "code", "that", "handles", "any", "error", "during", "unboxing", ".", "Args", "are", "cleaned", "up", "in", "reverse", "order", "of", "the", "parameter", "list", "and", "cleanup", "begins", "as", "soon", "as", "unboxing", "of", "any", "argument", "fails", ".", "E", ".", "g", ".", "failure", "on", "arg2", "will", "result", "in", "control", "flow", "going", "through", ":" ]

[ "def", "add_arg", "(", "self", ",", "obj", ",", "ty", ")", ":", "# Unbox argument", "native", "=", "self", ".", "api", ".", "to_native_value", "(", "ty", ",", "obj", ")", "# If an error occurred, go to the cleanup block for", "# the previous argument", "with", "cgutils", ".", "if_unlikely", "(", "self", ".", "builder", ",", "native", ".", "is_error", ")", ":", "self", ".", "builder", ".", "branch", "(", "self", ".", "nextblk", ")", "# Define the cleanup function for the argument", "def", "cleanup_arg", "(", ")", ":", "# Native value reflection", "self", ".", "api", ".", "reflect_native_value", "(", "ty", ",", "native", ".", "value", ",", "self", ".", "env_manager", ")", "# Native value cleanup", "if", "native", ".", "cleanup", "is", "not", "None", ":", "native", ".", "cleanup", "(", ")", "# NRT cleanup", "# (happens after the native value cleanup as the latter", "# may need the native value)", "if", "self", ".", "context", ".", "enable_nrt", ":", "self", ".", "context", ".", "nrt", ".", "decref", "(", "self", ".", "builder", ",", "ty", ",", "native", ".", "value", ")", "self", ".", "cleanups", ".", "append", "(", "cleanup_arg", ")", "# Write the on-error cleanup block for this argument", "cleanupblk", "=", "self", ".", "builder", ".", "append_basic_block", "(", "\"arg%d.err\"", "%", "self", ".", "arg_count", ")", "with", "self", ".", "builder", ".", "goto_block", "(", "cleanupblk", ")", ":", "cleanup_arg", "(", ")", "# Go to next cleanup block", "self", ".", "builder", ".", "branch", "(", "self", ".", "nextblk", ")", "self", ".", "nextblk", "=", "cleanupblk", "self", ".", "arg_count", "+=", "1", "return", "native", ".", "value" ]

[ "Get", "names", "of", "features", "." ]

[ "def", "feature_name", "(", "self", ")", ":", "num_feature", "=", "self", ".", "num_feature", "(", ")", "# Get name of features", "tmp_out_len", "=", "ctypes", ".", "c_int", "(", "0", ")", "string_buffers", "=", "[", "ctypes", ".", "create_string_buffer", "(", "255", ")", "for", "i", "in", "range_", "(", "num_feature", ")", "]", "ptr_string_buffers", "=", "(", "ctypes", ".", "c_char_p", "*", "num_feature", ")", "(", "*", "map", "(", "ctypes", ".", "addressof", ",", "string_buffers", ")", ")", "_safe_call", "(", "_LIB", ".", "LGBM_BoosterGetFeatureNames", "(", "self", ".", "handle", ",", "ctypes", ".", "byref", "(", "tmp_out_len", ")", ",", "ptr_string_buffers", ")", ")", "if", "num_feature", "!=", "tmp_out_len", ".", "value", ":", "raise", "ValueError", "(", "\"Length of feature names doesn't equal with num_feature\"", ")", "return", "[", "string_buffers", "[", "i", "]", ".", "value", ".", "decode", "(", ")", "for", "i", "in", "range_", "(", "num_feature", ")", "]" ]

[ "Create", "a", "builder", "that", "runs", "command", "." ]

[ "def", "__init__", "(", "self", ",", "sources", ",", "targets", ",", "command", ",", "pretty", "=", "None", ",", "cwd", "=", "None", ",", "workdir", "=", "None", ",", "environment", "=", "None", ",", "stdout", "=", "None", ")", ":", "if", "isinstance", "(", "stdout", ",", "Node", ")", "and", "stdout", "not", "in", "targets", ":", "targets", ".", "append", "(", "stdout", ")", "Builder", ".", "__init__", "(", "self", ",", "sources", ",", "targets", ")", "self", ".", "__command", "=", "command", "self", ".", "__pretty", "=", "pretty", "if", "cwd", "is", "not", "None", ":", "warnings", ".", "warn", "(", "'drake.ShellCommand `cwd` argument is deprecated in favor of `workdir`'", ",", "DeprecationWarning", ")", "self", ".", "__workdir", "=", "cwd", "else", ":", "self", ".", "__workdir", "=", "workdir", "self", ".", "__environment", "=", "environment", "self", ".", "__stdout", "=", "stdout" ]

[ "CacheBestSize", "(", "self", "Size", "size", ")" ]

[ "def", "CacheBestSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "Window_CacheBestSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "a", "list", "of", "dependency", "targets", "that", "are", "linked", "into", "this", "target", "." ]

[ "def", "LinkDependencies", "(", "self", ",", "targets", ",", "dependencies", "=", "None", ",", "initial", "=", "True", ")", ":", "if", "dependencies", "==", "None", ":", "dependencies", "=", "[", "]", "# Check for None, corresponding to the root node.", "if", "self", ".", "ref", "==", "None", ":", "return", "dependencies", "# It's kind of sucky that |targets| has to be passed into this function,", "# but that's presently the easiest way to access the target dicts so that", "# this function can find target types.", "if", "'target_name'", "not", "in", "targets", "[", "self", ".", "ref", "]", ":", "raise", "GypError", "(", "\"Missing 'target_name' field in target.\"", ")", "if", "'type'", "not", "in", "targets", "[", "self", ".", "ref", "]", ":", "raise", "GypError", "(", "\"Missing 'type' field in target %s\"", "%", "targets", "[", "self", ".", "ref", "]", "[", "'target_name'", "]", ")", "target_type", "=", "targets", "[", "self", ".", "ref", "]", "[", "'type'", "]", "is_linkable", "=", "target_type", "in", "linkable_types", "if", "initial", "and", "not", "is_linkable", ":", "# If this is the first target being examined and it's not linkable,", "# return an empty list of link dependencies, because the link", "# dependencies are intended to apply to the target itself (initial is", "# True) and this target won't be linked.", "return", "dependencies", "# Don't traverse 'none' targets if explicitly excluded.", "if", "(", "target_type", "==", "'none'", "and", "not", "targets", "[", "self", ".", "ref", "]", ".", "get", "(", "'dependencies_traverse'", ",", "True", ")", ")", ":", "if", "self", ".", "ref", "not", "in", "dependencies", ":", "dependencies", ".", "append", "(", "self", ".", "ref", ")", "return", "dependencies", "# Executables and loadable modules are already fully and finally linked.", "# Nothing else can be a link dependency of them, there can only be", "# dependencies in the sense that a dependent target might run an", "# executable or load the loadable_module.", "if", "not", "initial", "and", "target_type", "in", "(", "'executable'", ",", "'loadable_module'", ")", ":", "return", "dependencies", "# The target is linkable, add it to the list of link dependencies.", "if", "self", ".", "ref", "not", "in", "dependencies", ":", "dependencies", ".", "append", "(", "self", ".", "ref", ")", "if", "initial", "or", "not", "is_linkable", ":", "# If this is a subsequent target and it's linkable, don't look any", "# further for linkable dependencies, as they'll already be linked into", "# this target linkable. Always look at dependencies of the initial", "# target, and always look at dependencies of non-linkables.", "for", "dependency", "in", "self", ".", "dependencies", ":", "dependency", ".", "LinkDependencies", "(", "targets", ",", "dependencies", ",", "False", ")", "return", "dependencies" ]

[ "EndBatchUndo", "(", "self", ")", "-", ">", "bool" ]

[ "def", "EndBatchUndo", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextBuffer_EndBatchUndo", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Parse", "strings", "in", "the", "format", "20110323_17433900", "." ]

[ "def", "parseDateTimeStrings", "(", "dateString", ",", "timeString", ",", "useTimeFix", ",", "returnMinAndSecOnly", ")", ":", "MILLISECOND_TO_MICROSECOND", "=", "10000", "year", "=", "int", "(", "dateString", "[", "0", ":", "4", "]", ")", "month", "=", "int", "(", "dateString", "[", "4", ":", "6", "]", ")", "day", "=", "int", "(", "dateString", "[", "6", ":", "8", "]", ")", "hour", "=", "int", "(", "timeString", "[", "0", ":", "2", "]", ")", "minute", "=", "int", "(", "timeString", "[", "2", ":", "4", "]", ")", "second", "=", "int", "(", "timeString", "[", "4", ":", "6", "]", ")", "if", "returnMinAndSecOnly", ":", "return", "(", "minute", ",", "second", ")", "if", "useTimeFix", ":", "# Some files number the minutes and seconds from 1-60!", "minute", "=", "minute", "-", "1", "second", "=", "second", "-", "1", "usecond", "=", "0", "if", "len", "(", "timeString", ")", ">", "6", ":", "usecond", "=", "int", "(", "timeString", "[", "6", ":", "8", "]", ")", "*", "MILLISECOND_TO_MICROSECOND", "try", ":", "result", "=", "datetime", ".", "datetime", "(", "year", ",", "month", ",", "day", ",", "hour", ",", "minute", ",", "second", ",", "usecond", ")", "return", "result", "except", "Exception", "as", "e", ":", "raise", "Exception", "(", "'Caught exception processing dateString: '", "+", "dateString", "+", "', timeString: '", "+", "timeString", "+", "'\\n with values: '", "+", "str", "(", "(", "year", ",", "month", ",", "day", ",", "hour", ",", "minute", ",", "second", ",", "usecond", ")", ")", "+", "'\\n'", "+", "str", "(", "e", ")", ")" ]

[ "Returns", "a", "string", "with", "the", "declarations", "of", "the", "virtual", "wrapper", "and", "its", "default", "implementations", ".", "This", "string", "must", "be", "put", "inside", "the", "Wrapper", "body", "." ]

[ "def", "Declaration", "(", "self", ",", "method", ",", "indent", ")", ":", "pyste", "=", "namespaces", ".", "pyste", "python", "=", "namespaces", ".", "python", "rename", "=", "self", ".", "info", "[", "method", ".", "name", "]", ".", "rename", "or", "method", ".", "name", "result", "=", "method", ".", "result", ".", "FullName", "(", ")", "return_str", "=", "'return '", "if", "result", "==", "'void'", ":", "return_str", "=", "''", "params", ",", "param_names", ",", "param_types", "=", "_ParamsInfo", "(", "method", ")", "constantness", "=", "''", "if", "method", ".", "const", ":", "constantness", "=", "' const'", "# call_method callback", "decl", "=", "indent", "+", "'%s %s(%s)%s%s {\\n'", "%", "(", "result", ",", "method", ".", "name", ",", "params", ",", "constantness", ",", "method", ".", "Exceptions", "(", ")", ")", "param_names_str", "=", "', '", ".", "join", "(", "param_names", ")", "if", "param_names_str", ":", "param_names_str", "=", "', '", "+", "param_names_str", "self_str", "=", "self", ".", "SELF", "decl", "+=", "indent", "*", "2", "+", "'%(return_str)s%(python)scall_method< %(result)s >'", "'(%(self_str)s, \"%(rename)s\"%(param_names_str)s);\\n'", "%", "locals", "(", ")", "decl", "+=", "indent", "+", "'}\\n'", "# default implementations (with overloading)", "def", "DefaultImpl", "(", "method", ",", "param_names", ")", ":", "'Return the body of a default implementation wrapper'", "indent2", "=", "indent", "*", "2", "wrapper", "=", "self", ".", "info", "[", "method", ".", "name", "]", ".", "wrapper", "if", "not", "wrapper", ":", "# return the default implementation of the class", "return", "indent2", "+", "'%s%s(%s);\\n'", "%", "(", "return_str", ",", "method", ".", "FullName", "(", ")", ",", "', '", ".", "join", "(", "param_names", ")", ")", "else", ":", "if", "wrapper", ".", "code", ":", "self", ".", "codeunit", ".", "Write", "(", "'declaration-outside'", ",", "wrapper", ".", "code", ")", "# return a call for the wrapper", "params", "=", "', '", ".", "join", "(", "[", "'this'", "]", "+", "param_names", ")", "return", "indent2", "+", "'%s%s(%s);\\n'", "%", "(", "return_str", ",", "wrapper", ".", "FullName", "(", ")", ",", "params", ")", "if", "not", "method", ".", "abstract", "and", "method", ".", "visibility", "!=", "Scope", ".", "private", ":", "minArgs", "=", "method", ".", "minArgs", "maxArgs", "=", "method", ".", "maxArgs", "impl_names", "=", "self", ".", "DefaultImplementationNames", "(", "method", ")", "for", "impl_name", ",", "argNum", "in", "zip", "(", "impl_names", ",", "range", "(", "minArgs", ",", "maxArgs", "+", "1", ")", ")", ":", "params", ",", "param_names", ",", "param_types", "=", "_ParamsInfo", "(", "method", ",", "argNum", ")", "decl", "+=", "'\\n'", "decl", "+=", "indent", "+", "'%s %s(%s)%s {\\n'", "%", "(", "result", ",", "impl_name", ",", "params", ",", "constantness", ")", "decl", "+=", "DefaultImpl", "(", "method", ",", "param_names", ")", "decl", "+=", "indent", "+", "'}\\n'", "return", "decl" ]

[ "Runs", "inference", "to", "determine", "the", "class", "probability", "predictions", "." ]

[ "def", "predict_proba", "(", "self", ",", "x", "=", "None", ",", "input_fn", "=", "None", ",", "batch_size", "=", "None", ",", "outputs", "=", "None", ",", "as_iterable", "=", "False", ")", ":", "preds", "=", "self", ".", "_estimator", ".", "predict", "(", "x", "=", "x", ",", "input_fn", "=", "input_fn", ",", "batch_size", "=", "batch_size", ",", "outputs", "=", "[", "linear", ".", "_PROBABILITIES", "]", ",", "as_iterable", "=", "as_iterable", ")", "if", "as_iterable", ":", "return", "_as_iterable", "(", "preds", ",", "output", "=", "linear", ".", "_PROBABILITIES", ")", "return", "preds", "[", "linear", ".", "_PROBABILITIES", "]" ]

[ "Wait", "for", "the", "process", "to", "terminate", ".", "Returns", "the", "error", "code", "." ]

[ "def", "wait", "(", "self", ")", ":", "return", "self", ".", "proc", ".", "wait", "(", ")" ]

[ "Generates", "the", "current", "plot", "." ]

[ "def", "plot", "(", "*", "args", ")", ":", "if", "state", ".", "subProgram", "==", "\"tplot\"", ":", "return", "_tplot_plot", "(", ")", "if", "state", ".", "subProgram", "==", "\"detour\"", ":", "return", "_detour_plot", "(", ")" ]