Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Prepends", "a", "value", "to", "the", "specified", "item", "::" ]

[ "def", "prepend_value", "(", "self", ",", "var", ",", "val", ")", ":", "if", "isinstance", "(", "val", ",", "str", ")", ":", "val", "=", "[", "val", "]", "self", ".", "table", "[", "var", "]", "=", "val", "+", "self", ".", "_get_list_value_for_modification", "(", "var", ")" ]

[ "Find", "the", "appropriate", "name", "to", "pin", "to", "an", "operation", "result", ".", "This", "result", "should", "always", "be", "either", "an", "Index", "or", "a", "Series", "." ]

[ "def", "get_op_result_name", "(", "left", ",", "right", ")", ":", "if", "isinstance", "(", "right", ",", "(", "ABCSeries", ",", "ABCIndex", ")", ")", ":", "name", "=", "_maybe_match_name", "(", "left", ",", "right", ")", "else", ":", "name", "=", "left", ".", "name", "return", "name" ]

[ "Returns", "a", "unique", "name", "to", "use", "for", "a", "control", "flow", "function", "." ]

[ "def", "unique_fn_name", "(", "scope", ",", "name", ")", ":", "return", "(", "\"%s%s_%s\"", "%", "(", "scope", ",", "name", ",", "ops", ".", "uid", "(", ")", ")", ")", ".", "replace", "(", "\"/\"", ",", "\"_\"", ")" ]

[ "Convert", "an", "ndarray", "with", "integer", "-", "dtype", "to", "timedelta64", "[", "ns", "]", "dtype", "treating", "the", "integers", "as", "multiples", "of", "the", "given", "timedelta", "unit", "." ]

[ "def", "ints_to_td64ns", "(", "data", ",", "unit", "=", "\"ns\"", ")", ":", "copy_made", "=", "False", "unit", "=", "unit", "if", "unit", "is", "not", "None", "else", "\"ns\"", "if", "data", ".", "dtype", "!=", "np", ".", "int64", ":", "# converting to int64 makes a copy, so we can avoid", "# re-copying later", "data", "=", "data", ".", "astype", "(", "np", ".", "int64", ")", "copy_made", "=", "True", "if", "unit", "!=", "\"ns\"", ":", "dtype_str", "=", "\"timedelta64[{unit}]\"", ".", "format", "(", "unit", "=", "unit", ")", "data", "=", "data", ".", "view", "(", "dtype_str", ")", "# TODO: watch out for overflows when converting from lower-resolution", "data", "=", "data", ".", "astype", "(", "\"timedelta64[ns]\"", ")", "# the astype conversion makes a copy, so we can avoid re-copying later", "copy_made", "=", "True", "else", ":", "data", "=", "data", ".", "view", "(", "\"timedelta64[ns]\"", ")", "return", "data", ",", "copy_made" ]

[ "Returns", "the", ":", "class", ":", "pyalgotrade", ".", "bar", ".", "Bar", "for", "the", "given", "instrument", "or", "None", "if", "the", "instrument", "is", "not", "found", "." ]

[ "def", "getBar", "(", "self", ",", "instrument", ")", ":", "return", "self", ".", "__barDict", ".", "get", "(", "instrument", ",", "None", ")" ]

[ "Gets", "the", "id", "of", "this", "APIKey", ".", "#", "noqa", ":", "E501" ]

[ "def", "id", "(", "self", ")", ":", "return", "self", ".", "_id" ]

[ "**", "Description", "**" ]

[ "def", "onMessage", "(", "self", ",", "message", ")", ":", "pass" ]

[ "Shuffle", "the", "offscreen", "PixMap", "data", "because", "it", "may", "have", "funny", "stride", "values" ]

[ "def", "_getpixmapcontent", "(", "self", ")", ":", "rowbytes", "=", "Qdoffs", ".", "GetPixRowBytes", "(", "self", ".", "pixmap", ")", "width", "=", "self", ".", "videodescr", "[", "'width'", "]", "height", "=", "self", ".", "videodescr", "[", "'height'", "]", "start", "=", "0", "rv", "=", "[", "]", "for", "i", "in", "range", "(", "height", ")", ":", "nextline", "=", "Qdoffs", ".", "GetPixMapBytes", "(", "self", ".", "pixmap", ",", "start", ",", "width", "*", "4", ")", "start", "=", "start", "+", "rowbytes", "rv", ".", "append", "(", "nextline", ")", "return", "''", ".", "join", "(", "rv", ")" ]

[ "get", "SPICE", "TableWorkspaces", "group", "name", ":", "param", "exp_number", ":", ":", "param", "scan_number", ":", ":", "return", ":" ]

[ "def", "get_spice_group_name", "(", "exp_number", ")", ":", "return", "'HB3A_Exp{0}_SPICES'", ".", "format", "(", "exp_number", ")" ]

[ "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", ")" ]

[ "GetChildCount", "(", "self", "DataViewItem", "parent", ")", "-", ">", "int" ]

[ "def", "GetChildCount", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewTreeCtrl_GetChildCount", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Load", "node", "into", "the", "scene", "from", "a", "file", ".", ":", "param", "filename", ":", "full", "path", "of", "the", "file", "to", "load", ".", ":", "param", "filetype", ":", "specifies", "the", "file", "type", "which", "determines", "which", "IO", "class", "will", "load", "the", "file", ".", ":", "param", "properties", ":", "map", "containing", "additional", "parameters", "for", "the", "loading", ".", ":", "param", "returnNode", ":", "Deprecated", ".", "If", "set", "to", "true", "then", "the", "method", "returns", "status", "flag", "and", "node", "instead", "of", "signalling", "error", "by", "throwing", "an", "exception", ".", ":", "return", ":", "loaded", "node", "(", "if", "multiple", "nodes", "are", "loaded", "then", "a", "list", "of", "nodes", ")", ".", "If", "returnNode", "is", "True", "then", "a", "status", "flag", "and", "loaded", "node", "are", "returned", "." ]

[ "def", "loadNodeFromFile", "(", "filename", ",", "filetype", ",", "properties", "=", "{", "}", ",", "returnNode", "=", "False", ")", ":", "from", "slicer", "import", "app", "from", "vtk", "import", "vtkCollection", "properties", "[", "'fileName'", "]", "=", "filename", "loadedNodesCollection", "=", "vtkCollection", "(", ")", "success", "=", "app", ".", "coreIOManager", "(", ")", ".", "loadNodes", "(", "filetype", ",", "properties", ",", "loadedNodesCollection", ")", "loadedNode", "=", "loadedNodesCollection", ".", "GetItemAsObject", "(", "0", ")", "if", "loadedNodesCollection", ".", "GetNumberOfItems", "(", ")", ">", "0", "else", "None", "# Deprecated way of returning status and node", "if", "returnNode", ":", "import", "logging", "logging", ".", "warning", "(", "\"loadNodeFromFile `returnNode` argument is deprecated. Loaded node is now returned directly if `returnNode` is not specified.\"", ")", "return", "success", ",", "loadedNode", "if", "not", "success", ":", "errorMessage", "=", "\"Failed to load node from file: \"", "+", "str", "(", "filename", ")", "raise", "RuntimeError", "(", "errorMessage", ")", "return", "loadedNode" ]

[ "Check", "the", "given", "SdfLayer", "." ]

[ "def", "CheckLayer", "(", "self", ",", "layer", ")", ":", "pass" ]

[ "Strips", "accents", "from", "a", "piece", "of", "text", "." ]

[ "def", "_run_strip_accents", "(", "self", ",", "text", ")", ":", "text", "=", "unicodedata", ".", "normalize", "(", "\"NFD\"", ",", "text", ")", "output", "=", "[", "]", "for", "char", "in", "text", ":", "cat", "=", "unicodedata", ".", "category", "(", "char", ")", "if", "cat", "==", "\"Mn\"", ":", "continue", "output", ".", "append", "(", "char", ")", "return", "\"\"", ".", "join", "(", "output", ")" ]

[ "The", "whitespace", "and", "comments", "preceding", "this", "node", "in", "the", "input", "." ]

[ "def", "_prefix_getter", "(", "self", ")", ":", "if", "not", "self", ".", "children", ":", "return", "\"\"", "return", "self", ".", "children", "[", "0", "]", ".", "prefix" ]

[ "Maintains", "a", "map", "of", "functions", "that", "are", "called", "from", "other", "functions" ]

[ "def", "updateFunctionCallMap", "(", "self", ",", "caller", ",", "callee", ")", ":", "if", "not", "caller", "in", "self", ".", "calledFunctionTable", ":", "self", ".", "calledFunctionTable", "[", "caller", "]", "=", "[", "]", "if", "not", "callee", "in", "self", ".", "calledFunctionTable", "[", "caller", "]", ":", "self", ".", "calledFunctionTable", "[", "caller", "]", ".", "append", "(", "callee", ")", "if", "not", "caller", "in", "self", ".", "comprehensiveCalledFunctionTable", ":", "self", ".", "comprehensiveCalledFunctionTable", "[", "caller", "]", "=", "[", "]", "self", ".", "comprehensiveCalledFunctionTable", "[", "caller", "]", ".", "append", "(", "callee", ")" ]

[ "Starts", "the", ":", "class", ":", "SuperToolTip", "timer", "for", "creation", "handles", "the", "wx", ".", "EVT_ENTER_WINDOW", "event", "." ]

[ "def", "OnWidgetEnter", "(", "self", ",", "event", ")", ":", "if", "self", ".", "_superToolTip", ":", "# Not yet created", "return", "if", "not", "self", ".", "_runningApp", ".", "__superToolTip", ":", "# The running app doesn't want tooltips...", "return", "if", "not", "self", ".", "_widget", ".", "GetTopLevelParent", "(", ")", ".", "IsActive", "(", ")", ":", "self", ".", "_startTimer", ".", "Stop", "(", ")", "return", "if", "self", ".", "_startTimer", ".", "IsRunning", "(", ")", ":", "# We are already running", "event", ".", "Skip", "(", ")", "return", "self", ".", "_startTimer", ".", "Start", "(", "self", ".", "_startDelayTime", "*", "1000", ")", "event", ".", "Skip", "(", ")" ]

[ "runs", "the", "graph", "and", "print", "its", "execution", "time", "." ]

[ "def", "_run_graph", "(", "self", ",", "device", ",", "input_shape", ",", "perm", ",", "num_iters", ",", "datatype", ")", ":", "graph", "=", "ops", ".", "Graph", "(", ")", "with", "graph", ".", "as_default", "(", ")", ":", "outputs", "=", "build_graph", "(", "device", ",", "input_shape", ",", "perm", ",", "datatype", ",", "num_iters", ")", "with", "session_lib", ".", "Session", "(", "graph", "=", "graph", ")", "as", "session", ":", "variables", ".", "global_variables_initializer", "(", ")", ".", "run", "(", ")", "# warmup runs", "session", ".", "run", "(", "outputs", ")", "start_time", "=", "time", ".", "time", "(", ")", "session", ".", "run", "(", "outputs", ")", "duration", "=", "(", "time", ".", "time", "(", ")", "-", "start_time", ")", "/", "num_iters", "throughput", "=", "np", ".", "prod", "(", "np", ".", "array", "(", "input_shape", ")", ")", "*", "datatype", "(", ")", ".", "itemsize", "*", "2", "/", "duration", "/", "1e9", "print", "(", "\"%s %s inputshape:%s perm:%s %d %.6fsec, %.4fGB/s.\"", "%", "(", "device", ",", "str", "(", "datatype", ")", ",", "str", "(", "input_shape", ")", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ",", "str", "(", "perm", ")", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ",", "num_iters", ",", "duration", ",", "throughput", ")", ")", "name_template", "=", "(", "\"transpose_{device}_{dtype}_input_shape_{inputshape}_perm_{perm}\"", ")", "self", ".", "report_benchmark", "(", "name", "=", "name_template", ".", "format", "(", "device", "=", "device", ",", "dtype", "=", "str", "(", "datatype", ")", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ",", "inputshape", "=", "str", "(", "input_shape", ")", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ",", "perm", "=", "str", "(", "perm", ")", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ")", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ",", "iters", "=", "num_iters", ",", "wall_time", "=", "duration", ")", "return", "duration" ]

[ "File", "has", "a", "source", "file", "extension", "." ]

[ "def", "IsSource", "(", "self", ")", ":", "return", "self", ".", "Extension", "(", ")", "[", "1", ":", "]", "in", "(", "'c'", ",", "'cc'", ",", "'cpp'", ",", "'cxx'", ")" ]

[ "Map", "MXNet", "s", "_contrib_box_nms", "operator", "to", "ONNX" ]

