Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

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

[ "def", "uCSIsCatL", "(", "code", ")", ":", "ret", "=", "libxml2mod", ".", "xmlUCSIsCatL", "(", "code", ")", "return", "ret" ]

[ "GetNodeContent", "(", "self", "XmlNode", "node", ")", "-", ">", "String" ]

[ "def", "GetNodeContent", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_xrc", ".", "XmlResourceHandler_GetNodeContent", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Iterates", "over", "the", "response", "data", ".", "When", "stream", "=", "True", "is", "set", "on", "the", "request", "this", "avoids", "reading", "the", "content", "at", "once", "into", "memory", "for", "large", "responses", ".", "The", "chunk", "size", "is", "the", "number", "of", "bytes", "it", "should", "read", "into", "memory", ".", "This", "is", "not", "necessarily", "the", "length", "of", "each", "item", "returned", "as", "decoding", "can", "take", "place", "." ]

[ "def", "iter_content", "(", "self", ",", "chunk_size", "=", "1", ",", "decode_unicode", "=", "False", ")", ":", "def", "generate", "(", ")", ":", "try", ":", "# Special case for urllib3.", "try", ":", "for", "chunk", "in", "self", ".", "raw", ".", "stream", "(", "chunk_size", ",", "decode_content", "=", "True", ")", ":", "yield", "chunk", "except", "ProtocolError", "as", "e", ":", "raise", "ChunkedEncodingError", "(", "e", ")", "except", "DecodeError", "as", "e", ":", "raise", "ContentDecodingError", "(", "e", ")", "except", "ReadTimeoutError", "as", "e", ":", "raise", "ConnectionError", "(", "e", ")", "except", "AttributeError", ":", "# Standard file-like object.", "while", "True", ":", "chunk", "=", "self", ".", "raw", ".", "read", "(", "chunk_size", ")", "if", "not", "chunk", ":", "break", "yield", "chunk", "self", ".", "_content_consumed", "=", "True", "if", "self", ".", "_content_consumed", "and", "isinstance", "(", "self", ".", "_content", ",", "bool", ")", ":", "raise", "StreamConsumedError", "(", ")", "# simulate reading small chunks of the content", "reused_chunks", "=", "iter_slices", "(", "self", ".", "_content", ",", "chunk_size", ")", "stream_chunks", "=", "generate", "(", ")", "chunks", "=", "reused_chunks", "if", "self", ".", "_content_consumed", "else", "stream_chunks", "if", "decode_unicode", ":", "chunks", "=", "stream_decode_response_unicode", "(", "chunks", ",", "self", ")", "return", "chunks" ]

[ "Creates", "a", "new", "member", "push", "." ]

[ "def", "__init__", "(", "self", ",", "forward_ref", ",", "member_name", ",", "member_origin", ",", "push_value", ")", ":", "self", ".", "forward_ref", "=", "forward_ref", "self", ".", "member_name", "=", "member_name", "self", ".", "member_origin", "=", "member_origin", "self", ".", "push_value", "=", "push_value" ]

[ "GetNumQueues", "(", "self", ")", "-", ">", "uint32_t" ]

[ "def", "GetNumQueues", "(", "self", ")", ":", "return", "_lldb", ".", "SBProcess_GetNumQueues", "(", "self", ")" ]

[ "Find", "the", "max", "number", "of", "continuous", "frames", "when", "yaw", "error", "is", "lager", "than", "1", ".", "0d", "0", ".", "6d", "and", "0", ".", "3d" ]

[ "def", "get_angle_stat2_from_data", "(", "data", ")", ":", "max_con_frame_num_1_0", "=", "0", "max_con_frame_num_0_6", "=", "0", "max_con_frame_num_0_3", "=", "0", "tem_con_frame_num_1_0", "=", "0", "tem_con_frame_num_0_6", "=", "0", "tem_con_frame_num_0_3", "=", "0", "for", "d", "in", "data", ":", "if", "(", "d", ">", "0.3", ")", ":", "tem_con_frame_num_0_3", "+=", "1", "if", "(", "d", ">", "0.6", ")", ":", "tem_con_frame_num_0_6", "+=", "1", "if", "(", "d", ">", "1.0", ")", ":", "tem_con_frame_num_1_0", "+=", "1", "else", ":", "if", "tem_con_frame_num_1_0", ">", "max_con_frame_num_1_0", ":", "max_con_frame_num_1_0", "=", "tem_con_frame_num_1_0", "tem_con_frame_num_1_0", "=", "0", "else", ":", "if", "tem_con_frame_num_0_6", ">", "max_con_frame_num_0_6", ":", "max_con_frame_num_0_6", "=", "tem_con_frame_num_0_6", "tem_con_frame_num_0_6", "=", "0", "else", ":", "if", "tem_con_frame_num_0_3", ">", "max_con_frame_num_0_3", ":", "max_con_frame_num_0_3", "=", "tem_con_frame_num_0_3", "tem_con_frame_num_0_3", "=", "0", "stat", "=", "[", "max_con_frame_num_1_0", ",", "max_con_frame_num_0_6", ",", "max_con_frame_num_0_3", "]", "return", "stat" ]

[ "download", "aligns" ]

[ "def", "download_align", "(", "from_idx", ",", "to_idx", ",", "_params", ")", ":", "succ", "=", "set", "(", ")", "fail", "=", "set", "(", ")", "for", "idx", "in", "range", "(", "from_idx", ",", "to_idx", ")", ":", "name", "=", "'s'", "+", "str", "(", "idx", ")", "if", "idx", "==", "0", ":", "continue", "script", "=", "\"http://spandh.dcs.shef.ac.uk/gridcorpus/{nm}/align/{nm}.tar\"", ".", "format", "(", "nm", "=", "name", ")", "down_sc", "=", "'cd {align_path} && wget {script} && \\\n tar -xvf {nm}.tar'", ".", "format", "(", "script", "=", "script", ",", "nm", "=", "name", ",", "align_path", "=", "_params", "[", "'align_path'", "]", ")", "try", ":", "print", "(", "down_sc", ")", "os", ".", "system", "(", "down_sc", ")", "succ", ".", "add", "(", "idx", ")", "except", "OSError", "as", "error", ":", "print", "(", "error", ")", "fail", ".", "add", "(", "idx", ")", "return", "(", "succ", ",", "fail", ")" ]

[ "Return", "the", "value", "of", "the", "center", "in", "the", "slice", "dimension", "for", "the", "peak", "at", "the", "given", "index", ":", "param", "selected_index", ":", "Index", "of", "a", "peak", "in", "the", "table", ":", "param", "slice_info", ":", "Information", "on", "the", "current", "slice" ]

[ "def", "slicepoint", "(", "self", ",", "selected_index", ",", "slice_info", ",", "frame", ")", ":", "frame_to_slice_fn", "=", "self", ".", "_frame_to_slice_fn", "(", "frame", ")", "peak", "=", "self", ".", "ws", ".", "getPeak", "(", "selected_index", ")", "slicepoint", "=", "slice_info", ".", "slicepoint", "slicepoint", "[", "slice_info", ".", "z_index", "]", "=", "getattr", "(", "peak", ",", "frame_to_slice_fn", ")", "(", ")", "[", "slice_info", ".", "z_index", "]", "return", "slicepoint" ]

[ "Read", "a", "file", "." ]

[ "def", "read_file", "(", "path", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "path", ")", ":", "with", "open", "(", "path", ",", "'r'", ",", "encoding", "=", "'utf-8'", ")", "as", "fp", ":", "return", "fp", ".", "read", "(", ")", "else", ":", "raise", "Exception", "(", "\"Path does not exist: %s\"", "%", "(", "path", ")", ")" ]

[ "Unset", "the", "given", "string", "flag", "(", "s", ")", "without", "changing", "others", "." ]

[ "def", "remove_flag", "(", "self", ",", "flag", ")", ":", "if", "self", ".", "get_flags", "(", ")", "!=", "''", ":", "self", ".", "set_flags", "(", "''", ".", "join", "(", "set", "(", "self", ".", "get_flags", "(", ")", ")", "-", "set", "(", "flag", ")", ")", ")" ]

[ "Stops", "the", "server", "and", "cleans", "up", "auto", "generated", "resources", "(", "e", ".", "g", ".", "data", "dir", ")" ]

[ "def", "stop", "(", "self", ")", "->", "None", ":", "log", ".", "info", "(", "\"EtcdServer stop method called\"", ")", "stop_etcd", "(", "self", ".", "_etcd_proc", ",", "self", ".", "_base_data_dir", ")" ]

[ "Perform", "batch", "prediction", "with", "a", "2D", "sparse", "data", "matrix", ".", "Worker", "threads", "will", "internally", "divide", "up", "work", "for", "batch", "prediction", ".", "**", "Note", "that", "this", "function", "may", "be", "called", "by", "only", "one", "thread", "at", "a", "time", ".", "**" ]

[ "def", "predict", "(", "self", ",", "dmat", ",", "verbose", "=", "False", ",", "pred_margin", "=", "False", ")", ":", "if", "not", "isinstance", "(", "dmat", ",", "DMatrix", ")", ":", "raise", "TreeliteRuntimeError", "(", "'dmat must be of type DMatrix'", ")", "result_size", "=", "ctypes", ".", "c_size_t", "(", ")", "_check_call", "(", "_LIB", ".", "TreelitePredictorQueryResultSize", "(", "self", ".", "handle", ",", "dmat", ".", "handle", ",", "ctypes", ".", "byref", "(", "result_size", ")", ")", ")", "result_type", "=", "ctypes", ".", "c_char_p", "(", ")", "_check_call", "(", "_LIB", ".", "TreelitePredictorQueryLeafOutputType", "(", "self", ".", "handle", ",", "ctypes", ".", "byref", "(", "result_type", ")", ")", ")", "result_type", "=", "py_str", "(", "result_type", ".", "value", ")", "out_result", "=", "np", ".", "zeros", "(", "result_size", ".", "value", ",", "dtype", "=", "type_info_to_numpy_type", "(", "result_type", ")", ",", "order", "=", "'C'", ")", "out_result_size", "=", "ctypes", ".", "c_size_t", "(", ")", "_check_call", "(", "_LIB", ".", "TreelitePredictorPredictBatch", "(", "self", ".", "handle", ",", "dmat", ".", "handle", ",", "ctypes", ".", "c_int", "(", "1", "if", "verbose", "else", "0", ")", ",", "ctypes", ".", "c_int", "(", "1", "if", "pred_margin", "else", "0", ")", ",", "out_result", ".", "ctypes", ".", "data_as", "(", "ctypes", ".", "POINTER", "(", "type_info_to_ctypes_type", "(", "result_type", ")", ")", ")", ",", "ctypes", ".", "byref", "(", "out_result_size", ")", ")", ")", "idx", "=", "int", "(", "out_result_size", ".", "value", ")", "res", "=", "out_result", "[", "0", ":", "idx", "]", ".", "reshape", "(", "(", "dmat", ".", "shape", "[", "0", "]", ",", "-", "1", ")", ")", ".", "squeeze", "(", ")", "if", "self", ".", "num_class_", ">", "1", "and", "dmat", ".", "shape", "[", "0", "]", "!=", "idx", ":", "res", "=", "res", ".", "reshape", "(", "(", "-", "1", ",", "self", ".", "num_class_", ")", ")", "return", "res" ]

