Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

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

[ "def", "start", "(", "self", ")", ":", "self", ".", "_start_time", "=", "time", ".", "time", "(", ")" ]

[ "Returns", "prediction", "probabilities", "for", "given", "features", "(", "classification", ")", "." ]

[ "def", "predict_proba", "(", "self", ",", "x", "=", "None", ",", "input_fn", "=", "None", ",", "batch_size", "=", "None", ",", "as_iterable", "=", "False", ")", ":", "return", "super", "(", "TensorForestEstimator", ",", "self", ")", ".", "predict", "(", "x", "=", "x", ",", "input_fn", "=", "input_fn", ",", "batch_size", "=", "batch_size", ",", "as_iterable", "=", "as_iterable", ")" ]

[ "load", "volume", "windowing", "interpolate", "multiple", "slices", "clip", "black", "border", "resize", "according", "to", "spacing" ]

[ "def", "load_prep_img", "(", "imname", ",", "slice_idx", ",", "spacing", ",", "slice_intv", ",", "do_clip", "=", "False", ",", "num_slice", "=", "3", ")", ":", "if", "imname", ".", "endswith", "(", "'.nii.gz'", ")", "or", "imname", ".", "endswith", "(", "'.nii'", ")", ":", "im", ",", "mask", "=", "load_multislice_img_nifti", "(", "imname", ",", "slice_idx", ",", "slice_intv", ",", "do_clip", ",", "num_slice", ")", "else", ":", "im", ",", "mask", "=", "load_multislice_img_16bit_png", "(", "imname", ",", "slice_idx", ",", "slice_intv", ",", "do_clip", ",", "num_slice", ")", "im", "=", "windowing", "(", "im", ",", "config", ".", "WINDOWING", ")", "if", "do_clip", ":", "# clip black border", "c", "=", "get_range", "(", "mask", ",", "margin", "=", "0", ")", "im", "=", "im", "[", "c", "[", "0", "]", ":", "c", "[", "1", "]", "+", "1", ",", "c", "[", "2", "]", ":", "c", "[", "3", "]", "+", "1", ",", ":", "]", "# mask = mask[c[0]:c[1] + 1, c[2]:c[3] + 1]", "# print im.shape", "else", ":", "c", "=", "[", "0", ",", "im", ".", "shape", "[", "0", "]", "-", "1", ",", "0", ",", "im", ".", "shape", "[", "1", "]", "-", "1", "]", "im_shape", "=", "im", ".", "shape", "[", "0", ":", "2", "]", "if", "spacing", "is", "not", "None", "and", "config", ".", "NORM_SPACING", ">", "0", ":", "# spacing adjust, will overwrite simple scaling", "im_scale", "=", "float", "(", "spacing", ")", "/", "config", ".", "NORM_SPACING", "else", ":", "im_scale", "=", "float", "(", "config", ".", "SCALE", ")", "/", "float", "(", "np", ".", "min", "(", "im_shape", ")", ")", "# simple scaling", "max_shape", "=", "np", ".", "max", "(", "im_shape", ")", "*", "im_scale", "if", "max_shape", ">", "config", ".", "MAX_SIZE", ":", "im_scale1", "=", "float", "(", "config", ".", "MAX_SIZE", ")", "/", "max_shape", "im_scale", "*=", "im_scale1", "if", "im_scale", "!=", "1", ":", "im", "=", "cv2", ".", "resize", "(", "im", ",", "None", ",", "None", ",", "fx", "=", "im_scale", ",", "fy", "=", "im_scale", ",", "interpolation", "=", "cv2", ".", "INTER_LINEAR", ")", "# mask = cv2.resize(mask, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)", "return", "im", ",", "im_scale", ",", "c" ]

[ "Get", "the", "output", "tensor", "handle", "of", "a", "node", ".", ":", "param", "idx", ":", "<int", ">", "The", "index", "of", "the", "output", "tensor", ".", ":", "return", ":", "The", "tensor", "handle", "or", "None", "on", "error", "." ]

[ "def", "getOutputTensorByIdx", "(", "self", ",", "idx", ")", ":", "_LIB", ".", "get_node_output_tensor", ".", "restype", "=", "tensor_t", "tensor", "=", "_LIB", ".", "get_node_output_tensor", "(", "ctypes", ".", "c_void_p", "(", "self", ".", "node", ")", ",", "idx", ")", "return", "Tensor", "(", "tensor", "=", "tensor", ")" ]

[ "Return", "whether", "*", "func", "*", "is", "a", "coroutine", "function", "i", ".", "e", ".", "a", "function", "wrapped", "with", "~", ".", "gen", ".", "coroutine", "." ]

[ "def", "is_coroutine_function", "(", "func", ":", "Any", ")", "->", "bool", ":", "return", "getattr", "(", "func", ",", "\"__tornado_coroutine__\"", ",", "False", ")" ]

[ "Publicly", "accessible", "method", "for", "determining", "the", "current", "backend", "." ]

[ "def", "backend", "(", ")", ":", "return", "'tensorflow'" ]

[ "Takes", "an", "array", "add", "indentation", "to", "each", "entry", "and", "prints", "it", "." ]

[ "def", "PrintIdented", "(", "self", ",", "file", ",", "ident", ",", "code", ")", ":", "for", "entry", "in", "code", ":", "print", ">>", "file", ",", "'%s%s'", "%", "(", "ident", ",", "entry", ")" ]

[ "EditLabel", "(", "self", "TreeItemId", "item", "int", "column", "=", "-", "1", ")" ]