[ "def", "convert_contrib_box_nms", "(", "node", ",", "*", "*", "kwargs", ")", ":", "from", "onnx", ".", "helper", "import", "make_node", "name", ",", "input_nodes", ",", "attrs", "=", "get_inputs", "(", "node", ",", "kwargs", ")", "input_dtypes", "=", "get_input_dtypes", "(", "node", ",", "kwargs", ")", "dtype", "=", "input_dtypes", "[", "0", "]", "#dtype_t = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[dtype]", "opset_version", "=", "kwargs", "[", "'opset_version'", "]", "if", "opset_version", "<", "11", ":", "raise", "AttributeError", "(", "'ONNX opset 11 or greater is required to export this operator'", ")", "overlap_thresh", "=", "float", "(", "attrs", ".", "get", "(", "'overlap_thresh'", ",", "'0.5'", ")", ")", "valid_thresh", "=", "float", "(", "attrs", ".", "get", "(", "'valid_thresh'", ",", "'0'", ")", ")", "topk", "=", "int", "(", "attrs", ".", "get", "(", "'topk'", ",", "'-1'", ")", ")", "coord_start", "=", "int", "(", "attrs", ".", "get", "(", "'coord_start'", ",", "'2'", ")", ")", "score_index", "=", "int", "(", "attrs", ".", "get", "(", "'score_index'", ",", "'1'", ")", ")", "id_index", "=", "int", "(", "attrs", ".", "get", "(", "'id_index'", ",", "'-1'", ")", ")", "force_suppress", "=", "attrs", ".", "get", "(", "'force_suppress'", ",", "'True'", ")", "background_id", "=", "int", "(", "attrs", ".", "get", "(", "'background_id'", ",", "'-1'", ")", ")", "in_format", "=", "attrs", ".", "get", "(", "'in_format'", ",", "'corner'", ")", "out_format", "=", "attrs", ".", "get", "(", "'out_format'", ",", "'corner'", ")", "center_point_box", "=", "0", "if", "in_format", "==", "'corner'", "else", "1", "if", "topk", "==", "-", "1", ":", "topk", "=", "2", "**", "31", "-", "1", "if", "in_format", "!=", "out_format", ":", "raise", "NotImplementedError", "(", "'box_nms does not currently support in_fomat != out_format'", ")", "if", "background_id", "!=", "-", "1", ":", "raise", "NotImplementedError", "(", "'box_nms does not currently support background_id != -1'", ")", "if", "id_index", "!=", "-", "1", "or", "force_suppress", "==", "'False'", ":", "logging", ".", "warning", "(", "'box_nms: id_idex != -1 or/and force_suppress == False detected. '", "'However, due to ONNX limitations, boxes of different categories will NOT '", "'be exempted from suppression. This might lead to different behavior than '", "'native MXNet'", ")", "create_tensor", "(", "[", "coord_start", "]", ",", "name", "+", "'_cs'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "coord_start", "+", "4", "]", ",", "name", "+", "'_cs_p4'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "score_index", "]", ",", "name", "+", "'_si'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "score_index", "+", "1", "]", ",", "name", "+", "'_si_p1'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "topk", "]", ",", "name", "+", "'_topk'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "overlap_thresh", "]", ",", "name", "+", "'_ot'", ",", "kwargs", "[", "'initializer'", "]", ",", "dtype", "=", "np", ".", "float32", ")", "create_tensor", "(", "[", "valid_thresh", "]", ",", "name", "+", "'_vt'", ",", "kwargs", "[", "'initializer'", "]", ",", "dtype", "=", "np", ".", "float32", ")", "create_tensor", "(", "[", "-", "1", "]", ",", "name", "+", "'_m1'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "-", "1", "]", ",", "name", "+", "'_m1_f'", ",", "kwargs", "[", "'initializer'", "]", ",", "dtype", "=", "dtype", ")", "create_tensor", "(", "[", "0", "]", ",", "name", "+", "'_0'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "1", "]", ",", "name", "+", "'_1'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "2", "]", ",", "name", "+", "'_2'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "3", "]", ",", "name", "+", "'_3'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "0", ",", "1", ",", "-", "1", "]", ",", "name", "+", "'_scores_shape'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "0", ",", "0", ",", "1", ",", "0", "]", ",", "name", "+", "'_pad'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_tensor", "(", "[", "0", ",", "-", "1", "]", ",", "name", "+", "'_bat_spat_helper'", ",", "kwargs", "[", "'initializer'", "]", ")", "create_const_scalar_node", "(", "name", "+", "\"_0_s\"", ",", "np", ".", "int64", "(", "0", ")", ",", "kwargs", ")", "create_const_scalar_node", "(", "name", "+", "\"_1_s\"", ",", "np", ".", "int64", "(", "1", ")", ",", "kwargs", ")", "nodes", "=", "[", "make_node", "(", "'Shape'", ",", "[", "input_nodes", "[", "0", "]", "]", ",", "[", "name", "+", "'_shape'", "]", ")", ",", "make_node", "(", "'Shape'", ",", "[", "name", "+", "'_shape'", "]", ",", "[", "name", "+", "'_dim'", "]", ")", ",", "make_node", "(", "'Sub'", ",", "[", "name", "+", "'_dim'", ",", "name", "+", "'_2'", "]", ",", "[", "name", "+", "'_dim_m2'", "]", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_shape'", ",", "name", "+", "'_dim_m2'", ",", "name", "+", "'_dim'", "]", ",", "[", "name", "+", "'_shape_last2'", "]", ")", ",", "make_node", "(", "'Concat'", ",", "[", "name", "+", "'_m1'", ",", "name", "+", "'_shape_last2'", "]", ",", "[", "name", "+", "'_shape_3d'", "]", ",", "axis", "=", "0", ")", ",", "make_node", "(", "'Reshape'", ",", "[", "input_nodes", "[", "0", "]", ",", "name", "+", "'_shape_3d'", "]", ",", "[", "name", "+", "'_data_3d'", "]", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_data_3d'", ",", "name", "+", "'_cs'", ",", "name", "+", "'_cs_p4'", ",", "name", "+", "'_m1'", "]", ",", "[", "name", "+", "'_boxes'", "]", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_data_3d'", ",", "name", "+", "'_si'", ",", "name", "+", "'_si_p1'", ",", "name", "+", "'_m1'", "]", ",", "[", "name", "+", "'_scores_raw'", "]", ")", ",", "make_node", "(", "'Reshape'", ",", "[", "name", "+", "'_scores_raw'", ",", "name", "+", "'_scores_shape'", "]", ",", "[", "name", "+", "'_scores'", "]", ")", ",", "make_node", "(", "'Shape'", ",", "[", "name", "+", "'_scores'", "]", ",", "[", "name", "+", "'_scores_shape_actual'", "]", ")", ",", "make_node", "(", "'NonMaxSuppression'", ",", "[", "name", "+", "'_boxes'", ",", "name", "+", "'_scores'", ",", "name", "+", "'_topk'", ",", "name", "+", "'_ot'", ",", "name", "+", "'_vt'", "]", ",", "[", "name", "+", "'_nms'", "]", ",", "center_point_box", "=", "center_point_box", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_nms'", ",", "name", "+", "'_0'", ",", "name", "+", "'_3'", ",", "name", "+", "'_m1'", ",", "name", "+", "'_2'", "]", ",", "[", "name", "+", "'_nms_sliced'", "]", ")", ",", "make_node", "(", "'GatherND'", ",", "[", "name", "+", "'_data_3d'", ",", "name", "+", "'_nms_sliced'", "]", ",", "[", "name", "+", "'_candidates'", "]", ")", ",", "make_node", "(", "'Pad'", ",", "[", "name", "+", "'_candidates'", ",", "name", "+", "'_pad'", ",", "name", "+", "'_m1_f'", "]", ",", "[", "name", "+", "'_cand_padded'", "]", ")", ",", "make_node", "(", "'Shape'", ",", "[", "name", "+", "'_nms'", "]", ",", "[", "name", "+", "'_nms_shape'", "]", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_nms_shape'", ",", "name", "+", "'_0'", ",", "name", "+", "'_1'", "]", ",", "[", "name", "+", "'_cand_cnt'", "]", ")", ",", "make_node", "(", "'Squeeze'", ",", "[", "name", "+", "'_cand_cnt'", "]", ",", "[", "name", "+", "'_cc_s'", "]", ",", "axes", "=", "[", "0", "]", ")", ",", "make_node", "(", "'Range'", ",", "[", "name", "+", "'_0_s'", ",", "name", "+", "'_cc_s'", ",", "name", "+", "'_1_s'", "]", ",", "[", "name", "+", "'_cand_indices'", "]", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_scores_shape_actual'", ",", "name", "+", "'_0'", ",", "name", "+", "'_3'", ",", "name", "+", "'_m1'", ",", "name", "+", "'_2'", "]", ",", "[", "name", "+", "'_shape_bat_spat'", "]", ")", ",", "make_node", "(", "'Slice'", ",", "[", "name", "+", "'_shape_bat_spat'", ",", "name", "+", "'_1'", ",", "name", "+", "'_2'", "]", ",", "[", "name", "+", "'_spat_dim'", "]", ")", ",", "make_node", "(", "'Expand'", ",", "[", "name", "+", "'_cand_cnt'", ",", "name", "+", "'_shape_bat_spat'", "]", ",", "[", "name", "+", "'_base_indices'", "]", ")", ",", "make_node", "(", "'ScatterND'", ",", "[", "name", "+", "'_base_indices'", ",", "name", "+", "'_nms_sliced'", ",", "name", "+", "'_cand_indices'", "]", ",", "[", "name", "+", "'_indices'", "]", ")", ",", "make_node", "(", "'TopK'", ",", "[", "name", "+", "'_indices'", ",", "name", "+", "'_spat_dim'", "]", ",", "[", "name", "+", "'_indices_sorted'", ",", "name", "+", "'__'", "]", ",", "largest", "=", "0", ",", "axis", "=", "-", "1", ",", "sorted", "=", "1", ")", ",", "make_node", "(", "'Gather'", ",", "[", "name", "+", "'_cand_padded'", ",", "name", "+", "'_indices_sorted'", "]", ",", "[", "name", "+", "'_gather'", "]", ")", ",", "make_node", "(", "'Reshape'", ",", "[", "name", "+", "'_gather'", ",", "name", "+", "'_shape'", "]", ",", "[", "name", "+", "'0'", "]", ")", "]", "return", "nodes" ]

[ "Parse", "the", "date", "portion", "of", "an", "ISO", "string", "." ]

[ "def", "parse_isodate", "(", "self", ",", "datestr", ")", ":", "components", ",", "pos", "=", "self", ".", "_parse_isodate", "(", "datestr", ")", "if", "pos", "<", "len", "(", "datestr", ")", ":", "raise", "ValueError", "(", "'String contains unknown ISO '", "+", "'components: {}'", ".", "format", "(", "datestr", ")", ")", "return", "date", "(", "*", "components", ")" ]

[ "Converts", "a", "serialized", "blobprotovec", "to", "a", "list", "of", "arrays", "." ]

[ "def", "blobprotovector_str_to_arraylist", "(", "str", ")", ":", "vec", "=", "caffe_pb2", ".", "BlobProtoVector", "(", ")", "vec", ".", "ParseFromString", "(", "str", ")", "return", "[", "blobproto_to_array", "(", "blob", ")", "for", "blob", "in", "vec", ".", "blobs", "]" ]

[ "Return", "true", "if", "a", "parameter", "type", "needs", "wrapping", ".", "Currently", "this", "is", "true", "for", "byval", "aggregates", "." ]

[ "def", "TypeNeedsWrapping", "(", "self", ",", "type_node", ",", "array_dims", ")", ":", "is_aggregate", "=", "type_node", ".", "startswith", "(", "'struct'", ")", "or", "type_node", ".", "startswith", "(", "'union'", ")", "is_reference", "=", "(", "type_node", ".", "find", "(", "'*'", ")", "!=", "-", "1", "or", "array_dims", "!=", "[", "]", ")", "return", "is_aggregate", "and", "not", "is_reference" ]

[ "Returns", "the", "operator", "type", "of", "the", "given", "operator", "token", "." ]

[ "def", "_GetOperatorType", "(", "self", ",", "token", ")", ":", "if", "token", ".", "string", "==", "'?'", ":", "return", "EcmaMetaData", ".", "TERNARY_OPERATOR", "if", "token", ".", "string", "in", "TokenType", ".", "UNARY_OPERATORS", ":", "return", "EcmaMetaData", ".", "UNARY_OPERATOR", "last_code", "=", "token", ".", "metadata", ".", "last_code", "if", "not", "last_code", "or", "last_code", ".", "type", "==", "TokenType", ".", "END_BLOCK", ":", "return", "EcmaMetaData", ".", "UNARY_OPERATOR", "if", "(", "token", ".", "string", "in", "TokenType", ".", "UNARY_POST_OPERATORS", "and", "last_code", ".", "type", "in", "TokenType", ".", "EXPRESSION_ENDER_TYPES", ")", ":", "return", "EcmaMetaData", ".", "UNARY_POST_OPERATOR", "if", "(", "token", ".", "string", "in", "TokenType", ".", "UNARY_OK_OPERATORS", "and", "last_code", ".", "type", "not", "in", "TokenType", ".", "EXPRESSION_ENDER_TYPES", "and", "last_code", ".", "string", "not", "in", "TokenType", ".", "UNARY_POST_OPERATORS", ")", ":", "return", "EcmaMetaData", ".", "UNARY_OPERATOR", "return", "EcmaMetaData", ".", "BINARY_OPERATOR" ]

[ "Show", "the", "current", "context", "." ]

[ "def", "__repr__", "(", "self", ")", ":", "s", "=", "[", "]", "s", ".", "append", "(", "'Context(prec=%(prec)d, rounding=%(rounding)s, '", "'Emin=%(Emin)d, Emax=%(Emax)d, capitals=%(capitals)d'", "%", "vars", "(", "self", ")", ")", "names", "=", "[", "f", ".", "__name__", "for", "f", ",", "v", "in", "self", ".", "flags", ".", "items", "(", ")", "if", "v", "]", "s", ".", "append", "(", "'flags=['", "+", "', '", ".", "join", "(", "names", ")", "+", "']'", ")", "names", "=", "[", "t", ".", "__name__", "for", "t", ",", "v", "in", "self", ".", "traps", ".", "items", "(", ")", "if", "v", "]", "s", ".", "append", "(", "'traps=['", "+", "', '", ".", "join", "(", "names", ")", "+", "']'", ")", "return", "', '", ".", "join", "(", "s", ")", "+", "')'" ]

[ "Split", "a", "list", "of", "_TPUEmbeddingColumn", "into", "sequence", "and", "non", "-", "sequence", "columns", "." ]