[ "GetNumBreakpointLocationsFromEvent", "(", "SBEvent", "event_sp", ")", "-", ">", "uint32_t" ]

[ "def", "GetNumBreakpointLocationsFromEvent", "(", "*", "args", ")", ":", "return", "_lldb", ".", "SBBreakpoint_GetNumBreakpointLocationsFromEvent", "(", "*", "args", ")" ]

[ "Find", "position", "at", "the", "matching", "startchar", "." ]

[ "def", "FindStartOfExpressionInLine", "(", "line", ",", "endpos", ",", "depth", ",", "startchar", ",", "endchar", ")", ":", "for", "i", "in", "xrange", "(", "endpos", ",", "-", "1", ",", "-", "1", ")", ":", "if", "line", "[", "i", "]", "==", "endchar", ":", "depth", "+=", "1", "elif", "line", "[", "i", "]", "==", "startchar", ":", "depth", "-=", "1", "if", "depth", "==", "0", ":", "return", "(", "i", ",", "0", ")", "return", "(", "-", "1", ",", "depth", ")" ]

[ "Allocate", "a", "process", "Id", "." ]

[ "def", "_alloc_pid", "(", "self", ")", ":", "pid", "=", "self", ".", "_next_pid", "self", ".", "_next_pid", "+=", "1", "return", "pid" ]

[ "Creates", "a", "reader", "to", "read", "the", "give", "file", "if", "possible", ".", "This", "uses", "extension", "matching", "to", "determine", "the", "best", "reader", "possible", ".", "If", "a", "reader", "cannot", "be", "identified", "then", "this", "returns", "None", "." ]

[ "def", "OpenDataFile", "(", "filename", ",", "*", "*", "extraArgs", ")", ":", "session", "=", "servermanager", ".", "ActiveConnection", ".", "Session", "reader_factor", "=", "servermanager", ".", "vtkSMProxyManager", ".", "GetProxyManager", "(", ")", ".", "GetReaderFactory", "(", ")", "if", "reader_factor", ".", "GetNumberOfRegisteredPrototypes", "(", ")", "==", "0", ":", "reader_factor", ".", "UpdateAvailableReaders", "(", ")", "first_file", "=", "filename", "if", "type", "(", "filename", ")", "==", "list", ":", "first_file", "=", "filename", "[", "0", "]", "if", "not", "reader_factor", ".", "TestFileReadability", "(", "first_file", ",", "session", ")", ":", "msg", "=", "\"File not readable: %s \"", "%", "first_file", "raise", "RuntimeError", "(", "msg", ")", "if", "not", "reader_factor", ".", "CanReadFile", "(", "first_file", ",", "session", ")", ":", "msg", "=", "\"File not readable. No reader found for '%s' \"", "%", "first_file", "raise", "RuntimeError", "(", "msg", ")", "prototype", "=", "servermanager", ".", "ProxyManager", "(", ")", ".", "GetPrototypeProxy", "(", "reader_factor", ".", "GetReaderGroup", "(", ")", ",", "reader_factor", ".", "GetReaderName", "(", ")", ")", "xml_name", "=", "paraview", ".", "make_name_valid", "(", "prototype", ".", "GetXMLLabel", "(", ")", ")", "reader_func", "=", "_create_func", "(", "xml_name", ",", "servermanager", ".", "sources", ")", "pname", "=", "servermanager", ".", "vtkSMCoreUtilities", ".", "GetFileNameProperty", "(", "prototype", ")", "if", "pname", ":", "extraArgs", "[", "pname", "]", "=", "filename", "reader", "=", "reader_func", "(", "*", "*", "extraArgs", ")", "return", "reader" ]

[ "Create", "an", "op", "that", "places", "a", "value", "into", "the", "staging", "area", "." ]

[ "def", "put", "(", "self", ",", "values", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"%s_put\"", "%", "self", ".", "_name", ",", "self", ".", "_scope_vals", "(", "values", ")", ")", "as", "scope", ":", "if", "not", "isinstance", "(", "values", ",", "(", "list", ",", "tuple", ",", "dict", ")", ")", ":", "values", "=", "[", "values", "]", "# Hard-code indices for this staging area", "indices", "=", "list", "(", "six", ".", "moves", ".", "range", "(", "len", "(", "values", ")", ")", ")", "vals", ",", "_", "=", "self", ".", "_check_put_dtypes", "(", "values", ",", "indices", ")", "with", "ops", ".", "colocate_with", "(", "self", ".", "_coloc_op", ")", ":", "op", "=", "gen_data_flow_ops", ".", "stage", "(", "values", "=", "vals", ",", "shared_name", "=", "self", ".", "_name", ",", "name", "=", "scope", ",", "capacity", "=", "self", ".", "_capacity", ",", "memory_limit", "=", "self", ".", "_memory_limit", ")", "return", "op" ]

[ "Gets", "the", "tab", "border", "colour", "." ]

[ "def", "GetGradientColourBorder", "(", "self", ")", ":", "return", "self", ".", "_pages", ".", "_colorBorder" ]

[ "Return", "a", "context", "manager", "that", "makes", "this", "input", "active", "in", "the", "current", "event", "loop", "." ]

[ "def", "attach", "(", "self", ",", "input_ready_callback", ":", "Callable", "[", "[", "]", ",", "None", "]", ")", "->", "ContextManager", "[", "None", "]", ":", "return", "attach_win32_input", "(", "self", ",", "input_ready_callback", ")" ]

[ "Returns", "the", "truth", "value", "of", "(", "x", "!", "=", "y", ")", "element", "-", "wise", "." ]

[ "def", "not_equal", "(", "x", ",", "y", ",", "name", "=", "None", ")", ":", "return", "gen_math_ops", ".", "not_equal", "(", "x", ",", "y", ",", "name", "=", "name", ")" ]

[ "Add", "submodule", "into", "vendor" ]

[ "def", "add_submodules", "(", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "f\"vendor/morgan\"", ")", ":", "prnt_run", "(", "\"Use git to add the submodules\"", ")", "execute_shell", "(", "\"git submodule add https://github.com/luhuimao/morgan.git\"", ",", "silent", "=", "False", ",", "cwd", "=", "\"vendor\"", ")" ]

[ "Create", "a", "cell", "with", "output", "projection", "." ]

[ "def", "__init__", "(", "self", ",", "cell", ",", "output_size", ")", ":", "if", "not", "isinstance", "(", "cell", ",", "RNNCell", ")", ":", "raise", "TypeError", "(", "\"The parameter cell is not RNNCell.\"", ")", "if", "output_size", "<", "1", ":", "raise", "ValueError", "(", "\"Parameter output_size must be > 0: %d.\"", "%", "output_size", ")", "self", ".", "_cell", "=", "cell", "self", ".", "_output_size", "=", "output_size" ]

[ "Convert", "codec", "template", "mapping", "to", "byte", "order" ]

[ "def", "_convert_codecs", "(", "template", ",", "byte_order", ")", ":", "codecs", "=", "{", "}", "postfix", "=", "byte_order", "==", "'<'", "and", "'_le'", "or", "'_be'", "for", "k", ",", "v", "in", "template", ".", "items", "(", ")", ":", "codec", "=", "v", "[", "'codec'", "]", "try", ":", "\" \"", ".", "encode", "(", "codec", ")", "except", "LookupError", ":", "codecs", "[", "k", "]", "=", "None", "continue", "if", "v", "[", "'width'", "]", ">", "1", ":", "codec", "+=", "postfix", "codecs", "[", "k", "]", "=", "codec", "return", "codecs", ".", "copy", "(", ")" ]

[ "OffsetAddress", "(", "SBAddress", "self", "lldb", "::", "addr_t", "offset", ")", "-", ">", "bool" ]

[ "def", "OffsetAddress", "(", "self", ",", "offset", ")", ":", "return", "_lldb", ".", "SBAddress_OffsetAddress", "(", "self", ",", "offset", ")" ]

[ "Install", "an", "exception", "handler", "that", "formats", "tracebacks", "as", "HTML", "." ]

[ "def", "enable", "(", "display", "=", "1", ",", "logdir", "=", "None", ",", "context", "=", "5", ",", "format", "=", "\"html\"", ")", ":", "sys", ".", "excepthook", "=", "Hook", "(", "display", "=", "display", ",", "logdir", "=", "logdir", ",", "context", "=", "context", ",", "format", "=", "format", ")" ]

[ "return", "confidence", "based", "on", "existing", "data" ]

[ "def", "get_confidence", "(", "self", ")", ":", "# if we didn't receive any character in our consideration range,", "# return negative answer", "if", "self", ".", "_mTotalChars", "<=", "0", "or", "self", ".", "_mFreqChars", "<=", "MINIMUM_DATA_THRESHOLD", ":", "return", "SURE_NO", "if", "self", ".", "_mTotalChars", "!=", "self", ".", "_mFreqChars", ":", "r", "=", "(", "self", ".", "_mFreqChars", "/", "(", "(", "self", ".", "_mTotalChars", "-", "self", ".", "_mFreqChars", ")", "*", "self", ".", "_mTypicalDistributionRatio", ")", ")", "if", "r", "<", "SURE_YES", ":", "return", "r", "# normalize confidence (we don't want to be 100% sure)", "return", "SURE_YES" ]

[ "GetHeaderColourFg", "(", "self", ")", "-", ">", "Colour" ]