[ "def", "EditLabel", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "TreeListCtrl_EditLabel", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Handles", "the", "wx", ".", "EVT_LEFT_UP", "event", "for", ":", "class", ":", "AuiToolBar", "." ]

[ "def", "OnLeftUp", "(", "self", ",", "event", ")", ":", "self", ".", "SetPressedItem", "(", "None", ")", "hit_item", "=", "self", ".", "FindToolForPosition", "(", "*", "event", ".", "GetPosition", "(", ")", ")", "if", "hit_item", "and", "not", "hit_item", ".", "state", "&", "AUI_BUTTON_STATE_DISABLED", ":", "self", ".", "SetHoverItem", "(", "hit_item", ")", "if", "self", ".", "_dragging", ":", "# reset drag and drop member variables", "self", ".", "_dragging", "=", "False", "self", ".", "_action_pos", "=", "wx", ".", "Point", "(", "-", "1", ",", "-", "1", ")", "self", ".", "_action_item", "=", "None", "else", ":", "if", "self", ".", "_action_item", "and", "hit_item", "==", "self", ".", "_action_item", ":", "self", ".", "SetToolTipString", "(", "\"\"", ")", "if", "hit_item", ".", "kind", "in", "[", "ITEM_CHECK", ",", "ITEM_RADIO", "]", ":", "toggle", "=", "not", "(", "self", ".", "_action_item", ".", "state", "&", "AUI_BUTTON_STATE_CHECKED", ")", "self", ".", "ToggleTool", "(", "self", ".", "_action_item", ".", "id", ",", "toggle", ")", "# repaint immediately", "self", ".", "Refresh", "(", "False", ")", "self", ".", "Update", "(", ")", "e", "=", "wx", ".", "CommandEvent", "(", "wx", ".", "wxEVT_COMMAND_MENU_SELECTED", ",", "self", ".", "_action_item", ".", "id", ")", "e", ".", "SetEventObject", "(", "self", ")", "e", ".", "SetInt", "(", "toggle", ")", "self", ".", "_action_pos", "=", "wx", ".", "Point", "(", "-", "1", ",", "-", "1", ")", "self", ".", "_action_item", "=", "None", "self", ".", "ProcessEvent", "(", "e", ")", "self", ".", "DoIdleUpdate", "(", ")", "else", ":", "if", "self", ".", "_action_item", ".", "id", "==", "ID_RESTORE_FRAME", ":", "# find aui manager", "manager", "=", "self", ".", "GetAuiManager", "(", ")", "if", "not", "manager", ":", "return", "if", "self", ".", "_action_item", ".", "target", ":", "pane", "=", "manager", ".", "GetPane", "(", "self", ".", "_action_item", ".", "target", ")", "else", ":", "pane", "=", "manager", ".", "GetPane", "(", "self", ")", "e", "=", "framemanager", ".", "AuiManagerEvent", "(", "framemanager", ".", "wxEVT_AUI_PANE_MIN_RESTORE", ")", "e", ".", "SetManager", "(", "manager", ")", "e", ".", "SetPane", "(", "pane", ")", "manager", ".", "ProcessEvent", "(", "e", ")", "self", ".", "DoIdleUpdate", "(", ")", "else", ":", "e", "=", "wx", ".", "CommandEvent", "(", "wx", ".", "wxEVT_COMMAND_MENU_SELECTED", ",", "self", ".", "_action_item", ".", "id", ")", "e", ".", "SetEventObject", "(", "self", ")", "self", ".", "ProcessEvent", "(", "e", ")", "self", ".", "DoIdleUpdate", "(", ")", "# reset drag and drop member variables", "self", ".", "_dragging", "=", "False", "self", ".", "_action_pos", "=", "wx", ".", "Point", "(", "-", "1", ",", "-", "1", ")", "self", ".", "_action_item", "=", "None" ]

[ "Get", "all", "the", "available", "checkers", "from", "default", "and", "from", "the", "plugins", "." ]

[ "def", "get_checkers", "(", "clang", ",", "plugins", ")", ":", "load", "=", "[", "elem", "for", "plugin", "in", "plugins", "for", "elem", "in", "[", "'-load'", ",", "plugin", "]", "]", "cmd", "=", "[", "clang", ",", "'-cc1'", "]", "+", "load", "+", "[", "'-analyzer-checker-help'", "]", "lines", "=", "run_command", "(", "cmd", ")", "is_active_checker", "=", "is_active", "(", "get_active_checkers", "(", "clang", ",", "plugins", ")", ")", "checkers", "=", "{", "name", ":", "(", "description", ",", "is_active_checker", "(", "name", ")", ")", "for", "name", ",", "description", "in", "parse_checkers", "(", "lines", ")", "}", "if", "not", "checkers", ":", "raise", "Exception", "(", "'Could not query Clang for available checkers.'", ")", "return", "checkers" ]

[ "Read", "all", "jobdef", "resources", ".", "Built", "on", "console", "command", "_show", "filesets_", "." ]

[ "def", "read_all_filesets", "(", "*", ",", "response", ":", "Response", ",", "current_user", ":", "User", "=", "Depends", "(", "get_current_user", ")", ",", "verbose", ":", "Optional", "[", "bareosBool", "]", "=", "Query", "(", "\"yes\"", ",", "title", "=", "\"Verbose output\"", ")", ",", ")", ":", "return", "show_configuration_items", "(", "response", "=", "response", ",", "current_user", "=", "current_user", ",", "itemType", "=", "\"filesets\"", ",", "verbose", "=", "verbose", ",", ")" ]

[ "Convert", "arguments", "to", "ctypes", "and", "append", "to", "kernelargs" ]

[ "def", "_unpack_argument", "(", "ty", ",", "val", ",", "kernelargs", ",", "retr", ")", ":", "if", "isinstance", "(", "ty", ",", "types", ".", "Array", ")", ":", "c_intp", "=", "ctypes", ".", "c_ssize_t", "# if a dgpu is present, move the data to the device.", "if", "dgpu_present", ":", "devary", ",", "conv", "=", "devicearray", ".", "auto_device", "(", "val", ",", "devices", ".", "get_context", "(", ")", ")", "if", "conv", ":", "retr", ".", "append", "(", "lambda", ":", "devary", ".", "copy_to_host", "(", "val", ")", ")", "data", "=", "devary", ".", "device_ctypes_pointer", "else", ":", "data", "=", "ctypes", ".", "c_void_p", "(", "val", ".", "ctypes", ".", "data", ")", "meminfo", "=", "parent", "=", "ctypes", ".", "c_void_p", "(", "0", ")", "nitems", "=", "c_intp", "(", "val", ".", "size", ")", "itemsize", "=", "c_intp", "(", "val", ".", "dtype", ".", "itemsize", ")", "kernelargs", ".", "append", "(", "meminfo", ")", "kernelargs", ".", "append", "(", "parent", ")", "kernelargs", ".", "append", "(", "nitems", ")", "kernelargs", ".", "append", "(", "itemsize", ")", "kernelargs", ".", "append", "(", "data", ")", "for", "ax", "in", "range", "(", "val", ".", "ndim", ")", ":", "kernelargs", ".", "append", "(", "c_intp", "(", "val", ".", "shape", "[", "ax", "]", ")", ")", "for", "ax", "in", "range", "(", "val", ".", "ndim", ")", ":", "kernelargs", ".", "append", "(", "c_intp", "(", "val", ".", "strides", "[", "ax", "]", ")", ")", "elif", "isinstance", "(", "ty", ",", "types", ".", "Integer", ")", ":", "cval", "=", "getattr", "(", "ctypes", ",", "\"c_%s\"", "%", "ty", ")", "(", "val", ")", "kernelargs", ".", "append", "(", "cval", ")", "elif", "ty", "==", "types", ".", "float64", ":", "cval", "=", "ctypes", ".", "c_double", "(", "val", ")", "kernelargs", ".", "append", "(", "cval", ")", "elif", "ty", "==", "types", ".", "float32", ":", "cval", "=", "ctypes", ".", "c_float", "(", "val", ")", "kernelargs", ".", "append", "(", "cval", ")", "elif", "ty", "==", "types", ".", "boolean", ":", "cval", "=", "ctypes", ".", "c_uint8", "(", "int", "(", "val", ")", ")", "kernelargs", ".", "append", "(", "cval", ")", "elif", "ty", "==", "types", ".", "complex64", ":", "kernelargs", ".", "append", "(", "ctypes", ".", "c_float", "(", "val", ".", "real", ")", ")", "kernelargs", ".", "append", "(", "ctypes", ".", "c_float", "(", "val", ".", "imag", ")", ")", "elif", "ty", "==", "types", ".", "complex128", ":", "kernelargs", ".", "append", "(", "ctypes", ".", "c_double", "(", "val", ".", "real", ")", ")", "kernelargs", ".", "append", "(", "ctypes", ".", "c_double", "(", "val", ".", "imag", ")", ")", "else", ":", "raise", "NotImplementedError", "(", "ty", ",", "val", ")" ]

[ "SetSelection", "(", "self", "int", "nSel", ")" ]

[ "def", "SetSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "BookCtrlEvent_SetSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Always", "scalar", "." ]

[ "def", "shape_from_args", "(", "self", ")", "->", "Tuple", "[", "int", ",", "...", "]", ":", "return", "tuple", "(", ")" ]

[ "r", "Sets", "the", "texture", "generation", ".", "The", "array", "must", "be", "size", "m", "x", "4", "with", "m", "in", "the", "range", "0", "...", "4", ".", "If", "worldcoordinates", "=", "true", "the", "texture", "generation", "is", "performed", "in", "world", "coordinates", "rather", "than", "object", "coordinates", "." ]

[ "def", "setTexgen", "(", "self", ",", "np_array2", ":", "Vector", ",", "worldcoordinates", ":", "bool", "=", "False", ")", "->", "None", ":", "return", "_robotsim", ".", "Appearance_setTexgen", "(", "self", ",", "np_array2", ",", "worldcoordinates", ")" ]

[ "Calculate", "the", "generator", "specific", "info", "that", "gets", "fed", "to", "input", "(", "called", "by", "gyp", ")", "." ]

[ "def", "CalculateGeneratorInputInfo", "(", "params", ")", ":", "generator_flags", "=", "params", ".", "get", "(", "'generator_flags'", ",", "{", "}", ")", "if", "generator_flags", ".", "get", "(", "'adjust_static_libraries'", ",", "False", ")", ":", "global", "generator_wants_static_library_dependencies_adjusted", "generator_wants_static_library_dependencies_adjusted", "=", "True", "toplevel", "=", "params", "[", "'options'", "]", ".", "toplevel_dir", "generator_dir", "=", "os", ".", "path", ".", "relpath", "(", "params", "[", "'options'", "]", ".", "generator_output", "or", "'.'", ")", "# output_dir: relative path from generator_dir to the build directory.", "output_dir", "=", "generator_flags", ".", "get", "(", "'output_dir'", ",", "'out'", ")", "qualified_out_dir", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "toplevel", ",", "generator_dir", ",", "output_dir", ",", "'gypfiles'", ")", ")", "global", "generator_filelist_paths", "generator_filelist_paths", "=", "{", "'toplevel'", ":", "toplevel", ",", "'qualified_out_dir'", ":", "qualified_out_dir", ",", "}" ]

[ "Compute", "the", "2", "-", "dimensional", "inverse", "FFT", "of", "a", "real", "array", "." ]

[ "def", "irfft2", "(", "a", ",", "s", "=", "None", ",", "axes", "=", "(", "-", "2", ",", "-", "1", ")", ")", ":", "return", "irfftn", "(", "a", ",", "s", ",", "axes", ")" ]

[ "Return", "a", "relative", "version", "of", "a", "path" ]

[ "def", "relpath", "(", "path", ",", "start", "=", "None", ")", ":", "path", "=", "os", ".", "fspath", "(", "path", ")", "if", "isinstance", "(", "path", ",", "bytes", ")", ":", "sep", "=", "b'\\\\'", "curdir", "=", "b'.'", "pardir", "=", "b'..'", "else", ":", "sep", "=", "'\\\\'", "curdir", "=", "'.'", "pardir", "=", "'..'", "if", "start", "is", "None", ":", "start", "=", "curdir", "if", "not", "path", ":", "raise", "ValueError", "(", "\"no path specified\"", ")", "start", "=", "os", ".", "fspath", "(", "start", ")", "try", ":", "start_abs", "=", "abspath", "(", "normpath", "(", "start", ")", ")", "path_abs", "=", "abspath", "(", "normpath", "(", "path", ")", ")", "start_drive", ",", "start_rest", "=", "splitdrive", "(", "start_abs", ")", "path_drive", ",", "path_rest", "=", "splitdrive", "(", "path_abs", ")", "if", "normcase", "(", "start_drive", ")", "!=", "normcase", "(", "path_drive", ")", ":", "raise", "ValueError", "(", "\"path is on mount %r, start on mount %r\"", "%", "(", "path_drive", ",", "start_drive", ")", ")", "start_list", "=", "[", "x", "for", "x", "in", "start_rest", ".", "split", "(", "sep", ")", "if", "x", "]", "path_list", "=", "[", "x", "for", "x", "in", "path_rest", ".", "split", "(", "sep", ")", "if", "x", "]", "# Work out how much of the filepath is shared by start and path.", "i", "=", "0", "for", "e1", ",", "e2", "in", "zip", "(", "start_list", ",", "path_list", ")", ":", "if", "normcase", "(", "e1", ")", "!=", "normcase", "(", "e2", ")", ":", "break", "i", "+=", "1", "rel_list", "=", "[", "pardir", "]", "*", "(", "len", "(", "start_list", ")", "-", "i", ")", "+", "path_list", "[", "i", ":", "]", "if", "not", "rel_list", ":", "return", "curdir", "return", "join", "(", "*", "rel_list", ")", "except", "(", "TypeError", ",", "ValueError", ",", "AttributeError", ",", "BytesWarning", ",", "DeprecationWarning", ")", ":", "genericpath", ".", "_check_arg_types", "(", "'relpath'", ",", "path", ",", "start", ")", "raise" ]

[ "PlaceSOffsetT", "prepends", "a", "SOffsetT", "to", "the", "Builder", "without", "checking", "for", "space", "." ]

[ "def", "PlaceSOffsetT", "(", "self", ",", "x", ")", ":", "N", ".", "enforce_number", "(", "x", ",", "N", ".", "SOffsetTFlags", ")", "self", ".", "head", "=", "self", ".", "head", "-", "N", ".", "SOffsetTFlags", ".", "bytewidth", "encode", ".", "Write", "(", "packer", ".", "soffset", ",", "self", ".", "Bytes", ",", "self", ".", "Head", "(", ")", ",", "x", ")" ]

[ "Lazy", "initialized", "property", "of", "infer_program", "." ]

[ "def", "_infer_program", "(", "self", ")", ":", "return", "self", ".", "_clone_for_test", "(", "self", ".", "_origin_main_program", ")" ]

[ "Map", "MXNet", "s", "Flatten", "operator", "attributes", "to", "onnx", "s", "Flatten", "operator", "and", "return", "the", "created", "node", "." ]

[ "def", "convert_flatten", "(", "node", ",", "*", "*", "kwargs", ")", ":", "return", "create_basic_op_node", "(", "'Flatten'", ",", "node", ",", "kwargs", ")" ]

[ "Generate", "random", "characters" ]

[ "def", "random_chars", "(", "number", ")", ":", "char_map", "=", "{", "k", ":", "v", "for", "k", ",", "v", "in", "chars", ".", "CHARS", ".", "iteritems", "(", ")", "if", "not", "format_character", "(", "k", ")", ".", "startswith", "(", "'\\\\x'", ")", "}", "char_num", "=", "sum", "(", "char_map", ".", "values", "(", ")", ")", "return", "(", "format_character", "(", "nth_char", "(", "char_map", ",", "random", ".", "randint", "(", "0", ",", "char_num", "-", "1", ")", ")", ")", "for", "_", "in", "xrange", "(", "0", ",", "number", ")", ")" ]

[ "build", "Tracker", "binaries" ]

[ "def", "build_antennatracker", "(", "self", ",", "tag", ")", ":", "boards", "=", "self", ".", "common_boards", "(", ")", "[", ":", "]", "self", ".", "build_vehicle", "(", "tag", ",", "\"AntennaTracker\"", ",", "boards", ",", "\"AntennaTracker\"", ",", "\"antennatracker\"", ")" ]

[ "Checks", "that", "all", "classes", "and", "namespaces", "have", "been", "completely", "parsed", "." ]

[ "def", "CheckCompletedBlocks", "(", "self", ",", "filename", ",", "error", ")", ":", "# Note: This test can result in false positives if #ifdef constructs", "# get in the way of brace matching. See the testBuildClass test in", "# cpplint_unittest.py for an example of this.", "for", "obj", "in", "self", ".", "stack", ":", "if", "isinstance", "(", "obj", ",", "_ClassInfo", ")", ":", "error", "(", "filename", ",", "obj", ".", "starting_linenum", ",", "'build/class'", ",", "5", ",", "'Failed to find complete declaration of class %s'", "%", "obj", ".", "name", ")", "elif", "isinstance", "(", "obj", ",", "_NamespaceInfo", ")", ":", "error", "(", "filename", ",", "obj", ".", "starting_linenum", ",", "'build/namespaces'", ",", "5", ",", "'Failed to find complete declaration of namespace %s'", "%", "obj", ".", "name", ")" ]

[ "Return", "a", "new", "free", "identifier", "as", ":", "class", ":", "~jinja2", ".", "nodes", ".", "InternalName", "." ]

[ "def", "free_identifier", "(", "self", ",", "lineno", "=", "None", ")", ":", "self", ".", "_last_identifier", "+=", "1", "rv", "=", "object", ".", "__new__", "(", "nodes", ".", "InternalName", ")", "nodes", ".", "Node", ".", "__init__", "(", "rv", ",", "'fi%d'", "%", "self", ".", "_last_identifier", ",", "lineno", "=", "lineno", ")", "return", "rv" ]

[ "Accept", "/", "deny", "control", "of", "this", "MAV" ]

[ "def", "change_operator_control_ack_send", "(", "self", ",", "gcs_system_id", ",", "control_request", ",", "ack", ")", ":", "return", "self", ".", "send", "(", "self", ".", "change_operator_control_ack_encode", "(", "gcs_system_id", ",", "control_request", ",", "ack", ")", ")" ]

[ "Return", "the", "parameter", "as", "type", "str", "possibly", "encoding", "it", "." ]

[ "def", "to_string", "(", "b", ")", ":", "if", "isinstance", "(", "b", ",", "str", ")", ":", "# In Python2, this branch is taken for types 'str' and 'bytes'.", "# In Python3, this branch is taken only for 'str'.", "return", "b", "if", "isinstance", "(", "b", ",", "bytes", ")", ":", "# In Python2, this branch is never taken ('bytes' is handled as 'str').", "# In Python3, this is true only for 'bytes'.", "try", ":", "return", "b", ".", "decode", "(", "'utf-8'", ")", "except", "UnicodeDecodeError", ":", "# If the value is not valid Unicode, return the default", "# repr-line encoding.", "return", "str", "(", "b", ")", "# By this point, here's what we *don't* have:", "#", "# - In Python2:", "# - 'str' or 'bytes' (1st branch above)", "# - In Python3:", "# - 'str' (1st branch above)", "# - 'bytes' (2nd branch above)", "#", "# The last type we might expect is the Python2 'unicode' type. There is no", "# 'unicode' type in Python3 (all the Python3 cases were already handled). In", "# order to get a 'str' object, we need to encode the 'unicode' object.", "try", ":", "return", "b", ".", "encode", "(", "'utf-8'", ")", "except", "AttributeError", ":", "raise", "TypeError", "(", "'not sure how to convert %s to %s'", "%", "(", "type", "(", "b", ")", ",", "str", ")", ")" ]

[ "Join", "lines", "command", ".", "@see", ":", "vim_parser" ]

[ "def", "Join", "(", "editor", ",", "repeat", ",", "cmd", ")", ":", "editor", ".", "PushCaret", "(", ")", "editor", ".", "JoinLines", "(", "repeat", ")", "editor", ".", "PopCaret", "(", ")" ]

[ "Sets", "the", "value", "of", "the", "Spinbox", "to", "value", "." ]

[ "def", "set", "(", "self", ",", "value", ")", ":", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "\"set\"", ",", "value", ")" ]

[ "returns", "active", "and", "deleted", "specs", ".", "Returns", "read", "-", "only", "dict", "." ]

[ "def", "all_specs", "(", "self", ")", "->", "Mapping", "[", "str", ",", "ServiceSpec", "]", ":", "return", "self", ".", "_specs" ]

[ "Gets", "the", "value", "of", "variable", "on", "set", "on", "the", "first", "target", "in", "targets", "." ]

[ "def", "get_target_variable", "(", "self", ",", "targets", ",", "variable", ")", ":", "if", "isinstance", "(", "targets", ",", "str", ")", ":", "targets", "=", "[", "targets", "]", "assert", "is_iterable", "(", "targets", ")", "assert", "isinstance", "(", "variable", ",", "basestring", ")", "return", "bjam_interface", ".", "call", "(", "'get-target-variable'", ",", "targets", ",", "variable", ")" ]

[ "Execute", "as", "a", "callback", "when", "the", "delete", "button", "is", "pressed", "." ]

[ "def", "on_delete", "(", "self", ")", ":", "index", "=", "self", ".", "form", ".", "comboBoxStyles", ".", "currentIndex", "(", ")", "style", "=", "self", ".", "form", ".", "comboBoxStyles", ".", "itemText", "(", "index", ")", "if", "self", ".", "get_style_users", "(", "style", ")", ":", "reply", "=", "QtGui", ".", "QMessageBox", ".", "question", "(", "None", ",", "\"Style in use\"", ",", "\"This style is used by some objects in this document. Are you sure?\"", ",", "QtGui", ".", "QMessageBox", ".", "Yes", "|", "QtGui", ".", "QMessageBox", ".", "No", ",", "QtGui", ".", "QMessageBox", ".", "No", ")", "if", "reply", "==", "QtGui", ".", "QMessageBox", ".", "No", ":", "return", "self", ".", "form", ".", "comboBoxStyles", ".", "removeItem", "(", "index", ")", "del", "self", ".", "styles", "[", "style", "]" ]

[ "Construct", "a", "subgraph", "for", "NCCL", "hybrid", "all", "-", "reduce", "." ]

[ "def", "_build_nccl_hybrid", "(", "input_tensors", ",", "red_op", ",", "upper_level_f", ")", ":", "input_tensors", ",", "shape", "=", "_flatten_tensors", "(", "input_tensors", ")", "devices", "=", "[", "t", ".", "device", "for", "t", "in", "input_tensors", "]", "per_worker_devices", ",", "per_worker_values", "=", "_split_by_task", "(", "devices", ",", "input_tensors", ")", "num_workers", "=", "len", "(", "per_worker_devices", ")", "up_values", "=", "[", "None", "for", "w", "in", "range", "(", "0", ",", "num_workers", ")", "]", "up_devices", "=", "up_values", "[", ":", "]", "down_values", "=", "up_values", "[", ":", "]", "# First stage: reduce within each worker using NCCL", "for", "w", "in", "range", "(", "0", ",", "num_workers", ")", ":", "worker_values", "=", "build_nccl_all_reduce", "(", "per_worker_values", "[", "w", "]", ",", "red_op", ")", "# NOTE: these reductions will not run to completion unless", "# every output value is used. Since we only need one, we", "# need to put control dependencies on the rest.", "with", "ops", ".", "control_dependencies", "(", "worker_values", ")", ":", "with", "ops", ".", "device", "(", "worker_values", "[", "0", "]", ".", "device", ")", ":", "up_values", "[", "w", "]", "=", "array_ops", ".", "identity", "(", "worker_values", "[", "0", "]", ")", "up_devices", "[", "w", "]", "=", "per_worker_devices", "[", "w", "]", "[", "0", "]", "# Second stage: Apply upper_level_f to reduce across first device at", "# each worker", "level_2_output", "=", "upper_level_f", "(", "up_values", ")", "# Third stage: propagate within each worker using NCCL Broadcast", "for", "w", "in", "range", "(", "0", ",", "num_workers", ")", ":", "dst_tensors", "=", "[", "]", "with", "ops", ".", "device", "(", "per_worker_devices", "[", "w", "]", "[", "0", "]", ")", ":", "broadcast_src", "=", "nccl_ops", ".", "broadcast", "(", "array_ops", ".", "identity", "(", "level_2_output", "[", "w", "]", ")", ")", "for", "d", "in", "per_worker_devices", "[", "w", "]", ":", "with", "ops", ".", "device", "(", "d", ")", ":", "dst_tensors", ".", "append", "(", "array_ops", ".", "identity", "(", "broadcast_src", ")", ")", "down_values", "[", "w", "]", "=", "dst_tensors", "output_tensors", "=", "[", "v", "for", "sublist", "in", "down_values", "for", "v", "in", "sublist", "]", "if", "len", "(", "shape", ")", "!=", "1", ":", "output_tensors", "=", "_reshape_tensors", "(", "output_tensors", ",", "shape", ")", "return", "output_tensors" ]

[ "Initialize", "a", "CacheDir", "object", "." ]

[ "def", "__init__", "(", "self", ",", "path", ")", ":", "self", ".", "requests", "=", "0", "self", ".", "hits", "=", "0", "self", ".", "path", "=", "path", "self", ".", "current_cache_debug", "=", "None", "self", ".", "debugFP", "=", "None", "self", ".", "config", "=", "dict", "(", ")", "if", "path", "is", "None", ":", "return", "self", ".", "_readconfig", "(", "path", ")" ]

[ "Return", "the", "C", "++", "class", "type", "referenced", "by", "a", "CefRefPtr", "." ]

[ "def", "get_ptr_type", "(", "self", ")", ":", "if", "self", ".", "is_result_vector", "(", ")", "and", "self", ".", "is_result_vector_ptr", "(", ")", ":", "# return the vector RefPtr type", "return", "self", ".", "result_value", "[", "0", "]", "[", "'ptr_type'", "]", "# return the basic RefPtr type", "return", "self", ".", "ptr_type" ]

[ "Compose", "a", "base", "coord", "map", "with", "scale", "a1", "shift", "b1", "with", "a", "further", "coord", "map", "with", "scale", "a2", "shift", "b2", ".", "The", "scales", "multiply", "and", "the", "further", "shift", "b2", "is", "scaled", "by", "base", "coord", "scale", "a1", "." ]

[ "def", "compose", "(", "base_map", ",", "next_map", ")", ":", "ax1", ",", "a1", ",", "b1", "=", "base_map", "ax2", ",", "a2", ",", "b2", "=", "next_map", "if", "ax1", "is", "None", ":", "ax", "=", "ax2", "elif", "ax2", "is", "None", "or", "ax1", "==", "ax2", ":", "ax", "=", "ax1", "else", ":", "raise", "AxisMismatchException", "return", "ax", ",", "a1", "*", "a2", ",", "a1", "*", "b2", "+", "b1" ]

[ "Check", "namespace", "packages", "__init__", "for", "declare_namespace" ]

[ "def", "check_package", "(", "self", ",", "package", ",", "package_dir", ")", ":", "try", ":", "return", "self", ".", "packages_checked", "[", "package", "]", "except", "KeyError", ":", "pass", "init_py", "=", "orig", ".", "build_py", ".", "check_package", "(", "self", ",", "package", ",", "package_dir", ")", "self", ".", "packages_checked", "[", "package", "]", "=", "init_py", "if", "not", "init_py", "or", "not", "self", ".", "distribution", ".", "namespace_packages", ":", "return", "init_py", "for", "pkg", "in", "self", ".", "distribution", ".", "namespace_packages", ":", "if", "pkg", "==", "package", "or", "pkg", ".", "startswith", "(", "package", "+", "'.'", ")", ":", "break", "else", ":", "return", "init_py", "with", "io", ".", "open", "(", "init_py", ",", "'rb'", ")", "as", "f", ":", "contents", "=", "f", ".", "read", "(", ")", "if", "b'declare_namespace'", "not", "in", "contents", ":", "raise", "distutils", ".", "errors", ".", "DistutilsError", "(", "\"Namespace package problem: %s is a namespace package, but \"", "\"its\\n__init__.py does not call declare_namespace()! Please \"", "'fix it.\\n(See the setuptools manual under '", "'\"Namespace Packages\" for details.)\\n\"'", "%", "(", "package", ",", ")", ")", "return", "init_py" ]

[ "constant", ":", "ICONST", "|", "FCONST", "|", "CCONST" ]

[ "def", "p_constant", "(", "t", ")", ":", "pass" ]

[ "Count", "line", "in", "current", "function", "body", "." ]

[ "def", "Count", "(", "self", ")", ":", "if", "self", ".", "in_a_function", ":", "self", ".", "lines_in_function", "+=", "1" ]

[ "Compare", "debug", "info", "of", "two", "different", "files", ".", "Allowing", "unavoidable", "differences", "such", "as", "filenames", ".", "Return", "the", "first", "difference", "if", "the", "debug", "info", "differs", "or", "None", ".", "If", "there", "are", "differences", "in", "the", "code", "there", "will", "almost", "certainly", "be", "differences", "in", "the", "debug", "info", "too", "." ]

[ "def", "compare_debug_info", "(", "objfilea", ",", "objfileb", ")", ":", "dbga", "=", "dump_debug", "(", "objfilea", ")", "dbgb", "=", "dump_debug", "(", "objfileb", ")", "return", "first_diff", "(", "dbga", ",", "dbgb", ",", "objfilea", ",", "objfileb", ")" ]

[ "GetChosenFont", "(", "self", ")", "-", ">", "Font" ]

[ "def", "GetChosenFont", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "FontData_GetChosenFont", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Generate", "source", "file", "for", "enumerated", "types", "." ]

[ "def", "generateEnumeratedClasses", "(", "self", ")", ":", "if", "not", "self", ".", "enumerationList_", ".", "hasEnumeratedClasses", ":", "return", "buffer", "=", "''", "# code to register the enumeration", "for", "enumeratedClassGroup", "in", "self", ".", "enumerationList_", ".", "enumeratedClassGroups", "(", ")", ":", "buffer", "+=", "self", ".", "generateEnumeratedClass", "(", "enumeratedClassGroup", ")", "self", ".", "bufferEnumClasses_", ".", "set", "(", "{", "'buffer'", ":", "buffer", "}", ")", "fileName", "=", "self", ".", "rootPath_", "+", "'register_classes.cpp'", "outputfile", ".", "OutputFile", "(", "self", ",", "fileName", ",", "self", ".", "enumerationList_", ".", "enumeratedClassCopyright", "(", ")", ",", "self", ".", "bufferEnumClasses_", ")" ]

[ "Distance", "of", "the", "samples", "X", "to", "the", "separating", "hyperplane", "." ]

[ "def", "_decision_function", "(", "self", ",", "X", ")", ":", "# NOTE: _validate_for_predict contains check for is_fitted", "# hence must be placed before any other attributes are used.", "X", "=", "self", ".", "_validate_for_predict", "(", "X", ")", "X", "=", "self", ".", "_compute_kernel", "(", "X", ")", "if", "self", ".", "_sparse", ":", "dec_func", "=", "self", ".", "_sparse_decision_function", "(", "X", ")", "else", ":", "dec_func", "=", "self", ".", "_dense_decision_function", "(", "X", ")", "# In binary case, we need to flip the sign of coef, intercept and", "# decision function.", "if", "self", ".", "_impl", "in", "[", "'c_svc'", ",", "'nu_svc'", "]", "and", "len", "(", "self", ".", "classes_", ")", "==", "2", ":", "return", "-", "dec_func", ".", "ravel", "(", ")", "return", "dec_func" ]

[ "Convert", "a", "value", "to", "string", "." ]

[ "def", "_interpolate", "(", "self", ",", "val", ",", "formatter_key", ",", "location", ")", ":", "try", ":", "formatter", "=", "self", ".", "formatters", "[", "formatter_key", "]", "except", ":", "raise", "FormatterNotFoundError", "(", "formatter_key", ",", "location", ")", "if", "isinstance", "(", "val", ",", "bytes", ")", ":", "val", "=", "self", ".", "_bytes_to_str", "(", "val", ")", "elif", "not", "isinstance", "(", "val", ",", "str", ")", ":", "val", "=", "str", "(", "val", ")", "return", "formatter", "(", "val", ")" ]

[ "Appends", "a", "64", "-", "bit", "integer", "to", "our", "buffer", "zigzag", "-", "encoded", "and", "then", "varint", "-", "encoded", "." ]

[ "def", "AppendSInt64NoTag", "(", "self", ",", "value", ")", ":", "zigzag_value", "=", "wire_format", ".", "ZigZagEncode", "(", "value", ")", "self", ".", "_stream", ".", "AppendVarUInt64", "(", "zigzag_value", ")" ]

[ "Returns", "grad", "*", "(", "1", "-", "tanh", "(", "x", ")", "*", "tanh", "(", "x", "))", "." ]

[ "def", "_TanhGrad", "(", "op", ",", "grad", ")", ":", "y", "=", "op", ".", "outputs", "[", "0", "]", "# y = tanh(x)", "with", "ops", ".", "control_dependencies", "(", "[", "grad", ".", "op", "]", ")", ":", "y", "=", "math_ops", ".", "conj", "(", "y", ")", "# pylint: disable=protected-access", "return", "gen_math_ops", ".", "_tanh_grad", "(", "y", ",", "grad", ")" ]

[ "Save", "breakpoints", "when", "file", "is", "saved" ]

[ "def", "store_file_breaks", "(", "self", ")", ":", "# XXX 13 Dec 2002 KBK Currently the file must be saved before it can", "# be run. The breaks are saved at that time. If we introduce", "# a temporary file save feature the save breaks functionality", "# needs to be re-verified, since the breaks at the time the", "# temp file is created may differ from the breaks at the last", "# permanent save of the file. Currently, a break introduced", "# after a save will be effective, but not persistent.", "# This is necessary to keep the saved breaks synched with the", "# saved file.", "#", "# Breakpoints are set as tagged ranges in the text. Certain", "# kinds of edits cause these ranges to be deleted: Inserting", "# or deleting a line just before a breakpoint, and certain", "# deletions prior to a breakpoint. These issues need to be", "# investigated and understood. It's not clear if they are", "# Tk issues or IDLE issues, or whether they can actually", "# be fixed. Since a modified file has to be saved before it is", "# run, and since self.breakpoints (from which the subprocess", "# debugger is loaded) is updated during the save, the visible", "# breaks stay synched with the subprocess even if one of these", "# unexpected breakpoint deletions occurs.", "breaks", "=", "self", ".", "breakpoints", "filename", "=", "self", ".", "io", ".", "filename", "try", ":", "with", "open", "(", "self", ".", "breakpointPath", ",", "\"r\"", ")", "as", "old_file", ":", "lines", "=", "old_file", ".", "readlines", "(", ")", "except", "IOError", ":", "lines", "=", "[", "]", "try", ":", "with", "open", "(", "self", ".", "breakpointPath", ",", "\"w\"", ")", "as", "new_file", ":", "for", "line", "in", "lines", ":", "if", "not", "line", ".", "startswith", "(", "filename", "+", "'='", ")", ":", "new_file", ".", "write", "(", "line", ")", "self", ".", "update_breakpoints", "(", ")", "breaks", "=", "self", ".", "breakpoints", "if", "breaks", ":", "new_file", ".", "write", "(", "filename", "+", "'='", "+", "str", "(", "breaks", ")", "+", "'\\n'", ")", "except", "IOError", "as", "err", ":", "if", "not", "getattr", "(", "self", ".", "root", ",", "\"breakpoint_error_displayed\"", ",", "False", ")", ":", "self", ".", "root", ".", "breakpoint_error_displayed", "=", "True", "tkMessageBox", ".", "showerror", "(", "title", "=", "'IDLE Error'", ",", "message", "=", "'Unable to update breakpoint list:\\n%s'", "%", "str", "(", "err", ")", ",", "parent", "=", "self", ".", "text", ")" ]

[ "Send", "a", "TIME", "command", "." ]

[ "def", "time", "(", "self", ",", "server", "=", "\"\"", ")", ":", "self", ".", "send_raw", "(", "\"TIME\"", "+", "(", "server", "and", "(", "\" \"", "+", "server", ")", ")", ")" ]

[ "exo", ".", "put_elem_blk_names", "(", "elem_blk_names", ")" ]

[ "def", "put_elem_blk_names", "(", "self", ",", "names", ")", ":", "objType", "=", "ex_entity_type", "(", "\"EX_ELEM_BLOCK\"", ")", "inqType", "=", "ex_inquiry", "(", "\"EX_INQ_ELEM_BLK\"", ")", "self", ".", "__ex_put_names", "(", "objType", ",", "inqType", ",", "names", ")" ]

[ ":", "raises", ":", ":", "exc", ":", "KeyError", "If", "not", "registered" ]

[ "def", "get_registered", "(", "self", ",", "full_msg_type", ")", ":", "full_msg_type", "=", "bare_msg_type", "(", "full_msg_type", ")", "if", "self", ".", "is_registered", "(", "full_msg_type", ")", ":", "package", ",", "base_type", "=", "package_resource_name", "(", "full_msg_type", ")", "return", "self", ".", "_registered_packages", "[", "package", "]", "[", "base_type", "]", "else", ":", "raise", "KeyError", "(", "full_msg_type", ")" ]

[ "Run", "the", "code", "without", "invoking", "the", "debugger" ]

[ "def", "runcommand", "(", "self", ",", "code", ")", ":", "# The code better not raise an exception!", "if", "self", ".", "tkconsole", ".", "executing", ":", "self", ".", "display_executing_dialog", "(", ")", "return", "0", "if", "self", ".", "rpcclt", ":", "self", ".", "rpcclt", ".", "remotequeue", "(", "\"exec\"", ",", "\"runcode\"", ",", "(", "code", ",", ")", ",", "{", "}", ")", "else", ":", "exec", "code", "in", "self", ".", "locals", "return", "1" ]

[ "py", ":", "function", "::", "piexif", ".", "insert", "(", "exif_bytes", "filename", ")" ]

[ "def", "insert", "(", "exif", ",", "image", ",", "new_file", "=", "None", ")", ":", "if", "exif", "[", "0", ":", "6", "]", "!=", "b\"\\x45\\x78\\x69\\x66\\x00\\x00\"", ":", "raise", "ValueError", "(", "\"Given data is not exif data\"", ")", "output_file", "=", "False", "# Prevents \"UnicodeWarning: Unicode equal comparison failed\" warnings on Python 2", "maybe_image", "=", "sys", ".", "version_info", ">=", "(", "3", ",", "0", ",", "0", ")", "or", "isinstance", "(", "image", ",", "str", ")", "if", "maybe_image", "and", "image", "[", "0", ":", "2", "]", "==", "b\"\\xff\\xd8\"", ":", "image_data", "=", "image", "file_type", "=", "\"jpeg\"", "elif", "maybe_image", "and", "image", "[", "0", ":", "4", "]", "==", "b\"RIFF\"", "and", "image", "[", "8", ":", "12", "]", "==", "b\"WEBP\"", ":", "image_data", "=", "image", "file_type", "=", "\"webp\"", "else", ":", "with", "open", "(", "image", ",", "'rb'", ")", "as", "f", ":", "image_data", "=", "f", ".", "read", "(", ")", "if", "image_data", "[", "0", ":", "2", "]", "==", "b\"\\xff\\xd8\"", ":", "file_type", "=", "\"jpeg\"", "elif", "image_data", "[", "0", ":", "4", "]", "==", "b\"RIFF\"", "and", "image_data", "[", "8", ":", "12", "]", "==", "b\"WEBP\"", ":", "file_type", "=", "\"webp\"", "else", ":", "raise", "InvalidImageDataError", "output_file", "=", "True", "if", "file_type", "==", "\"jpeg\"", ":", "exif", "=", "b\"\\xff\\xe1\"", "+", "struct", ".", "pack", "(", "\">H\"", ",", "len", "(", "exif", ")", "+", "2", ")", "+", "exif", "segments", "=", "split_into_segments", "(", "image_data", ")", "new_data", "=", "merge_segments", "(", "segments", ",", "exif", ")", "elif", "file_type", "==", "\"webp\"", ":", "exif", "=", "exif", "[", "6", ":", "]", "new_data", "=", "_webp", ".", "insert", "(", "image_data", ",", "exif", ")", "if", "isinstance", "(", "new_file", ",", "io", ".", "BytesIO", ")", ":", "new_file", ".", "write", "(", "new_data", ")", "new_file", ".", "seek", "(", "0", ")", "elif", "new_file", ":", "with", "open", "(", "new_file", ",", "\"wb+\"", ")", "as", "f", ":", "f", ".", "write", "(", "new_data", ")", "elif", "output_file", ":", "with", "open", "(", "image", ",", "\"wb+\"", ")", "as", "f", ":", "f", ".", "write", "(", "new_data", ")", "else", ":", "raise", "ValueError", "(", "\"Give a 3rd argument to 'insert' to output file\"", ")" ]

[ "r", "GetSpatialReference", "(", "Geometry", "self", ")", "-", ">", "SpatialReference", "OGRSpatialReferenceH", "OGR_G_GetSpatialReference", "(", "OGRGeometryH", "hGeom", ")" ]

[ "def", "GetSpatialReference", "(", "self", ",", "*", "args", ")", ":", "return", "_ogr", ".", "Geometry_GetSpatialReference", "(", "self", ",", "*", "args", ")" ]

[ "Adds", "all", "activity", "from", "another", "scope", "to", "this", "scope", "." ]

[ "def", "merge_from", "(", "self", ",", "other", ")", ":", "assert", "not", "self", ".", "is_final", "if", "self", ".", "parent", "is", "not", "None", ":", "assert", "other", ".", "parent", "is", "not", "None", "self", ".", "parent", ".", "merge_from", "(", "other", ".", "parent", ")", "self", ".", "isolated_names", ".", "update", "(", "other", ".", "isolated_names", ")", "self", ".", "read", ".", "update", "(", "other", ".", "read", ")", "self", ".", "modified", ".", "update", "(", "other", ".", "modified", ")", "self", ".", "bound", ".", "update", "(", "other", ".", "bound", ")", "self", ".", "deleted", ".", "update", "(", "other", ".", "deleted", ")", "self", ".", "annotations", ".", "update", "(", "other", ".", "annotations", ")", "self", ".", "params", ".", "update", "(", "other", ".", "params", ")" ]

[ "Load", "the", "Content", "section", "." ]

[ "def", "_yaml_load_content", "(", "config", ",", "in_ext", ")", ":", "options", "=", "config", ".", "get", "(", "'Content'", ",", "None", ")", "if", "options", "is", "None", ":", "msg", "=", "\"The 'Content' section is required.\"", "raise", "exceptions", ".", "MooseDocsException", "(", "msg", ")", "items", "=", "MooseDocs", ".", "common", ".", "get_items", "(", "options", ")", "return", "MooseDocs", ".", "common", ".", "get_content", "(", "items", ",", "in_ext", ")" ]

[ "Set", "parameter", "broadcast", "mode", "for", "this", "cell", "." ]

[ "def", "set_broadcast_flag", "(", "self", ",", "mode", "=", "True", ")", ":", "self", ".", "add_flags_recursive", "(", "broadcast_flag", "=", "mode", ")", "return", "self" ]

[ "Decorator", "for", "marking", "specific", "function", "arguments", "as", "deprecated", "." ]

[ "def", "deprecated_args", "(", "date", ",", "instructions", ",", "*", "deprecated_arg_names", ")", ":", "_validate_deprecation_args", "(", "date", ",", "instructions", ")", "if", "not", "deprecated_arg_names", ":", "raise", "ValueError", "(", "'Specify which argument is deprecated.'", ")", "def", "deprecated_wrapper", "(", "func", ")", ":", "\"\"\"Deprecation decorator.\"\"\"", "_validate_callable", "(", "func", ",", "'deprecated_args'", ")", "arg_spec", "=", "inspect", ".", "getargspec", "(", "func", ")", "deprecated_positions", "=", "[", "(", "i", ",", "arg_name", ")", "for", "(", "i", ",", "arg_name", ")", "in", "enumerate", "(", "arg_spec", ".", "args", ")", "if", "arg_name", "in", "deprecated_arg_names", "]", "is_varargs_deprecated", "=", "arg_spec", ".", "varargs", "in", "deprecated_arg_names", "is_kwargs_deprecated", "=", "arg_spec", ".", "keywords", "in", "deprecated_arg_names", "if", "(", "len", "(", "deprecated_positions", ")", "+", "is_varargs_deprecated", "+", "is_kwargs_deprecated", "!=", "len", "(", "deprecated_arg_names", ")", ")", ":", "known_args", "=", "arg_spec", ".", "args", "+", "[", "arg_spec", ".", "varargs", ",", "arg_spec", ".", "keywords", "]", "missing_args", "=", "[", "arg_name", "for", "arg_name", "in", "deprecated_arg_names", "if", "arg_name", "not", "in", "known_args", "]", "raise", "ValueError", "(", "'The following deprecated arguments are not present '", "'in the function signature: %s'", "%", "missing_args", ")", "@", "functools", ".", "wraps", "(", "func", ")", "def", "new_func", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "\"\"\"Deprecation wrapper.\"\"\"", "invalid_args", "=", "[", "]", "for", "(", "i", ",", "arg_name", ")", "in", "deprecated_positions", ":", "if", "i", "<", "len", "(", "args", ")", ":", "invalid_args", ".", "append", "(", "arg_name", ")", "if", "is_varargs_deprecated", "and", "len", "(", "args", ")", ">", "len", "(", "arg_spec", ".", "args", ")", ":", "invalid_args", ".", "append", "(", "arg_spec", ".", "varargs", ")", "if", "is_kwargs_deprecated", "and", "kwargs", ":", "invalid_args", ".", "append", "(", "arg_spec", ".", "keywords", ")", "for", "arg_name", "in", "deprecated_arg_names", ":", "if", "arg_name", "in", "kwargs", ":", "invalid_args", ".", "append", "(", "arg_name", ")", "for", "arg_name", "in", "invalid_args", ":", "logging", ".", "warning", "(", "'Calling %s (from %s) with %s is deprecated and will be removed '", "'after %s.\\nInstructions for updating:\\n%s'", ",", "_get_qualified_name", "(", "func", ")", ",", "func", ".", "__module__", ",", "arg_name", ",", "date", ",", "instructions", ")", "return", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "new_func", ".", "__doc__", "=", "_add_deprecated_arg_notice_to_docstring", "(", "func", ".", "__doc__", ",", "date", ",", "instructions", ")", "return", "new_func", "return", "deprecated_wrapper" ]

[ "Writes", "|uint32|", "as", "an", "unsinged", "32", "-", "bit", "integer", "to", "the", "file", "-", "like", "|file|", "object", "treating", "it", "as", "having", "endianness", "specified", "by", "|endian|", "(", "per", "the", "|struct|", "module", ")", "." ]

[ "def", "WriteUInt32", "(", "file", ",", "uint32", ",", "endian", ")", ":", "bytes", "=", "struct", ".", "pack", "(", "endian", "+", "'I'", ",", "uint32", ")", "assert", "len", "(", "bytes", ")", "==", "4", "file", ".", "write", "(", "bytes", ")" ]

[ "Reconstruct", "an", "array", "view", "on", "a", "memmory", "mapped", "file" ]

[ "def", "_strided_from_memmap", "(", "filename", ",", "dtype", ",", "mode", ",", "offset", ",", "order", ",", "shape", ",", "strides", ",", "total_buffer_len", ")", ":", "if", "mode", "==", "'w+'", ":", "# Do not zero the original data when unpickling", "mode", "=", "'r+'", "if", "strides", "is", "None", ":", "# Simple, contiguous memmap", "return", "np", ".", "memmap", "(", "filename", ",", "dtype", "=", "dtype", ",", "shape", "=", "shape", ",", "mode", "=", "mode", ",", "offset", "=", "offset", ",", "order", "=", "order", ")", "else", ":", "# For non-contiguous data, memmap the total enclosing buffer and then", "# extract the non-contiguous view with the stride-tricks API", "base", "=", "np", ".", "memmap", "(", "filename", ",", "dtype", "=", "dtype", ",", "shape", "=", "total_buffer_len", ",", "mode", "=", "mode", ",", "offset", "=", "offset", ",", "order", "=", "order", ")", "return", "as_strided", "(", "base", ",", "shape", "=", "shape", ",", "strides", "=", "strides", ")" ]

[]

[ "def", "__init__", "(", "self", ",", "input_ab_initio_filename", ")", ":", "if", "not", "isinstance", "(", "input_ab_initio_filename", ",", "str", ")", ":", "raise", "TypeError", "(", "'Filename must be a string'", ")", "elif", "not", "Path", "(", "input_ab_initio_filename", ")", ".", "is_file", "(", ")", ":", "raise", "IOError", "(", "f'Ab initio file {input_ab_initio_filename} not found.'", ")", "super", "(", ")", ".", "__init__", "(", "input_ab_initio_filename", "=", "input_ab_initio_filename", ")", "self", ".", "_ab_initio_program", "=", "\"FORCECONSTANTS\"" ]

[ "Determine", "if", "two", "arrays", "might", "share", "memory" ]

[ "def", "may_share_memory", "(", "a", ",", "b", ",", "max_work", "=", "None", ")", ":", "return", "_mx_nd_np", ".", "may_share_memory", "(", "a", ",", "b", ",", "max_work", ")" ]

[ "Appends", "the", "contents", "of", "another", "repeated", "field", "of", "the", "same", "type", "to", "this", "one", "copying", "each", "individual", "message", "." ]

[ "def", "MergeFrom", "(", "self", ",", "other", ")", ":", "self", ".", "extend", "(", "other", ".", "_values", ")" ]

[ "Saves", "a", "model", "as", "a", "TensorFlow", "SavedModel", "or", "HDF5", "file", "." ]

[ "def", "save_model", "(", "model", ",", "filepath", ",", "overwrite", "=", "True", ",", "include_optimizer", "=", "True", ",", "save_format", "=", "None", ",", "signatures", "=", "None", ")", ":", "from", "tensorflow", ".", "python", ".", "keras", ".", "engine", "import", "sequential", "# pylint: disable=g-import-not-at-top", "default_format", "=", "'tf'", "if", "tf2", ".", "enabled", "(", ")", "else", "'h5'", "save_format", "=", "save_format", "or", "default_format", "if", "(", "save_format", "==", "'h5'", "or", "(", "h5py", "is", "not", "None", "and", "isinstance", "(", "filepath", ",", "h5py", ".", "File", ")", ")", "or", "os", ".", "path", ".", "splitext", "(", "filepath", ")", "[", "1", "]", "in", "_HDF5_EXTENSIONS", ")", ":", "# TODO(b/130258301): add utility method for detecting model type.", "if", "(", "not", "model", ".", "_is_graph_network", "and", "# pylint:disable=protected-access", "not", "isinstance", "(", "model", ",", "sequential", ".", "Sequential", ")", ")", ":", "raise", "NotImplementedError", "(", "'Saving the model to HDF5 format requires the model to be a '", "'Functional model or a Sequential model. It does not work for '", "'subclassed models, because such models are defined via the body of '", "'a Python method, which isn\\'t safely serializable. Consider saving '", "'to the Tensorflow SavedModel format (by setting save_format=\"tf\") '", "'or using `save_weights`.'", ")", "hdf5_format", ".", "save_model_to_hdf5", "(", "model", ",", "filepath", ",", "overwrite", ",", "include_optimizer", ")", "else", ":", "saved_model_save", ".", "save", "(", "model", ",", "filepath", ",", "overwrite", ",", "include_optimizer", ",", "signatures", ")" ]

[ "Right", "now", "shuffle", "directories", "only", "based", "on", "idleness", ".", "Later", "we", "probably", "want", "to", "avoid", "shuffling", "images", "that", "were", "recently", "shuffled", "." ]

[ "def", "can_shuffle_dir", "(", "self", ",", "dir_path", ")", ":", "log", ".", "debug", "(", "f'can_shuffle_dir: {dir_path}'", ")", "dir_state", "=", "self", ".", "dir_states", "[", "dir_path", "]", "return", "StateTransition", ".", "is_idle", "(", "dir_state", ".", "state", ")", "and", "(", "time", ".", "time", "(", ")", "-", "dir_state", "[", "'mapped_time'", "]", ")", ">", "Policy", ".", "DIR_SHUFFLE_THROTTLE_INTERVAL" ]

[ "Linear", "map", ":", "sum_i", "(", "args", "[", "i", "]", "*", "W", "[", "i", "]", ")", "where", "W", "[", "i", "]", "is", "a", "variable", "." ]

[ "def", "_linear", "(", "args", ",", "output_size", ",", "bias", ",", "bias_initializer", "=", "None", ",", "kernel_initializer", "=", "None", ")", ":", "if", "args", "is", "None", "or", "(", "nest", ".", "is_sequence", "(", "args", ")", "and", "not", "args", ")", ":", "raise", "ValueError", "(", "\"`args` must be specified\"", ")", "if", "not", "nest", ".", "is_sequence", "(", "args", ")", ":", "args", "=", "[", "args", "]", "# Calculate the total size of arguments on dimension 1.", "total_arg_size", "=", "0", "shapes", "=", "[", "a", ".", "get_shape", "(", ")", "for", "a", "in", "args", "]", "for", "shape", "in", "shapes", ":", "if", "shape", ".", "ndims", "!=", "2", ":", "raise", "ValueError", "(", "\"linear is expecting 2D arguments: %s\"", "%", "shapes", ")", "if", "shape", "[", "1", "]", ".", "value", "is", "None", ":", "raise", "ValueError", "(", "\"linear expects shape[1] to be provided for shape %s, \"", "\"but saw %s\"", "%", "(", "shape", ",", "shape", "[", "1", "]", ")", ")", "else", ":", "total_arg_size", "+=", "shape", "[", "1", "]", ".", "value", "dtype", "=", "[", "a", ".", "dtype", "for", "a", "in", "args", "]", "[", "0", "]", "# Now the computation.", "scope", "=", "vs", ".", "get_variable_scope", "(", ")", "with", "vs", ".", "variable_scope", "(", "scope", ")", "as", "outer_scope", ":", "weights", "=", "vs", ".", "get_variable", "(", "_WEIGHTS_VARIABLE_NAME", ",", "[", "total_arg_size", ",", "output_size", "]", ",", "dtype", "=", "dtype", ",", "initializer", "=", "kernel_initializer", ")", "if", "len", "(", "args", ")", "==", "1", ":", "res", "=", "math_ops", ".", "matmul", "(", "args", "[", "0", "]", ",", "weights", ")", "else", ":", "res", "=", "math_ops", ".", "matmul", "(", "array_ops", ".", "concat", "(", "args", ",", "1", ")", ",", "weights", ")", "if", "not", "bias", ":", "return", "res", "with", "vs", ".", "variable_scope", "(", "outer_scope", ")", "as", "inner_scope", ":", "inner_scope", ".", "set_partitioner", "(", "None", ")", "if", "bias_initializer", "is", "None", ":", "bias_initializer", "=", "init_ops", ".", "constant_initializer", "(", "0.0", ",", "dtype", "=", "dtype", ")", "biases", "=", "vs", ".", "get_variable", "(", "_BIAS_VARIABLE_NAME", ",", "[", "output_size", "]", ",", "dtype", "=", "dtype", ",", "initializer", "=", "bias_initializer", ")", "return", "nn_ops", ".", "bias_add", "(", "res", ",", "biases", ")" ]

[ "Return", "a", "file", "handle", "of", "the", "base64", "-", "decoded", "and", "unzipped", "sample", "." ]

[ "def", "rfh", "(", "self", ")", ":", "zfh", "=", "self", ".", "zfh", "rfh", "=", "io", ".", "BytesIO", "(", ")", "with", "zipfile", ".", "ZipFile", "(", "zfh", ",", "'r'", ")", "as", "zf", ":", "for", "entry", "in", "zf", ".", "infolist", "(", ")", ":", "rfh", ".", "write", "(", "zf", ".", "read", "(", "entry", ".", "filename", ",", "self", ".", "get", "(", "m", ".", "PASSWORD", ")", ")", ")", "rfh", ".", "seek", "(", "0", ")", "return", "rfh" ]

[ "Always", "integer", "for", "UInt64Index" ]

[ "def", "inferred_type", "(", "self", ")", "->", "str", ":", "return", "\"integer\"" ]

[ "Returns", "True", "if", "the", "cursor", "refers", "to", "a", "C", "++", "member", "function", "or", "member", "function", "template", "that", "is", "declared", "const", "." ]

[ "def", "is_const_method", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_CXXMethod_isConst", "(", "self", ")" ]

[ "Convert", "a", "Morsel", "object", "into", "a", "Cookie", "containing", "the", "one", "k", "/", "v", "pair", "." ]

[ "def", "morsel_to_cookie", "(", "morsel", ")", ":", "expires", "=", "None", "if", "morsel", "[", "'max-age'", "]", ":", "try", ":", "expires", "=", "int", "(", "time", ".", "time", "(", ")", "+", "int", "(", "morsel", "[", "'max-age'", "]", ")", ")", "except", "ValueError", ":", "raise", "TypeError", "(", "'max-age: %s must be integer'", "%", "morsel", "[", "'max-age'", "]", ")", "elif", "morsel", "[", "'expires'", "]", ":", "time_template", "=", "'%a, %d-%b-%Y %H:%M:%S GMT'", "expires", "=", "calendar", ".", "timegm", "(", "time", ".", "strptime", "(", "morsel", "[", "'expires'", "]", ",", "time_template", ")", ")", "return", "create_cookie", "(", "comment", "=", "morsel", "[", "'comment'", "]", ",", "comment_url", "=", "bool", "(", "morsel", "[", "'comment'", "]", ")", ",", "discard", "=", "False", ",", "domain", "=", "morsel", "[", "'domain'", "]", ",", "expires", "=", "expires", ",", "name", "=", "morsel", ".", "key", ",", "path", "=", "morsel", "[", "'path'", "]", ",", "port", "=", "None", ",", "rest", "=", "{", "'HttpOnly'", ":", "morsel", "[", "'httponly'", "]", "}", ",", "rfc2109", "=", "False", ",", "secure", "=", "bool", "(", "morsel", "[", "'secure'", "]", ")", ",", "value", "=", "morsel", ".", "value", ",", "version", "=", "morsel", "[", "'version'", "]", "or", "0", ",", ")" ]

[ "Check", "whether", "the", "character", "is", "part", "of", "Pi", "UCS", "Category" ]

[ "def", "uCSIsCatPi", "(", "code", ")", ":", "ret", "=", "libxml2mod", ".", "xmlUCSIsCatPi", "(", "code", ")", "return", "ret" ]

[ "Initialize", "." ]

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

[ "GetRightLocation", "(", "String", "location", ")", "-", ">", "String" ]

[ "def", "GetRightLocation", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "FileSystemHandler_GetRightLocation", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "the", "time", "the", "robots", ".", "txt", "file", "was", "last", "fetched", "to", "the", "current", "time", "." ]

[ "def", "modified", "(", "self", ")", ":", "import", "time", "self", ".", "last_checked", "=", "time", ".", "time", "(", ")" ]

[ "Returns", "a", "list", "of", "build", "outputs", "for", "filename", "." ]

[ "def", "GetNinjaBuildOutputsForSourceFile", "(", "out_dir", ",", "filename", ")", ":", "# Ninja needs the path to the source file relative to the output build", "# directory.", "rel_filename", "=", "os", ".", "path", ".", "relpath", "(", "filename", ",", "out_dir", ")", "p", "=", "subprocess", ".", "Popen", "(", "[", "'ninja'", ",", "'-C'", ",", "out_dir", ",", "'-t'", ",", "'query'", ",", "rel_filename", "]", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "STDOUT", ",", "universal_newlines", "=", "True", ")", "stdout", ",", "_", "=", "p", ".", "communicate", "(", ")", "if", "p", ".", "returncode", "!=", "0", ":", "return", "[", "]", "# The output looks like:", "# ../../relative/path/to/source.cc:", "# outputs:", "# obj/reative/path/to/target.source.o", "# obj/some/other/target2.source.o", "# another/target.txt", "#", "outputs_text", "=", "stdout", ".", "partition", "(", "'\\n outputs:\\n'", ")", "[", "2", "]", "output_lines", "=", "[", "line", ".", "strip", "(", ")", "for", "line", "in", "outputs_text", ".", "split", "(", "'\\n'", ")", "]", "return", "[", "target", "for", "target", "in", "output_lines", "if", "target", "and", "(", "target", ".", "endswith", "(", "'.o'", ")", "or", "target", ".", "endswith", "(", "'.obj'", ")", ")", "]" ]

[ "Creates", "a", "message", "service", "class", "." ]

[ "def", "__init__", "(", "cls", ",", "name", ",", "bases", ",", "dictionary", ")", ":", "# Don't do anything if this class doesn't have a descriptor. This happens", "# when a service class is subclassed.", "if", "GeneratedServiceType", ".", "_DESCRIPTOR_KEY", "not", "in", "dictionary", ":", "return", "descriptor", "=", "dictionary", "[", "GeneratedServiceType", ".", "_DESCRIPTOR_KEY", "]", "service_builder", "=", "_ServiceBuilder", "(", "descriptor", ")", "service_builder", ".", "BuildService", "(", "cls", ")" ]

[ "Looks", "for", "misplaced", "braces", "(", "e", ".", "g", ".", "at", "the", "end", "of", "line", ")", "." ]

[ "def", "CheckBraces", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# get rid of comments and strings", "if", "Match", "(", "r'\\s*{\\s*$'", ",", "line", ")", ":", "# We allow an open brace to start a line in the case where someone is using", "# braces in a block to explicitly create a new scope, which is commonly used", "# to control the lifetime of stack-allocated variables. Braces are also", "# used for brace initializers inside function calls. We don't detect this", "# perfectly: we just don't complain if the last non-whitespace character on", "# the previous non-blank line is ',', ';', ':', '(', '{', or '}', or if the", "# previous line starts a preprocessor block.", "prevline", "=", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", "[", "0", "]", "if", "(", "not", "Search", "(", "r'[,;:}{(]\\s*$'", ",", "prevline", ")", "and", "not", "Match", "(", "r'\\s*#'", ",", "prevline", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/braces'", ",", "4", ",", "'{ should almost always be at the end of the previous line'", ")", "# An else clause should be on the same line as the preceding closing brace.", "if", "Match", "(", "r'\\s*else\\s*'", ",", "line", ")", ":", "prevline", "=", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", "[", "0", "]", "if", "Match", "(", "r'\\s*}\\s*$'", ",", "prevline", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/newline'", ",", "4", ",", "'An else should appear on the same line as the preceding }'", ")", "# If braces come on one side of an else, they should be on both.", "# However, we have to worry about \"else if\" that spans multiple lines!", "if", "Search", "(", "r'}\\s*else[^{]*$'", ",", "line", ")", "or", "Match", "(", "r'[^}]*else\\s*{'", ",", "line", ")", ":", "if", "Search", "(", "r'}\\s*else if([^{]*)$'", ",", "line", ")", ":", "# could be multi-line if", "# find the ( after the if", "pos", "=", "line", ".", "find", "(", "'else if'", ")", "pos", "=", "line", ".", "find", "(", "'('", ",", "pos", ")", "if", "pos", ">", "0", ":", "(", "endline", ",", "_", ",", "endpos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", ")", "if", "endline", "[", "endpos", ":", "]", ".", "find", "(", "'{'", ")", "==", "-", "1", ":", "# must be brace after if", "error", "(", "filename", ",", "linenum", ",", "'readability/braces'", ",", "5", ",", "'If an else has a brace on one side, it should have it on both'", ")", "else", ":", "# common case: else not followed by a multi-line if", "error", "(", "filename", ",", "linenum", ",", "'readability/braces'", ",", "5", ",", "'If an else has a brace on one side, it should have it on both'", ")", "# Likewise, an else should never have the else clause on the same line", "if", "Search", "(", "r'\\belse [^\\s{]'", ",", "line", ")", "and", "not", "Search", "(", "r'\\belse if\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/newline'", ",", "4", ",", "'Else clause should never be on same line as else (use 2 lines)'", ")", "# In the same way, a do/while should never be on one line", "if", "Match", "(", "r'\\s*do [^\\s{]'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/newline'", ",", "4", ",", "'do/while clauses should not be on a single line'", ")", "# Block bodies should not be followed by a semicolon. Due to C++11", "# brace initialization, there are more places where semicolons are", "# required than not, so we use a whitelist approach to check these", "# rather than a blacklist. These are the places where \"};\" should", "# be replaced by just \"}\":", "# 1. Some flavor of block following closing parenthesis:", "# for (;;) {};", "# while (...) {};", "# switch (...) {};", "# Function(...) {};", "# if (...) {};", "# if (...) else if (...) {};", "#", "# 2. else block:", "# if (...) else {};", "#", "# 3. const member function:", "# Function(...) const {};", "#", "# 4. Block following some statement:", "# x = 42;", "# {};", "#", "# 5. Block at the beginning of a function:", "# Function(...) {", "# {};", "# }", "#", "# Note that naively checking for the preceding \"{\" will also match", "# braces inside multi-dimensional arrays, but this is fine since", "# that expression will not contain semicolons.", "#", "# 6. Block following another block:", "# while (true) {}", "# {};", "#", "# 7. End of namespaces:", "# namespace {};", "#", "# These semicolons seems far more common than other kinds of", "# redundant semicolons, possibly due to people converting classes", "# to namespaces. For now we do not warn for this case.", "#", "# Try matching case 1 first.", "match", "=", "Match", "(", "r'^(.*\\)\\s*)\\{'", ",", "line", ")", "if", "match", ":", "# Matched closing parenthesis (case 1). Check the token before the", "# matching opening parenthesis, and don't warn if it looks like a", "# macro. This avoids these false positives:", "# - macro that defines a base class", "# - multi-line macro that defines a base class", "# - macro that defines the whole class-head", "#", "# But we still issue warnings for macros that we know are safe to", "# warn, specifically:", "# - TEST, TEST_F, TEST_P, MATCHER, MATCHER_P", "# - TYPED_TEST", "# - INTERFACE_DEF", "# - EXCLUSIVE_LOCKS_REQUIRED, SHARED_LOCKS_REQUIRED, LOCKS_EXCLUDED:", "#", "# We implement a whitelist of safe macros instead of a blacklist of", "# unsafe macros, even though the latter appears less frequently in", "# google code and would have been easier to implement. This is because", "# the downside for getting the whitelist wrong means some extra", "# semicolons, while the downside for getting the blacklist wrong", "# would result in compile errors.", "#", "# In addition to macros, we also don't want to warn on compound", "# literals.", "closing_brace_pos", "=", "match", ".", "group", "(", "1", ")", ".", "rfind", "(", "')'", ")", "opening_parenthesis", "=", "ReverseCloseExpression", "(", "clean_lines", ",", "linenum", ",", "closing_brace_pos", ")", "if", "opening_parenthesis", "[", "2", "]", ">", "-", "1", ":", "line_prefix", "=", "opening_parenthesis", "[", "0", "]", "[", "0", ":", "opening_parenthesis", "[", "2", "]", "]", "macro", "=", "Search", "(", "r'\\b([A-Z_]+)\\s*$'", ",", "line_prefix", ")", "if", "(", "(", "macro", "and", "macro", ".", "group", "(", "1", ")", "not", "in", "(", "'TEST'", ",", "'TEST_F'", ",", "'MATCHER'", ",", "'MATCHER_P'", ",", "'TYPED_TEST'", ",", "'EXCLUSIVE_LOCKS_REQUIRED'", ",", "'SHARED_LOCKS_REQUIRED'", ",", "'LOCKS_EXCLUDED'", ",", "'INTERFACE_DEF'", ")", ")", "or", "Search", "(", "r'\\s+=\\s*$'", ",", "line_prefix", ")", ")", ":", "match", "=", "None", "else", ":", "# Try matching cases 2-3.", "match", "=", "Match", "(", "r'^(.*(?:else|\\)\\s*const)\\s*)\\{'", ",", "line", ")", "if", "not", "match", ":", "# Try matching cases 4-6. These are always matched on separate lines.", "#", "# Note that we can't simply concatenate the previous line to the", "# current line and do a single match, otherwise we may output", "# duplicate warnings for the blank line case:", "# if (cond) {", "# // blank line", "# }", "prevline", "=", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", "[", "0", "]", "if", "prevline", "and", "Search", "(", "r'[;{}]\\s*$'", ",", "prevline", ")", ":", "match", "=", "Match", "(", "r'^(\\s*)\\{'", ",", "line", ")", "# Check matching closing brace", "if", "match", ":", "(", "endline", ",", "endlinenum", ",", "endpos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "len", "(", "match", ".", "group", "(", "1", ")", ")", ")", "if", "endpos", ">", "-", "1", "and", "Match", "(", "r'^\\s*;'", ",", "endline", "[", "endpos", ":", "]", ")", ":", "# Current {} pair is eligible for semicolon check, and we have found", "# the redundant semicolon, output warning here.", "#", "# Note: because we are scanning forward for opening braces, and", "# outputting warnings for the matching closing brace, if there are", "# nested blocks with trailing semicolons, we will get the error", "# messages in reversed order.", "error", "(", "filename", ",", "endlinenum", ",", "'readability/braces'", ",", "4", ",", "\"You don't need a ; after a }\"", ")" ]

[ "Adds", "a", "bunch", "of", "children", "to", "our", "list" ]

[ "def", "AddChildren", "(", "self", ",", "children", ")", ":", "self", ".", "children", "+=", "children", "self", ".", "_GenPoints", "(", ")", "self", ".", "_UpdateLength", "(", ")" ]

[ "Shape", "function", "for", "a", "DepthwiseConv2D", "op", "." ]

[ "def", "depthwise_conv2d_native_shape", "(", "op", ")", ":", "input_shape", "=", "op", ".", "inputs", "[", "0", "]", ".", "get_shape", "(", ")", ".", "with_rank", "(", "4", ")", "filter_shape", "=", "op", ".", "inputs", "[", "1", "]", ".", "get_shape", "(", ")", ".", "with_rank", "(", "4", ")", "batch_size", "=", "input_shape", "[", "0", "]", "in_rows", "=", "input_shape", "[", "1", "]", "in_cols", "=", "input_shape", "[", "2", "]", "filter_rows", "=", "filter_shape", "[", "0", "]", "filter_cols", "=", "filter_shape", "[", "1", "]", "depth_out", "=", "filter_shape", "[", "3", "]", "*", "filter_shape", "[", "2", "]", "# Check that the input depths are compatible.", "input_shape", "[", "3", "]", ".", "assert_is_compatible_with", "(", "filter_shape", "[", "2", "]", ")", "stride_b", ",", "stride_r", ",", "stride_c", ",", "stride_d", "=", "op", ".", "get_attr", "(", "\"strides\"", ")", "if", "stride_b", "!=", "1", "or", "stride_d", "!=", "1", ":", "raise", "ValueError", "(", "\"Current implementation does not yet support \"", "\"strides in the batch and depth dimensions.\"", ")", "if", "stride_r", "!=", "stride_c", ":", "# TODO(shlens): Add support for this.", "raise", "ValueError", "(", "\"Current implementation only supports equal length \"", "\"strides in the row and column dimensions.\"", ")", "# TODO(mrry,shlens): Raise an error if the stride would cause", "# information in the input to be ignored. This will require a change", "# in the kernel implementation.", "stride", "=", "stride_r", "padding", "=", "op", ".", "get_attr", "(", "\"padding\"", ")", "out_rows", ",", "out_cols", "=", "get2d_conv_output_size", "(", "in_rows", ",", "in_cols", ",", "filter_rows", ",", "filter_cols", ",", "stride", ",", "stride", ",", "padding", ")", "return", "[", "tensor_shape", ".", "TensorShape", "(", "[", "batch_size", ",", "out_rows", ",", "out_cols", ",", "depth_out", "]", ")", "]" ]

[ "creates", "a", "file", "at", "filepath", "or", "updates", "the", "timestamp", "on", "filepath" ]

[ "def", "touch_filepath", "(", "self", ",", "filepath", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "filepath", ")", ":", "os", ".", "utime", "(", "filepath", ",", "None", ")", "else", ":", "with", "open", "(", "filepath", ",", "\"a\"", ")", ":", "pass" ]

[ "Like", "test", "1", "but", "with", "header", "padding", "+", "payload", "offset", "." ]

[ "def", "test_001_headerpadding_payload_offset", "(", "self", ")", ":", "n_zeros", "=", "3", "header", "=", "[", "1", ",", "2", ",", "3", "]", "header_padding", "=", "1", "payload_offset", "=", "-", "1", "payload", "=", "list", "(", "range", "(", "5", ",", "20", ")", ")", "data_signal", "=", "[", "0", ",", "]", "*", "n_zeros", "+", "header", "+", "payload", "+", "[", "0", ",", "]", "*", "100", "trigger_signal", "=", "[", "0", "]", "*", "len", "(", "data_signal", ")", "trigger_signal", "[", "n_zeros", "]", "=", "1", "# This goes on output 1, item 3 + 1 (for payload offset)", "testtag4", "=", "make_tag", "(", "'tag4'", ",", "314", ",", "n_zeros", "+", "len", "(", "header", ")", "+", "3", ")", "data_src", "=", "blocks", ".", "vector_source_f", "(", "data_signal", ",", "False", ",", "tags", "=", "(", "testtag4", ",", ")", ")", "trigger_src", "=", "blocks", ".", "vector_source_b", "(", "trigger_signal", ",", "False", ")", "hpd", "=", "digital", ".", "header_payload_demux", "(", "len", "(", "header", ")", ",", "1", ",", "# Items per symbol", "0", ",", "# Guard interval", "\"frame_len\"", ",", "# TSB tag key", "\"detect\"", ",", "# Trigger tag key", "False", ",", "# No symbols please", "gr", ".", "sizeof_float", ",", "# Item size", "\"\"", ",", "# Timing tag key", "1.0", ",", "# Samp rate", "(", ")", ",", "# No special tags", "header_padding", ")", "# extra system port defined for you", "self", ".", "assertEqual", "(", "pmt", ".", "length", "(", "hpd", ".", "message_ports_in", "(", ")", ")", ",", "2", ")", "header_sink", "=", "blocks", ".", "vector_sink_f", "(", ")", "payload_sink", "=", "blocks", ".", "vector_sink_f", "(", ")", "self", ".", "tb", ".", "connect", "(", "data_src", ",", "(", "hpd", ",", "0", ")", ")", "self", ".", "tb", ".", "connect", "(", "trigger_src", ",", "(", "hpd", ",", "1", ")", ")", "self", ".", "tb", ".", "connect", "(", "(", "hpd", ",", "0", ")", ",", "header_sink", ")", "self", ".", "tb", ".", "connect", "(", "(", "hpd", ",", "1", ")", ",", "payload_sink", ")", "self", ".", "tb", ".", "start", "(", ")", "time", ".", "sleep", "(", ".2", ")", "# Need this, otherwise, the next message is ignored", "hpd", ".", "to_basic_block", "(", ")", ".", "_post", "(", "pmt", ".", "intern", "(", "'header_data'", ")", ",", "pmt", ".", "to_pmt", "(", "{", "'frame_len'", ":", "len", "(", "payload", ")", ",", "'payload_offset'", ":", "payload_offset", "}", ")", ")", "while", "len", "(", "payload_sink", ".", "data", "(", ")", ")", "<", "len", "(", "payload", ")", ":", "time", ".", "sleep", "(", ".2", ")", "self", ".", "tb", ".", "stop", "(", ")", "self", ".", "tb", ".", "wait", "(", ")", "# Header is now padded:", "self", ".", "assertEqual", "(", "header_sink", ".", "data", "(", ")", ",", "[", "0", ",", "]", "+", "header", "+", "[", "payload", "[", "0", "]", ",", "]", ")", "# Payload is now offset:", "self", ".", "assertEqual", "(", "payload_sink", ".", "data", "(", ")", ",", "data_signal", "[", "n_zeros", "+", "len", "(", "header", ")", "+", "payload_offset", ":", "n_zeros", "+", "len", "(", "header", ")", "+", "payload_offset", "+", "len", "(", "payload", ")", "]", ")", "ptags_payload", "=", "{", "}", "for", "tag", "in", "payload_sink", ".", "tags", "(", ")", ":", "ptag", "=", "gr", ".", "tag_to_python", "(", "tag", ")", "ptags_payload", "[", "ptag", ".", "key", "]", "=", "ptag", ".", "offset", "expected_tags_payload", "=", "{", "'frame_len'", ":", "0", ",", "'payload_offset'", ":", "0", ",", "'tag4'", ":", "3", "-", "payload_offset", ",", "}", "self", ".", "assertEqual", "(", "expected_tags_payload", ",", "ptags_payload", ")" ]

[ "Replaces", "instances", "of", "pattern", "in", "a", "string", "with", "a", "replacement", "." ]

[ "def", "ReplaceAll", "(", "pattern", ",", "rep", ",", "s", ")", ":", "if", "pattern", "not", "in", "_regexp_compile_cache", ":", "_regexp_compile_cache", "[", "pattern", "]", "=", "sre_compile", ".", "compile", "(", "pattern", ")", "return", "_regexp_compile_cache", "[", "pattern", "]", ".", "sub", "(", "rep", ",", "s", ")" ]

[ "Returns", "the", "module", "s", "list", "of", "output", "filters", "as", "a", "list", "." ]

[ "def", "_Filters", "(", ")", ":", "return", "_cpplint_state", ".", "filters" ]

[ "Customize", "Python", "build", "configuration", "variables", "." ]

[ "def", "customize_config_vars", "(", "_config_vars", ")", ":", "if", "not", "_supports_universal_builds", "(", ")", ":", "# On Mac OS X before 10.4, check if -arch and -isysroot", "# are in CFLAGS or LDFLAGS and remove them if they are.", "# This is needed when building extensions on a 10.3 system", "# using a universal build of python.", "_remove_universal_flags", "(", "_config_vars", ")", "# Allow user to override all archs with ARCHFLAGS env var", "_override_all_archs", "(", "_config_vars", ")", "# Remove references to sdks that are not found", "_check_for_unavailable_sdk", "(", "_config_vars", ")", "return", "_config_vars" ]

[ "Function", "to", "return", "a", "string", "of", "commands", "to", "replicate", "the", "current", "state", "of", "user", "-", "modified", "options", ".", "Used", "to", "capture", "C", "++", "options", "information", "for", "distributed", "(", "sow", "/", "reap", ")", "input", "files", "." ]

[ "def", "prepare_options_for_modules", "(", "changedOnly", "=", "False", ",", "commandsInsteadDict", "=", "False", ")", ":", "options", "=", "collections", ".", "defaultdict", "(", "dict", ")", "commands", "=", "''", "for", "opt", "in", "core", ".", "get_global_option_list", "(", ")", ":", "if", "core", ".", "has_global_option_changed", "(", "opt", ")", "or", "not", "changedOnly", ":", "if", "opt", "in", "[", "'DFT_CUSTOM_FUNCTIONAL'", ",", "'EXTERN'", "]", ":", "# Feb 2017 hack", "continue", "val", "=", "core", ".", "get_global_option", "(", "opt", ")", "options", "[", "'GLOBALS'", "]", "[", "opt", "]", "=", "{", "'value'", ":", "val", ",", "'has_changed'", ":", "core", ".", "has_global_option_changed", "(", "opt", ")", "}", "if", "isinstance", "(", "val", ",", "str", ")", ":", "commands", "+=", "\"\"\"core.set_global_option('%s', '%s')\\n\"\"\"", "%", "(", "opt", ",", "val", ")", "else", ":", "commands", "+=", "\"\"\"core.set_global_option('%s', %s)\\n\"\"\"", "%", "(", "opt", ",", "val", ")", "#if changedOnly:", "# print('Appending module %s option %s value %s has_changed %s.' % \\", "# ('GLOBALS', opt, core.get_global_option(opt), core.has_global_option_changed(opt)))", "for", "module", "in", "_modules", ":", "if", "core", ".", "option_exists_in_module", "(", "module", ",", "opt", ")", ":", "hoc", "=", "core", ".", "has_option_changed", "(", "module", ",", "opt", ")", "if", "hoc", "or", "not", "changedOnly", ":", "val", "=", "core", ".", "get_option", "(", "module", ",", "opt", ")", "options", "[", "module", "]", "[", "opt", "]", "=", "{", "'value'", ":", "val", ",", "'has_changed'", ":", "hoc", "}", "if", "isinstance", "(", "val", ",", "str", ")", ":", "commands", "+=", "\"\"\"core.set_local_option('%s', '%s', '%s')\\n\"\"\"", "%", "(", "module", ",", "opt", ",", "val", ")", "else", ":", "commands", "+=", "\"\"\"core.set_local_option('%s', '%s', %s)\\n\"\"\"", "%", "(", "module", ",", "opt", ",", "val", ")", "#if changedOnly:", "# print('Appending module %s option %s value %s has_changed %s.' % \\", "# (module, opt, core.get_option(module, opt), hoc))", "if", "commandsInsteadDict", ":", "return", "commands", "else", ":", "return", "options" ]

[ "Make", "a", "file", "copy", ".", "This", "might", "be", "used", "to", "make", "other", "kinds", "of", "file", "processing", "(", "even", "calling", "a", "compiler", "is", "possible", ")" ]

[ "def", "copy_func", "(", "tsk", ")", ":", "env", "=", "tsk", ".", "env", "infile", "=", "tsk", ".", "inputs", "[", "0", "]", ".", "abspath", "(", ")", "outfile", "=", "tsk", ".", "outputs", "[", "0", "]", ".", "abspath", "(", ")", "try", ":", "shutil", ".", "copy2", "(", "infile", ",", "outfile", ")", "except", "(", "OSError", ",", "IOError", ")", ":", "return", "1", "else", ":", "if", "tsk", ".", "chmod", ":", "os", ".", "chmod", "(", "outfile", ",", "tsk", ".", "chmod", ")", "return", "0" ]

[ "__init__", "(", "self", "Object", "generator", "int", "id", "bool", "collapsed", ")", "-", ">", "CollapsiblePaneEvent" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_controls_", ".", "CollapsiblePaneEvent_swiginit", "(", "self", ",", "_controls_", ".", "new_CollapsiblePaneEvent", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

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

[ "def", "CanSave", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextFileHandler_CanSave", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "unpack", "serialized", "message", "in", "str", "into", "this", "message", "instance", "using", "numpy", "for", "array", "types", ":", "param", "str", ":", "byte", "array", "of", "serialized", "message", "str", ":", "param", "numpy", ":", "numpy", "python", "module" ]

[ "def", "deserialize_numpy", "(", "self", ",", "str", ",", "numpy", ")", ":", "try", ":", "end", "=", "0", "start", "=", "end", "end", "+=", "4", "(", "length", ",", ")", "=", "_struct_I", ".", "unpack", "(", "str", "[", "start", ":", "end", "]", ")", "start", "=", "end", "end", "+=", "length", "if", "python3", ":", "self", ".", "command", "=", "str", "[", "start", ":", "end", "]", ".", "decode", "(", "'utf-8'", ")", "else", ":", "self", ".", "command", "=", "str", "[", "start", ":", "end", "]", "return", "self", "except", "struct", ".", "error", "as", "e", ":", "raise", "genpy", ".", "DeserializationError", "(", "e", ")" ]

[ "Adds", "an", "arch", "string", "to", "an", "output", "path", "." ]

[ "def", "AddArch", "(", "output", ",", "arch", ")", ":", "output", ",", "extension", "=", "os", ".", "path", ".", "splitext", "(", "output", ")", "return", "'%s.%s%s'", "%", "(", "output", ",", "arch", ",", "extension", ")" ]

[ "Reset", "all", "variables", "and", "passes", "setter", "/", "getter", "functions", "for", "variable", "types", "are", "kept" ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "vars", "=", "{", "}", "self", ".", "passes", "=", "0" ]

[ "refine", "boxes", "Input", ":", "boxes", ":", "detected", "polys", "<numpy", ".", "ndarray", "(", "n", "9", ")", ">", "ratio_w", ":", "ratio", "of", "width", "ratio_h", ":", "ratio", "of", "height", "Output", ":", "refined", "boxes" ]

[ "def", "adjust_ratio", "(", "boxes", ",", "ratio_w", ",", "ratio_h", ")", ":", "if", "boxes", "is", "None", "or", "boxes", ".", "size", "==", "0", ":", "return", "None", "boxes", "[", ":", ",", "[", "0", ",", "2", ",", "4", ",", "6", "]", "]", "/=", "ratio_w", "boxes", "[", ":", ",", "[", "1", ",", "3", ",", "5", ",", "7", "]", "]", "/=", "ratio_h", "return", "np", ".", "around", "(", "boxes", ")" ]

[ "Convert", "to", "float", "." ]

[ "def", "__float__", "(", "self", ")", ":", "if", "self", ".", "size", ">", "1", ":", "raise", "TypeError", "(", "\"Only length-1 arrays can be converted \"", "\"to Python scalars\"", ")", "elif", "self", ".", "_mask", ":", "warnings", ".", "warn", "(", "\"Warning: converting a masked element to nan.\"", ")", "return", "np", ".", "nan", "return", "float", "(", "self", ".", "item", "(", ")", ")" ]

[ "push", "call", "variables", "to", "right", "before", "their", "call", "site", ".", "assuming", "one", "global", "/", "getattr", "is", "created", "for", "each", "call", "site", "and", "control", "flow", "doesn", "t", "change", "it", "." ]

[ "def", "push_call_vars", "(", "blocks", ",", "saved_globals", ",", "saved_getattrs", ",", "nested", "=", "False", ")", ":", "for", "block", "in", "blocks", ".", "values", "(", ")", ":", "new_body", "=", "[", "]", "# global/attr variables that are defined in this block already,", "# no need to reassign them", "block_defs", "=", "set", "(", ")", "for", "stmt", "in", "block", ".", "body", ":", "def", "process_assign", "(", "stmt", ")", ":", "if", "isinstance", "(", "stmt", ",", "ir", ".", "Assign", ")", ":", "rhs", "=", "stmt", ".", "value", "lhs", "=", "stmt", ".", "target", "if", "(", "isinstance", "(", "rhs", ",", "ir", ".", "Global", ")", ")", ":", "saved_globals", "[", "lhs", ".", "name", "]", "=", "stmt", "block_defs", ".", "add", "(", "lhs", ".", "name", ")", "elif", "isinstance", "(", "rhs", ",", "ir", ".", "Expr", ")", "and", "rhs", ".", "op", "==", "'getattr'", ":", "if", "(", "rhs", ".", "value", ".", "name", "in", "saved_globals", "or", "rhs", ".", "value", ".", "name", "in", "saved_getattrs", ")", ":", "saved_getattrs", "[", "lhs", ".", "name", "]", "=", "stmt", "block_defs", ".", "add", "(", "lhs", ".", "name", ")", "if", "not", "nested", "and", "isinstance", "(", "stmt", ",", "Parfor", ")", ":", "for", "s", "in", "stmt", ".", "init_block", ".", "body", ":", "process_assign", "(", "s", ")", "pblocks", "=", "stmt", ".", "loop_body", ".", "copy", "(", ")", "push_call_vars", "(", "pblocks", ",", "saved_globals", ",", "saved_getattrs", ",", "nested", "=", "True", ")", "new_body", ".", "append", "(", "stmt", ")", "continue", "else", ":", "process_assign", "(", "stmt", ")", "for", "v", "in", "stmt", ".", "list_vars", "(", ")", ":", "new_body", "+=", "_get_saved_call_nodes", "(", "v", ".", "name", ",", "saved_globals", ",", "saved_getattrs", ",", "block_defs", ")", "new_body", ".", "append", "(", "stmt", ")", "block", ".", "body", "=", "new_body", "return" ]

[ "Return", "a", "string", "which", "is", "the", "concatenation", "of", "the", "strings", "in", "the", "sequence", "seq", "." ]

[ "def", "join", "(", "sep", ",", "seq", ")", ":", "return", "_to_string_or_unicode_array", "(", "_vec_string", "(", "sep", ",", "object_", ",", "'join'", ",", "(", "seq", ",", ")", ")", ")" ]

[ "Merge", "config", "dictionary", "a", "into", "config", "dictionary", "b", "clobbering", "the", "options", "in", "b", "whenever", "they", "are", "also", "specified", "in", "a", "." ]

[ "def", "_merge_a_into_b", "(", "a", ",", "b", ")", ":", "if", "type", "(", "a", ")", "is", "not", "edict", ":", "return", "for", "k", ",", "v", "in", "a", ".", "iteritems", "(", ")", ":", "# a must specify keys that are in b", "if", "not", "b", ".", "has_key", "(", "k", ")", ":", "raise", "KeyError", "(", "'{} is not a valid config key'", ".", "format", "(", "k", ")", ")", "# the types must match, too", "old_type", "=", "type", "(", "b", "[", "k", "]", ")", "if", "old_type", "is", "not", "type", "(", "v", ")", ":", "if", "isinstance", "(", "b", "[", "k", "]", ",", "np", ".", "ndarray", ")", ":", "v", "=", "np", ".", "array", "(", "v", ",", "dtype", "=", "b", "[", "k", "]", ".", "dtype", ")", "else", ":", "raise", "ValueError", "(", "(", "'Type mismatch ({} vs. {}) '", "'for config key: {}'", ")", ".", "format", "(", "type", "(", "b", "[", "k", "]", ")", ",", "type", "(", "v", ")", ",", "k", ")", ")", "# recursively merge dicts", "if", "type", "(", "v", ")", "is", "edict", ":", "try", ":", "_merge_a_into_b", "(", "a", "[", "k", "]", ",", "b", "[", "k", "]", ")", "except", ":", "print", "(", "'Error under config key: {}'", ".", "format", "(", "k", ")", ")", "raise", "else", ":", "b", "[", "k", "]", "=", "v" ]

[ "RefreshColumns", "(", "self", "size_t", "from", "size_t", "to", ")" ]

[ "def", "RefreshColumns", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "VarHScrollHelper_RefreshColumns", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Computes", "matmul", "(", "x", "weights", ")", "+", "biases", "." ]

[ "def", "xw_plus_b_v1", "(", "x", ",", "weights", ",", "biases", ",", "name", "=", "None", ")", ":", "# pylint: disable=invalid-name", "with", "ops", ".", "op_scope", "(", "[", "x", ",", "weights", ",", "biases", "]", ",", "name", ",", "\"xw_plus_b_v1\"", ")", "as", "name", ":", "x", "=", "ops", ".", "convert_to_tensor", "(", "x", ",", "name", "=", "\"x\"", ")", "weights", "=", "ops", ".", "convert_to_tensor", "(", "weights", ",", "name", "=", "\"weights\"", ")", "biases", "=", "ops", ".", "convert_to_tensor", "(", "biases", ",", "name", "=", "\"biases\"", ")", "mm", "=", "math_ops", ".", "matmul", "(", "x", ",", "weights", ")", "return", "bias_add_v1", "(", "mm", ",", "biases", ",", "name", "=", "name", ")" ]

[ "Assert", "that", "we", "are", "working", "with", "a", "properly", "shaped", "image", "." ]

[ "def", "_Assert3DImage", "(", "image", ")", ":", "return", "control_flow_ops", ".", "with_dependencies", "(", "_Check3DImage", "(", "image", ",", "require_static", "=", "False", ")", ",", "image", ")" ]

[ "create", "&", "return", "the", "directory", "joined", "with", "args", ".", "pass", "a", "msg", "keyword", "argument", "to", "set", "the", "commit", "message", "." ]

[ "def", "mkdir", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "commit_msg", "=", "kwargs", ".", "get", "(", "'msg'", ",", "\"mkdir by py lib invocation\"", ")", "createpath", "=", "self", ".", "join", "(", "*", "args", ")", "createpath", ".", "_svnwrite", "(", "'mkdir'", ",", "'-m'", ",", "commit_msg", ")", "self", ".", "_norev_delentry", "(", "createpath", ".", "dirpath", "(", ")", ")", "return", "createpath" ]

[ "Get", "this", "windows", "Shelf", "@return", ":", "reference", "to", "L", "{", "iface", ".", "Shelf", "}", "instance", "@note", ":", "returns", "the", "plugin", "instance", "not", "the", "actual", "notebook", "if", "a", "reference", "to", "the", "notebook", "is", "needed", "for", "parenting", "call", "GetWindow", "on", "the", "object", "returned", "by", "this", "function", "." ]

[ "def", "GetShelf", "(", "self", ")", ":", "return", "self", ".", "_shelf" ]