[ "def", "split_sequence_columns", "(", "feature_columns", ")", ":", "sequence_columns", "=", "[", "]", "non_sequence_columns", "=", "[", "]", "for", "column", "in", "feature_columns", ":", "if", "not", "isinstance", "(", "column", ",", "(", "_TPUEmbeddingColumn", ",", "_TPUSharedEmbeddingColumn", ")", ")", ":", "raise", "TypeError", "(", "'column must be a _TPUEmbeddingColumn or _TPUSharedEmbeddingColumn '", "'but got %s instead.'", "%", "(", "type", "(", "column", ")", ")", ")", "if", "column", ".", "is_sequence_column", "(", ")", ":", "sequence_columns", ".", "append", "(", "column", ")", "else", ":", "non_sequence_columns", ".", "append", "(", "column", ")", "return", "sequence_columns", ",", "non_sequence_columns" ]

[ "Return", "a", "CPU", "context", "." ]

[ "def", "cpu", "(", "device_id", "=", "0", ")", ":", "return", "Context", "(", "'cpu'", ",", "device_id", ")" ]

[ "Creates", "a", "GatherEncoder", "for", "encoding", "tensorspec", "-", "like", "values", "." ]

[ "def", "__init__", "(", "self", ",", "tensorspec", ",", "commuting_structure", ",", "state_update_aggregation_modes", ",", "initial_state_fn", ",", "get_params_fn", ",", "encode_fn", ",", "decode_before_sum_fn", ",", "decode_after_sum_fn", ",", "update_state_fn", ")", ":", "self", ".", "_tensorspec", "=", "tensorspec", "self", ".", "_commuting_structure", "=", "commuting_structure", "self", ".", "_state_update_aggregation_modes", "=", "state_update_aggregation_modes", "self", ".", "_initial_state_fn", "=", "initial_state_fn", "self", ".", "_get_params_fn", "=", "get_params_fn", "self", ".", "_encode_fn", "=", "encode_fn", "self", ".", "_decode_before_sum_fn", "=", "decode_before_sum_fn", "self", ".", "_decode_after_sum_fn", "=", "decode_after_sum_fn", "self", ".", "_update_state_fn", "=", "update_state_fn" ]

[ "Generates", "a", "prediction", "for", "an", "example", "by", "looking", "at", "its", "closest", "neighbors" ]

[ "def", "PredictExample", "(", "self", ",", "example", ",", "appendExamples", "=", "0", ",", "weightedAverage", "=", "0", ",", "neighborList", "=", "None", ")", ":", "if", "appendExamples", ":", "self", ".", "_examples", ".", "append", "(", "example", ")", "# first find the k-closest examples in the training set", "knnLst", "=", "self", ".", "GetNeighbors", "(", "example", ")", "accum", "=", "0.0", "denom", "=", "0.0", "for", "knn", "in", "knnLst", ":", "if", "knn", "[", "1", "]", "is", "None", ":", "continue", "if", "weightedAverage", ":", "dist", "=", "knn", "[", "0", "]", "if", "dist", "==", "0.0", ":", "w", "=", "1.", "else", ":", "w", "=", "1.", "/", "dist", "else", ":", "w", "=", "1.0", "accum", "+=", "w", "*", "knn", "[", "1", "]", "[", "-", "1", "]", "denom", "+=", "w", "if", "denom", ":", "accum", "/=", "denom", "if", "neighborList", "is", "not", "None", ":", "neighborList", ".", "extend", "(", "knnLst", ")", "return", "accum" ]

[ "import", "volumes", "the", "_import_", "command" ]

[ "def", "import_volume", "(", "*", ",", "response", ":", "Response", ",", "current_user", ":", "User", "=", "Depends", "(", "get_current_user", ")", ",", "importParams", ":", "volumeImport", "=", "Body", "(", "...", ",", "title", "=", "\"Volume import parameters\"", ")", ",", ")", ":", "responseDict", "=", "{", "}", "updateCommand", "=", "\"import\"", "updateCommand", "+=", "parseCommandOptions", "(", "importParams", ".", "dict", "(", ")", ")", "# print(updateCommand)", "try", ":", "responseDict", "=", "current_user", ".", "jsonDirector", ".", "call", "(", "updateCommand", ")", "except", "Exception", "as", "e", ":", "response", ".", "status_code", "=", "500", "return", "{", "\"message\"", ":", "\"Could not import volumes on director %s. Message: '%s'\"", "%", "(", "CONFIG_DIRECTOR_NAME", ",", "e", ")", "}", "# Director delivers empty response", "response", ".", "status_code", "=", "200", "return", "responseDict" ]

[ "Delete", "stamp", "with", "given", "stampid" ]

[ "def", "clearstamp", "(", "self", ",", "stampid", ")", ":", "self", ".", "_clearstamp", "(", "stampid", ")", "self", ".", "_update", "(", ")" ]

[ "Filters", "a", "sequence", "of", "objects", "by", "applying", "a", "test", "to", "the", "specified", "attribute", "of", "each", "object", "and", "rejecting", "the", "objects", "with", "the", "test", "succeeding", "." ]

[ "def", "do_rejectattr", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "select_or_reject", "(", "args", ",", "kwargs", ",", "lambda", "x", ":", "not", "x", ",", "True", ")" ]

[ "Copy", "a", "complete", "file", "tree", "to", "a", "new", "destination" ]

[ "def", "copytree", "(", "src", ",", "dst", ",", "copydates", "=", "1", ")", ":", "if", "os", ".", "path", ".", "isdir", "(", "src", ")", ":", "mkdirs", "(", "dst", ")", "files", "=", "os", ".", "listdir", "(", "src", ")", "for", "f", "in", "files", ":", "copytree", "(", "os", ".", "path", ".", "join", "(", "src", ",", "f", ")", ",", "os", ".", "path", ".", "join", "(", "dst", ",", "f", ")", ",", "copydates", ")", "else", ":", "copy", "(", "src", ",", "dst", ",", "1", ",", "copydates", ")" ]

[ "Determine", "if", "op", "callbacks", "are", "present", "and", "should", "be", "invoked", "." ]

[ "def", "should_invoke_op_callbacks", "(", ")", ":", "ctx", "=", "context", ".", "context", "(", ")", "return", "ctx", ".", "op_callbacks", "and", "not", "ctx", ".", "invoking_op_callbacks" ]

[ "Returns", "all", "the", "fields", "sharing", "the", "same", "fieldname", "base", ".", "The", "fieldname", "base", "is", "either", "_data", "or", "_mask", "." ]

[ "def", "__getitem__", "(", "self", ",", "indx", ")", ":", "_localdict", "=", "self", ".", "__dict__", "_mask", "=", "ndarray", ".", "__getattribute__", "(", "self", ",", "'_mask'", ")", "_data", "=", "ndarray", ".", "view", "(", "self", ",", "_localdict", "[", "'_baseclass'", "]", ")", "# We want a field ........", "if", "isinstance", "(", "indx", ",", "basestring", ")", ":", "#!!!: Make sure _sharedmask is True to propagate back to _fieldmask", "#!!!: Don't use _set_mask, there are some copies being made...", "#!!!: ...that break propagation", "#!!!: Don't force the mask to nomask, that wrecks easy masking", "obj", "=", "_data", "[", "indx", "]", ".", "view", "(", "MaskedArray", ")", "obj", ".", "_mask", "=", "_mask", "[", "indx", "]", "obj", ".", "_sharedmask", "=", "True", "fval", "=", "_localdict", "[", "'_fill_value'", "]", "if", "fval", "is", "not", "None", ":", "obj", ".", "_fill_value", "=", "fval", "[", "indx", "]", "# Force to masked if the mask is True", "if", "not", "obj", ".", "ndim", "and", "obj", ".", "_mask", ":", "return", "masked", "return", "obj", "# We want some elements ..", "# First, the data ........", "obj", "=", "np", ".", "array", "(", "_data", "[", "indx", "]", ",", "copy", "=", "False", ")", ".", "view", "(", "mrecarray", ")", "obj", ".", "_mask", "=", "np", ".", "array", "(", "_mask", "[", "indx", "]", ",", "copy", "=", "False", ")", ".", "view", "(", "recarray", ")", "return", "obj" ]

[ "find_tests_for_inputs", "(", "lit_config", "inputs", ")", "-", ">", "[", "Test", "]" ]

[ "def", "find_tests_for_inputs", "(", "lit_config", ",", "inputs", ",", "indirectlyRunCheck", ")", ":", "# Expand '@...' form in inputs.", "actual_inputs", "=", "[", "]", "for", "input", "in", "inputs", ":", "if", "input", ".", "startswith", "(", "'@'", ")", ":", "f", "=", "open", "(", "input", "[", "1", ":", "]", ")", "try", ":", "for", "ln", "in", "f", ":", "ln", "=", "ln", ".", "strip", "(", ")", "if", "ln", ":", "actual_inputs", ".", "append", "(", "ln", ")", "finally", ":", "f", ".", "close", "(", ")", "else", ":", "actual_inputs", ".", "append", "(", "input", ")", "# Load the tests from the inputs.", "tests", "=", "[", "]", "test_suite_cache", "=", "{", "}", "local_config_cache", "=", "{", "}", "for", "input", "in", "actual_inputs", ":", "prev", "=", "len", "(", "tests", ")", "tests", ".", "extend", "(", "getTests", "(", "input", ",", "lit_config", ",", "test_suite_cache", ",", "local_config_cache", ",", "indirectlyRunCheck", ")", "[", "1", "]", ")", "if", "prev", "==", "len", "(", "tests", ")", ":", "lit_config", ".", "warning", "(", "'input %r contained no tests'", "%", "input", ")", "# This data is no longer needed but keeping it around causes awful", "# performance problems while the test suites run.", "for", "k", ",", "suite", "in", "test_suite_cache", ".", "items", "(", ")", ":", "if", "suite", "[", "0", "]", ":", "suite", "[", "0", "]", ".", "test_times", "=", "None", "# If there were any errors during test discovery, exit now.", "if", "lit_config", ".", "numErrors", ":", "sys", ".", "stderr", ".", "write", "(", "'%d errors, exiting.\\n'", "%", "lit_config", ".", "numErrors", ")", "sys", ".", "exit", "(", "2", ")", "return", "tests" ]

[ "Counts", "the", "number", "of", "workers", "in", "cluster_spec", "." ]

[ "def", "_count_worker", "(", "cluster_spec", ")", ":", "return", "len", "(", "cluster_spec", ".", "as_dict", "(", ")", ".", "get", "(", "'worker'", ",", "[", "]", ")", ")", "if", "cluster_spec", "else", "0" ]

[ "has_private", "()", ":", "bool", "Return", "a", "Boolean", "denoting", "whether", "the", "object", "contains", "private", "components", "." ]

[ "def", "has_private", "(", "self", ")", ":", "if", "hasattr", "(", "self", ",", "'d'", ")", ":", "return", "1", "else", ":", "return", "0" ]

[ "Finds", "a", "function", "in", "the", "graph", "starting", "from", "node", "and", "doing", "a", "depth", "-", "first", "search", ".", "It", "assumes", "that", "the", "name", "occurs", "only", "once", "." ]

[ "def", "find_by_name", "(", "node", ",", "node_name", ",", "depth", "=", "0", ")", ":", "if", "not", "isinstance", "(", "node_name", ",", "str", ")", ":", "raise", "ValueError", "(", "'node name has to be a string. You gave '", "'a %s'", "%", "type", "(", "node_name", ")", ")", "result", "=", "depth_first_search", "(", "node", ",", "lambda", "x", ":", "x", ".", "name", "==", "node_name", ",", "depth", ")", "if", "len", "(", "result", ")", ">", "1", ":", "raise", "ValueError", "(", "'found multiple functions matching \"%s\". '", "'If that was expected call find_all_with_name'", "%", "node_name", ")", "if", "not", "result", ":", "return", "None", "return", "result", "[", "0", "]" ]

[ "Round", "an", "array", "to", "the", "given", "number", "of", "decimals", "." ]

[ "def", "round_", "(", "a", ",", "decimals", "=", "0", ",", "out", "=", "None", ")", ":", "return", "around", "(", "a", ",", "decimals", "=", "decimals", ",", "out", "=", "out", ")" ]

[ "Overrides", "the", "ctypes", "semi", "-", "magic", "method" ]

[ "def", "_as_parameter_", "(", "self", ")", ":", "return", "self", ".", "data_as", "(", "ctypes", ".", "c_void_p", ")" ]

[ "Instantiate", "property", "with", "raw", "value", "type" ]

[ "def", "new_raw_property", "(", "name", ",", "raw_value", ")", ":", "if", "FdtProperty", ".", "__check_prop_strings", "(", "raw_value", ")", ":", "return", "FdtPropertyStrings", ".", "init_raw", "(", "name", ",", "raw_value", ")", "elif", "len", "(", "raw_value", ")", "and", "len", "(", "raw_value", ")", "%", "4", "==", "0", ":", "return", "FdtPropertyWords", ".", "init_raw", "(", "name", ",", "raw_value", ")", "elif", "len", "(", "raw_value", ")", "and", "len", "(", "raw_value", ")", ":", "return", "FdtPropertyBytes", ".", "init_raw", "(", "name", ",", "raw_value", ")", "else", ":", "return", "FdtProperty", "(", "name", ")" ]

[ "Dumps", "the", "symbols", "of", "binary", "and", "places", "them", "in", "the", "given", "directory", "." ]