[ "def", "GetHeaderColourFg", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_calendar", ".", "CalendarCtrlBase_GetHeaderColourFg", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "WebPDecodeRGB", "(", "uint8_t", "data", ")", "-", ">", "(", "rgb", "width", "height", ")" ]

[ "def", "WebPDecodeRGB", "(", "*", "args", ")", ":", "return", "_libwebp", ".", "WebPDecodeRGB", "(", "*", "args", ")" ]

[ "Obtain", "the", "Bazel", "dependencies", "for", "the", "import", "paths", "from", "a", ".", "proto", "file", "." ]

[ "def", "GetImportDeps", "(", "proto_path", ")", ":", "imports", "=", "[", "]", "with", "open", "(", "proto_path", ",", "'r'", ",", "encoding", "=", "'utf8'", ")", "as", "f", ":", "for", "line", "in", "f", ":", "match", "=", "re", ".", "match", "(", "IMPORT_REGEX", ",", "line", ")", "if", "match", ":", "import_path", "=", "match", ".", "group", "(", "1", ")", "# We can ignore imports provided implicitly by api_proto_package().", "if", "any", "(", "import_path", ".", "startswith", "(", "p", ")", "for", "p", "in", "API_BUILD_SYSTEM_IMPORT_PREFIXES", ")", ":", "continue", "# Special case handling for UDPA annotations.", "if", "import_path", ".", "startswith", "(", "'udpa/annotations/'", ")", ":", "imports", ".", "append", "(", "'@com_github_cncf_udpa//udpa/annotations:pkg'", ")", "continue", "# Special case handling for UDPA core.", "if", "import_path", ".", "startswith", "(", "'udpa/core/v1/'", ")", ":", "imports", ".", "append", "(", "'@com_github_cncf_udpa//udpa/core/v1:pkg'", ")", "continue", "# Explicit remapping for external deps, compute paths for envoy/*.", "if", "import_path", "in", "external_proto_deps", ".", "EXTERNAL_PROTO_IMPORT_BAZEL_DEP_MAP", ":", "imports", ".", "append", "(", "external_proto_deps", ".", "EXTERNAL_PROTO_IMPORT_BAZEL_DEP_MAP", "[", "import_path", "]", ")", "continue", "if", "import_path", ".", "startswith", "(", "'envoy/'", ")", ":", "# Ignore package internal imports.", "if", "os", ".", "path", ".", "dirname", "(", "proto_path", ")", ".", "endswith", "(", "os", ".", "path", ".", "dirname", "(", "import_path", ")", ")", ":", "continue", "imports", ".", "append", "(", "'//%s:pkg'", "%", "os", ".", "path", ".", "dirname", "(", "import_path", ")", ")", "continue", "raise", "ProtoSyncError", "(", "'Unknown import path mapping for %s, please update the mappings in tools/proto_format/proto_sync.py.\\n'", "%", "import_path", ")", "return", "imports" ]

[ "Implementation", "of", "getitem", "." ]

[ "def", "getitem", "(", "data", ",", "index", ")", ":", "return", "data", ".", "__getitem__", "(", "index", ")" ]

[ "Return", "a", "formatted", "month", "as", "a", "table", "." ]

[ "def", "formatmonth", "(", "self", ",", "theyear", ",", "themonth", ",", "withyear", "=", "True", ")", ":", "v", "=", "[", "]", "a", "=", "v", ".", "append", "a", "(", "'<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" class=\"month\">'", ")", "a", "(", "'\\n'", ")", "a", "(", "self", ".", "formatmonthname", "(", "theyear", ",", "themonth", ",", "withyear", "=", "withyear", ")", ")", "a", "(", "'\\n'", ")", "a", "(", "self", ".", "formatweekheader", "(", ")", ")", "a", "(", "'\\n'", ")", "for", "week", "in", "self", ".", "monthdays2calendar", "(", "theyear", ",", "themonth", ")", ":", "a", "(", "self", ".", "formatweek", "(", "week", ")", ")", "a", "(", "'\\n'", ")", "a", "(", "'</table>'", ")", "a", "(", "'\\n'", ")", "return", "''", ".", "join", "(", "v", ")" ]

[ "Patch", "func_name", "in", "target_mod", "with", "replacement" ]

[ "def", "patch_func", "(", "replacement", ",", "target_mod", ",", "func_name", ")", ":", "original", "=", "getattr", "(", "target_mod", ",", "func_name", ")", "# set the 'unpatched' attribute on the replacement to", "# point to the original.", "vars", "(", "replacement", ")", ".", "setdefault", "(", "'unpatched'", ",", "original", ")", "# replace the function in the original module", "setattr", "(", "target_mod", ",", "func_name", ",", "replacement", ")" ]

[ "Constructor" ]

[ "def", "__init__", "(", "self", ",", "carla_actor", ",", "parent", ",", "communication", ",", "vehicle_control_applied_callback", ")", ":", "super", "(", "EgoVehicle", ",", "self", ")", ".", "__init__", "(", "carla_actor", "=", "carla_actor", ",", "parent", "=", "parent", ",", "communication", "=", "communication", ",", "prefix", "=", "carla_actor", ".", "attributes", ".", "get", "(", "'role_name'", ")", ")", "self", ".", "vehicle_info_published", "=", "False", "self", ".", "vehicle_control_override", "=", "False", "self", ".", "_vehicle_control_applied_callback", "=", "vehicle_control_applied_callback", "self", ".", "control_subscriber", "=", "rospy", ".", "Subscriber", "(", "self", ".", "get_topic_prefix", "(", ")", "+", "\"/vehicle_control_cmd\"", ",", "CarlaEgoVehicleControl", ",", "lambda", "data", ":", "self", ".", "control_command_updated", "(", "data", ",", "manual_override", "=", "False", ")", ")", "self", ".", "manual_control_subscriber", "=", "rospy", ".", "Subscriber", "(", "self", ".", "get_topic_prefix", "(", ")", "+", "\"/vehicle_control_cmd_manual\"", ",", "CarlaEgoVehicleControl", ",", "lambda", "data", ":", "self", ".", "control_command_updated", "(", "data", ",", "manual_override", "=", "True", ")", ")", "self", ".", "control_override_subscriber", "=", "rospy", ".", "Subscriber", "(", "self", ".", "get_topic_prefix", "(", ")", "+", "\"/vehicle_control_manual_override\"", ",", "Bool", ",", "self", ".", "control_command_override", ")", "self", ".", "enable_autopilot_subscriber", "=", "rospy", ".", "Subscriber", "(", "self", ".", "get_topic_prefix", "(", ")", "+", "\"/enable_autopilot\"", ",", "Bool", ",", "self", ".", "enable_autopilot_updated", ")", "self", ".", "twist_control_subscriber", "=", "rospy", ".", "Subscriber", "(", "self", ".", "get_topic_prefix", "(", ")", "+", "\"/twist_cmd\"", ",", "Twist", ",", "self", ".", "twist_command_updated", ")" ]

[ "Remove", "any", "solution", "hint", "from", "the", "model", "." ]

[ "def", "ClearHints", "(", "self", ")", ":", "self", ".", "__model", ".", "ClearField", "(", "'solution_hint'", ")" ]

[ "Take", "a", "line", "of", "text", "and", "process", "it", "for", "a", "warning", "." ]

[ "def", "process_line", "(", "self", ",", "line", ")", ":", "filtered", "=", "RE_STRIP_COLORS", ".", "sub", "(", "''", ",", "line", ")", "# Clang warnings in files included from the one(s) being compiled will", "# start with \"In file included from /path/to/file:line:\". Here, we", "# record those.", "if", "filtered", ".", "startswith", "(", "IN_FILE_INCLUDED_FROM", ")", ":", "included_from", "=", "filtered", "[", "len", "(", "IN_FILE_INCLUDED_FROM", ")", ":", "]", "parts", "=", "included_from", ".", "split", "(", "':'", ")", "self", ".", "included_from", ".", "append", "(", "parts", "[", "0", "]", ")", "return", "warning", "=", "CompilerWarning", "(", ")", "filename", "=", "None", "# TODO make more efficient so we run minimal regexp matches.", "match_clang", "=", "RE_CLANG_WARNING", ".", "match", "(", "filtered", ")", "match_msvc", "=", "RE_MSVC_WARNING", ".", "match", "(", "filtered", ")", "if", "match_clang", ":", "d", "=", "match_clang", ".", "groupdict", "(", ")", "filename", "=", "d", "[", "'file'", "]", "warning", "[", "'line'", "]", "=", "int", "(", "d", "[", "'line'", "]", ")", "warning", "[", "'column'", "]", "=", "int", "(", "d", "[", "'column'", "]", ")", "warning", "[", "'flag'", "]", "=", "d", "[", "'flag'", "]", "warning", "[", "'message'", "]", "=", "d", "[", "'message'", "]", ".", "rstrip", "(", ")", "elif", "match_msvc", ":", "d", "=", "match_msvc", ".", "groupdict", "(", ")", "filename", "=", "d", "[", "'file'", "]", "warning", "[", "'line'", "]", "=", "int", "(", "d", "[", "'line'", "]", ")", "warning", "[", "'flag'", "]", "=", "d", "[", "'flag'", "]", "warning", "[", "'message'", "]", "=", "d", "[", "'message'", "]", ".", "rstrip", "(", ")", "else", ":", "self", ".", "included_from", "=", "[", "]", "return", "None", "filename", "=", "os", ".", "path", ".", "normpath", "(", "filename", ")", "# Sometimes we get relative includes. These typically point to files in", "# the object directory. We try to resolve the relative path.", "if", "not", "os", ".", "path", ".", "isabs", "(", "filename", ")", ":", "filename", "=", "self", ".", "_normalize_relative_path", "(", "filename", ")", "if", "not", "os", ".", "path", ".", "exists", "(", "filename", ")", "and", "self", ".", "resolve_files", ":", "raise", "Exception", "(", "'Could not find file containing warning: %s'", "%", "filename", ")", "warning", "[", "'filename'", "]", "=", "filename", "self", ".", "database", ".", "insert", "(", "warning", ",", "compute_hash", "=", "self", ".", "resolve_files", ")", "return", "warning" ]

[ "InTopK", "TBE", "register" ]

[ "def", "_in_top_k_tbe", "(", ")", ":", "return" ]

[ "Arguments", "are", "as", "described", "in", "the", "attribute", "description", "above", "." ]

[ "def", "__init__", "(", "self", ",", "name", ",", "full_name", ",", "filename", ",", "values", ",", "containing_type", "=", "None", ",", "options", "=", "None", ",", "serialized_options", "=", "None", ",", "file", "=", "None", ",", "# pylint: disable=redefined-builtin", "serialized_start", "=", "None", ",", "serialized_end", "=", "None", ",", "create_key", "=", "None", ")", ":", "if", "create_key", "is", "not", "_internal_create_key", ":", "_Deprecated", "(", "'EnumDescriptor'", ")", "super", "(", "EnumDescriptor", ",", "self", ")", ".", "__init__", "(", "options", ",", "'EnumOptions'", ",", "name", ",", "full_name", ",", "file", ",", "containing_type", ",", "serialized_start", "=", "serialized_start", ",", "serialized_end", "=", "serialized_end", ",", "serialized_options", "=", "serialized_options", ")", "self", ".", "values", "=", "values", "for", "value", "in", "self", ".", "values", ":", "value", ".", "type", "=", "self", "self", ".", "values_by_name", "=", "dict", "(", "(", "v", ".", "name", ",", "v", ")", "for", "v", "in", "values", ")", "# Values are reversed to ensure that the first alias is retained.", "self", ".", "values_by_number", "=", "dict", "(", "(", "v", ".", "number", ",", "v", ")", "for", "v", "in", "reversed", "(", "values", ")", ")" ]

[ "Add", "files", "with", "the", "given", "pattern", "in", "the", "given", "component", "." ]

[ "def", "add", "(", "self", ",", "component", ",", "pattern", ")", ":", "assert", "not", "self", ".", "_closed", "added", "=", "False", "for", "p", ",", "f", "in", "self", ".", "_finder", ".", "find", "(", "pattern", ")", ":", "added", "=", "True", "if", "is_manifest", "(", "p", ")", ":", "self", ".", "_manifests", ".", "add", "(", "p", ")", "dest", "=", "mozpath", ".", "join", "(", "component", ".", "destdir", ",", "SimpleManifestSink", ".", "normalize_path", "(", "p", ")", ")", "self", ".", "packager", ".", "add", "(", "dest", ",", "f", ")", "if", "not", "added", ":", "errors", ".", "error", "(", "'Missing file(s): %s'", "%", "pattern", ")" ]

[ "Convert", "an", "arbitrary", "string", "to", "a", "standard", "distribution", "name" ]

[ "def", "safe_name", "(", "name", ")", ":", "return", "re", ".", "sub", "(", "'[^A-Za-z0-9.]+'", ",", "'-'", ",", "name", ")" ]

[ "A", "convenience", "method", "to", "get", "a", "string", "that", "contains", "the", ":", "const", ":", "CERT_ORGANIZATION_UNIT", "sub", "field", "of", "the", "subject", "field", "in", "the", "ssl", "certificate", "." ]

[ "def", "get_cert_organization_unit", "(", "self", ")", "->", "str", ":", "return", "self", ".", "get_cert_subject_subfield", "(", "SSL", ".", "CERT_ORGANIZATION_UNIT", ")" ]

[ "Assert", "the", "condition", "x", "<", "y", "holds", "element", "-", "wise", "." ]

[ "def", "assert_less", "(", "x", ",", "y", ",", "data", "=", "None", ",", "summarize", "=", "None", ",", "message", "=", "None", ",", "name", "=", "None", ")", ":", "message", "=", "message", "or", "''", "with", "ops", ".", "op_scope", "(", "[", "x", ",", "y", ",", "data", "]", ",", "name", ",", "'assert_less'", ")", ":", "x", "=", "ops", ".", "convert_to_tensor", "(", "x", ",", "name", "=", "'x'", ")", "y", "=", "ops", ".", "convert_to_tensor", "(", "y", ",", "name", "=", "'y'", ")", "if", "data", "is", "None", ":", "data", "=", "[", "message", ",", "'Condition x < y did not hold element-wise: x = '", ",", "x", ".", "name", ",", "x", ",", "'y = '", ",", "y", ".", "name", ",", "y", "]", "condition", "=", "math_ops", ".", "reduce_all", "(", "math_ops", ".", "less", "(", "x", ",", "y", ")", ")", "return", "logging_ops", ".", "Assert", "(", "condition", ",", "data", ",", "summarize", "=", "summarize", ")" ]

[ "part", "of", "public", "interface" ]

[ "def", "set_language_standard", "(", "self", ",", "standard", ")", ":", "self", ".", "c_flags", ".", "append", "(", "'-std='", "+", "standard", ")" ]

[ "!", "Get", "selected", "function", "." ]

[ "def", "_get_selected", "(", "self", ")", ":", "return", "self", ".", "_selected" ]

[ "Arrange", "for", "all", "signatures", "to", "be", "stored", "in", "a", "global", ".", "sconsign", ".", "db", "*", "file", "." ]

[ "def", "File", "(", "name", ",", "dbm_module", "=", "None", ")", ":", "global", "ForDirectory", ",", "DB_Name", ",", "DB_Module", "if", "name", "is", "None", ":", "ForDirectory", "=", "DirFile", "DB_Module", "=", "None", "else", ":", "ForDirectory", "=", "DB", "DB_Name", "=", "name", "if", "not", "dbm_module", "is", "None", ":", "DB_Module", "=", "dbm_module" ]

[ "Outputs", "deterministic", "pseudorandom", "values", "from", "a", "normal", "distribution", "." ]

[ "def", "stateless_random_normal", "(", "shape", ",", "seed", ",", "mean", "=", "0.0", ",", "stddev", "=", "1.0", ",", "dtype", "=", "dtypes", ".", "float32", ",", "name", "=", "None", ",", "alg", "=", "\"auto_select\"", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "\"stateless_random_normal\"", ",", "[", "shape", ",", "seed", ",", "mean", ",", "stddev", "]", ")", "as", "name", ":", "shape", "=", "tensor_util", ".", "shape_tensor", "(", "shape", ")", "mean", "=", "ops", ".", "convert_to_tensor", "(", "mean", ",", "dtype", "=", "dtype", ",", "name", "=", "\"mean\"", ")", "stddev", "=", "ops", ".", "convert_to_tensor", "(", "stddev", ",", "dtype", "=", "dtype", ",", "name", "=", "\"stddev\"", ")", "key", ",", "counter", ",", "alg", "=", "_get_key_counter_alg", "(", "seed", ",", "alg", ")", "rnd", "=", "gen_stateless_random_ops_v2", ".", "stateless_random_normal_v2", "(", "shape", ",", "key", "=", "key", ",", "counter", "=", "counter", ",", "dtype", "=", "dtype", ",", "alg", "=", "alg", ")", "result", "=", "math_ops", ".", "add", "(", "rnd", "*", "stddev", ",", "mean", ",", "name", "=", "name", ")", "tensor_util", ".", "maybe_set_static_shape", "(", "result", ",", "shape", ")", "return", "result" ]

[ "Returns", "the", "parse", "results", "as", "a", "nested", "list", "of", "matching", "tokens", "all", "converted", "to", "strings", "." ]

[ "def", "asList", "(", "self", ")", ":", "return", "[", "res", ".", "asList", "(", ")", "if", "isinstance", "(", "res", ",", "ParseResults", ")", "else", "res", "for", "res", "in", "self", ".", "__toklist", "]" ]

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

[ "def", "GetUrl", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html2", ".", "WebViewHistoryItem_GetUrl", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Creation", "of", "a", "new", "node", "element", "." ]

[ "def", "newNodeEatName", "(", "self", ",", "name", ")", ":", "ret", "=", "libxml2mod", ".", "xmlNewNodeEatName", "(", "self", ".", "_o", ",", "name", ")", "if", "ret", "is", "None", ":", "raise", "treeError", "(", "'xmlNewNodeEatName() failed'", ")", "__tmp", "=", "xmlNode", "(", "_obj", "=", "ret", ")", "return", "__tmp" ]

[ "Returns", "a", "type", "checker", "for", "a", "message", "field", "of", "the", "specified", "types", "." ]

[ "def", "GetTypeChecker", "(", "cpp_type", ",", "field_type", ")", ":", "if", "(", "cpp_type", "==", "_FieldDescriptor", ".", "CPPTYPE_STRING", "and", "field_type", "==", "_FieldDescriptor", ".", "TYPE_STRING", ")", ":", "return", "UnicodeValueChecker", "(", ")", "return", "_VALUE_CHECKERS", "[", "cpp_type", "]" ]

[ "Intermediate", "callback", "to", "wrap", "the", "locator" ]

[ "def", "_xmlTextReaderErrorFunc", "(", "xxx_todo_changeme", ",", "msg", ",", "severity", ",", "locator", ")", ":", "(", "f", ",", "arg", ")", "=", "xxx_todo_changeme", "return", "f", "(", "arg", ",", "msg", ",", "severity", ",", "xmlTextReaderLocator", "(", "locator", ")", ")" ]

[ "Compute", "gradient", "of", "the", "digamma", "function", "with", "respect", "to", "its", "argument", "." ]

[ "def", "_DigammaGrad", "(", "op", ",", "grad", ")", ":", "x", "=", "op", ".", "inputs", "[", "0", "]", "with", "ops", ".", "control_dependencies", "(", "[", "grad", "]", ")", ":", "x", "=", "math_ops", ".", "conj", "(", "x", ")", "partial_x", "=", "math_ops", ".", "polygamma", "(", "array_ops", ".", "constant", "(", "1", ",", "dtype", "=", "x", ".", "dtype", ")", ",", "x", ")", "if", "compat", ".", "forward_compatible", "(", "2019", ",", "9", ",", "14", ")", ":", "return", "math_ops", ".", "mul_no_nan", "(", "partial_x", ",", "grad", ")", "else", ":", "return", "grad", "*", "partial_x" ]

[ "Add", "Builders", "and", "construction", "variables", "for", "as", "to", "an", "Environment", "." ]

[ "def", "generate", "(", "env", ")", ":", "static_obj", ",", "shared_obj", "=", "SCons", ".", "Tool", ".", "createObjBuilders", "(", "env", ")", "for", "suffix", "in", "ASSuffixes", ":", "static_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "ASAction", ")", "shared_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "ASAction", ")", "static_obj", ".", "add_emitter", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "StaticObjectEmitter", ")", "shared_obj", ".", "add_emitter", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "SharedObjectEmitter", ")", "for", "suffix", "in", "ASPPSuffixes", ":", "static_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "ASPPAction", ")", "shared_obj", ".", "add_action", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "ASPPAction", ")", "static_obj", ".", "add_emitter", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "StaticObjectEmitter", ")", "shared_obj", ".", "add_emitter", "(", "suffix", ",", "SCons", ".", "Defaults", ".", "SharedObjectEmitter", ")", "env", "[", "'AS'", "]", "=", "env", ".", "Detect", "(", "assemblers", ")", "or", "'as'", "env", "[", "'ASFLAGS'", "]", "=", "SCons", ".", "Util", ".", "CLVar", "(", "''", ")", "env", "[", "'ASCOM'", "]", "=", "'$AS $ASFLAGS -o $TARGET $SOURCES'", "env", "[", "'ASPPFLAGS'", "]", "=", "'$ASFLAGS'", "env", "[", "'ASPPCOM'", "]", "=", "'$CC $ASPPFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'" ]

[ "Encode", "the", "message", "s", "payload", "in", "quoted", "-", "printable", "." ]

[ "def", "encode_quopri", "(", "msg", ")", ":", "orig", "=", "msg", ".", "get_payload", "(", ")", "encdata", "=", "_qencode", "(", "orig", ")", "msg", ".", "set_payload", "(", "encdata", ")", "msg", "[", "'Content-Transfer-Encoding'", "]", "=", "'quoted-printable'" ]

[ "r", "GetFeature", "(", "Layer", "self", "GIntBig", "fid", ")", "-", ">", "Feature", "OGRFeatureH", "OGR_L_GetFeature", "(", "OGRLayerH", "hLayer", "GIntBig", "nFeatureId", ")" ]

[ "def", "GetFeature", "(", "self", ",", "*", "args", ")", ":", "return", "_ogr", ".", "Layer_GetFeature", "(", "self", ",", "*", "args", ")" ]

[ "Returns", "true", "if", "the", "path", "represents", "a", "git", "checkout", "." ]

[ "def", "is_git_checkout", "(", "path", ")", ":", "return", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "path", ",", "'.git'", ")", ")" ]

[ "Fetches", "authentication", "cookies", "for", "an", "authentication", "token", "." ]

[ "def", "_GetAuthCookie", "(", "self", ",", "auth_token", ")", ":", "# This is a dummy value to allow us to identify when we're successful.", "continue_location", "=", "\"http://localhost/\"", "args", "=", "{", "\"continue\"", ":", "continue_location", ",", "\"auth\"", ":", "auth_token", "}", "req", "=", "self", ".", "_CreateRequest", "(", "\"%s/_ah/login?%s\"", "%", "(", "self", ".", "host", ",", "urllib", ".", "urlencode", "(", "args", ")", ")", ")", "try", ":", "response", "=", "self", ".", "opener", ".", "open", "(", "req", ")", "except", "urllib2", ".", "HTTPError", ",", "e", ":", "response", "=", "e", "if", "(", "response", ".", "code", "!=", "302", "or", "response", ".", "info", "(", ")", "[", "\"location\"", "]", "!=", "continue_location", ")", ":", "raise", "urllib2", ".", "HTTPError", "(", "req", ".", "get_full_url", "(", ")", ",", "response", ".", "code", ",", "response", ".", "msg", ",", "response", ".", "headers", ",", "response", ".", "fp", ")", "self", ".", "authenticated", "=", "True" ]