[ "def", "GenerateSymbols", "(", "options", ",", "binaries", ")", ":", "q", "=", "queue", ".", "Queue", "(", ")", "print_lock", "=", "threading", ".", "Lock", "(", ")", "def", "_Worker", "(", ")", ":", "dump_syms", "=", "options", ".", "dumpsyms_bin", "while", "True", ":", "binary", "=", "q", ".", "get", "(", ")", "if", "options", ".", "verbose", ":", "with", "print_lock", ":", "print", "(", "\"Generating symbols for %s\"", "%", "binary", ")", "syms", "=", "GetCommandOutput", "(", "[", "dump_syms", ",", "binary", "]", ")", "module_line", "=", "re", ".", "match", "(", "\"MODULE [^ ]+ [^ ]+ ([0-9A-Fa-f]+) (.*)\\r\\n\"", ",", "syms", ")", "if", "module_line", "==", "None", ":", "with", "print_lock", ":", "print", "(", "\"Failed to get symbols for %s\"", "%", "binary", ")", "q", ".", "task_done", "(", ")", "continue", "output_path", "=", "os", ".", "path", ".", "join", "(", "options", ".", "symbols_dir", ",", "module_line", ".", "group", "(", "2", ")", ",", "module_line", ".", "group", "(", "1", ")", ")", "mkdir_p", "(", "output_path", ")", "symbol_file", "=", "\"%s.sym\"", "%", "module_line", ".", "group", "(", "2", ")", "[", ":", "-", "4", "]", "# strip .pdb", "f", "=", "open", "(", "os", ".", "path", ".", "join", "(", "output_path", ",", "symbol_file", ")", ",", "'w'", ")", "f", ".", "write", "(", "syms", ")", "f", ".", "close", "(", ")", "q", ".", "task_done", "(", ")", "for", "binary", "in", "binaries", ":", "q", ".", "put", "(", "binary", ")", "for", "_", "in", "range", "(", "options", ".", "jobs", ")", ":", "t", "=", "threading", ".", "Thread", "(", "target", "=", "_Worker", ")", "t", ".", "daemon", "=", "True", "t", ".", "start", "(", ")", "q", ".", "join", "(", ")" ]

[ "Initialize", "a", "LOC", "record", "instance", "." ]

[ "def", "__init__", "(", "self", ",", "rdclass", ",", "rdtype", ",", "latitude", ",", "longitude", ",", "altitude", ",", "size", "=", "1.0", ",", "hprec", "=", "10000.0", ",", "vprec", "=", "10.0", ")", ":", "super", "(", "LOC", ",", "self", ")", ".", "__init__", "(", "rdclass", ",", "rdtype", ")", "if", "isinstance", "(", "latitude", ",", "int", ")", "or", "isinstance", "(", "latitude", ",", "long", ")", ":", "latitude", "=", "float", "(", "latitude", ")", "if", "isinstance", "(", "latitude", ",", "float", ")", ":", "latitude", "=", "_float_to_tuple", "(", "latitude", ")", "self", ".", "latitude", "=", "latitude", "if", "isinstance", "(", "longitude", ",", "int", ")", "or", "isinstance", "(", "longitude", ",", "long", ")", ":", "longitude", "=", "float", "(", "longitude", ")", "if", "isinstance", "(", "longitude", ",", "float", ")", ":", "longitude", "=", "_float_to_tuple", "(", "longitude", ")", "self", ".", "longitude", "=", "longitude", "self", ".", "altitude", "=", "float", "(", "altitude", ")", "self", ".", "size", "=", "float", "(", "size", ")", "self", ".", "horizontal_precision", "=", "float", "(", "hprec", ")", "self", ".", "vertical_precision", "=", "float", "(", "vprec", ")" ]

[ "Yield", "a", "list", "of", "sequential", "items", "from", "*", "iterable", "*", "of", "length", "n", "for", "each", "integer", "n", "in", "*", "sizes", "*", "." ]

[ "def", "split_into", "(", "iterable", ",", "sizes", ")", ":", "# convert the iterable argument into an iterator so its contents can", "# be consumed by islice in case it is a generator", "it", "=", "iter", "(", "iterable", ")", "for", "size", "in", "sizes", ":", "if", "size", "is", "None", ":", "yield", "list", "(", "it", ")", "return", "else", ":", "yield", "list", "(", "islice", "(", "it", ",", "size", ")", ")" ]

[ "Updates", "the", "list", "of", "global", "error", "suppressions", "." ]

[ "def", "ProcessGlobalSuppressions", "(", "lines", ")", ":", "for", "line", "in", "lines", ":", "if", "_SEARCH_C_FILE", ".", "search", "(", "line", ")", ":", "for", "category", "in", "_DEFAULT_C_SUPPRESSED_CATEGORIES", ":", "_global_error_suppressions", "[", "category", "]", "=", "True", "if", "_SEARCH_KERNEL_FILE", ".", "search", "(", "line", ")", ":", "for", "category", "in", "_DEFAULT_KERNEL_SUPPRESSED_CATEGORIES", ":", "_global_error_suppressions", "[", "category", "]", "=", "True" ]

[ "this", "is", "called", "when", "the", "global", "clock", "gets", "adjusted", "timeDelta", "is", "equal", "to", "the", "amount", "of", "time", "in", "seconds", "that", "has", "been", "added", "to", "the", "global", "clock" ]

[ "def", "__resetClock", "(", "self", ",", "timeDelta", ")", ":", "assert", "self", ".", "notify", ".", "debug", "(", "\"adjusting timebase by %f seconds\"", "%", "timeDelta", ")", "# adjust our timebase by the same amount", "self", ".", "delta", "+=", "timeDelta" ]

[ "Return", "an", "iterator", "on", "the", "rule", "targets", "." ]

[ "def", "targets", "(", "self", ")", ":", "# Ensure the returned iterator is actually just that, an iterator.", "# Avoids caller fiddling with the set itself.", "return", "iter", "(", "self", ".", "_targets", ")" ]

[ "Extract", "the", "raw", "traceback", "from", "the", "current", "stack", "frame", "." ]

[ "def", "extract_stack", "(", "f", "=", "None", ",", "limit", "=", "None", ")", ":", "if", "f", "is", "None", ":", "try", ":", "raise", "ZeroDivisionError", "except", "ZeroDivisionError", ":", "f", "=", "sys", ".", "exc_info", "(", ")", "[", "2", "]", ".", "tb_frame", ".", "f_back", "if", "limit", "is", "None", ":", "if", "hasattr", "(", "sys", ",", "'tracebacklimit'", ")", ":", "limit", "=", "sys", ".", "tracebacklimit", "list", "=", "[", "]", "n", "=", "0", "while", "f", "is", "not", "None", "and", "(", "limit", "is", "None", "or", "n", "<", "limit", ")", ":", "lineno", "=", "f", ".", "f_lineno", "co", "=", "f", ".", "f_code", "filename", "=", "co", ".", "co_filename", "name", "=", "co", ".", "co_name", "linecache", ".", "checkcache", "(", "filename", ")", "line", "=", "linecache", ".", "getline", "(", "filename", ",", "lineno", ",", "f", ".", "f_globals", ")", "if", "line", ":", "line", "=", "line", ".", "strip", "(", ")", "else", ":", "line", "=", "None", "list", ".", "append", "(", "(", "filename", ",", "lineno", ",", "name", ",", "line", ")", ")", "f", "=", "f", ".", "f_back", "n", "=", "n", "+", "1", "list", ".", "reverse", "(", ")", "return", "list" ]

[ "serialize", "message", "with", "numpy", "array", "types", "into", "buffer", ":", "param", "buff", ":", "buffer", "StringIO", ":", "param", "numpy", ":", "numpy", "python", "module" ]

[ "def", "serialize_numpy", "(", "self", ",", "buff", ",", "numpy", ")", ":", "try", ":", "_x", "=", "self", "buff", ".", "write", "(", "_struct_3I", ".", "pack", "(", "_x", ".", "header", ".", "seq", ",", "_x", ".", "header", ".", "stamp", ".", "secs", ",", "_x", ".", "header", ".", "stamp", ".", "nsecs", ")", ")", "_x", "=", "self", ".", "header", ".", "frame_id", "length", "=", "len", "(", "_x", ")", "if", "python3", "or", "type", "(", "_x", ")", "==", "unicode", ":", "_x", "=", "_x", ".", "encode", "(", "'utf-8'", ")", "length", "=", "len", "(", "_x", ")", "if", "python3", ":", "buff", ".", "write", "(", "struct", ".", "pack", "(", "'<I%sB'", "%", "length", ",", "length", ",", "*", "_x", ")", ")", "else", ":", "buff", ".", "write", "(", "struct", ".", "pack", "(", "'<I%ss'", "%", "length", ",", "length", ",", "_x", ")", ")", "_x", "=", "self", "buff", ".", "write", "(", "_struct_H16d", ".", "pack", "(", "_x", ".", "loop_rate", ",", "_x", ".", "voltage", ",", "_x", ".", "orientation", ".", "x", ",", "_x", ".", "orientation", ".", "y", ",", "_x", ".", "orientation", ".", "z", ",", "_x", ".", "orientation", ".", "w", ",", "_x", ".", "angular_velocity", ".", "x", ",", "_x", ".", "angular_velocity", ".", "y", ",", "_x", ".", "angular_velocity", ".", "z", ",", "_x", ".", "linear_acceleration", ".", "x", ",", "_x", ".", "linear_acceleration", ".", "y", ",", "_x", ".", "linear_acceleration", ".", "z", ",", "_x", ".", "pressure_dheight", ",", "_x", ".", "pressure_height", ",", "_x", ".", "magnetic_field", ".", "x", ",", "_x", ".", "magnetic_field", ".", "y", ",", "_x", ".", "magnetic_field", ".", "z", ")", ")", "_x", "=", "self", ".", "radio_channel", "# - if encoded as a list instead, serialize as bytes instead of string", "if", "type", "(", "_x", ")", "in", "[", "list", ",", "tuple", "]", ":", "buff", ".", "write", "(", "_struct_8B", ".", "pack", "(", "*", "_x", ")", ")", "else", ":", "buff", ".", "write", "(", "_struct_8s", ".", "pack", "(", "_x", ")", ")", "buff", ".", "write", "(", "_struct_B", ".", "pack", "(", "self", ".", "seq", ")", ")", "except", "struct", ".", "error", "as", "se", ":", "self", ".", "_check_types", "(", "struct", ".", "error", "(", "\"%s: '%s' when writing '%s'\"", "%", "(", "type", "(", "se", ")", ",", "str", "(", "se", ")", ",", "str", "(", "_x", ")", ")", ")", ")", "except", "TypeError", "as", "te", ":", "self", ".", "_check_types", "(", "ValueError", "(", "\"%s: '%s' when writing '%s'\"", "%", "(", "type", "(", "te", ")", ",", "str", "(", "te", ")", ",", "str", "(", "_x", ")", ")", ")", ")" ]

[ "Define", "the", "calculation", "efficiency", "of", "operator", "which", "refers", "to", "the", "value", "of", "the", "cost", "model", "in", "the", "tiling", "module", "." ]

[ "def", "compute_cost", "(", "self", ",", "compute_cost", "=", "10", ")", ":", "self", ".", "_is_int", "(", "compute_cost", ")", "self", ".", "compute_cost_", "=", "compute_cost", "return", "self" ]

[ "It", "s", "not", "sufficient", "to", "have", "the", "absolute", "path", "to", "the", "compiler", "linker", "etc", ".", "on", "Windows", "as", "those", "tools", "rely", "on", ".", "dlls", "being", "in", "the", "PATH", ".", "We", "also", "need", "to", "support", "both", "x86", "and", "x64", "compilers", ".", "Different", "architectures", "require", "a", "different", "compiler", "binary", "and", "different", "supporting", "environment", "variables", "(", "INCLUDE", "LIB", "LIBPATH", ")", ".", "So", "we", "extract", "the", "environment", "here", "wrap", "all", "invocations", "of", "compiler", "tools", "(", "cl", "link", "lib", "rc", "midl", "etc", ".", ")", "to", "set", "up", "the", "environment", "and", "then", "do", "not", "prefix", "the", "compiler", "with", "an", "absolute", "path", "instead", "preferring", "something", "like", "cl", ".", "exe", "in", "the", "rule", "which", "will", "then", "run", "whichever", "the", "environment", "setup", "has", "put", "in", "the", "path", "." ]

[ "def", "_GenerateEnvironmentFiles", "(", "install_dir", ",", "out_dir", ",", "script_path", ")", ":", "archs", "=", "(", "'x86'", ",", "'amd64'", ",", "'arm64'", ")", "result", "=", "[", "]", "for", "arch", "in", "archs", ":", "# Extract environment variables for subprocesses.", "args", "=", "[", "os", ".", "path", ".", "join", "(", "install_dir", ",", "script_path", ")", "]", "script_arch_name", "=", "arch", "if", "script_path", ".", "endswith", "(", "'SetEnv.cmd'", ")", "and", "arch", "==", "'amd64'", ":", "script_arch_name", "=", "'/x64'", "if", "arch", "==", "'arm64'", ":", "script_arch_name", "=", "'x86_arm64'", "args", ".", "extend", "(", "(", "script_arch_name", ",", "'&&'", ",", "'set'", ")", ")", "popen", "=", "subprocess", ".", "Popen", "(", "args", ",", "shell", "=", "True", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "STDOUT", ")", "variables", ",", "_", "=", "popen", ".", "communicate", "(", ")", "if", "popen", ".", "returncode", "!=", "0", ":", "raise", "Exception", "(", "'\"%s\" failed with error %d'", "%", "(", "args", ",", "popen", ".", "returncode", ")", ")", "env", "=", "_ExtractImportantEnvironment", "(", "variables", ")", "env_block", "=", "_FormatAsEnvironmentBlock", "(", "env", ")", "basename", "=", "'environment.'", "+", "arch", "with", "open", "(", "os", ".", "path", ".", "join", "(", "out_dir", ",", "basename", ")", ",", "'wb'", ")", "as", "f", ":", "f", ".", "write", "(", "env_block", ")", "result", ".", "append", "(", "basename", ")", "return", "result" ]

[ "Check", "if", "the", "persistent", "cache", "is", "consistent", "with", "the", "gamestate", "and", "fix", "it", "if", "not", "." ]