[ "Check", "to", "see", "whether", "actual_seq", "has", "same", "elements", "as", "expected_seq", "." ]

[ "def", "equals", "(", "self", ",", "actual_seq", ")", ":", "try", ":", "expected", "=", "dict", "(", "[", "(", "element", ",", "None", ")", "for", "element", "in", "self", ".", "_expected_seq", "]", ")", "actual", "=", "dict", "(", "[", "(", "element", ",", "None", ")", "for", "element", "in", "actual_seq", "]", ")", "except", "TypeError", ":", "# Fall back to slower list-compare if any of the objects are unhashable.", "expected", "=", "list", "(", "self", ".", "_expected_seq", ")", "actual", "=", "list", "(", "actual_seq", ")", "expected", ".", "sort", "(", ")", "actual", ".", "sort", "(", ")", "return", "expected", "==", "actual" ]

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

[ "def", "IsToolbar", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiPaneInfo_IsToolbar", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Computes", "the", "Levenshtein", "distance", "between", "sequences", "." ]

[ "def", "edit_distance", "(", "hypothesis", ",", "truth", ",", "normalize", "=", "True", ",", "name", "=", "\"edit_distance\"", ")", ":", "if", "not", "isinstance", "(", "hypothesis", ",", "(", "ops", ".", "SparseTensor", ",", "ops", ".", "SparseTensorValue", ")", ")", ":", "raise", "TypeError", "(", "\"Hypothesis must be a SparseTensor.\"", ")", "if", "not", "isinstance", "(", "truth", ",", "(", "ops", ".", "SparseTensor", ",", "ops", ".", "SparseTensorValue", ")", ")", ":", "raise", "TypeError", "(", "\"Truth must be a SparseTensor.\"", ")", "return", "gen_array_ops", ".", "_edit_distance", "(", "hypothesis", ".", "indices", ",", "hypothesis", ".", "values", ",", "hypothesis", ".", "shape", ",", "truth", ".", "indices", ",", "truth", ".", "values", ",", "truth", ".", "shape", ",", "normalize", "=", "normalize", ",", "name", "=", "name", ")" ]

[ "Starts", "measuring", "time", "and", "prints", "the", "bar", "at", "0%", "." ]

[ "def", "start", "(", "self", ")", ":", "if", "self", ".", "maxval", "is", "None", ":", "self", ".", "maxval", "=", "self", ".", "_DEFAULT_MAXVAL", "self", ".", "num_intervals", "=", "max", "(", "100", ",", "self", ".", "term_width", ")", "self", ".", "next_update", "=", "0", "if", "self", ".", "maxval", "is", "not", "UnknownLength", ":", "if", "self", ".", "maxval", "<", "0", ":", "raise", "ValueError", "(", "'Value out of range'", ")", "self", ".", "update_interval", "=", "self", ".", "maxval", "/", "self", ".", "num_intervals", "self", ".", "start_time", "=", "self", ".", "last_update_time", "=", "time", ".", "time", "(", ")", "self", ".", "update", "(", "0", ")", "return", "self" ]

[ "Construct", "a", "Toeplitz", "matrix", "." ]

[ "def", "toeplitz", "(", "c", ",", "r", "=", "None", ")", ":", "c", "=", "np", ".", "asarray", "(", "c", ")", ".", "ravel", "(", ")", "if", "r", "is", "None", ":", "r", "=", "c", ".", "conjugate", "(", ")", "else", ":", "r", "=", "np", ".", "asarray", "(", "r", ")", ".", "ravel", "(", ")", "# Form a 1D array containing a reversed c followed by r[1:] that could be", "# strided to give us toeplitz matrix.", "vals", "=", "np", ".", "concatenate", "(", "(", "c", "[", ":", ":", "-", "1", "]", ",", "r", "[", "1", ":", "]", ")", ")", "out_shp", "=", "len", "(", "c", ")", ",", "len", "(", "r", ")", "n", "=", "vals", ".", "strides", "[", "0", "]", "return", "as_strided", "(", "vals", "[", "len", "(", "c", ")", "-", "1", ":", "]", ",", "shape", "=", "out_shp", ",", "strides", "=", "(", "-", "n", ",", "n", ")", ")", ".", "copy", "(", ")" ]

[ "Called", "when", "the", "other", "end", "calls", "write_eof", "()", "or", "equivalent", "." ]

[ "def", "eof_received", "(", "self", ")", ":" ]

[ "Callback", "function", "to", "produce", "point", "cloud", "registered", "with", "semantic", "class", "color", "based", "on", "input", "color", "image", "and", "depth", "image", "\\", "param", "color_img_ros", "(", "sensor_msgs", ".", "Image", ")", "the", "input", "color", "image", "(", "bgr8", ")", "\\", "param", "depth_img_ros", "(", "sensor_msgs", ".", "Image", ")", "the", "input", "depth", "image", "(", "registered", "to", "the", "color", "image", "frame", ")", "(", "float32", ")", "values", "are", "in", "meters" ]

[ "def", "color_depth_callback", "(", "self", ",", "color_img_ros", ",", "depth_img_ros", ")", ":", "# Convert ros Image message to numpy array", "try", ":", "color_img", "=", "self", ".", "bridge", ".", "imgmsg_to_cv2", "(", "color_img_ros", ",", "\"bgr8\"", ")", "depth_img", "=", "self", ".", "bridge", ".", "imgmsg_to_cv2", "(", "depth_img_ros", ",", "\"32FC1\"", ")", "except", "CvBridgeError", "as", "e", ":", "print", "(", "e", ")", "# Resize depth", "if", "depth_img", ".", "shape", "[", "0", "]", "is", "not", "self", ".", "img_height", "or", "depth_img", ".", "shape", "[", "1", "]", "is", "not", "self", ".", "img_width", ":", "depth_img", "=", "resize", "(", "depth_img", ",", "(", "self", ".", "img_height", ",", "self", ".", "img_width", ")", ",", "order", "=", "0", ",", "mode", "=", "'reflect'", ",", "anti_aliasing", "=", "False", ",", "preserve_range", "=", "True", ")", "# order = 0, nearest neighbour", "depth_img", "=", "depth_img", ".", "astype", "(", "np", ".", "float32", ")", "if", "self", ".", "point_type", "is", "PointType", ".", "COLOR", ":", "cloud_ros", "=", "self", ".", "cloud_generator", ".", "generate_cloud_color", "(", "color_img", ",", "depth_img", ",", "color_img_ros", ".", "header", ".", "stamp", ")", "else", ":", "# Do semantic segmantation", "if", "self", ".", "point_type", "is", "PointType", ".", "SEMANTICS_MAX", ":", "semantic_color", ",", "pred_confidence", "=", "self", ".", "predict_max", "(", "color_img", ")", "cloud_ros", "=", "self", ".", "cloud_generator", ".", "generate_cloud_semantic_max", "(", "color_img", ",", "depth_img", ",", "semantic_color", ",", "pred_confidence", ",", "color_img_ros", ".", "header", ".", "stamp", ")", "elif", "self", ".", "point_type", "is", "PointType", ".", "SEMANTICS_BAYESIAN", ":", "self", ".", "predict_bayesian", "(", "color_img", ")", "# Produce point cloud with rgb colors, semantic colors and confidences", "cloud_ros", "=", "self", ".", "cloud_generator", ".", "generate_cloud_semantic_bayesian", "(", "color_img", ",", "depth_img", ",", "self", ".", "semantic_colors", ",", "self", ".", "confidences", ",", "color_img_ros", ".", "header", ".", "stamp", ")", "# Publish semantic image", "if", "self", ".", "sem_img_pub", ".", "get_num_connections", "(", ")", ">", "0", ":", "if", "self", ".", "point_type", "is", "PointType", ".", "SEMANTICS_MAX", ":", "semantic_color_msg", "=", "self", ".", "bridge", ".", "cv2_to_imgmsg", "(", "semantic_color", ",", "encoding", "=", "\"bgr8\"", ")", "else", ":", "semantic_color_msg", "=", "self", ".", "bridge", ".", "cv2_to_imgmsg", "(", "self", ".", "semantic_colors", "[", "0", "]", ",", "encoding", "=", "\"bgr8\"", ")", "self", ".", "sem_img_pub", ".", "publish", "(", "semantic_color_msg", ")", "# Publish point cloud", "self", ".", "pcl_pub", ".", "publish", "(", "cloud_ros", ")" ]

[ "tterm", ":", "tapp" ]

[ "def", "p_tterm_term", "(", "p", ")", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]" ]

[ "SetChildMenuBar", "(", "self", "AuiMDIChildFrame", "pChild", ")" ]

[ "def", "SetChildMenuBar", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiMDIParentFrame_SetChildMenuBar", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "class", "-", "level", "attributes", "for", "all", "enum", "fields", "defined", "in", "this", "message", "." ]

[ "def", "_AddEnumValues", "(", "descriptor", ",", "cls", ")", ":", "for", "enum_type", "in", "descriptor", ".", "enum_types", ":", "setattr", "(", "cls", ",", "enum_type", ".", "name", ",", "enum_type_wrapper", ".", "EnumTypeWrapper", "(", "enum_type", ")", ")", "for", "enum_value", "in", "enum_type", ".", "values", ":", "setattr", "(", "cls", ",", "enum_value", ".", "name", ",", "enum_value", ".", "number", ")" ]

[ "Called", "by", "the", "reactor", "when", "data", "is", "received", "over", "the", "connection", ".", "This", "method", "will", "do", "nothing", "if", "we", "don", "t", "receive", "a", "full", "message", "." ]

[ "def", "dataReceived", "(", "self", ",", "data", ")", ":", "#print '\\n\\nData Received:',", "#pprintHex(binary_to_hex(data), withAddr=False)", "# Put the current buffer into an unpacker, process until empty", "self", ".", "recvData", "+=", "data", "buf", "=", "BinaryUnpacker", "(", "self", ".", "recvData", ")", "messages", "=", "[", "]", "while", "True", ":", "try", ":", "# recvData is only modified if the unserialize succeeds", "# Had a serious issue with references, so I had to convert ", "# messages to strings to guarantee that copies were being ", "# made! (yes, hacky...)", "thisMsg", "=", "PyMessage", "(", ")", ".", "unserialize", "(", "buf", ")", "messages", ".", "append", "(", "thisMsg", ".", "serialize", "(", ")", ")", "self", ".", "recvData", "=", "buf", ".", "getRemainingString", "(", ")", "except", "NetworkIDError", ":", "LOGERROR", "(", "'Message for a different network!'", ")", "if", "BLOCKCHAINS", ".", "has_key", "(", "self", ".", "recvData", "[", ":", "4", "]", ")", ":", "LOGERROR", "(", "'(for network: %s)'", ",", "BLOCKCHAINS", "[", "self", ".", "recvData", "[", ":", "4", "]", "]", ")", "# Before raising the error, we should've finished reading the msg", "# So pop it off the front of the buffer", "self", ".", "recvData", "=", "buf", ".", "getRemainingString", "(", ")", "return", "except", "UnknownNetworkPayload", ":", "return", "except", "UnpackerError", ":", "# Expect this error when buffer isn't full enough for a whole msg", "break", "# We might've gotten here without anything to process -- if so, bail", "if", "len", "(", "messages", ")", "==", "0", ":", "return", "# Finally, we have some message to process, let's do it", "for", "msgStr", "in", "messages", ":", "msg", "=", "PyMessage", "(", ")", ".", "unserialize", "(", "msgStr", ")", "cmd", "=", "msg", ".", "cmd", "# Log the message if netlog option", "if", "CLI_OPTIONS", ".", "netlog", ":", "LOGDEBUG", "(", "'DataReceived: %s'", ",", "msg", ".", "payload", ".", "command", ")", "if", "msg", ".", "payload", ".", "command", "==", "'tx'", ":", "LOGDEBUG", "(", "'\\t'", "+", "binary_to_hex", "(", "msg", ".", "payload", ".", "tx", ".", "thisHash", ")", ")", "elif", "msg", ".", "payload", ".", "command", "==", "'block'", ":", "LOGDEBUG", "(", "'\\t'", "+", "msg", ".", "payload", ".", "header", ".", "getHashHex", "(", ")", ")", "elif", "msg", ".", "payload", ".", "command", "==", "'inv'", ":", "for", "inv", "in", "msg", ".", "payload", ".", "invList", ":", "LOGDEBUG", "(", "(", "'\\tBLOCK: '", "if", "inv", "[", "0", "]", "==", "2", "else", "'\\tTX : '", ")", "+", "binary_to_hex", "(", "inv", "[", "1", "]", ")", ")", "# We process version and verackk only if we haven't yet", "if", "cmd", "==", "'version'", "and", "not", "self", ".", "sentVerack", ":", "self", ".", "peerInfo", "=", "{", "}", "self", ".", "peerInfo", "[", "'version'", "]", "=", "msg", ".", "payload", ".", "version", "self", ".", "peerInfo", "[", "'subver'", "]", "=", "msg", ".", "payload", ".", "subver", "self", ".", "peerInfo", "[", "'time'", "]", "=", "msg", ".", "payload", ".", "time", "self", ".", "peerInfo", "[", "'height'", "]", "=", "msg", ".", "payload", ".", "height0", "LOGINFO", "(", "'Received version message from peer:'", ")", "LOGINFO", "(", "' Version: %s'", ",", "str", "(", "self", ".", "peerInfo", "[", "'version'", "]", ")", ")", "LOGINFO", "(", "' SubVersion: %s'", ",", "str", "(", "self", ".", "peerInfo", "[", "'subver'", "]", ")", ")", "LOGINFO", "(", "' TimeStamp: %s'", ",", "str", "(", "self", ".", "peerInfo", "[", "'time'", "]", ")", ")", "LOGINFO", "(", "' StartHeight: %s'", ",", "str", "(", "self", ".", "peerInfo", "[", "'height'", "]", ")", ")", "self", ".", "sentVerack", "=", "True", "self", ".", "sendMessage", "(", "PayloadVerack", "(", ")", ")", "elif", "cmd", "==", "'verack'", ":", "self", ".", "gotVerack", "=", "True", "self", ".", "factory", ".", "handshakeFinished", "(", "self", ")", "#self.startHeaderDL()", "####################################################################", "# Don't process any other messages unless the handshake is finished", "if", "self", ".", "gotVerack", "and", "self", ".", "sentVerack", ":", "self", ".", "processMessage", "(", "msg", ")" ]

[ "3x3", "convolution", "with", "padding" ]

[ "def", "binaryconv3x3", "(", "in_planes", ",", "out_planes", ",", "stride", "=", "1", ")", ":", "return", "HardBinaryConv", "(", "in_planes", ",", "out_planes", ",", "kernel_size", "=", "3", ",", "stride", "=", "stride", ",", "padding", "=", "1", ")" ]

[ "Check", "if", "a", "header", "is", "in", "alphabetical", "order", "with", "the", "previous", "header", "." ]

[ "def", "IsInAlphabeticalOrder", "(", "self", ",", "clean_lines", ",", "linenum", ",", "header_path", ")", ":", "# If previous section is different from current section, _last_header will", "# be reset to empty string, so it's always less than current header.", "#", "# If previous line was a blank line, assume that the headers are", "# intentionally sorted the way they are.", "if", "(", "self", ".", "_last_header", ">", "header_path", "and", "not", "Match", "(", "r'^\\s*$'", ",", "clean_lines", ".", "elided", "[", "linenum", "-", "1", "]", ")", ")", ":", "return", "False", "return", "True" ]

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

[ "Checks", "whether", "chars", "is", "a", "whitespace", "character", "." ]

[ "def", "_is_whitespace", "(", "char", ")", ":", "# \\t, \\n, and \\r are technically contorl characters but we treat them", "# as whitespace since they are generally considered as such.", "if", "char", "==", "\" \"", "or", "char", "==", "\"\\t\"", "or", "char", "==", "\"\\n\"", "or", "char", "==", "\"\\r\"", ":", "return", "True", "cat", "=", "unicodedata", ".", "category", "(", "char", ")", "if", "cat", "==", "\"Zs\"", ":", "return", "True", "return", "False" ]

[ ":", "type", "arr", ":", "List", "[", "int", "]", ":", "rtype", ":", "int" ]

[ "def", "maxChunksToSorted", "(", "self", ",", "arr", ")", ":", "def", "compare", "(", "i1", ",", "i2", ")", ":", "return", "arr", "[", "i1", "]", "-", "arr", "[", "i2", "]", "if", "arr", "[", "i1", "]", "!=", "arr", "[", "i2", "]", "else", "i1", "-", "i2", "idxs", "=", "[", "i", "for", "i", "in", "xrange", "(", "len", "(", "arr", ")", ")", "]", "result", ",", "max_i", "=", "0", ",", "0", "for", "i", ",", "v", "in", "enumerate", "(", "sorted", "(", "idxs", ",", "cmp", "=", "compare", ")", ")", ":", "max_i", "=", "max", "(", "max_i", ",", "v", ")", "if", "max_i", "==", "i", ":", "result", "+=", "1", "return", "result" ]

[ "Test", "whether", "a", "path", "is", "a", "file", "including", "image", "files", "." ]

[ "def", "isfile", "(", "p", ")", ":", "try", ":", "return", "swi", ".", "swi", "(", "'OS_File'", ",", "'5s;i'", ",", "p", ")", "in", "[", "1", ",", "3", "]", "except", "swi", ".", "error", ":", "return", "0" ]

[ "Unselect", "currently", "selected", "tool", "." ]

[ "def", "unselect_tool", "(", "self", ")", ":", "self", ".", "_toolspalett", ".", "unselect", "(", ")" ]

[ "Return", "a", "tuple", "of", "column", "and", "row", "which", "identify", "the", "cell", "at", "which", "the", "pixel", "at", "position", "X", "and", "Y", "inside", "the", "master", "widget", "is", "located", "." ]

[ "def", "grid_location", "(", "self", ",", "x", ",", "y", ")", ":", "return", "self", ".", "_getints", "(", "self", ".", "tk", ".", "call", "(", "'grid'", ",", "'location'", ",", "self", ".", "_w", ",", "x", ",", "y", ")", ")", "or", "None" ]

[ ":", "type", "nums", ":", "List", "[", "int", "]", ":", "rtype", ":", "int" ]

[ "def", "maxProduct", "(", "self", ",", "nums", ")", ":", "m1", "=", "m2", "=", "0", "for", "num", "in", "nums", ":", "if", "num", ">", "m1", ":", "m1", ",", "m2", "=", "num", ",", "m1", "elif", "num", ">", "m2", ":", "m2", "=", "num", "return", "(", "m1", "-", "1", ")", "*", "(", "m2", "-", "1", ")" ]

[ "Consumes", "an", "unsigned", "64bit", "integer", "number", "." ]

[ "def", "ConsumeUint64", "(", "self", ")", ":", "try", ":", "result", "=", "ParseInteger", "(", "self", ".", "token", ",", "is_signed", "=", "False", ",", "is_long", "=", "True", ")", "except", "ValueError", ",", "e", ":", "raise", "self", ".", "_ParseError", "(", "str", "(", "e", ")", ")", "self", ".", "NextToken", "(", ")", "return", "result" ]

[ "AutoComplete", "(", "self", "wxArrayString", "choices", ")", "-", ">", "bool" ]

[ "def", "AutoComplete", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "TextEntryBase_AutoComplete", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "returns", "information", "about", "the", "given", "bit" ]

[ "def", "GetBitInfo", "(", "self", ",", "idx", ")", ":", "if", "idx", ">=", "self", ".", "_sigSize", ":", "raise", "IndexError", "(", "f'bad index ({idx}) queried. {self._sigSize} is the max'", ")", "# first figure out how many points are in the p'cophore", "nPts", "=", "self", ".", "minPointCount", "while", "nPts", "<", "self", ".", "maxPointCount", "and", "self", ".", "_starts", "[", "nPts", "+", "1", "]", "<=", "idx", ":", "nPts", "+=", "1", "# how far are we in from the start point?", "offsetFromStart", "=", "idx", "-", "self", ".", "_starts", "[", "nPts", "]", "if", "_verbose", ":", "print", "(", "f'\\t {nPts} Points, {offsetFromStart} offset'", ")", "# lookup the number of scaffolds", "nDists", "=", "len", "(", "Utils", ".", "nPointDistDict", "[", "nPts", "]", ")", "scaffolds", "=", "self", ".", "_scaffolds", "[", "nDists", "]", "nScaffolds", "=", "len", "(", "scaffolds", ")", "# figure out to which proto-pharmacophore we belong:", "protoIdx", "=", "offsetFromStart", "//", "nScaffolds", "indexCombos", "=", "Utils", ".", "GetIndexCombinations", "(", "self", ".", "_nFeats", ",", "nPts", ")", "combo", "=", "tuple", "(", "indexCombos", "[", "protoIdx", "]", ")", "if", "_verbose", ":", "print", "(", "f'\\t combo: {str(combo)}'", ")", "# and which scaffold:", "scaffoldIdx", "=", "offsetFromStart", "%", "nScaffolds", "scaffold", "=", "scaffolds", "[", "scaffoldIdx", "]", "if", "_verbose", ":", "print", "(", "f'\\t scaffold: {str(scaffold)}'", ")", "return", "nPts", ",", "combo", ",", "scaffold" ]

[ ">>>", "list", "(", "install_lib", ".", "_all_packages", "(", "foo", ".", "bar", ".", "baz", "))", "[", "foo", ".", "bar", ".", "baz", "foo", ".", "bar", "foo", "]" ]

[ "def", "_all_packages", "(", "pkg_name", ")", ":", "while", "pkg_name", ":", "yield", "pkg_name", "pkg_name", ",", "sep", ",", "child", "=", "pkg_name", ".", "rpartition", "(", "'.'", ")" ]

[ "Create", "a", "function", "from", "the", "strings", "name", "signature", "and", "body", ".", "evaldict", "is", "the", "evaluation", "dictionary", ".", "If", "addsource", "is", "true", "an", "attribute", "__source__", "is", "added", "to", "the", "result", ".", "The", "attributes", "attrs", "are", "added", "if", "any", "." ]

[ "def", "create", "(", "cls", ",", "obj", ",", "body", ",", "evaldict", ",", "defaults", "=", "None", ",", "doc", "=", "None", ",", "module", "=", "None", ",", "addsource", "=", "True", ",", "*", "*", "attrs", ")", ":", "if", "isinstance", "(", "obj", ",", "str", ")", ":", "# \"name(signature)\"", "name", ",", "rest", "=", "obj", ".", "strip", "(", ")", ".", "split", "(", "'('", ",", "1", ")", "signature", "=", "rest", "[", ":", "-", "1", "]", "# strip a right parens", "func", "=", "None", "else", ":", "# a function", "name", "=", "None", "signature", "=", "None", "func", "=", "obj", "self", "=", "cls", "(", "func", ",", "name", ",", "signature", ",", "defaults", ",", "doc", ",", "module", ")", "ibody", "=", "'\\n'", ".", "join", "(", "' '", "+", "line", "for", "line", "in", "body", ".", "splitlines", "(", ")", ")", "caller", "=", "evaldict", ".", "get", "(", "'_call_'", ")", "# when called from `decorate`", "if", "caller", "and", "iscoroutinefunction", "(", "caller", ")", ":", "body", "=", "(", "'async def %(name)s(%(signature)s):\\n'", "+", "ibody", ")", ".", "replace", "(", "'return'", ",", "'return await'", ")", "else", ":", "body", "=", "'def %(name)s(%(signature)s):\\n'", "+", "ibody", "return", "self", ".", "make", "(", "body", ",", "evaldict", ",", "addsource", ",", "*", "*", "attrs", ")" ]

[ "Compute", "the", "roots", "of", "a", "Hermite", "series", "." ]

[ "def", "hermroots", "(", "cs", ")", ":", "# cs is a trimmed copy", "[", "cs", "]", "=", "pu", ".", "as_series", "(", "[", "cs", "]", ")", "if", "len", "(", "cs", ")", "<=", "1", ":", "return", "np", ".", "array", "(", "[", "]", ",", "dtype", "=", "cs", ".", "dtype", ")", "if", "len", "(", "cs", ")", "==", "2", ":", "return", "np", ".", "array", "(", "[", "-", ".5", "*", "cs", "[", "0", "]", "/", "cs", "[", "1", "]", "]", ")", "n", "=", "len", "(", "cs", ")", "-", "1", "cs", "/=", "cs", "[", "-", "1", "]", "cmat", "=", "np", ".", "zeros", "(", "(", "n", ",", "n", ")", ",", "dtype", "=", "cs", ".", "dtype", ")", "cmat", "[", "1", ",", "0", "]", "=", ".5", "for", "i", "in", "range", "(", "1", ",", "n", ")", ":", "cmat", "[", "i", "-", "1", ",", "i", "]", "=", "i", "if", "i", "!=", "n", "-", "1", ":", "cmat", "[", "i", "+", "1", ",", "i", "]", "=", ".5", "else", ":", "cmat", "[", ":", ",", "i", "]", "-=", "cs", "[", ":", "-", "1", "]", "*", ".5", "roots", "=", "la", ".", "eigvals", "(", "cmat", ")", "roots", ".", "sort", "(", ")", "return", "roots" ]

[ "GetPageRoot", "(", "self", "int", "index", ")", "-", ">", "PGProperty" ]

[ "def", "GetPageRoot", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridManager_GetPageRoot", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "True", "if", "Role", "is", "done", ";", "False", "otherwise", "." ]

[ "def", "is_done", "(", "self", ",", "world_state", ":", "stp", ".", "rc", ".", "WorldState", ")", "->", "bool", ":", "..." ]

[ "Send", "a", "RDM", "Set", "message", "." ]

[ "def", "Set", "(", "self", ",", "universe", ",", "uid", ",", "sub_device", ",", "pid", ",", "callback", ",", "args", "=", "[", "]", ",", "include_frames", "=", "False", ")", ":", "return", "self", ".", "_SendRequest", "(", "universe", ",", "uid", ",", "sub_device", ",", "pid", ",", "callback", ",", "args", ",", "PidStore", ".", "RDM_SET", ",", "include_frames", ")" ]

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

[ "def", "GetToolBarFits", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBar_GetToolBarFits", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Set", "the", "selection", "anchor", "to", "the", "cell", "at", "(", "x", "y", ")", "." ]

[ "def", "anchor_set", "(", "self", ",", "x", ",", "y", ")", ":", "self", ".", "tk", ".", "call", "(", "self", ",", "'anchor'", ",", "'set'", ",", "x", ",", "y", ")" ]

[ "Returns", "V8", "conversion", "type", "adding", "any", "additional", "includes", "." ]

[ "def", "v8_conversion_type", "(", "idl_type", ",", "extended_attributes", ")", ":", "extended_attributes", "=", "extended_attributes", "or", "{", "}", "# Nullable dictionaries need to be handled differently than either", "# non-nullable dictionaries or unions.", "if", "idl_type", ".", "is_dictionary", "and", "idl_type", ".", "is_nullable", ":", "return", "'NullableDictionary'", "if", "idl_type", ".", "is_dictionary", "or", "idl_type", ".", "is_union_type", ":", "return", "'DictionaryOrUnion'", "# Array or sequence types", "native_array_element_type", "=", "idl_type", ".", "native_array_element_type", "if", "native_array_element_type", ":", "return", "'array'", "# Simple types", "base_idl_type", "=", "idl_type", ".", "base_type", "# Basic types, without additional includes", "if", "base_idl_type", "in", "CPP_INT_TYPES", ":", "return", "'int'", "if", "base_idl_type", "in", "CPP_UNSIGNED_TYPES", ":", "return", "'unsigned'", "if", "idl_type", ".", "is_string_type", ":", "if", "idl_type", ".", "is_nullable", ":", "return", "'StringOrNull'", "if", "'TreatReturnedNullStringAs'", "not", "in", "extended_attributes", ":", "return", "base_idl_type", "treat_returned_null_string_as", "=", "extended_attributes", "[", "'TreatReturnedNullStringAs'", "]", "if", "treat_returned_null_string_as", "==", "'Null'", ":", "return", "'StringOrNull'", "if", "treat_returned_null_string_as", "==", "'Undefined'", ":", "return", "'StringOrUndefined'", "raise", "'Unrecognized TreatReturnedNullStringAs value: \"%s\"'", "%", "treat_returned_null_string_as", "if", "idl_type", ".", "is_basic_type", "or", "base_idl_type", "==", "'ScriptValue'", ":", "return", "base_idl_type", "# Generic dictionary type", "if", "base_idl_type", "==", "'Dictionary'", ":", "return", "'Dictionary'", "# Data type with potential additional includes", "if", "base_idl_type", "in", "V8_SET_RETURN_VALUE", ":", "# Special v8SetReturnValue treatment", "return", "base_idl_type", "# Pointer type", "return", "'DOMWrapper'" ]

[ "Builds", "the", "corresponding", "_ir", ".", "AffineExpr", "from", "the", "definitions", "." ]

[ "def", "build", "(", "self", ",", "state", ":", "Optional", "[", "AffineBuildState", "]", "=", "None", ")", "->", "_ir", ".", "AffineExpr", ":", "state", "=", "AffineBuildState", "(", ")", "if", "state", "is", "None", "else", "state", "expr", "=", "self", ".", "_create", "(", "state", ")", "return", "expr" ]

[ "Converts", "a", "field", "name", "from", "camelCase", "to", "snake_case", "." ]

[ "def", "_CamelCaseToSnakeCase", "(", "path_name", ")", ":", "result", "=", "[", "]", "for", "c", "in", "path_name", ":", "if", "c", "==", "'_'", ":", "raise", "ParseError", "(", "'Fail to parse FieldMask: Path name '", "'{0} must not contain \"_\"s.'", ".", "format", "(", "path_name", ")", ")", "if", "c", ".", "isupper", "(", ")", ":", "result", "+=", "'_'", "result", "+=", "c", ".", "lower", "(", ")", "else", ":", "result", "+=", "c", "return", "''", ".", "join", "(", "result", ")" ]

[ "Configure", "root", "logger" ]

[ "def", "set_up_logging", "(", "args", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", ")", "# Get the log level from the config", "log_level", "=", "getattr", "(", "logging", ",", "args", ".", "log_level", ".", "upper", "(", ")", ",", "None", ")", "if", "not", "isinstance", "(", "log_level", ",", "int", ")", ":", "logging", ".", "error", "(", "f\"Invalid log level: {log_level}\"", ")", "sys", ".", "exit", "(", "1", ")", "logger", ".", "setLevel", "(", "log_level", ")", "# Determine format", "fmt", "=", "\"%(asctime)s %(message)s\"", "datefmt", "=", "\"%m/%d/%y %H:%M:%S\"", "if", "\"debug_levels\"", "in", "args", ":", "fmts", "=", "config", ".", "debug2fmt", "(", "args", ".", "debug_levels", ")", "fmt", "=", "fmts", "[", "\"fmt\"", "]", "datefmt", "=", "fmts", "[", "\"datefmt\"", "]", "# Check if we're logging to a file", "if", "args", ".", "log_file", "is", "not", "None", ":", "log_path", "=", "Path", "(", "args", ".", "log_file", ")", "# Make sure the parent directory exists", "if", "not", "log_path", ".", "parent", ".", "exists", "(", ")", ":", "logging", ".", "debug", "(", "f\"Attempting to create {log_path.parent}\"", ")", "try", ":", "log_path", ".", "parent", ".", "mkdir", "(", "parents", "=", "True", ")", "except", "Exception", ":", "logging", ".", "exception", "(", "f\"Error while creating log file directory {log_path.parent}\"", ")", "sys", ".", "exit", "(", "1", ")", "filehandler", "=", "logging", ".", "handlers", ".", "RotatingFileHandler", "(", "args", ".", "log_file", ",", "maxBytes", "=", "100000", ")", "filehandler", ".", "setFormatter", "(", "logging", ".", "Formatter", "(", "fmt", "=", "fmt", ",", "datefmt", "=", "datefmt", ")", ")", "logger", ".", "addHandler", "(", "filehandler", ")", "# Check if logging to stdout is worthwhile", "if", "os", ".", "isatty", "(", "sys", ".", "stdout", ".", "fileno", "(", ")", ")", ":", "streamhandler", "=", "logging", ".", "StreamHandler", "(", "stream", "=", "sys", ".", "stdout", ")", "streamhandler", ".", "setFormatter", "(", "logging", ".", "Formatter", "(", "fmt", "=", "fmt", ",", "datefmt", "=", "datefmt", ")", ")", "logger", ".", "addHandler", "(", "streamhandler", ")" ]

[ "Return", "the", "index", "of", "top", "K", "gallery", "images", "most", "similar", "to", "the", "query", "images", ":", "param", "query_feat", ":", "array", "of", "feature", "vectors", "of", "query", "images", ":", "param", "gallery_feat", ":", "array", "of", "feature", "vectors", "of", "gallery", "images", ":", "param", "topk", ":", "number", "of", "gallery", "images", "to", "return" ]

[ "def", "topk", "(", "query_feat", ",", "gallery_feat", ",", "topk", "=", "5", ")", ":", "sim", "=", "similarity", "(", "query_feat", ",", "gallery_feat", ")", "index", "=", "np", ".", "argsort", "(", "-", "sim", ",", "axis", "=", "1", ")", "return", "[", "i", "[", "0", ":", "int", "(", "topk", ")", "]", "for", "i", "in", "index", "]" ]

[ "Restore", "this", "object", "and", "either", "queue", "its", "dependencies", "or", "defer", "them", "." ]

[ "def", "_single_restoration_from_checkpoint_position", "(", "self", ",", "checkpoint_position", ",", "visit_queue", ")", ":", "self", ".", "_maybe_initialize_trackable", "(", ")", "checkpoint", "=", "checkpoint_position", ".", "checkpoint", "# If the UID of this restore is lower than our current update UID, we don't", "# need to actually restore the object. However, we should pass the", "# restoration on to our dependencies.", "if", "checkpoint", ".", "restore_uid", ">", "self", ".", "_self_update_uid", ":", "restore_ops", ",", "tensor_saveables", ",", "python_saveables", "=", "(", "checkpoint_position", ".", "gather_ops_or_named_saveables", "(", ")", ")", "self", ".", "_self_update_uid", "=", "checkpoint", ".", "restore_uid", "else", ":", "restore_ops", "=", "(", ")", "tensor_saveables", "=", "{", "}", "python_saveables", "=", "(", ")", "for", "child", "in", "checkpoint_position", ".", "object_proto", ".", "children", ":", "child_position", "=", "CheckpointPosition", "(", "checkpoint", "=", "checkpoint", ",", "proto_id", "=", "child", ".", "node_id", ")", "local_object", "=", "self", ".", "_lookup_dependency", "(", "child", ".", "local_name", ")", "if", "local_object", "is", "None", ":", "# We don't yet have a dependency registered with this name. Save it", "# in case we do.", "self", ".", "_deferred_dependencies", ".", "setdefault", "(", "child", ".", "local_name", ",", "[", "]", ")", ".", "append", "(", "child_position", ")", "else", ":", "if", "child_position", ".", "bind_object", "(", "trackable", "=", "local_object", ")", ":", "# This object's correspondence is new, so dependencies need to be", "# visited. Delay doing it so that we get a breadth-first dependency", "# resolution order (shallowest paths first). The caller is responsible", "# for emptying visit_queue.", "visit_queue", ".", "append", "(", "child_position", ")", "return", "restore_ops", ",", "tensor_saveables", ",", "python_saveables" ]

[ "Returns", "the", "group", "and", "element", "type", "of", "the", "source", "file", "." ]

[ "def", "_MapFileToMsBuildSourceType", "(", "source", ",", "rule_dependencies", ",", "extension_to_rule_name", ")", ":", "_", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "source", ")", "if", "ext", "in", "extension_to_rule_name", ":", "group", "=", "'rule'", "element", "=", "extension_to_rule_name", "[", "ext", "]", "elif", "ext", "in", "[", "'.cc'", ",", "'.cpp'", ",", "'.c'", ",", "'.cxx'", "]", ":", "group", "=", "'compile'", "element", "=", "'ClCompile'", "elif", "ext", "in", "[", "'.h'", ",", "'.hxx'", "]", ":", "group", "=", "'include'", "element", "=", "'ClInclude'", "elif", "ext", "==", "'.rc'", ":", "group", "=", "'resource'", "element", "=", "'ResourceCompile'", "elif", "ext", "==", "'.asm'", ":", "group", "=", "'masm'", "element", "=", "'MASM'", "elif", "ext", "==", "'.idl'", ":", "group", "=", "'midl'", "element", "=", "'Midl'", "elif", "source", "in", "rule_dependencies", ":", "group", "=", "'rule_dependency'", "element", "=", "'CustomBuild'", "else", ":", "group", "=", "'none'", "element", "=", "'None'", "return", "(", "group", ",", "element", ")" ]

[ "Toggle", "between", "basic", "and", "advanced", "keys", "." ]

[ "def", "toggle_level", "(", "self", ")", ":", "if", "self", ".", "button_level", ".", "cget", "(", "'text'", ")", ".", "startswith", "(", "'Advanced'", ")", ":", "self", ".", "clear_key_seq", "(", ")", "self", ".", "button_level", ".", "config", "(", "text", "=", "'<< Basic Key Binding Entry'", ")", "self", ".", "frame_keyseq_advanced", ".", "lift", "(", ")", "self", ".", "frame_help_advanced", ".", "lift", "(", ")", "self", ".", "advanced_keys", ".", "focus_set", "(", ")", "self", ".", "advanced", "=", "True", "else", ":", "self", ".", "clear_key_seq", "(", ")", "self", ".", "button_level", ".", "config", "(", "text", "=", "'Advanced Key Binding Entry >>'", ")", "self", ".", "frame_keyseq_basic", ".", "lift", "(", ")", "self", ".", "frame_controls_basic", ".", "lift", "(", ")", "self", ".", "advanced", "=", "False" ]

[ "Returns", "the", "raw", "comment", "text", "associated", "with", "that", "Cursor" ]

[ "def", "raw_comment", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_Cursor_getRawCommentText", "(", "self", ")" ]

[ "r", "Sets", "self", "to", "a", "reduced", "version", "of", "robot", "where", "all", "fixed", "DOFs", "are", "eliminated", ".", "The", "return", "value", "is", "a", "map", "from", "the", "original", "robot", "DOF", "indices", "to", "the", "reduced", "DOFs", "." ]

[ "def", "reduce", "(", "self", ",", "robot", ":", "\"RobotModel\"", ")", "->", "None", ":", "return", "_robotsim", ".", "RobotModel_reduce", "(", "self", ",", "robot", ")" ]

[ "GetValueForExpressionPath", "(", "SBValue", "self", "char", "const", "*", "expr_path", ")", "-", ">", "SBValue" ]

[ "def", "GetValueForExpressionPath", "(", "self", ",", "expr_path", ")", ":", "return", "_lldb", ".", "SBValue_GetValueForExpressionPath", "(", "self", ",", "expr_path", ")" ]

[ "Creates", "a", "two", "-", "dimensional", "Bayer", "pattern", "with", "a", "width", "and", "height", "of", "2", "**", "Log2Width", "." ]

[ "def", "GetBayerPattern", "(", "Log2Width", ")", ":", "X", ",", "Y", "=", "np", ".", "meshgrid", "(", "range", "(", "2", "**", "Log2Width", ")", ",", "range", "(", "2", "**", "Log2Width", ")", ")", "Result", "=", "np", ".", "zeros_like", "(", "X", ")", "for", "i", "in", "range", "(", "Log2Width", ")", ":", "StripesY", "=", "np", ".", "where", "(", "np", ".", "bitwise_and", "(", "Y", ",", "2", "**", "(", "Log2Width", "-", "1", "-", "i", ")", ")", "!=", "0", ",", "1", ",", "0", ")", "StripesX", "=", "np", ".", "where", "(", "np", ".", "bitwise_and", "(", "X", ",", "2", "**", "(", "Log2Width", "-", "1", "-", "i", ")", ")", "!=", "0", ",", "1", ",", "0", ")", "Checker", "=", "np", ".", "bitwise_xor", "(", "StripesX", ",", "StripesY", ")", "Result", "+=", "np", ".", "bitwise_or", "(", "StripesY", "*", "2", "**", "(", "2", "*", "i", ")", ",", "Checker", "*", "2", "**", "(", "2", "*", "i", "+", "1", ")", ")", "return", "Result" ]

[ "Re", "-", "map", "the", "characters", "in", "the", "string", "according", "to", "UTS46", "processing", "." ]

[ "def", "uts46_remap", "(", "domain", ",", "std3_rules", "=", "True", ",", "transitional", "=", "False", ")", ":", "from", ".", "uts46data", "import", "uts46data", "output", "=", "u\"\"", "try", ":", "for", "pos", ",", "char", "in", "enumerate", "(", "domain", ")", ":", "code_point", "=", "ord", "(", "char", ")", "uts46row", "=", "uts46data", "[", "code_point", "if", "code_point", "<", "256", "else", "bisect", ".", "bisect_left", "(", "uts46data", ",", "(", "code_point", ",", "\"Z\"", ")", ")", "-", "1", "]", "status", "=", "uts46row", "[", "1", "]", "replacement", "=", "uts46row", "[", "2", "]", "if", "len", "(", "uts46row", ")", "==", "3", "else", "None", "if", "(", "status", "==", "\"V\"", "or", "(", "status", "==", "\"D\"", "and", "not", "transitional", ")", "or", "(", "status", "==", "\"3\"", "and", "std3_rules", "and", "replacement", "is", "None", ")", ")", ":", "output", "+=", "char", "elif", "replacement", "is", "not", "None", "and", "(", "status", "==", "\"M\"", "or", "(", "status", "==", "\"3\"", "and", "std3_rules", ")", "or", "(", "status", "==", "\"D\"", "and", "transitional", ")", ")", ":", "output", "+=", "replacement", "elif", "status", "!=", "\"I\"", ":", "raise", "IndexError", "(", ")", "return", "unicodedata", ".", "normalize", "(", "\"NFC\"", ",", "output", ")", "except", "IndexError", ":", "raise", "InvalidCodepoint", "(", "\"Codepoint {0} not allowed at position {1} in {2}\"", ".", "format", "(", "_unot", "(", "code_point", ")", ",", "pos", "+", "1", ",", "repr", "(", "domain", ")", ")", ")" ]