[ "def", "_check_cache_for_consistency", "(", "self", ")", ":", "debug", "(", "\"Checking persistent cache for consistency...\"", ")", "try", ":", "for", "partname", "in", "self", ".", "part_by_partname", ":", "cached_name", "=", "self", ".", "part_by_partname", "[", "partname", "]", ".", "name", "if", "cached_name", "!=", "partname", ":", "self", ".", "part_by_partname", "[", "partname", "]", "=", "fo", ".", "getShipPart", "(", "partname", ")", "error", "(", "\"Part cache corrupted. Expected: %s, got: %s. Cache was repaired.\"", "%", "(", "partname", ",", "cached_name", ")", ")", "except", "Exception", "as", "e", ":", "self", ".", "part_by_partname", ".", "clear", "(", ")", "error", "(", "e", ",", "exc_info", "=", "True", ")", "corrupted", "=", "[", "]", "# create a copy of the dict-keys so we can alter the dict", "for", "designname", "in", "list", "(", "self", ".", "design_id_by_name", ")", ":", "# dropping invalid designs from cache", "if", "self", ".", "design_id_by_name", "[", "designname", "]", "==", "INVALID_ID", ":", "del", "self", ".", "design_id_by_name", "[", "designname", "]", "continue", "try", ":", "cached_name", "=", "fo", ".", "getShipDesign", "(", "self", ".", "design_id_by_name", "[", "designname", "]", ")", ".", "name", "if", "cached_name", "!=", "designname", ":", "warning", "(", "\"ShipID cache corrupted. Expected: %s, got: %s.\"", "%", "(", "designname", ",", "cached_name", ")", ")", "design_id", "=", "next", "(", "iter", "(", "[", "shipDesignID", "for", "shipDesignID", "in", "fo", ".", "getEmpire", "(", ")", ".", "allShipDesigns", "if", "designname", "==", "fo", ".", "getShipDesign", "(", "shipDesignID", ")", ".", "name", "]", ")", ",", "None", ",", ")", "if", "design_id", "is", "not", "None", ":", "self", ".", "design_id_by_name", "[", "designname", "]", "=", "design_id", "else", ":", "corrupted", ".", "append", "(", "designname", ")", "except", "AttributeError", ":", "warning", "(", "\"ShipID cache corrupted. Could not get cached shipdesign. Repairing Cache.\"", ",", "exc_info", "=", "True", ")", "design_id", "=", "next", "(", "iter", "(", "[", "shipDesignID", "for", "shipDesignID", "in", "fo", ".", "getEmpire", "(", ")", ".", "allShipDesigns", "if", "designname", "==", "fo", ".", "getShipDesign", "(", "shipDesignID", ")", ".", "name", "]", ")", ",", "None", ",", ")", "if", "design_id", "is", "not", "None", ":", "self", ".", "design_id_by_name", "[", "designname", "]", "=", "design_id", "else", ":", "corrupted", ".", "append", "(", "designname", ")", "for", "corrupted_entry", "in", "corrupted", ":", "del", "self", ".", "design_id_by_name", "[", "corrupted_entry", "]", "bad_ref", "=", "next", "(", "iter", "(", "[", "_key", "for", "_key", ",", "_val", "in", "self", ".", "map_reference_design_name", ".", "items", "(", ")", "if", "_val", "==", "corrupted_entry", "]", ")", ",", "None", ")", "if", "bad_ref", "is", "not", "None", ":", "del", "self", ".", "map_reference_design_name", "[", "bad_ref", "]" ]

[ "Delegate", "an", "info", "call", "to", "the", "underlying", "logger", "after", "adding", "contextual", "information", "from", "this", "adapter", "instance", "." ]

[ "def", "info", "(", "self", ",", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "msg", ",", "kwargs", "=", "self", ".", "process", "(", "msg", ",", "kwargs", ")", "self", ".", "logger", ".", "info", "(", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[]

[ "def", "_get_dark_run_name_and_path", "(", "self", ",", "setting", ")", ":", "dark_run_ws_name", "=", "None", "dark_run_file_path", "=", "None", "try", ":", "dark_run_file_path", ",", "dark_run_ws_name", "=", "getFileAndName", "(", "setting", ".", "run_number", ")", "dark_run_file_path", "=", "dark_run_file_path", ".", "replace", "(", "\"\\\\\"", ",", "\"/\"", ")", "except", ":", "raise", "RuntimeError", "(", "\"DarkRunSubtration: The specified dark run file cannot be found or loaded. \"", "\"Please make sure that that it exists in your search directory.\"", ")", "return", "dark_run_ws_name", ",", "dark_run_file_path" ]

[ "Create", "dependency", "list", "for", "a", "file", "(", "incl", ".", "all", "source", "files", "needed", ")", "." ]

[ "def", "get_all_dependencies_of_file", "(", "headers_flag", ",", "filename", ")", ":", "errors", "=", "[", "]", "# a queue to process files", "queue_cc", "=", "queue", ".", "SimpleQueue", "(", ")", "# a set of items that have ever been in queue_cc (faster access time)", "queue_cc_set", "=", "set", "(", ")", "# store processed files", "processed_cc", "=", "set", "(", ")", "# add the source file to the queue", "queue_cc", ".", "put", "(", "filename", ")", "queue_cc_set", ".", "add", "(", "filename", ")", "while", "not", "queue_cc", ".", "empty", "(", ")", ":", "# process the first item in the queue", "curr_cc", "=", "queue_cc", ".", "get", "(", ")", "deps", ",", "error", "=", "get_dependencies_of_file", "(", "headers_flag", ",", "curr_cc", ")", "errors", ".", "append", "(", "error", ")", "processed_cc", ".", "add", "(", "curr_cc", ")", "# prepare its dependencies for processing", "for", "dep_h", "in", "deps", ":", "dep_cc", "=", "build_source_file_path", "(", "dep_h", ")", "# ignore if marked as an external dependency", "if", "dep_cc", "==", "\"EXTERNAL\"", ":", "processed_cc", ".", "add", "(", "dep_h", ")", "continue", "# add to queue if needs processing", "if", "needs_processing", "(", "dep_cc", ",", "processed_cc", ",", "queue_cc_set", ")", ":", "queue_cc", ".", "put", "(", "dep_cc", ")", "queue_cc_set", ".", "add", "(", "dep_cc", ")", "logger", ".", "debug", "(", "'file: {} | deps: {}'", ".", "format", "(", "os", ".", "path", ".", "basename", "(", "filename", ")", ",", "len", "(", "processed_cc", ")", ")", ")", "return", "list", "(", "processed_cc", ")", ",", "\"\"", ".", "join", "(", "errors", ")" ]

[ "Coerce", "**", "s", "**", "to", "six", ".", "binary_type", "." ]

[ "def", "ensure_binary", "(", "s", ",", "encoding", "=", "\"utf-8\"", ",", "errors", "=", "\"strict\"", ")", ":", "if", "isinstance", "(", "s", ",", "text_type", ")", ":", "return", "s", ".", "encode", "(", "encoding", ",", "errors", ")", "elif", "isinstance", "(", "s", ",", "binary_type", ")", ":", "return", "s", "else", ":", "raise", "TypeError", "(", "\"not expecting type '%s'\"", "%", "type", "(", "s", ")", ")" ]

[ "Classifies", "the", "given", "operation", "as", "action", "or", "transformation", "and", "returns", "the", "type", "." ]

[ "def", "_classify_operation", "(", "self", ",", "name", ")", ":", "operations_dict", "=", "{", "\"Define\"", ":", "Operation", ".", "TRANSFORMATION", ",", "\"DefinePerSample\"", ":", "Operation", ".", "TRANSFORMATION", ",", "\"Filter\"", ":", "Operation", ".", "TRANSFORMATION", ",", "\"Range\"", ":", "Operation", ".", "TRANSFORMATION", ",", "\"Aggregate\"", ":", "Operation", ".", "ACTION", ",", "\"Histo1D\"", ":", "Operation", ".", "ACTION", ",", "\"Histo2D\"", ":", "Operation", ".", "ACTION", ",", "\"Histo3D\"", ":", "Operation", ".", "ACTION", ",", "\"HistoND\"", ":", "Operation", ".", "ACTION", ",", "\"Profile1D\"", ":", "Operation", ".", "ACTION", ",", "\"Profile2D\"", ":", "Operation", ".", "ACTION", ",", "\"Profile3D\"", ":", "Operation", ".", "ACTION", ",", "\"Count\"", ":", "Operation", ".", "ACTION", ",", "\"Min\"", ":", "Operation", ".", "ACTION", ",", "\"Max\"", ":", "Operation", ".", "ACTION", ",", "\"Mean\"", ":", "Operation", ".", "ACTION", ",", "\"Sum\"", ":", "Operation", ".", "ACTION", ",", "\"Fill\"", ":", "Operation", ".", "ACTION", ",", "\"Redefine\"", ":", "Operation", ".", "TRANSFORMATION", ",", "\"Reduce\"", ":", "Operation", ".", "ACTION", ",", "\"Report\"", ":", "Operation", ".", "ACTION", ",", "\"Take\"", ":", "Operation", ".", "ACTION", ",", "\"Graph\"", ":", "Operation", ".", "ACTION", ",", "\"Snapshot\"", ":", "Operation", ".", "INSTANT_ACTION", ",", "\"Foreach\"", ":", "Operation", ".", "INSTANT_ACTION", ",", "\"AsNumpy\"", ":", "Operation", ".", "INSTANT_ACTION", "}", "op_type", "=", "operations_dict", ".", "get", "(", "name", ")", "if", "not", "op_type", ":", "raise", "Exception", "(", "\"Invalid operation \\\"{}\\\"\"", ".", "format", "(", "name", ")", ")", "return", "op_type" ]

[ "Return", "absolute", "paths", "to", "all", "shared", "library", "dependencies", "of", "the", "binary", "." ]

[ "def", "GetSharedLibraryDependenciesChromeOS", "(", "binary", ")", ":", "return", "_GetSharedLibraryDependenciesAndroidOrChromeOS", "(", "binary", ")" ]

[ "Downloads", "confi", ".", "py", "used", "in", "run_admin_cmds" ]

[ "def", "download_conf", "(", "ctx", ",", "config", ")", ":", "assert", "isinstance", "(", "config", ",", "dict", ")", "log", ".", "info", "(", "'Downloading conf...'", ")", "testdir", "=", "teuthology", ".", "get_testdir", "(", "ctx", ")", "conf_branch", "=", "'main'", "conf_repo", "=", "'https://github.com/TRYTOBE8TME/scripts.git'", "for", "(", "client", ",", "_", ")", "in", "config", ".", "items", "(", ")", ":", "ctx", ".", "cluster", ".", "only", "(", "client", ")", ".", "run", "(", "args", "=", "[", "'git'", ",", "'clone'", ",", "'-b'", ",", "conf_branch", ",", "conf_repo", ",", "'{tdir}/scripts'", ".", "format", "(", "tdir", "=", "testdir", ")", ",", "]", ",", ")", "try", ":", "yield", "finally", ":", "log", ".", "info", "(", "'Removing conf...'", ")", "testdir", "=", "teuthology", ".", "get_testdir", "(", "ctx", ")", "for", "client", "in", "config", ":", "ctx", ".", "cluster", ".", "only", "(", "client", ")", ".", "run", "(", "args", "=", "[", "'rm'", ",", "'-rf'", ",", "'{tdir}/scripts'", ".", "format", "(", "tdir", "=", "testdir", ")", ",", "]", ",", ")" ]

[ "For", "backwards", "-", "compatibility", ".", "Defers", "to", "run", "()", "." ]

[ "def", "runctx", "(", "self", ",", "cmd", ",", "globals", ",", "locals", ")", ":", "# B/W compatibility", "self", ".", "run", "(", "cmd", ",", "globals", ",", "locals", ")" ]

[ "Returns", "the", "list", "of", "unique", "node", "names", "used", "within", "this", "context", "." ]

[ "def", "nodes", "(", "self", ")", ":", "return", "self", ".", "_nodes" ]

[ "Writes", "publish", "content", "into", "htaccess", "-", "file", "." ]

[ "def", "_WritePublishContentToHtaccessFile", "(", "self", ",", "htaccess_file", ",", "target_paths_list", ")", ":", "default_target_path", "=", "self", ".", "_GetEcDefaultDbTargetPath", "(", ")", "# Write publish header to file.", "htaccess_file", ".", "write", "(", "\"%s\"", "%", "PublishManagerHelper", ".", "HTACCESS_GE_PUBLISH_BEGIN", ")", "# Write RewriteBase to file.", "htaccess_file", ".", "write", "(", "\"%s\"", "%", "HTACCESS_REWRITE_BASE", ")", "logger", ".", "info", "(", "\"Default target path is currently set to: %s \"", "%", "default_target_path", ")", "if", "default_target_path", ":", "# Database is set to default for Earth Client:", "relative_target_path", "=", "default_target_path", "[", "1", ":", "]", "htaccess_file", ".", "write", "(", "EC_DEFAULT_MAP_LINE0_LOCAL_REWRITECOND", ")", "htaccess_file", ".", "write", "(", "EC_DEFAULT_MAP_LINE1_GOOGLE_REDIRECT", "%", "relative_target_path", ")", "htaccess_file", ".", "write", "(", "EC_DEFAULT_MAP_LINE2_GOOGLE_REDIRECT", "%", "relative_target_path", ")", "# Collects all the needed information for all the target paths based on", "# target ID and adds corresponding rewrite rules into htacces-file.", "for", "(", "target_path", ",", "target_id", ",", "serve_wms", ")", "in", "target_paths_list", ":", "(", "virtual_host_url", ",", "db_name", ",", "host_name", ",", "db_flags", ")", "=", "self", ".", "_QueryTargetDetailsById", "(", "target_id", ")", "if", "(", "not", "virtual_host_url", ")", "or", "(", "not", "db_name", ")", ":", "continue", "# no DB published on this target path.", "# Identify type of published DB.", "(", "unused_norm_db_path", ",", "db_type", ")", "=", "serve_utils", ".", "IdentifyPublishedDb", "(", "db_name", ")", "if", "serve_utils", ".", "IsFusionDb", "(", "db_type", ")", ":", "if", "not", "host_name", ":", "raise", "exceptions", ".", "PublishServeException", "(", "\"Internal Error - undefined host name for Fusion database %s.\"", "%", "db_name", ")", "else", ":", "assert", "serve_utils", ".", "IsPortable", "(", "db_type", ")", "if", "host_name", ":", "raise", "exceptions", ".", "PublishServeException", "(", "\"Internal Error - host name is not empty for portable %s.\"", "%", "db_name", ")", "# Put the rules into htacces file for current target", "url_parse_res", "=", "urlparse", ".", "urlparse", "(", "virtual_host_url", ")", "virtual_host_path", "=", "url_parse_res", ".", "path", "relative_target_path", "=", "target_path", "[", "1", ":", "]", "# Common lines for all the databases, globes.", "htaccess_file", ".", "write", "(", "LINE0_TARGETDESCR", "%", "target_path", ")", "htaccess_file", ".", "write", "(", "LINE1_TRAILING_SLASH_REWRITERULE", "%", "(", "relative_target_path", ",", "relative_target_path", ")", ")", "htaccess_file", ".", "write", "(", "LINE2_POISEARCH_REWRITERULE", "%", "(", "relative_target_path", ",", "constants", ".", "POI_SEARCH_SERVICE_NAME", ",", "constants", ".", "POI_SEARCH_SERVICE_NAME", ")", ")", "if", "serve_wms", ":", "htaccess_file", ".", "write", "(", "WMS_LINE0_REWRITECOND", ")", "htaccess_file", ".", "write", "(", "WMS_LINE1_REWRITERULE", "%", "(", "relative_target_path", ",", "target_path", ")", ")", "else", ":", "htaccess_file", ".", "write", "(", "WMS_LINE0_REWRITERULE_R404", "%", "(", "relative_target_path", ")", ")", "# Content for Fusion earth (GE database).", "if", "db_type", "==", "basic_types", ".", "DbType", ".", "TYPE_GE", ":", "htaccess_file", ".", "write", "(", "GE_LINE0_REWRITERULE", "%", "relative_target_path", ")", "htaccess_file", ".", "write", "(", "GE_LINE1_REWRITECOND", ")", "htaccess_file", ".", "write", "(", "GE_LINE2_REWRITERULE", "%", "(", "relative_target_path", ",", "virtual_host_path", ",", "target_path", ",", "db_type", ")", ")", "# Content for Fusion map (map database).", "elif", "db_type", "==", "basic_types", ".", "DbType", ".", "TYPE_MAP", ":", "assert", "isinstance", "(", "db_flags", ",", "int", ")", "if", "db_flags", "&", "basic_types", ".", "DbFlags", ".", "USE_GOOGLE_BASEMAP", "==", "0", ":", "htaccess_file", ".", "write", "(", "MAP_LINE0_LOCAL_REWRITERULE", "%", "relative_target_path", ")", "else", ":", "htaccess_file", ".", "write", "(", "MAP_LINE0_GOOGLE_REWRITERULE", "%", "relative_target_path", ")", "htaccess_file", ".", "write", "(", "MAP_LINE1_REWRITERULE", "%", "relative_target_path", ")", "htaccess_file", ".", "write", "(", "MAP_LINE2_REWRITECOND", ")", "htaccess_file", ".", "write", "(", "MAP_LINE3_REWRITERULE", "%", "(", "relative_target_path", ",", "virtual_host_path", ",", "target_path", ",", "db_type", ")", ")", "# Content for portable globes.", "elif", "serve_utils", ".", "IsPortable", "(", "db_type", ")", ":", "htaccess_file", ".", "write", "(", "GLX_LINE0_REWRITERULE", "%", "(", "relative_target_path", ",", "target_path", ")", ")", "htaccess_file", ".", "write", "(", "GLX_LINE1_REWRITECOND", ")", "htaccess_file", ".", "write", "(", "GLX_LINE2_REWRITERULE", "%", "(", "relative_target_path", ",", "virtual_host_path", ",", "target_path", ",", "db_type", ")", ")", "else", ":", "raise", "exceptions", ".", "PublishServeException", "(", "\"Unsupported DB type %s.\"", ",", "db_type", ")", "# write publish footer to file.", "htaccess_file", ".", "write", "(", "\"\\n%s\"", "%", "PublishManagerHelper", ".", "HTACCESS_GE_PUBLISH_END", ")" ]

[ "Initialize", "FakeQuantPerChannelGrad", "Fill" ]

[ "def", "__init__", "(", "self", ",", "num_bits", "=", "8", ",", "quant_delay", "=", "0", ",", "symmetric", "=", "False", ",", "narrow_range", "=", "False", ",", "channel_axis", "=", "1", ")", ":", "if", "context", ".", "get_context", "(", "'device_target'", ")", "==", "\"Ascend\"", ":", "from", "mindspore", ".", "ops", ".", "_op_impl", ".", "_custom_op", "import", "fake_quant_perchannel_grad", "if", "num_bits", "not", "in", "self", ".", "support_quant_bit", ":", "raise", "ValueError", "(", "f\"For '{self.name}' attr \\'num_bits\\' is not support.\"", ")", "self", ".", "num_bits", "=", "validator", ".", "check_positive_int", "(", "num_bits", ",", "'num_bits'", ",", "self", ".", "name", ")", "self", ".", "quant_delay", "=", "validator", ".", "check_value_type", "(", "'quant_delay'", ",", "quant_delay", ",", "(", "int", ",", ")", ",", "self", ".", "name", ")", "self", ".", "symmetric", "=", "validator", ".", "check_value_type", "(", "'symmetric'", ",", "symmetric", ",", "(", "bool", ",", ")", ",", "self", ".", "name", ")", "self", ".", "narrow_range", "=", "validator", ".", "check_value_type", "(", "'narrow_range'", ",", "narrow_range", ",", "(", "bool", ",", ")", ",", "self", ".", "name", ")", "self", ".", "channel_axis", "=", "validator", ".", "check_non_negative_int", "(", "channel_axis", ",", "'channel axis'", ",", "self", ".", "name", ")", "self", ".", "init_prim_io_names", "(", "inputs", "=", "[", "'dout'", ",", "'x'", ",", "'min'", ",", "'max'", "]", ",", "outputs", "=", "[", "'dx'", "]", ")" ]

[ "Look", "in", "the", "given", "locations", "relative", "to", "the", "makefile", "working", "directory", "for", "a", "file", ".", "Return", "a", "pair", "of", "the", "target", "and", "the", "mtime", "if", "found", "None", "if", "not", "." ]

[ "def", "searchinlocs", "(", "self", ",", "makefile", ",", "locs", ")", ":", "for", "t", "in", "locs", ":", "fspath", "=", "util", ".", "normaljoin", "(", "makefile", ".", "workdir", ",", "t", ")", ".", "replace", "(", "'\\\\'", ",", "'/'", ")", "mtime", "=", "getmtime", "(", "fspath", ")", "# _log.info(\"Searching %s ... checking %s ... mtime %r\" % (t, fspath, mtime))", "if", "mtime", "is", "not", "None", ":", "return", "(", "t", ",", "mtime", ")", "return", "None" ]

[ "Return", "a", "list", "representing", "the", "axes", "of", "the", "DataFrame", "." ]

[ "def", "axes", "(", "self", ")", "->", "List", "[", "Index", "]", ":", "return", "[", "self", ".", "index", ",", "self", ".", "columns", "]" ]

[ "Register", "pretty", "-", "printer", "PRINTER", "with", "OBJ", "." ]

[ "def", "register_pretty_printer", "(", "obj", ",", "printer", ")", ":", "# Watch for both __name__ and name.", "# Functions get the former for free, but we don't want to use an", "# attribute named __foo__ for pretty-printers-as-objects.", "# If printer has both, we use `name'.", "if", "not", "hasattr", "(", "printer", ",", "\"__name__\"", ")", "and", "not", "hasattr", "(", "printer", ",", "\"name\"", ")", ":", "raise", "TypeError", "(", "\"printer missing attribute: name\"", ")", "if", "hasattr", "(", "printer", ",", "\"name\"", ")", "and", "not", "hasattr", "(", "printer", ",", "\"enabled\"", ")", ":", "raise", "TypeError", "(", "\"printer missing attribute: enabled\"", ")", "if", "not", "hasattr", "(", "printer", ",", "\"__call__\"", ")", ":", "raise", "TypeError", "(", "\"printer missing attribute: __call__\"", ")", "if", "obj", "is", "None", ":", "if", "gdb", ".", "parameter", "(", "\"verbose\"", ")", ":", "gdb", ".", "write", "(", "\"Registering global %s pretty-printer ...\\n\"", "%", "name", ")", "obj", "=", "gdb", "else", ":", "if", "gdb", ".", "parameter", "(", "\"verbose\"", ")", ":", "gdb", ".", "write", "(", "\"Registering %s pretty-printer for %s ...\\n\"", "%", "(", "printer", ".", "name", ",", "obj", ".", "filename", ")", ")", "if", "hasattr", "(", "printer", ",", "\"name\"", ")", ":", "if", "not", "isinstance", "(", "printer", ".", "name", ",", "basestring", ")", ":", "raise", "TypeError", "(", "\"printer name is not a string\"", ")", "# If printer provides a name, make sure it doesn't contain \";\".", "# Semicolon is used by the info/enable/disable pretty-printer commands", "# to delimit subprinters.", "if", "printer", ".", "name", ".", "find", "(", "\";\"", ")", ">=", "0", ":", "raise", "ValueError", "(", "\"semicolon ';' in printer name\"", ")", "# Also make sure the name is unique.", "# Alas, we can't do the same for functions and __name__, they could", "# all have a canonical name like \"lookup_function\".", "# PERF: gdb records printers in a list, making this inefficient.", "if", "(", "printer", ".", "name", "in", "[", "p", ".", "name", "for", "p", "in", "obj", ".", "pretty_printers", "if", "hasattr", "(", "p", ",", "\"name\"", ")", "]", ")", ":", "raise", "RuntimeError", "(", "\"pretty-printer already registered: %s\"", "%", "printer", ".", "name", ")", "obj", ".", "pretty_printers", ".", "insert", "(", "0", ",", "printer", ")" ]

[ "Check", "whether", "an", "array", "-", "like", "is", "of", "a", "pandas", "extension", "class", "instance", "." ]

[ "def", "is_extension_type", "(", "arr", ")", "->", "bool", ":", "warnings", ".", "warn", "(", "\"'is_extension_type' is deprecated and will be removed in a future \"", "\"version. Use 'is_extension_array_dtype' instead.\"", ",", "FutureWarning", ",", "stacklevel", "=", "2", ",", ")", "if", "is_categorical", "(", "arr", ")", ":", "return", "True", "elif", "is_sparse", "(", "arr", ")", ":", "return", "True", "elif", "is_datetime64tz_dtype", "(", "arr", ")", ":", "return", "True", "return", "False" ]

[ "Copy", "(", "self", "RichTextParagraph", "obj", ")" ]

[ "def", "Copy", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextParagraph_Copy", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "r", ">>>", "import", "io", ">>>", "read_uint2", "(", "io", ".", "BytesIO", "(", "b", "\\", "xff", "\\", "x00", "))", "255", ">>>", "read_uint2", "(", "io", ".", "BytesIO", "(", "b", "\\", "xff", "\\", "xff", "))", "65535" ]

[ "def", "read_uint2", "(", "f", ")", ":", "data", "=", "f", ".", "read", "(", "2", ")", "if", "len", "(", "data", ")", "==", "2", ":", "return", "_unpack", "(", "\"<H\"", ",", "data", ")", "[", "0", "]", "raise", "ValueError", "(", "\"not enough data in stream to read uint2\"", ")" ]

[ "remove", "ir", ".", "Arg", "nodes" ]

[ "def", "remove_args", "(", "blocks", ")", ":", "for", "block", "in", "blocks", ".", "values", "(", ")", ":", "new_body", "=", "[", "]", "for", "stmt", "in", "block", ".", "body", ":", "if", "isinstance", "(", "stmt", ",", "ir", ".", "Assign", ")", "and", "isinstance", "(", "stmt", ".", "value", ",", "ir", ".", "Arg", ")", ":", "continue", "new_body", ".", "append", "(", "stmt", ")", "block", ".", "body", "=", "new_body", "return" ]

[ "Returns", "a", "path", "canonicalized", "for", "alphabetical", "comparison", "." ]

[ "def", "CanonicalizeAlphabeticalOrder", "(", "self", ",", "header_path", ")", ":", "return", "header_path", ".", "replace", "(", "'-inl.h'", ",", "'.h'", ")", ".", "replace", "(", "'-'", ",", "'_'", ")", ".", "lower", "(", ")" ]

[ "Return", "the", "zeros", "of", "the", "spline", "." ]

[ "def", "roots", "(", "self", ")", ":", "k", "=", "self", ".", "_data", "[", "5", "]", "if", "k", "==", "3", ":", "z", ",", "m", ",", "ier", "=", "dfitpack", ".", "sproot", "(", "*", "self", ".", "_eval_args", "[", ":", "2", "]", ")", "if", "not", "ier", "==", "0", ":", "raise", "ValueError", "(", "\"Error code returned by spalde: %s\"", "%", "ier", ")", "return", "z", "[", ":", "m", "]", "raise", "NotImplementedError", "(", "'finding roots unsupported for '", "'non-cubic splines'", ")" ]

[ "Helper", "to", "create", "a", "parse", "action", "for", "converting", "parsed", "date", "string", "to", "Python", "datetime", ".", "date" ]

[ "def", "convertToDate", "(", "fmt", "=", "\"%Y-%m-%d\"", ")", ":", "def", "cvt_fn", "(", "s", ",", "l", ",", "t", ")", ":", "try", ":", "return", "datetime", ".", "strptime", "(", "t", "[", "0", "]", ",", "fmt", ")", ".", "date", "(", ")", "except", "ValueError", "as", "ve", ":", "raise", "ParseException", "(", "s", ",", "l", ",", "str", "(", "ve", ")", ")", "return", "cvt_fn" ]

[ "Globally", "enables", "/", "disables", "drawing", "of", "gradient", "selections", "." ]

[ "def", "EnableSelectionGradient", "(", "self", ",", "enable", "=", "True", ")", ":", "self", ".", "_usegradients", "=", "enable", "self", ".", "_vistaselection", "=", "False", "self", ".", "RefreshSelected", "(", ")" ]

[ "Create", "a", "user", ".", "Password", "read", "from", "-", "i", "<file", ">" ]

[ "def", "ac_user_create_cmd", "(", "_", ",", "username", ":", "str", ",", "inbuf", ":", "str", ",", "rolename", ":", "Optional", "[", "str", "]", "=", "None", ",", "name", ":", "Optional", "[", "str", "]", "=", "None", ",", "email", ":", "Optional", "[", "str", "]", "=", "None", ",", "enabled", ":", "bool", "=", "True", ",", "force_password", ":", "bool", "=", "False", ",", "pwd_expiration_date", ":", "Optional", "[", "int", "]", "=", "None", ",", "pwd_update_required", ":", "bool", "=", "False", ")", ":", "password", "=", "inbuf", "try", ":", "role", "=", "mgr", ".", "ACCESS_CTRL_DB", ".", "get_role", "(", "rolename", ")", "if", "rolename", "else", "None", "except", "RoleDoesNotExist", "as", "ex", ":", "if", "rolename", "not", "in", "SYSTEM_ROLES", ":", "return", "-", "errno", ".", "ENOENT", ",", "''", ",", "str", "(", "ex", ")", "role", "=", "SYSTEM_ROLES", "[", "rolename", "]", "try", ":", "if", "not", "force_password", ":", "pw_check", "=", "PasswordPolicy", "(", "password", ",", "username", ")", "pw_check", ".", "check_all", "(", ")", "user", "=", "mgr", ".", "ACCESS_CTRL_DB", ".", "create_user", "(", "username", ",", "password", ",", "name", ",", "email", ",", "enabled", ",", "pwd_expiration_date", ",", "pwd_update_required", ")", "except", "PasswordPolicyException", "as", "ex", ":", "return", "-", "errno", ".", "EINVAL", ",", "''", ",", "str", "(", "ex", ")", "except", "UserAlreadyExists", "as", "ex", ":", "return", "0", ",", "str", "(", "ex", ")", ",", "''", "if", "role", ":", "user", ".", "set_roles", "(", "[", "role", "]", ")", "mgr", ".", "ACCESS_CTRL_DB", ".", "save", "(", ")", "return", "0", ",", "json", ".", "dumps", "(", "user", ".", "to_dict", "(", ")", ")", ",", "''" ]

[ "Takes", "the", "log", "base", "10", "of", "each", "input", "in", "the", "tensor", "." ]

[ "def", "tensor_log10", "(", "t1", ",", "out_format", ",", "dtype", "=", "None", ")", ":", "t1", "=", "as_tensor", "(", "t1", ",", "copy", "=", "False", ")", "cast_val", "=", "_cm", ".", "max_type", "(", "_cm", ".", "float32", ",", "t1", ".", "dtype", ")", "f", "=", "lambda", "x", ":", "_cm", ".", "log10", "(", "_cm", ".", "cast", "(", "x", ",", "cast_val", ")", ")", "return", "_compute_unary_elt_eise_op", "(", "f", ",", "t1", ",", "out_format", ",", "dtype", ")" ]

[ "Prepends", "a", "value", "to", "the", "specified", "item", "::" ]

[ "def", "prepend_value", "(", "self", ",", "var", ",", "val", ")", ":", "if", "isinstance", "(", "val", ",", "str", ")", ":", "val", "=", "[", "val", "]", "self", ".", "table", "[", "var", "]", "=", "val", "+", "self", ".", "_get_list_value_for_modification", "(", "var", ")" ]

[ "Variance", "of", "the", "distribution", "." ]

[ "def", "variance", "(", "self", ",", "name", "=", "\"variance\"", ")", ":", "with", "ops", ".", "name_scope", "(", "self", ".", "name", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "self", ".", "_a", ",", "self", ".", "_b", ",", "self", ".", "_a_b_sum", "]", ",", "name", ")", ":", "return", "(", "self", ".", "_a", "*", "self", ".", "_b", ")", "/", "(", "self", ".", "_a_b_sum", "**", "2", "*", "(", "self", ".", "_a_b_sum", "+", "1", ")", ")" ]

[ "PreEditableListBox", "()", "-", ">", "EditableListBox" ]

[ "def", "PreEditableListBox", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_gizmos", ".", "new_PreEditableListBox", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Update", "hardware", "state", "." ]

[ "def", "update_hardware_state", "(", "self", ")", ":", "joystick_reading", "=", "self", ".", "read_joystick", "(", ")", "self", ".", "trigger_hardware_event", "(", "JOYSTICK_READING", ",", "joystick_reading", ")" ]

[ "Returns", "True", "if", "a", "certain", "JAR", "does", "not", "have", "any", "classes", "outside", "the", "allowed", "namespaces", "." ]

[ "def", "IsMergeableJar", "(", "jar_path", ")", ":", "with", "zipfile", ".", "ZipFile", "(", "jar_path", ")", "as", "zip_file", ":", "for", "entry_name", "in", "zip_file", ".", "namelist", "(", ")", ":", "if", "entry_name", ".", "endswith", "(", "'/'", ")", ":", "# Directories are irrelevant.", "continue", "if", "any", "(", "fnmatch", ".", "fnmatchcase", "(", "entry_name", ",", "f", ")", "for", "f", "in", "JAR_ENTRY_WHITELIST", ")", ":", "continue", "return", "False", "return", "True" ]

[ "Select", "comment", "handler", "for", "a", "file", "based", "on", "file", "name", "and", "input", "options", "." ]

[ "def", "select_comment_handler", "(", "override", ",", "filename", ")", ":", "filetype", "=", "override", "if", "not", "filetype", "and", "filename", "!=", "'-'", ":", "basename", "=", "os", ".", "path", ".", "basename", "(", "filename", ")", "root", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "basename", ")", "if", "ext", "==", "'.cmakein'", ":", "dummy", ",", "ext2", "=", "os", ".", "path", ".", "splitext", "(", "root", ")", "if", "ext2", ":", "ext", "=", "ext2", "if", "ext", "in", "(", "'.c'", ",", "'.cu'", ",", "'.cpp'", ",", "'.cl'", ",", "'.h'", ",", "'.cuh'", ",", "'.clh'", ",", "'.y'", ",", "'.l'", ",", "'.pre'", ",", "'.bm'", ")", ":", "filetype", "=", "'c'", "elif", "ext", "in", "(", "'.tex'", ",", ")", ":", "filetype", "=", "'tex'", "elif", "basename", "in", "(", "'CMakeLists.txt'", ",", "'GMXRC'", ",", "'git-pre-commit'", ")", "or", "ext", "in", "(", "'.cmake'", ",", "'.cmakein'", ",", "'.py'", ",", "'.sh'", ",", "'.bash'", ",", "'.csh'", ",", "'.zsh'", ")", ":", "filetype", "=", "'sh'", "if", "filetype", "in", "comment_handlers", ":", "return", "comment_handlers", "[", "filetype", "]", "if", "filetype", ":", "sys", ".", "stderr", ".", "write", "(", "\"Unsupported input format: {0}\\n\"", ".", "format", "(", "filetype", ")", ")", "elif", "filename", "!=", "'-'", ":", "sys", ".", "stderr", ".", "write", "(", "\"Unsupported input format: {0}\\n\"", ".", "format", "(", "filename", ")", ")", "else", ":", "sys", ".", "stderr", ".", "write", "(", "\"No file name or file type provided.\\n\"", ")", "sys", ".", "exit", "(", "1", ")" ]

[ "An", "ordered", "list", "of", "(", "name", "type", ")", "for", "the", "fields", "." ]

[ "def", "members", "(", "self", ")", ":", "ordered", "=", "sorted", "(", "self", ".", "fields", ".", "items", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", "[", "1", "]", ".", "offset", ")", "return", "[", "(", "k", ",", "v", ".", "type", ")", "for", "k", ",", "v", "in", "ordered", "]" ]

[ "GetTip", "(", "self", ")", "-", ">", "String" ]

[ "def", "GetTip", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "TipProvider_GetTip", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "strip", "(", "s", ")", "-", ">", "string" ]

[ "def", "strip", "(", "s", ")", ":", "return", "s", ".", "strip", "(", ")" ]

[ "Return", "(", "z", "p", "k", ")", "of", "Nth", "-", "order", "elliptic", "analog", "lowpass", "filter", "." ]

[ "def", "ellipap", "(", "N", ",", "rp", ",", "rs", ")", ":", "if", "abs", "(", "int", "(", "N", ")", ")", "!=", "N", ":", "raise", "ValueError", "(", "\"Filter order must be a nonnegative integer\"", ")", "elif", "N", "==", "0", ":", "# Avoid divide-by-zero warning", "# Even order filters have DC gain of -rp dB", "return", "numpy", ".", "array", "(", "[", "]", ")", ",", "numpy", ".", "array", "(", "[", "]", ")", ",", "10", "**", "(", "-", "rp", "/", "20", ")", "elif", "N", "==", "1", ":", "p", "=", "-", "sqrt", "(", "1.0", "/", "(", "10", "**", "(", "0.1", "*", "rp", ")", "-", "1.0", ")", ")", "k", "=", "-", "p", "z", "=", "[", "]", "return", "asarray", "(", "z", ")", ",", "asarray", "(", "p", ")", ",", "k", "eps", "=", "numpy", ".", "sqrt", "(", "10", "**", "(", "0.1", "*", "rp", ")", "-", "1", ")", "ck1", "=", "eps", "/", "numpy", ".", "sqrt", "(", "10", "**", "(", "0.1", "*", "rs", ")", "-", "1", ")", "ck1p", "=", "numpy", ".", "sqrt", "(", "1", "-", "ck1", "*", "ck1", ")", "if", "ck1p", "==", "1", ":", "raise", "ValueError", "(", "\"Cannot design a filter with given rp and rs\"", "\" specifications.\"", ")", "val", "=", "special", ".", "ellipk", "(", "[", "ck1", "*", "ck1", ",", "ck1p", "*", "ck1p", "]", ")", "if", "abs", "(", "1", "-", "ck1p", "*", "ck1p", ")", "<", "EPSILON", ":", "krat", "=", "0", "else", ":", "krat", "=", "N", "*", "val", "[", "0", "]", "/", "val", "[", "1", "]", "m", "=", "optimize", ".", "fmin", "(", "_kratio", ",", "[", "0.5", "]", ",", "args", "=", "(", "krat", ",", ")", ",", "maxfun", "=", "250", ",", "maxiter", "=", "250", ",", "disp", "=", "0", ")", "if", "m", "<", "0", "or", "m", ">", "1", ":", "m", "=", "optimize", ".", "fminbound", "(", "_kratio", ",", "0", ",", "1", ",", "args", "=", "(", "krat", ",", ")", ",", "maxfun", "=", "250", ",", "disp", "=", "0", ")", "capk", "=", "special", ".", "ellipk", "(", "m", ")", "j", "=", "numpy", ".", "arange", "(", "1", "-", "N", "%", "2", ",", "N", ",", "2", ")", "jj", "=", "len", "(", "j", ")", "[", "s", ",", "c", ",", "d", ",", "phi", "]", "=", "special", ".", "ellipj", "(", "j", "*", "capk", "/", "N", ",", "m", "*", "numpy", ".", "ones", "(", "jj", ")", ")", "snew", "=", "numpy", ".", "compress", "(", "abs", "(", "s", ")", ">", "EPSILON", ",", "s", ",", "axis", "=", "-", "1", ")", "z", "=", "1.0", "/", "(", "sqrt", "(", "m", ")", "*", "snew", ")", "z", "=", "1j", "*", "z", "z", "=", "numpy", ".", "concatenate", "(", "(", "z", ",", "conjugate", "(", "z", ")", ")", ")", "r", "=", "optimize", ".", "fmin", "(", "_vratio", ",", "special", ".", "ellipk", "(", "m", ")", ",", "args", "=", "(", "1.", "/", "eps", ",", "ck1p", "*", "ck1p", ")", ",", "maxfun", "=", "250", ",", "maxiter", "=", "250", ",", "disp", "=", "0", ")", "v0", "=", "capk", "*", "r", "/", "(", "N", "*", "val", "[", "0", "]", ")", "[", "sv", ",", "cv", ",", "dv", ",", "phi", "]", "=", "special", ".", "ellipj", "(", "v0", ",", "1", "-", "m", ")", "p", "=", "-", "(", "c", "*", "d", "*", "sv", "*", "cv", "+", "1j", "*", "s", "*", "dv", ")", "/", "(", "1", "-", "(", "d", "*", "sv", ")", "**", "2.0", ")", "if", "N", "%", "2", ":", "newp", "=", "numpy", ".", "compress", "(", "abs", "(", "p", ".", "imag", ")", ">", "EPSILON", "*", "numpy", ".", "sqrt", "(", "numpy", ".", "sum", "(", "p", "*", "numpy", ".", "conjugate", "(", "p", ")", ",", "axis", "=", "0", ")", ".", "real", ")", ",", "p", ",", "axis", "=", "-", "1", ")", "p", "=", "numpy", ".", "concatenate", "(", "(", "p", ",", "conjugate", "(", "newp", ")", ")", ")", "else", ":", "p", "=", "numpy", ".", "concatenate", "(", "(", "p", ",", "conjugate", "(", "p", ")", ")", ")", "k", "=", "(", "numpy", ".", "prod", "(", "-", "p", ",", "axis", "=", "0", ")", "/", "numpy", ".", "prod", "(", "-", "z", ",", "axis", "=", "0", ")", ")", ".", "real", "if", "N", "%", "2", "==", "0", ":", "k", "=", "k", "/", "numpy", ".", "sqrt", "(", "(", "1", "+", "eps", "*", "eps", ")", ")", "return", "z", ",", "p", ",", "k" ]

[ "Sets", "the", "position", "and", "size", "of", "the", "window", "in", "pixels", ".", "The", "sizeFlags", "parameter", "indicates", "the", "interpretation", "of", "the", "other", "params", "if", "they", "are", "equal", "to", "-", "1", "." ]

[ "def", "DoSetSize", "(", "self", ",", "x", ",", "y", ",", "width", ",", "height", ",", "sizeFlags", "=", "wx", ".", "SIZE_AUTO", ")", ":", "parent_size", "=", "self", ".", "GetParent", "(", ")", ".", "GetClientSize", "(", ")", "if", "x", "+", "width", ">", "parent_size", ".", "x", ":", "width", "=", "max", "(", "0", ",", "parent_size", ".", "x", "-", "x", ")", "if", "y", "+", "height", ">", "parent_size", ".", "y", ":", "height", "=", "max", "(", "0", ",", "parent_size", ".", "y", "-", "y", ")", "wx", ".", "PyControl", ".", "DoSetSize", "(", "self", ",", "x", ",", "y", ",", "width", ",", "height", ",", "sizeFlags", ")" ]

[ "Returns", "the", "string", "representation", "of", "the", "model" ]

[ "def", "to_str", "(", "self", ")", ":", "return", "pprint", ".", "pformat", "(", "self", ".", "to_dict", "(", ")", ")" ]

[ "Handles", "the", "main", "entry", "point", "into", "this", "script" ]

[ "def", "main", "(", ")", ":", "# validate and get command line arguments", "reverse_dd_test_dir", "=", "process_command_arguments", "(", ")", "# configure up all the paths", "base_dir", ",", "reversed_dir", "=", "configure_root_dirs", "(", "reverse_dd_test_dir", ")", "# configure paths for both csv and mtr outputs", "base_csv", ",", "reversed_csv", "=", "configure_paths", "(", "base_dir", ",", "reversed_dir", ",", "'eplusout'", ")", "base_mtr", ",", "rev_mtr", "=", "configure_paths", "(", "base_dir", ",", "reversed_dir", ",", "'eplusmtr'", ")", "if", "both_csv_files_missing", "(", "base_csv", ",", "reversed_csv", ")", ":", "return", "0", "# assume everything is fine if the CSV is missing in *both* builds", "# do comparison of the outputs", "csv_match", "=", "files_match", "(", "base_csv", ",", "reversed_csv", ")", "mtr_match", "=", "files_match", "(", "base_mtr", ",", "rev_mtr", ")", "if", "os", ".", "path", ".", "exists", "(", "rev_mtr", ")", "else", "True", "# report the results of the comparisons", "if", "csv_match", "and", "mtr_match", ":", "return", "0", "return", "1" ]

[ "Checks", "for", "improper", "use", "of", "DISALLOW", "*", "macros", "." ]

[ "def", "CheckAccess", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# get rid of comments and strings", "matched", "=", "Match", "(", "(", "r'\\s*(DISALLOW_COPY_AND_ASSIGN|'", "r'DISALLOW_EVIL_CONSTRUCTORS|'", "r'DISALLOW_IMPLICIT_CONSTRUCTORS)'", ")", ",", "line", ")", "if", "not", "matched", ":", "return", "if", "nesting_state", ".", "stack", "and", "isinstance", "(", "nesting_state", ".", "stack", "[", "-", "1", "]", ",", "_ClassInfo", ")", ":", "if", "nesting_state", ".", "stack", "[", "-", "1", "]", ".", "access", "!=", "'private'", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/constructors'", ",", "3", ",", "'%s must be in the private: section'", "%", "matched", ".", "group", "(", "1", ")", ")", "else", ":", "# Found DISALLOW* macro outside a class declaration, or perhaps it", "# was used inside a function when it should have been part of the", "# class declaration. We could issue a warning here, but it", "# probably resulted in a compiler error already.", "pass" ]

[ "Construct", "an", "MLModel", "from", "a", ".", "mlmodel" ]

[ "def", "__init__", "(", "self", ",", "model", ",", "useCPUOnly", "=", "False", ")", ":", "if", "isinstance", "(", "model", ",", "_string_types", ")", ":", "self", ".", "__proxy__", ",", "self", ".", "_spec", ",", "self", ".", "_framework_error", "=", "_get_proxy_and_spec", "(", "model", ",", "useCPUOnly", ")", "elif", "isinstance", "(", "model", ",", "_Model_pb2", ".", "Model", ")", ":", "filename", "=", "_tempfile", ".", "mktemp", "(", "suffix", "=", "\".mlmodel\"", ")", "_save_spec", "(", "model", ",", "filename", ")", "self", ".", "__proxy__", ",", "self", ".", "_spec", ",", "self", ".", "_framework_error", "=", "_get_proxy_and_spec", "(", "filename", ",", "useCPUOnly", ")", "try", ":", "_os", ".", "remove", "(", "filename", ")", "except", "OSError", ":", "pass", "else", ":", "raise", "TypeError", "(", "\"Expected model to be a .mlmodel file or a Model_pb2 object\"", ")", "self", ".", "_input_description", "=", "_FeatureDescription", "(", "self", ".", "_spec", ".", "description", ".", "input", ")", "self", ".", "_output_description", "=", "_FeatureDescription", "(", "self", ".", "_spec", ".", "description", ".", "output", ")" ]

[ "Returns", "a", "dictionary", "of", "values", "to", "checkpoint", "with", "this", "object", "." ]

[ "def", "_gather_saveables_for_checkpoint", "(", "self", ")", ":", "return", "{", "}" ]

[ "Describe", "the", "key", "flags", "of", "the", "main", "module", "." ]

[ "def", "MainModuleHelp", "(", "self", ")", ":", "return", "self", ".", "ModuleHelp", "(", "_GetMainModule", "(", ")", ")" ]

[ "Returns", "a", "ComDate", "from", "a", "datetime", "in", "inputformat" ]

[ "def", "COMDate", "(", "self", ",", "obj", ")", ":", "raise", "NotImplementedError", "#\"Abstract class\"" ]

[ "Iterates", "over", "several", "runs", "and", "handles", "the", "output", "for", "all", "traces", "." ]

[ "def", "Run", "(", "self", ",", "runner", ",", "trybot", ")", ":", "stdout", ",", "stdout_secondary", "=", "Unzip", "(", "runner", "(", ")", ")", "return", "(", "AccumulateResults", "(", "self", ".", "graphs", ",", "self", ".", "_children", ",", "iter_output", "=", "self", ".", "PostProcess", "(", "stdout", ")", ",", "perform_measurement", "=", "True", ",", "calc_total", "=", "self", ".", "total", ",", ")", ",", "AccumulateResults", "(", "self", ".", "graphs", ",", "self", ".", "_children", ",", "iter_output", "=", "self", ".", "PostProcess", "(", "stdout_secondary", ")", ",", "perform_measurement", "=", "trybot", ",", "# only run second time on trybots", "calc_total", "=", "self", ".", "total", ",", ")", ",", ")" ]

[ "Initialize", "RPaths", "callable", "object", ".", "**", "Arguments", "**", ":", "-", "*", "env", "*", "-", "a", "SCons", ".", "Environment", ".", "Environment", "object", "defines", "*", "current", "working", "dir", "*", "." ]

[ "def", "__init__", "(", "self", ",", "env", ")", ":", "self", ".", "env", "=", "env" ]

[ "Returns", "a", "non", "-", "empty", "error", "message", "if", "the", "next", "header", "is", "out", "of", "order", "." ]

[ "def", "CheckNextIncludeOrder", "(", "self", ",", "header_type", ")", ":", "error_message", "=", "(", "'Found %s after %s'", "%", "(", "self", ".", "_TYPE_NAMES", "[", "header_type", "]", ",", "self", ".", "_SECTION_NAMES", "[", "self", ".", "_section", "]", ")", ")", "last_section", "=", "self", ".", "_section", "if", "header_type", "==", "_C_SYS_HEADER", ":", "if", "self", ".", "_section", "<=", "self", ".", "_C_SECTION", ":", "self", ".", "_section", "=", "self", ".", "_C_SECTION", "else", ":", "self", ".", "_last_header", "=", "''", "return", "error_message", "elif", "header_type", "==", "_CPP_SYS_HEADER", ":", "if", "self", ".", "_section", "<=", "self", ".", "_CPP_SECTION", ":", "self", ".", "_section", "=", "self", ".", "_CPP_SECTION", "else", ":", "self", ".", "_last_header", "=", "''", "return", "error_message", "elif", "header_type", "==", "_LIKELY_MY_HEADER", ":", "if", "self", ".", "_section", "<=", "self", ".", "_MY_H_SECTION", ":", "self", ".", "_section", "=", "self", ".", "_MY_H_SECTION", "else", ":", "self", ".", "_section", "=", "self", ".", "_OTHER_H_SECTION", "elif", "header_type", "==", "_POSSIBLE_MY_HEADER", ":", "if", "self", ".", "_section", "<=", "self", ".", "_MY_H_SECTION", ":", "self", ".", "_section", "=", "self", ".", "_MY_H_SECTION", "else", ":", "# This will always be the fallback because we're not sure", "# enough that the header is associated with this file.", "self", ".", "_section", "=", "self", ".", "_OTHER_H_SECTION", "else", ":", "assert", "header_type", "==", "_OTHER_HEADER", "self", ".", "_section", "=", "self", ".", "_OTHER_H_SECTION", "if", "last_section", "!=", "self", ".", "_section", ":", "self", ".", "_last_header", "=", "''", "return", "''" ]

[ "Add", "all", "files", "from", "pathname", "to", "the", "ZIP", "archive", "." ]

[ "def", "writepy", "(", "self", ",", "pathname", ",", "basename", "=", "\"\"", ")", ":", "dir", ",", "name", "=", "os", ".", "path", ".", "split", "(", "pathname", ")", "if", "os", ".", "path", ".", "isdir", "(", "pathname", ")", ":", "initname", "=", "os", ".", "path", ".", "join", "(", "pathname", ",", "\"__init__.py\"", ")", "if", "os", ".", "path", ".", "isfile", "(", "initname", ")", ":", "# This is a package directory, add it", "if", "basename", ":", "basename", "=", "\"%s/%s\"", "%", "(", "basename", ",", "name", ")", "else", ":", "basename", "=", "name", "if", "self", ".", "debug", ":", "print", "\"Adding package in\"", ",", "pathname", ",", "\"as\"", ",", "basename", "fname", ",", "arcname", "=", "self", ".", "_get_codename", "(", "initname", "[", "0", ":", "-", "3", "]", ",", "basename", ")", "if", "self", ".", "debug", ":", "print", "\"Adding\"", ",", "arcname", "self", ".", "write", "(", "fname", ",", "arcname", ")", "dirlist", "=", "os", ".", "listdir", "(", "pathname", ")", "dirlist", ".", "remove", "(", "\"__init__.py\"", ")", "# Add all *.py files and package subdirectories", "for", "filename", "in", "dirlist", ":", "path", "=", "os", ".", "path", ".", "join", "(", "pathname", ",", "filename", ")", "root", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "if", "os", ".", "path", ".", "isdir", "(", "path", ")", ":", "if", "os", ".", "path", ".", "isfile", "(", "os", ".", "path", ".", "join", "(", "path", ",", "\"__init__.py\"", ")", ")", ":", "# This is a package directory, add it", "self", ".", "writepy", "(", "path", ",", "basename", ")", "# Recursive call", "elif", "ext", "==", "\".py\"", ":", "fname", ",", "arcname", "=", "self", ".", "_get_codename", "(", "path", "[", "0", ":", "-", "3", "]", ",", "basename", ")", "if", "self", ".", "debug", ":", "print", "\"Adding\"", ",", "arcname", "self", ".", "write", "(", "fname", ",", "arcname", ")", "else", ":", "# This is NOT a package directory, add its files at top level", "if", "self", ".", "debug", ":", "print", "\"Adding files from directory\"", ",", "pathname", "for", "filename", "in", "os", ".", "listdir", "(", "pathname", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "pathname", ",", "filename", ")", "root", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "filename", ")", "if", "ext", "==", "\".py\"", ":", "fname", ",", "arcname", "=", "self", ".", "_get_codename", "(", "path", "[", "0", ":", "-", "3", "]", ",", "basename", ")", "if", "self", ".", "debug", ":", "print", "\"Adding\"", ",", "arcname", "self", ".", "write", "(", "fname", ",", "arcname", ")", "else", ":", "if", "pathname", "[", "-", "3", ":", "]", "!=", "\".py\"", ":", "raise", "RuntimeError", ",", "'Files added with writepy() must end with \".py\"'", "fname", ",", "arcname", "=", "self", ".", "_get_codename", "(", "pathname", "[", "0", ":", "-", "3", "]", ",", "basename", ")", "if", "self", ".", "debug", ":", "print", "\"Adding file\"", ",", "arcname", "self", ".", "write", "(", "fname", ",", "arcname", ")" ]

[ "Returns", "an", "attribute", "string", "in", "the", "form", "key", "=", "val" ]

[ "def", "make_attrstring", "(", "attr", ")", ":", "attrstring", "=", "' '", ".", "join", "(", "[", "'%s=\"%s\"'", "%", "(", "k", ",", "v", ")", "for", "k", ",", "v", "in", "attr", ".", "items", "(", ")", "]", ")", "return", "'%s%s'", "%", "(", "' '", "if", "attrstring", "!=", "''", "else", "''", ",", "attrstring", ")" ]