Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Sets", "the", "module", "s", "counting", "options", "." ]

[ "def", "_SetCountingStyle", "(", "level", ")", ":", "_cpplint_state", ".", "SetCountingStyle", "(", "level", ")" ]

[ "Generate", "the", "InvocationBaseGen", "class", "for", "a", "command", "s", "base", "class", "." ]

[ "def", "gen_invocation_base_class_declaration", "(", "self", ",", "command", ")", ":", "# type: (ast.Command) -> None", "class_declaration", "=", "'class InvocationBaseGen : public _TypedCommandInvocationBase {'", "with", "writer", ".", "IndentedScopedBlock", "(", "self", ".", "_writer", ",", "class_declaration", ",", "'};'", ")", ":", "# public requires special indentation that aligns with the class definition.", "self", ".", "_writer", ".", "unindent", "(", ")", "self", ".", "_writer", ".", "write_line", "(", "'public:'", ")", "self", ".", "_writer", ".", "indent", "(", ")", "# Inherit base constructor.", "self", ".", "_writer", ".", "write_line", "(", "'using _TypedCommandInvocationBase::_TypedCommandInvocationBase;'", ")", "self", ".", "_writer", ".", "write_line", "(", "'virtual Reply typedRun(OperationContext* opCtx) = 0;'", ")", "if", "command", ".", "access_checks", "==", "[", "]", ":", "self", ".", "_writer", ".", "write_line", "(", "'void doCheckAuthorization(OperationContext* opCtx) const final {}'", ")" ]

[ "Easily", "create", "a", "trivial", "completer", "for", "a", "command", "." ]

[ "def", "quick_completer", "(", "cmd", ",", "completions", ")", ":", "if", "isinstance", "(", "completions", ",", "string_types", ")", ":", "completions", "=", "completions", ".", "split", "(", ")", "def", "do_complete", "(", "self", ",", "event", ")", ":", "return", "completions", "get_ipython", "(", ")", ".", "set_hook", "(", "'complete_command'", ",", "do_complete", ",", "str_key", "=", "cmd", ")" ]

[ "Return", "state", "of", "constrain", "to", "axis", "mode", "." ]

[ "def", "getconstrain", "(", "self", ")", ":", "return", "self", ".", "_constrain" ]

[ "Compare", "two", "nodes", "for", "equality", "." ]

[ "def", "__eq__", "(", "self", ",", "other", ")", ":", "if", "self", ".", "__class__", "is", "not", "other", ".", "__class__", ":", "return", "NotImplemented", "return", "self", ".", "_eq", "(", "other", ")" ]

[ "Prints", "a", "reprentation", "of", "this", "object", "to", "file", "adhering", "to", "Xcode", "output", "formatting", "." ]

[ "def", "Print", "(", "self", ",", "file", "=", "sys", ".", "stdout", ")", ":", "self", ".", "VerifyHasRequiredProperties", "(", ")", "if", "self", ".", "_should_print_single_line", ":", "# When printing an object in a single line, Xcode doesn't put any space", "# between the beginning of a dictionary (or presumably a list) and the", "# first contained item, so you wind up with snippets like", "# ...CDEF = {isa = PBXFileReference; fileRef = 0123...", "# If it were me, I would have put a space in there after the opening", "# curly, but I guess this is just another one of those inconsistencies", "# between how Xcode prints PBXFileReference and PBXBuildFile objects as", "# compared to other objects. Mimic Xcode's behavior here by using an", "# empty string for sep.", "sep", "=", "\"\"", "end_tabs", "=", "0", "else", ":", "sep", "=", "\"\\n\"", "end_tabs", "=", "2", "# Start the object. For example, '\\t\\tPBXProject = {\\n'.", "self", ".", "_XCPrint", "(", "file", ",", "2", ",", "self", ".", "_XCPrintableValue", "(", "2", ",", "self", ")", "+", "\" = {\"", "+", "sep", ")", "# \"isa\" isn't in the _properties dictionary, it's an intrinsic property", "# of the class which the object belongs to. Xcode always outputs \"isa\"", "# as the first element of an object dictionary.", "self", ".", "_XCKVPrint", "(", "file", ",", "3", ",", "\"isa\"", ",", "self", ".", "__class__", ".", "__name__", ")", "# The remaining elements of an object dictionary are sorted alphabetically.", "for", "property", ",", "value", "in", "sorted", "(", "self", ".", "_properties", ".", "items", "(", ")", ")", ":", "self", ".", "_XCKVPrint", "(", "file", ",", "3", ",", "property", ",", "value", ")", "# End the object.", "self", ".", "_XCPrint", "(", "file", ",", "end_tabs", ",", "\"};\\n\"", ")" ]

[ "Given", "a", "directory", "(", "dirName", ")", "return", "a", "list", "containing", "the", "full", "-", "path", "of", "all", "files", "inside", "that", "directory", "(", "including", "all", "hierarchy", ")", "." ]

[ "def", "getListOfFiles", "(", "dirName", ")", ":", "listOfFiles", "=", "os", ".", "listdir", "(", "dirName", ")", "allFiles", "=", "list", "(", ")", "for", "entry", "in", "listOfFiles", ":", "fullPath", "=", "os", ".", "path", ".", "join", "(", "dirName", ",", "entry", ")", "if", "os", ".", "path", ".", "isdir", "(", "fullPath", ")", ":", "allFiles", "=", "allFiles", "+", "getListOfFiles", "(", "fullPath", ")", "else", ":", "allFiles", ".", "append", "(", "fullPath", ")", "return", "allFiles" ]

[ "..", "deprecated", "::", "1", ".", "1", "Instead", "you", "should", "use", ":", "func", ":", "Expression", ".", "get_value", "and", "call", ":", "func", ":", "str", "on", "that", "." ]

[ "def", "solution", "(", "self", ",", "solver", "=", "None", ")", ":", "save_str", "=", "Expression", ".", "__str__", "Expression", ".", "__str__", "=", "lambda", "x", ":", "x", ".", "solution", "(", "solver", ")", "output", "=", "self", ".", "__str__", "(", ")", "Expression", ".", "__str__", "=", "save_str", "return", "output" ]

[ "Keep", "a", "record", "of", "peace", "requests", "made", "or", "received", "by", "this", "empire", "." ]

[ "def", "log_peace_request", "(", "self", ",", "initiating_empire_id", ",", "recipient_empire_id", ")", ":", "peace_requests", "=", "self", ".", "diplomatic_logs", ".", "setdefault", "(", "\"peace_requests\"", ",", "{", "}", ")", "log_index", "=", "(", "initiating_empire_id", ",", "recipient_empire_id", ")", "peace_requests", ".", "setdefault", "(", "log_index", ",", "[", "]", ")", ".", "append", "(", "fo", ".", "currentTurn", "(", ")", ")" ]

[ "Prints", "out", "nearby", "words", "given", "a", "list", "of", "words", "." ]

[ "def", "nearby", "(", "self", ",", "words", ",", "num", "=", "20", ")", ":", "ids", "=", "np", ".", "array", "(", "[", "self", ".", "_word2id", ".", "get", "(", "x", ",", "0", ")", "for", "x", "in", "words", "]", ")", "vals", ",", "idx", "=", "self", ".", "_session", ".", "run", "(", "[", "self", ".", "_nearby_val", ",", "self", ".", "_nearby_idx", "]", ",", "{", "self", ".", "_nearby_word", ":", "ids", "}", ")", "for", "i", "in", "xrange", "(", "len", "(", "words", ")", ")", ":", "print", "(", "\"\\n%s\\n=====================================\"", "%", "(", "words", "[", "i", "]", ")", ")", "for", "(", "neighbor", ",", "distance", ")", "in", "zip", "(", "idx", "[", "i", ",", ":", "num", "]", ",", "vals", "[", "i", ",", ":", "num", "]", ")", ":", "print", "(", "\"%-20s %6.4f\"", "%", "(", "self", ".", "_id2word", "[", "neighbor", "]", ",", "distance", ")", ")" ]

[ "Returns", "whether", "the", ":", "class", ":", "AuiToolBar", "size", "fits", "in", "a", "specified", "size", "." ]

[ "def", "GetToolBarFits", "(", "self", ")", ":", "if", "len", "(", "self", ".", "_items", ")", "==", "0", ":", "# empty toolbar always 'fits'", "return", "True", "# entire toolbar content fits if the last tool fits", "return", "self", ".", "GetToolFitsByIndex", "(", "len", "(", "self", ".", "_items", ")", "-", "1", ")" ]

[ "Copy", "a", "directory", "tree", "." ]

[ "def", "copy_dir", "(", "src", ",", "dst", ",", "quiet", "=", "True", ")", ":", "try", ":", "remove_dir", "(", "dst", ",", "quiet", ")", "shutil", ".", "copytree", "(", "src", ",", "dst", ")", "if", "not", "quiet", ":", "sys", ".", "stdout", ".", "write", "(", "'Transferring '", "+", "src", "+", "' directory.\\n'", ")", "except", "IOError", "as", "e", ":", "(", "errno", ",", "strerror", ")", "=", "e", ".", "args", "sys", ".", "stderr", ".", "write", "(", "'Failed to copy directory from '", "+", "src", "+", "' to '", "+", "dst", "+", "': '", "+", "strerror", ")", "raise" ]

[ "A", "single", "-", "digit", "base", "-", "52", "encoding", "using", "a", "-", "zA", "-", "Z", "." ]

[ "def", "CharFromNumber", "(", "self", ",", "number", ")", ":", "if", "number", "<", "26", ":", "return", "chr", "(", "number", "+", "97", ")", "number", "-=", "26", "return", "chr", "(", "number", "+", "65", ")" ]

[ "Echo", "a", "packet", "back", "to", "the", "host", "." ]

[ "def", "ReceivePacket", "(", "self", ",", "endpoint", ",", "data", ")", ":", "assert", "endpoint", "&", "usb_constants", ".", "Dir", ".", "IN", "==", "0", "self", ".", "SendPacket", "(", "endpoint", "|", "usb_constants", ".", "Dir", ".", "IN", ",", "data", ")" ]

[ "Calls", "clang", "-", "apply", "-", "fixes", "on", "a", "given", "directory", "." ]

[ "def", "apply_fixes", "(", "args", ",", "tmpdir", ")", ":", "invocation", "=", "[", "args", ".", "clang_apply_replacements_binary", "]", "if", "args", ".", "format", ":", "invocation", ".", "append", "(", "'-format'", ")", "if", "args", ".", "style", ":", "invocation", ".", "append", "(", "'-style='", "+", "args", ".", "style", ")", "invocation", ".", "append", "(", "tmpdir", ")", "subprocess", ".", "call", "(", "invocation", ")" ]

[ "r", "Randomly", "split", "a", "dataset", "into", "non", "-", "overlapping", "new", "datasets", "of", "given", "lengths", ".", "Optionally", "fix", "the", "generator", "for", "reproducible", "results", "e", ".", "g", ".", ":" ]

[ "def", "random_split", "(", "dataset", ":", "Dataset", "[", "T", "]", ",", "lengths", ":", "Sequence", "[", "int", "]", ",", "generator", ":", "Optional", "[", "Generator", "]", "=", "default_generator", ")", "->", "List", "[", "Subset", "[", "T", "]", "]", ":", "# Cannot verify that dataset is Sized", "if", "sum", "(", "lengths", ")", "!=", "len", "(", "dataset", ")", ":", "raise", "ValueError", "(", "\"Sum of input lengths does not equal the length of the input dataset!\"", ")", "indices", "=", "randperm", "(", "sum", "(", "lengths", ")", ",", "generator", "=", "generator", ")", ".", "tolist", "(", ")", "return", "[", "Subset", "(", "dataset", ",", "indices", "[", "offset", "-", "length", ":", "offset", "]", ")", "for", "offset", ",", "length", "in", "zip", "(", "_accumulate", "(", "lengths", ")", ",", "lengths", ")", "]" ]

[ "DoFitWithScrolling", "(", "Dialog", "dialog", "ScrolledWindow", "scrolledWindow", ")", "-", ">", "bool" ]

[ "def", "DoFitWithScrolling", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "StandardDialogLayoutAdapter_DoFitWithScrolling", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Clear", "ConfigObj", "instance", "and", "restore", "to", "freshly", "created", "state", "." ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "clear", "(", ")", "self", ".", "_initialise", "(", ")", "# FIXME: Should be done by '_initialise', but ConfigObj constructor (and reload)", "# requires an empty dictionary", "self", ".", "configspec", "=", "None", "# Just to be sure ;-)", "self", ".", "_original_configspec", "=", "None" ]

[ "Format", "a", "service", "MethodDescriptorProto", "." ]

[ "def", "format_service_method", "(", "type_context", ",", "method", ")", ":", "def", "format_streaming", "(", "s", ")", ":", "return", "'stream '", "if", "s", "else", "''", "leading_comment", ",", "trailing_comment", "=", "format_type_context_comments", "(", "type_context", ")", "return", "'%srpc %s(%s%s%s) returns (%s%s) {%s}\\n'", "%", "(", "leading_comment", ",", "method", ".", "name", ",", "trailing_comment", ",", "format_streaming", "(", "method", ".", "client_streaming", ")", ",", "normalize_field_type_name", "(", "type_context", ",", "method", ".", "input_type", ")", ",", "format_streaming", "(", "method", ".", "server_streaming", ")", ",", "normalize_field_type_name", "(", "type_context", ",", "method", ".", "output_type", ")", ",", "format_options", "(", "method", ".", "options", ")", ")" ]

[ "Parse", "command", "-", "line", "argument", "vector", "." ]

[ "def", "parse_argv", "(", "tokens", ",", "options", ",", "options_first", "=", "False", ")", ":", "parsed", "=", "[", "]", "while", "tokens", ".", "current", "(", ")", "is", "not", "None", ":", "if", "tokens", ".", "current", "(", ")", "==", "'--'", ":", "return", "parsed", "+", "[", "Argument", "(", "None", ",", "v", ")", "for", "v", "in", "tokens", "]", "elif", "tokens", ".", "current", "(", ")", ".", "startswith", "(", "'--'", ")", ":", "parsed", "+=", "parse_long", "(", "tokens", ",", "options", ")", "elif", "tokens", ".", "current", "(", ")", ".", "startswith", "(", "'-'", ")", "and", "tokens", ".", "current", "(", ")", "!=", "'-'", ":", "parsed", "+=", "parse_shorts", "(", "tokens", ",", "options", ")", "elif", "options_first", ":", "return", "parsed", "+", "[", "Argument", "(", "None", ",", "v", ")", "for", "v", "in", "tokens", "]", "else", ":", "parsed", ".", "append", "(", "Argument", "(", "None", ",", "tokens", ".", "move", "(", ")", ")", ")", "return", "parsed" ]

[ "Main", "entry", "-", "point", "into", "the", "rendezvous", "barrier", "." ]

[ "def", "next_rendezvous", "(", "self", ",", ")", "->", "Tuple", "[", "Store", ",", "int", ",", "int", "]", ":" ]

[ "Returns", "the", "list", "of", "AbstractTargets", "which", "are", "used", "as", "sources", ".", "The", "extra", "properties", "specified", "for", "sources", "are", "not", "represented", ".", "The", "only", "used", "of", "this", "rule", "at", "the", "moment", "is", "the", "--", "dump", "-", "tests", "feature", "of", "the", "test", "system", "." ]

[ "def", "sources", "(", "self", ")", ":", "if", "self", ".", "source_targets_", "==", "None", ":", "self", ".", "source_targets_", "=", "[", "]", "for", "s", "in", "self", ".", "sources_", ":", "self", ".", "source_targets_", ".", "append", "(", "resolve_reference", "(", "s", ",", "self", ".", "project_", ")", "[", "0", "]", ")", "return", "self", ".", "source_targets_" ]

[ "Allow", "to", "run", "the", "server", "on", "the", "same", "computer", "as", "the", "client", "." ]

[ "def", "check_origin", "(", "self", ",", "origin", ")", ":", "return", "True" ]

[ "Slice", "substrings", "from", "each", "element", "in", "the", "Series", "or", "Index", "." ]

[ "def", "str_slice", "(", "arr", ",", "start", "=", "None", ",", "stop", "=", "None", ",", "step", "=", "None", ")", ":", "obj", "=", "slice", "(", "start", ",", "stop", ",", "step", ")", "f", "=", "lambda", "x", ":", "x", "[", "obj", "]", "return", "_na_map", "(", "f", ",", "arr", ",", "dtype", "=", "str", ")" ]

[ "Creates", "an", "op", "that", "encodes", "an", "audio", "file", "using", "sampled", "audio", "from", "a", "tensor", "." ]

[ "def", "encode_audio", "(", "audio", ",", "file_format", "=", "None", ",", "samples_per_second", "=", "None", ")", ":", "return", "gen_encode_audio_op_py", ".", "encode_audio_v2", "(", "audio", ",", "file_format", "=", "file_format", ",", "samples_per_second", "=", "samples_per_second", ",", "bits_per_second", "=", "192000", ")" ]

[ "r", "..", "math", "::", "VAR", "(", "B", ")", "=", "probs1", "*", "probs0" ]

[ "def", "_var", "(", "self", ",", "probs1", "=", "None", ")", ":", "probs1", "=", "self", ".", "_check_param_type", "(", "probs1", ")", "probs0", "=", "1.0", "-", "probs1", "return", "self", ".", "exp", "(", "self", ".", "log", "(", "probs0", ")", "+", "self", ".", "log", "(", "probs1", ")", ")" ]

[ "Returns", "True", "if", "the", "cursor", "refers", "to", "a", "C", "++", "move", "constructor", "." ]

[ "def", "is_move_constructor", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_CXXConstructor_isMoveConstructor", "(", "self", ")" ]

[ "For", "print", "and", "pprint" ]

[ "def", "__repr__", "(", "self", ")", ":", "return", "self", ".", "to_str", "(", ")" ]

[ "Tests", "whether", "name", "is", "registered", "in", "this", "graph", "s", "function", "library", "." ]

[ "def", "_is_function", "(", "self", ",", "name", ")", ":", "return", "name", "in", "self", ".", "_functions" ]

[ "FileSystem_FileNameToURL", "(", "String", "filename", ")", "-", ">", "String" ]

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

[ ":", "type", "str", ":", "str", ":", "rtype", ":", "str" ]

[ "def", "toLowerCase", "(", "self", ",", "str", ")", ":", "return", "str", ".", "lower", "(", ")" ]

[ "Iterate", "on", "the", "raw", "PTB", "data", "." ]

[ "def", "ptb_producer", "(", "raw_data", ",", "batch_size", ",", "num_steps", ",", "name", "=", "None", ")", ":", "with", "tf", ".", "name_scope", "(", "name", ",", "\"PTBProducer\"", ",", "[", "raw_data", ",", "batch_size", ",", "num_steps", "]", ")", ":", "raw_data", "=", "tf", ".", "convert_to_tensor", "(", "raw_data", ",", "name", "=", "\"raw_data\"", ",", "dtype", "=", "tf", ".", "int32", ")", "data_len", "=", "tf", ".", "size", "(", "raw_data", ")", "batch_len", "=", "data_len", "//", "batch_size", "data", "=", "tf", ".", "reshape", "(", "raw_data", "[", "0", ":", "batch_size", "*", "batch_len", "]", ",", "[", "batch_size", ",", "batch_len", "]", ")", "epoch_size", "=", "(", "batch_len", "-", "1", ")", "//", "num_steps", "assertion", "=", "tf", ".", "assert_positive", "(", "epoch_size", ",", "message", "=", "\"epoch_size == 0, decrease batch_size or num_steps\"", ")", "with", "tf", ".", "control_dependencies", "(", "[", "assertion", "]", ")", ":", "epoch_size", "=", "tf", ".", "identity", "(", "epoch_size", ",", "name", "=", "\"epoch_size\"", ")", "i", "=", "tf", ".", "train", ".", "range_input_producer", "(", "epoch_size", ",", "shuffle", "=", "False", ")", ".", "dequeue", "(", ")", "x", "=", "tf", ".", "slice", "(", "data", ",", "[", "0", ",", "i", "*", "num_steps", "]", ",", "[", "batch_size", ",", "num_steps", "]", ")", "y", "=", "tf", ".", "slice", "(", "data", ",", "[", "0", ",", "i", "*", "num_steps", "+", "1", "]", ",", "[", "batch_size", ",", "num_steps", "]", ")", "return", "x", ",", "y" ]

[ "Returns", "a", "set", "of", "free", "operator", "declarations", "that", "match", "a", "defined", "criteria", "." ]

[ "def", "free_operators", "(", "self", ",", "name", "=", "None", ",", "function", "=", "None", ",", "symbol", "=", "None", ",", "return_type", "=", "None", ",", "arg_types", "=", "None", ",", "header_dir", "=", "None", ",", "header_file", "=", "None", ",", "recursive", "=", "None", ",", "allow_empty", "=", "None", ")", ":", "return", "(", "self", ".", "_find_multiple", "(", "scopedef", ".", "scopedef_t", ".", "_impl_matchers", "[", "namespace_t", ".", "free_operator", "]", ",", "name", "=", "self", ".", "_build_operator_name", "(", "name", ",", "function", ",", "symbol", ")", ",", "symbol", "=", "symbol", ",", "function", "=", "self", ".", "_build_operator_function", "(", "name", ",", "function", ")", ",", "decl_type", "=", "self", ".", "_impl_decl_types", "[", "namespace_t", ".", "free_operator", "]", ",", "return_type", "=", "return_type", ",", "arg_types", "=", "arg_types", ",", "header_dir", "=", "header_dir", ",", "header_file", "=", "header_file", ",", "recursive", "=", "recursive", ",", "allow_empty", "=", "allow_empty", ")", ")" ]

[ "Return", "the", "path", "to", "the", "source", "file", "as", "found", "by", "the", "finder", "." ]

[ "def", "get_filename", "(", "self", ",", "fullname", ")", ":", "return", "self", ".", "path" ]

[ "Construct", "a", "cudf", "DataFrame", "from", "df", "if", "it", "supports", "__dataframe__" ]

[ "def", "from_dataframe", "(", "df", ":", "DataFrameObject", ",", "allow_copy", ":", "bool", "=", "False", ")", "->", "_CuDFDataFrame", ":", "if", "isinstance", "(", "df", ",", "cudf", ".", "DataFrame", ")", ":", "return", "df", "if", "not", "hasattr", "(", "df", ",", "\"__dataframe__\"", ")", ":", "raise", "ValueError", "(", "\"`df` does not support __dataframe__\"", ")", "return", "_from_dataframe", "(", "df", ".", "__dataframe__", "(", "allow_copy", "=", "allow_copy", ")", ")" ]

[ "Adds", "the", "printed", "JSON", "list", "representation", "of", "values", "to", "_output", "." ]

[ "def", "_print_list", "(", "self", ",", "values", ":", "List", "[", "Any", "]", ",", "print_func", ":", "Callable", "[", "[", "Any", "]", ",", "None", "]", ")", "->", "None", ":", "self", ".", "generator", ".", "open_json_list", "(", ")", "field_size", "=", "len", "(", "values", ")", "for", "i", "in", "range", "(", "field_size", ")", ":", "print_func", "(", "values", "[", "i", "]", ")", "if", "i", "<", "(", "field_size", "-", "1", ")", ":", "self", ".", "generator", ".", "push", "(", "','", ")", "self", ".", "generator", ".", "add_newline", "(", ")", "self", ".", "generator", ".", "close_json_list", "(", ")" ]

[ "Set", "sequences", "using", "the", "given", "name", "-", "to", "-", "key", "-", "list", "dictionary", "." ]

[ "def", "set_sequences", "(", "self", ",", "sequences", ")", ":", "f", "=", "open", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_path", ",", "'.mh_sequences'", ")", ",", "'r+'", ",", "encoding", "=", "'ASCII'", ")", "try", ":", "os", ".", "close", "(", "os", ".", "open", "(", "f", ".", "name", ",", "os", ".", "O_WRONLY", "|", "os", ".", "O_TRUNC", ")", ")", "for", "name", ",", "keys", "in", "sequences", ".", "items", "(", ")", ":", "if", "len", "(", "keys", ")", "==", "0", ":", "continue", "f", ".", "write", "(", "name", "+", "':'", ")", "prev", "=", "None", "completing", "=", "False", "for", "key", "in", "sorted", "(", "set", "(", "keys", ")", ")", ":", "if", "key", "-", "1", "==", "prev", ":", "if", "not", "completing", ":", "completing", "=", "True", "f", ".", "write", "(", "'-'", ")", "elif", "completing", ":", "completing", "=", "False", "f", ".", "write", "(", "'%s %s'", "%", "(", "prev", ",", "key", ")", ")", "else", ":", "f", ".", "write", "(", "' %s'", "%", "key", ")", "prev", "=", "key", "if", "completing", ":", "f", ".", "write", "(", "str", "(", "prev", ")", "+", "'\\n'", ")", "else", ":", "f", ".", "write", "(", "'\\n'", ")", "finally", ":", "_sync_close", "(", "f", ")" ]

[ "Invoke", "the", "underlying", "transport", "s", "listen", "()", "method" ]

[ "def", "listen", "(", "self", ")", ":", "self", ".", "__trans", ".", "listen", "(", ")" ]

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

[ "def", "IsEditable", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html2", ".", "WebView_IsEditable", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Circle", "from", "three", "tangents", "." ]

[ "def", "circleFrom3tan", "(", "tan1", ",", "tan2", ",", "tan3", ")", ":", "tan1IsLine", "=", "(", "geomType", "(", "tan1", ")", "==", "\"Line\"", ")", "tan2IsLine", "=", "(", "geomType", "(", "tan2", ")", "==", "\"Line\"", ")", "tan3IsLine", "=", "(", "geomType", "(", "tan3", ")", "==", "\"Line\"", ")", "tan1IsCircle", "=", "(", "geomType", "(", "tan1", ")", "==", "\"Circle\"", ")", "tan2IsCircle", "=", "(", "geomType", "(", "tan2", ")", "==", "\"Circle\"", ")", "tan3IsCircle", "=", "(", "geomType", "(", "tan3", ")", "==", "\"Circle\"", ")", "if", "tan1IsLine", "and", "tan2IsLine", "and", "tan3IsLine", ":", "return", "circleFrom3LineTangents", "(", "tan1", ",", "tan2", ",", "tan3", ")", "elif", "tan1IsCircle", "and", "tan2IsCircle", "and", "tan3IsCircle", ":", "return", "circleFrom3CircleTangents", "(", "tan1", ",", "tan2", ",", "tan3", ")", "elif", "tan1IsCircle", "and", "tan2IsLine", "and", "tan3IsLine", ":", "return", "circleFrom1Circle2Lines", "(", "tan1", ",", "tan2", ",", "tan3", ")", "elif", "tan1IsLine", "and", "tan2IsCircle", "and", "tan3IsLine", ":", "return", "circleFrom1Circle2Lines", "(", "tan2", ",", "tan1", ",", "tan3", ")", "elif", "tan1IsLine", "and", "tan2IsLine", "and", "tan3IsCircle", ":", "return", "circleFrom1Circle2Lines", "(", "tan3", ",", "tan1", ",", "tan2", ")", "elif", "tan1IsLine", "and", "tan2IsCircle", "and", "tan3IsCircle", ":", "return", "circleFrom2Circle1Lines", "(", "tan2", ",", "tan3", ",", "tan1", ")", "elif", "tan1IsCircle", "and", "tan2IsLine", "and", "tan3IsCircle", ":", "return", "circleFrom2Circle1Lines", "(", "tan1", ",", "tan3", ",", "tan2", ")", "elif", "tan1IsCircle", "and", "tan2IsCircle", "and", "tan3IsLine", ":", "return", "circleFrom2Circle1Lines", "(", "tan1", ",", "tan2", ",", "tan3", ")" ]

[ "For", "this", "KEY_EVENT_RECORD", "return", "a", "list", "of", "KeyPress", "instances", "." ]

[ "def", "_event_to_key_presses", "(", "self", ",", "ev", ":", "KEY_EVENT_RECORD", ")", "->", "List", "[", "KeyPress", "]", ":", "assert", "type", "(", "ev", ")", "==", "KEY_EVENT_RECORD", "and", "ev", ".", "KeyDown", "result", ":", "Optional", "[", "KeyPress", "]", "=", "None", "control_key_state", "=", "ev", ".", "ControlKeyState", "u_char", "=", "ev", ".", "uChar", ".", "UnicodeChar", "# Use surrogatepass because u_char may be an unmatched surrogate", "ascii_char", "=", "u_char", ".", "encode", "(", "\"utf-8\"", ",", "\"surrogatepass\"", ")", "# NOTE: We don't use `ev.uChar.AsciiChar`. That appears to be the", "# unicode code point truncated to 1 byte. See also:", "# https://github.com/ipython/ipython/issues/10004", "# https://github.com/jonathanslenders/python-prompt-toolkit/issues/389", "if", "u_char", "==", "\"\\x00\"", ":", "if", "ev", ".", "VirtualKeyCode", "in", "self", ".", "keycodes", ":", "result", "=", "KeyPress", "(", "self", ".", "keycodes", "[", "ev", ".", "VirtualKeyCode", "]", ",", "\"\"", ")", "else", ":", "if", "ascii_char", "in", "self", ".", "mappings", ":", "if", "self", ".", "mappings", "[", "ascii_char", "]", "==", "Keys", ".", "ControlJ", ":", "u_char", "=", "(", "\"\\n\"", "# Windows sends \\n, turn into \\r for unix compatibility.", ")", "result", "=", "KeyPress", "(", "self", ".", "mappings", "[", "ascii_char", "]", ",", "u_char", ")", "else", ":", "result", "=", "KeyPress", "(", "u_char", ",", "u_char", ")", "# First we handle Shift-Control-Arrow/Home/End (need to do this first)", "if", "(", "(", "control_key_state", "&", "self", ".", "LEFT_CTRL_PRESSED", "or", "control_key_state", "&", "self", ".", "RIGHT_CTRL_PRESSED", ")", "and", "control_key_state", "&", "self", ".", "SHIFT_PRESSED", "and", "result", ")", ":", "mapping", ":", "Dict", "[", "str", ",", "str", "]", "=", "{", "Keys", ".", "Left", ":", "Keys", ".", "ControlShiftLeft", ",", "Keys", ".", "Right", ":", "Keys", ".", "ControlShiftRight", ",", "Keys", ".", "Up", ":", "Keys", ".", "ControlShiftUp", ",", "Keys", ".", "Down", ":", "Keys", ".", "ControlShiftDown", ",", "Keys", ".", "Home", ":", "Keys", ".", "ControlShiftHome", ",", "Keys", ".", "End", ":", "Keys", ".", "ControlShiftEnd", ",", "Keys", ".", "Insert", ":", "Keys", ".", "ControlShiftInsert", ",", "Keys", ".", "PageUp", ":", "Keys", ".", "ControlShiftPageUp", ",", "Keys", ".", "PageDown", ":", "Keys", ".", "ControlShiftPageDown", ",", "}", "result", ".", "key", "=", "mapping", ".", "get", "(", "result", ".", "key", ",", "result", ".", "key", ")", "# Correctly handle Control-Arrow/Home/End and Control-Insert/Delete keys.", "if", "(", "control_key_state", "&", "self", ".", "LEFT_CTRL_PRESSED", "or", "control_key_state", "&", "self", ".", "RIGHT_CTRL_PRESSED", ")", "and", "result", ":", "mapping", "=", "{", "Keys", ".", "Left", ":", "Keys", ".", "ControlLeft", ",", "Keys", ".", "Right", ":", "Keys", ".", "ControlRight", ",", "Keys", ".", "Up", ":", "Keys", ".", "ControlUp", ",", "Keys", ".", "Down", ":", "Keys", ".", "ControlDown", ",", "Keys", ".", "Home", ":", "Keys", ".", "ControlHome", ",", "Keys", ".", "End", ":", "Keys", ".", "ControlEnd", ",", "Keys", ".", "Insert", ":", "Keys", ".", "ControlInsert", ",", "Keys", ".", "Delete", ":", "Keys", ".", "ControlDelete", ",", "Keys", ".", "PageUp", ":", "Keys", ".", "ControlPageUp", ",", "Keys", ".", "PageDown", ":", "Keys", ".", "ControlPageDown", ",", "}", "result", ".", "key", "=", "mapping", ".", "get", "(", "result", ".", "key", ",", "result", ".", "key", ")", "# Turn 'Tab' into 'BackTab' when shift was pressed.", "# Also handle other shift-key combination", "if", "control_key_state", "&", "self", ".", "SHIFT_PRESSED", "and", "result", ":", "mapping", "=", "{", "Keys", ".", "Tab", ":", "Keys", ".", "BackTab", ",", "Keys", ".", "Left", ":", "Keys", ".", "ShiftLeft", ",", "Keys", ".", "Right", ":", "Keys", ".", "ShiftRight", ",", "Keys", ".", "Up", ":", "Keys", ".", "ShiftUp", ",", "Keys", ".", "Down", ":", "Keys", ".", "ShiftDown", ",", "Keys", ".", "Home", ":", "Keys", ".", "ShiftHome", ",", "Keys", ".", "End", ":", "Keys", ".", "ShiftEnd", ",", "Keys", ".", "Insert", ":", "Keys", ".", "ShiftInsert", ",", "Keys", ".", "Delete", ":", "Keys", ".", "ShiftDelete", ",", "Keys", ".", "PageUp", ":", "Keys", ".", "ShiftPageUp", ",", "Keys", ".", "PageDown", ":", "Keys", ".", "ShiftPageDown", ",", "}", "result", ".", "key", "=", "mapping", ".", "get", "(", "result", ".", "key", ",", "result", ".", "key", ")", "# Turn 'Space' into 'ControlSpace' when control was pressed.", "if", "(", "(", "control_key_state", "&", "self", ".", "LEFT_CTRL_PRESSED", "or", "control_key_state", "&", "self", ".", "RIGHT_CTRL_PRESSED", ")", "and", "result", "and", "result", ".", "data", "==", "\" \"", ")", ":", "result", "=", "KeyPress", "(", "Keys", ".", "ControlSpace", ",", "\" \"", ")", "# Turn Control-Enter into META-Enter. (On a vt100 terminal, we cannot", "# detect this combination. But it's really practical on Windows.)", "if", "(", "(", "control_key_state", "&", "self", ".", "LEFT_CTRL_PRESSED", "or", "control_key_state", "&", "self", ".", "RIGHT_CTRL_PRESSED", ")", "and", "result", "and", "result", ".", "key", "==", "Keys", ".", "ControlJ", ")", ":", "return", "[", "KeyPress", "(", "Keys", ".", "Escape", ",", "\"\"", ")", ",", "result", "]", "# Return result. If alt was pressed, prefix the result with an", "# 'Escape' key, just like unix VT100 terminals do.", "# NOTE: Only replace the left alt with escape. The right alt key often", "# acts as altgr and is used in many non US keyboard layouts for", "# typing some special characters, like a backslash. We don't want", "# all backslashes to be prefixed with escape. (Esc-\\ has a", "# meaning in E-macs, for instance.)", "if", "result", ":", "meta_pressed", "=", "control_key_state", "&", "self", ".", "LEFT_ALT_PRESSED", "if", "meta_pressed", ":", "return", "[", "KeyPress", "(", "Keys", ".", "Escape", ",", "\"\"", ")", ",", "result", "]", "else", ":", "return", "[", "result", "]", "else", ":", "return", "[", "]" ]

[ "r", "RegisterAll", "()" ]

[ "def", "RegisterAll", "(", "*", "args", ")", ":", "return", "_ogr", ".", "RegisterAll", "(", "*", "args", ")" ]

[ "Dequeues", "and", "concatenates", "n", "elements", "from", "this", "queue", "." ]

[ "def", "dequeue_up_to", "(", "self", ",", "n", ",", "name", "=", "None", ")", ":", "if", "name", "is", "None", ":", "name", "=", "\"%s_DequeueUpTo\"", "%", "self", ".", "_name", "ret", "=", "gen_data_flow_ops", ".", "_queue_dequeue_up_to_v2", "(", "self", ".", "_queue_ref", ",", "n", "=", "n", ",", "component_types", "=", "self", ".", "_dtypes", ",", "name", "=", "name", ")", "# NOTE(mrry): Not using a shape function because we need access to", "# the Queue object.", "if", "context", ".", "in_graph_mode", "(", ")", ":", "op", "=", "ret", "[", "0", "]", ".", "op", "for", "output", ",", "shape", "in", "zip", "(", "op", ".", "values", "(", ")", ",", "self", ".", "_shapes", ")", ":", "output", ".", "set_shape", "(", "tensor_shape", ".", "TensorShape", "(", "[", "None", "]", ")", ".", "concatenate", "(", "shape", ")", ")", "return", "self", ".", "_dequeue_return_value", "(", "ret", ")" ]

[ "return", "an", "ndarray", "for", "our", "input", "in", "a", "platform", "independent", "manner" ]

[ "def", "_sanitize_values", "(", "arr", ")", ":", "if", "hasattr", "(", "arr", ",", "'values'", ")", ":", "arr", "=", "arr", ".", "values", "else", ":", "# scalar", "if", "is_scalar", "(", "arr", ")", ":", "arr", "=", "[", "arr", "]", "# ndarray", "if", "isinstance", "(", "arr", ",", "np", ".", "ndarray", ")", ":", "pass", "elif", "is_list_like", "(", "arr", ")", "and", "len", "(", "arr", ")", ">", "0", ":", "arr", "=", "maybe_convert_platform", "(", "arr", ")", "else", ":", "arr", "=", "np", ".", "asarray", "(", "arr", ")", "return", "arr" ]

[ "Changes", "the", "cwd", "to", "to", "path", "defined", "in", "the", "current", "graph", "." ]

[ "def", "ChangeCWD", "(", "self", ",", "suite_path", ")", ":", "suite_dir", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "dirname", "(", "suite_path", ")", ")", "bench_dir", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "*", "self", ".", "path", ")", ")", "os", ".", "chdir", "(", "os", ".", "path", ".", "join", "(", "suite_dir", ",", "bench_dir", ")", ")" ]

[ "Parses", "the", "command", "line", "arguments", "." ]

[ "def", "ParseArguments", "(", "args", ")", ":", "try", ":", "(", "opts", ",", "filenames", ")", "=", "getopt", ".", "getopt", "(", "args", ",", "''", ",", "[", "'help'", ",", "'output='", ",", "'verbose='", ",", "'counting='", ",", "'filter='", ",", "'root='", ",", "'linelength='", ",", "'extensions='", ",", "'headers='", ",", "'quiet'", "]", ")", "except", "getopt", ".", "GetoptError", ":", "PrintUsage", "(", "'Invalid arguments.'", ")", "verbosity", "=", "_VerboseLevel", "(", ")", "output_format", "=", "_OutputFormat", "(", ")", "filters", "=", "''", "quiet", "=", "_Quiet", "(", ")", "counting_style", "=", "''", "for", "(", "opt", ",", "val", ")", "in", "opts", ":", "if", "opt", "==", "'--help'", ":", "PrintUsage", "(", "None", ")", "elif", "opt", "==", "'--output'", ":", "if", "val", "not", "in", "(", "'emacs'", ",", "'vs7'", ",", "'eclipse'", ")", ":", "PrintUsage", "(", "'The only allowed output formats are emacs, vs7 and eclipse.'", ")", "output_format", "=", "val", "elif", "opt", "==", "'--quiet'", ":", "quiet", "=", "True", "elif", "opt", "==", "'--verbose'", ":", "verbosity", "=", "int", "(", "val", ")", "elif", "opt", "==", "'--filter'", ":", "filters", "=", "val", "if", "not", "filters", ":", "PrintCategories", "(", ")", "elif", "opt", "==", "'--counting'", ":", "if", "val", "not", "in", "(", "'total'", ",", "'toplevel'", ",", "'detailed'", ")", ":", "PrintUsage", "(", "'Valid counting options are total, toplevel, and detailed'", ")", "counting_style", "=", "val", "elif", "opt", "==", "'--root'", ":", "global", "_root", "_root", "=", "val", "elif", "opt", "==", "'--linelength'", ":", "global", "_line_length", "try", ":", "_line_length", "=", "int", "(", "val", ")", "except", "ValueError", ":", "PrintUsage", "(", "'Line length must be digits.'", ")", "elif", "opt", "==", "'--extensions'", ":", "global", "_valid_extensions", "try", ":", "_valid_extensions", "=", "set", "(", "val", ".", "split", "(", "','", ")", ")", "except", "ValueError", ":", "PrintUsage", "(", "'Extensions must be comma separated list.'", ")", "elif", "opt", "==", "'--headers'", ":", "ProcessHppHeadersOption", "(", "val", ")", "if", "not", "filenames", ":", "PrintUsage", "(", "'No files were specified.'", ")", "_SetOutputFormat", "(", "output_format", ")", "_SetQuiet", "(", "quiet", ")", "_SetVerboseLevel", "(", "verbosity", ")", "_SetFilters", "(", "filters", ")", "_SetCountingStyle", "(", "counting_style", ")", "return", "filenames" ]

[ "Check", "for", "unwanted", "file", "attributes" ]

[ "def", "check_file_attributes", "(", "filename", ")", ":", "mode", "=", "os", ".", "stat", "(", "filename", ")", ".", "st_mode", "if", "bool", "(", "mode", "&", "stat", ".", "S_IXUSR", ")", "or", "bool", "(", "mode", "&", "stat", ".", "S_IXGRP", ")", "or", "bool", "(", "mode", "&", "stat", ".", "S_IXOTH", ")", ":", "cc", ".", "log_warning", "(", "\"check_file_attributes\"", ",", "filename", ",", "0", ",", "\"may not have file executable bits set\"", ",", "\"\"", ")" ]

[ "check", "in", "bounds", "x", "y" ]

[ "def", "xy_bounds", "(", "self", ",", "x", ",", "y", ")", ":", "(", "r", ",", "c", ")", "=", "self", ".", "xy2rc", "(", "x", ",", "y", ")", "return", "self", ".", "rc_bounds", "(", "r", ",", "c", ")" ]

[ "Explicitly", "constructs", "the", "full", "Fisher", "block", "." ]

[ "def", "full_fisher_block", "(", "self", ")", ":", "left_factor", "=", "self", ".", "_input_factor", ".", "get_cov", "(", ")", "right_factor", "=", "self", ".", "_output_factor", ".", "get_cov", "(", ")", "return", "self", ".", "_renorm_coeff", "*", "utils", ".", "kronecker_product", "(", "left_factor", ",", "right_factor", ")" ]

[ "Sets", "the", "plot", "duration", "." ]

[ "def", "setPlotDuration", "(", "name", ":", "str", ",", "time", ":", "float", ")", "->", "None", ":", "setAttribute", "(", "name", ",", "'duration'", ",", "time", ")" ]

[ "Implement", "the", "ceiling", "()", "XPath", "function", "number", "ceiling", "(", "number", ")", "The", "ceiling", "function", "returns", "the", "smallest", "(", "closest", "to", "negative", "infinity", ")", "number", "that", "is", "not", "less", "than", "the", "argument", "and", "that", "is", "an", "integer", "." ]

[ "def", "xpathCeilingFunction", "(", "self", ",", "nargs", ")", ":", "libxml2mod", ".", "xmlXPathCeilingFunction", "(", "self", ".", "_o", ",", "nargs", ")" ]

[ "Return", "list", "of", "registry", "keys", "." ]

[ "def", "read_keys", "(", "base", ",", "key", ")", ":", "try", ":", "handle", "=", "RegOpenKeyEx", "(", "base", ",", "key", ")", "except", "RegError", ":", "return", "None", "L", "=", "[", "]", "i", "=", "0", "while", "True", ":", "try", ":", "k", "=", "RegEnumKey", "(", "handle", ",", "i", ")", "except", "RegError", ":", "break", "L", ".", "append", "(", "k", ")", "i", "+=", "1", "return", "L" ]

[ "SetDirectory", "(", "self", "String", "dir", ")" ]

[ "def", "SetDirectory", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "FileDialog_SetDirectory", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Get", "an", "generator", "returning", "random", "free", "ports", "on", "the", "system", "." ]

[ "def", "FindProbableFreePorts", "(", ")", ":", "# This is the range of dynamic ports. See RFC6335 page 10.", "dynamic_ports", "=", "list", "(", "range", "(", "49152", ",", "65535", ")", ")", "random", ".", "shuffle", "(", "dynamic_ports", ")", "for", "port", "in", "dynamic_ports", ":", "try", ":", "socket", ".", "create_connection", "(", "(", "'127.0.0.1'", ",", "port", ")", ",", "0.2", ")", ".", "close", "(", ")", "except", "socket", ".", "error", ":", "# If we can't connect to the port, then clearly nothing is listening on", "# it.", "yield", "port", "raise", "RuntimeError", "(", "'Cannot find open port'", ")" ]

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

[ "def", "GetSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PrintDialogData_GetSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Extracts", "discoverable", "resource", "urls", "from", "a", "loading", "trace", "according", "to", "a", "sub", "-", "resource", "discoverer", "." ]

[ "def", "_ExtractDiscoverableUrls", "(", "original_headers_path", ",", "loading_trace_path", ",", "subresource_discoverer", ")", ":", "assert", "subresource_discoverer", "in", "SUBRESOURCE_DISCOVERERS", ",", "'unknown prefetch simulation {}'", ".", "format", "(", "subresource_discoverer", ")", "logging", ".", "info", "(", "'loading %s'", ",", "loading_trace_path", ")", "trace", "=", "loading_trace", ".", "LoadingTrace", ".", "FromJsonFile", "(", "loading_trace_path", ")", "dependencies_lens", "=", "RequestDependencyLens", "(", "trace", ")", "# Build the list of discovered requests according to the desired simulation.", "discovered_requests", "=", "[", "]", "if", "subresource_discoverer", "==", "Discoverer", ".", "HTMLPreloadScannerStore", ":", "requests", "=", "_DiscoverRequests", "(", "dependencies_lens", ",", "Discoverer", ".", "HTMLPreloadScanner", ")", "discovered_requests", "=", "_PruneOutOriginalNoStoreRequests", "(", "original_headers_path", ",", "requests", ")", "else", ":", "discovered_requests", "=", "_DiscoverRequests", "(", "dependencies_lens", ",", "subresource_discoverer", ")", "whitelisted_urls", "=", "set", "(", ")", "for", "request", "in", "sandwich_utils", ".", "FilterOutDataAndIncompleteRequests", "(", "discovered_requests", ")", ":", "logging", ".", "debug", "(", "'white-listing %s'", ",", "request", ".", "url", ")", "whitelisted_urls", ".", "add", "(", "request", ".", "url", ")", "logging", ".", "info", "(", "'number of white-listed resources: %d'", ",", "len", "(", "whitelisted_urls", ")", ")", "return", "whitelisted_urls" ]

[ "Generate", "kernel_arg_access_qual", "metadata" ]

[ "def", "gen_arg_access_qual_md", "(", "fn", ")", ":", "mod", "=", "fn", ".", "module", "consts", "=", "[", "lc", ".", "MetaDataString", ".", "get", "(", "mod", ",", "\"none\"", ")", "]", "*", "len", "(", "fn", ".", "args", ")", "name", "=", "lc", ".", "MetaDataString", ".", "get", "(", "mod", ",", "\"kernel_arg_access_qual\"", ")", "return", "lc", ".", "MetaData", ".", "get", "(", "mod", ",", "[", "name", "]", "+", "consts", ")" ]

[ "Read", "size", "bytes", "from", "the", "serial", "port", ".", "If", "a", "timeout", "is", "set", "it", "may", "return", "less", "characters", "as", "requested", ".", "With", "no", "timeout", "it", "will", "block", "until", "the", "requested", "number", "of", "bytes", "is", "read", "." ]

[ "def", "read", "(", "self", ",", "size", "=", "1", ")", ":", "if", "not", "self", ".", "_isOpen", ":", "raise", "portNotOpenError", "data", "=", "bytearray", "(", ")", "if", "self", ".", "_timeout", "is", "not", "None", ":", "timeout", "=", "time", ".", "time", "(", ")", "+", "self", ".", "_timeout", "else", ":", "timeout", "=", "None", "while", "len", "(", "data", ")", "<", "size", "and", "(", "timeout", "is", "None", "or", "time", ".", "time", "(", ")", "<", "timeout", ")", ":", "try", ":", "# an implementation with internal buffer would be better", "# performing...", "t", "=", "time", ".", "time", "(", ")", "block", "=", "self", ".", "_socket", ".", "recv", "(", "size", "-", "len", "(", "data", ")", ")", "duration", "=", "time", ".", "time", "(", ")", "-", "t", "if", "block", ":", "data", ".", "extend", "(", "block", ")", "else", ":", "# no data -> EOF (connection probably closed)", "break", "except", "socket", ".", "timeout", ":", "# just need to get out of recv from time to time to check if", "# still alive", "continue", "except", "socket", ".", "error", ",", "e", ":", "# connection fails -> terminate loop", "raise", "SerialException", "(", "'connection failed (%s)'", "%", "e", ")", "return", "bytes", "(", "data", ")" ]

[ "Draws", "a", "caffe", "net", "and", "returns", "the", "image", "string", "encoded", "using", "the", "given", "extension", "." ]

[ "def", "draw_net", "(", "caffe_net", ",", "rankdir", ",", "ext", "=", "'png'", ",", "phase", "=", "None", ")", ":", "return", "get_pydot_graph", "(", "caffe_net", ",", "rankdir", ",", "phase", "=", "phase", ")", ".", "create", "(", "format", "=", "ext", ")" ]

[ "Skip", "a", "fixed64", "value", ".", "Returns", "the", "new", "position", "." ]

[ "def", "_SkipFixed64", "(", "buffer", ",", "pos", ",", "end", ")", ":", "pos", "+=", "8", "if", "pos", ">", "end", ":", "raise", "_DecodeError", "(", "'Truncated message.'", ")", "return", "pos" ]

[ "This", "will", "always", "alias", "the", "supplied", "buffer", "-", "like", "object", ".", "Pass", "in", "a", "copy", "to", "avoid", "unintentional", "aliasing", "." ]

[ "def", "__init__", "(", "self", ",", "data", ":", "BufferT", ",", "info", ":", "SensorInfo", ",", "timestamp", ":", "Optional", "[", "float", "]", "=", "None", ")", "->", "None", ":", "self", ".", "_pf", "=", "_client", ".", "PacketFormat", ".", "from_info", "(", "info", ")", "self", ".", "_data", "=", "np", ".", "frombuffer", "(", "data", ",", "dtype", "=", "np", ".", "uint8", ",", "count", "=", "self", ".", "_pf", ".", "imu_packet_size", ")", "self", ".", "capture_timestamp", "=", "timestamp" ]

[ "Compute", "an", "ns", "-", "package", "subpath", "for", "a", "filesystem", "or", "zipfile", "importer" ]

[ "def", "file_ns_handler", "(", "importer", ",", "path_item", ",", "packageName", ",", "module", ")", ":", "subpath", "=", "os", ".", "path", ".", "join", "(", "path_item", ",", "packageName", ".", "split", "(", "'.'", ")", "[", "-", "1", "]", ")", "normalized", "=", "_normalize_cached", "(", "subpath", ")", "for", "item", "in", "module", ".", "__path__", ":", "if", "_normalize_cached", "(", "item", ")", "==", "normalized", ":", "break", "else", ":", "# Only return the path if it's not already there", "return", "subpath" ]

[ "Terminate", "the", "curses", "screen", "." ]

[ "def", "_screen_terminate", "(", "self", ")", ":", "self", ".", "_stdscr", ".", "keypad", "(", "0", ")", "curses", ".", "nocbreak", "(", ")", "curses", ".", "echo", "(", ")", "curses", ".", "endwin", "(", ")" ]

[ "sanitizes", "the", "pipeline", "graph" ]

[ "def", "get_pipeline", "(", ")", ":", "proxies", "=", "inspect", "(", "skip_invisible", "=", "False", ")", "for", "proxy", "in", "proxies", ":", "source", "=", "paraview", ".", "simple", ".", "FindSource", "(", "proxy", "[", "'name'", "]", ")", "numberOfProducers", "=", "source", ".", "GetNumberOfProducers", "(", ")", "if", "proxy", "[", "'parent'", "]", "==", "'0'", "and", "numberOfProducers", ">", "0", ":", "# this proxy is the result of a merge", "parents", "=", "[", "]", "for", "i", "in", "xrange", "(", "numberOfProducers", ")", ":", "parents", ".", "append", "(", "source", ".", "GetProducerProxy", "(", "i", ")", ".", "GetGlobalIDAsString", "(", ")", ")", "proxy", "[", "'parents'", "]", "=", "parents", "else", ":", "proxy", "[", "'parents'", "]", "=", "[", "proxy", "[", "'parent'", "]", "]", "del", "proxy", "[", "'parent'", "]", "for", "proxy", "in", "proxies", ":", "proxy", "[", "'children'", "]", "=", "[", "p", "[", "'id'", "]", "for", "p", "in", "proxies", "if", "proxy", "[", "'id'", "]", "in", "p", "[", "'parents'", "]", "]", "return", "proxies" ]

[ "Return", "a", "true", "filesystem", "path", "for", "specified", "resource" ]

[ "def", "resource_filename", "(", "self", ",", "package_or_requirement", ",", "resource_name", ")", ":", "return", "get_provider", "(", "package_or_requirement", ")", ".", "get_resource_filename", "(", "self", ",", "resource_name", ")" ]

[ "Return", "None" ]

[ "def", "get_code", "(", "self", ",", "fullname", ")", ":", "self", ".", "__get_module", "(", "fullname", ")", "# eventually raises ImportError", "return", "None" ]

[ "Publishes", "a", "single", "diagnostic", "status", "or", "a", "vector", "of", "diagnostic", "statuses", "." ]

[ "def", "publish", "(", "self", ",", "msg", ")", ":", "if", "not", "type", "(", "msg", ")", "is", "list", ":", "msg", "=", "[", "msg", "]", "for", "stat", "in", "msg", ":", "stat", ".", "name", "=", "rospy", ".", "get_name", "(", ")", "[", "1", ":", "]", "+", "\": \"", "+", "stat", ".", "name", "da", "=", "DiagnosticArray", "(", ")", "da", ".", "status", "=", "msg", "da", ".", "header", ".", "stamp", "=", "rospy", ".", "Time", ".", "now", "(", ")", "# Add timestamp for ROS 0.10", "self", ".", "publisher", ".", "publish", "(", "da", ")" ]

[ "changed_callback", "-", "Callable", "will", "be", "called", "after", "insert", "or", "delete", "operations", "with", "the", "current", "end", "line", "number", "." ]

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

[ "Function", "to", "explore", "pointer", "types", ".", "See", "Explorer", ".", "explore_type", "for", "more", "information", "." ]

[ "def", "explore_type", "(", "name", ",", "datatype", ",", "is_child", ")", ":", "target_type", "=", "datatype", ".", "target", "(", ")", "Explorer", ".", "explore_type", "(", "name", ",", "target_type", ",", "is_child", ")", "return", "False" ]

[ "TODO", "WRITEME", "." ]

[ "def", "wait", "(", "*", "*", "kwargs", ")", ":", "# plt.pause seems to be broken in mpl:2.1", "# ax.canvas.draw_onIdle()", "updateAxes", "(", "plt", ".", "gca", "(", ")", ")", "kp", "=", "kwargs", ".", "pop", "(", "'untilKeyPressed'", ",", "False", ")", "if", "kp", "==", "True", ":", "plt", ".", "waitforbuttonpress", "(", "*", "*", "kwargs", ")", "else", ":", "plt", ".", "show", "(", "*", "*", "kwargs", ")" ]

[ "Default", "class", "constructor", ".", "For", "internal", "use", ":", "do", "not", "call", "it", "in", "your", "code!" ]

[ "def", "__init__", "(", "self", ",", "evtType", ",", "evtId", ",", "*", "*", "kwargs", ")", ":", "wx", ".", "PyCommandEvent", ".", "__init__", "(", "self", ",", "evtType", ",", "evtId", ",", "*", "*", "kwargs", ")" ]

[ "A", "dual", "channel", "memory", "system", "using", "DDR4_2400_8x8", "based", "DIMM" ]

[ "def", "DualChannelDDR4_2400", "(", "size", ":", "Optional", "[", "str", "]", "=", "None", ",", ")", "->", "AbstractMemorySystem", ":", "return", "ChanneledMemory", "(", "DDR4_2400_8x8", ",", "2", ",", "64", ",", "size", "=", "size", ",", ")" ]

[ "Return", "a", "ndarray", "of", "the", "minimum", "argument", "indexer", "." ]

[ "def", "argmin", "(", "self", ",", "axis", "=", "None", ",", "skipna", "=", "True", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "nv", ".", "validate_minmax_axis", "(", "axis", ")", "nv", ".", "validate_argmax_with_skipna", "(", "skipna", ",", "args", ",", "kwargs", ")", "return", "nanops", ".", "nanargmin", "(", "self", ".", "_values", ",", "skipna", "=", "skipna", ")" ]

[ "Fragments", "atomic", "pairwise", "dispersion", "contributions", "from", "DFTD3", "for", "inclusion", "in", "F", "-", "SAPT", "-", "D", ".", "Arguments", "---------", "d3disp", ":", "numpy", ".", "ndarray", "[", "float", "]", "(", "NA", "NB", ")", "array", "of", "atom", "-", "pairwise", "dispersion", "computed", "by", "DFTD3", "frags", ":", "Dict", "[", "str", "Dict", "[", "str", "List", "[", "str", "]]]", "Dictionary", "containing", "fragment", "information", "read", "from", "fA", ".", "dat", "and", "fB", ".", "dat", "natoms", ":", "Dict", "[", "str", "int", "]", "Dictionary", "containing", "number", "of", "atoms", "in", "each", "monomer", "Returns", "-------", "Edisp", ":", "float", "Dispersion", "energy", "computed", "from", "pairwise", "analysis", "D3pairs", ":", "Dict", "[", "str", "Dict", "[", "str", "float", "]]", "Dictionary", "containing", "reduced", "order", "-", "2", "dispersion", "interactions", "between", "fragments" ]

[ "def", "fragment_d3_disp", "(", "d3disp", ":", "np", ".", "ndarray", ",", "frags", ":", "Dict", "[", "str", ",", "Dict", "[", "str", ",", "List", "[", "str", "]", "]", "]", ")", "->", "Tuple", "[", "float", ",", "Dict", "[", "str", ",", "Dict", "[", "str", ",", "float", "]", "]", "]", ":", "# Iterate over fragments, pull out relevant contributions to each", "D3frags", "=", "{", "}", "for", "fA", ",", "idA", "in", "frags", "[", "'A'", "]", ".", "items", "(", ")", ":", "if", "'Link'", "in", "fA", ":", "continue", "idA", "=", "np", ".", "array", "(", "idA", ")", "D3frags", "[", "fA", "]", "=", "{", "}", "for", "fB", ",", "idB", "in", "frags", "[", "'B'", "]", ".", "items", "(", ")", ":", "if", "'Link'", "in", "fB", ":", "continue", "fe", "=", "0.0", "for", "i", "in", "idA", ":", "for", "j", "in", "idB", ":", "fe", "+=", "d3disp", "[", "i", "]", "[", "j", "]", "# Energies read are already in kcal/mol!", "D3frags", "[", "fA", "]", "[", "fB", "]", "=", "fe", "return", "D3frags" ]

[ "sleep", "until", "time", "." ]

[ "def", "sleep_until", "(", "self", ",", "cyber_time", ")", ":", "if", "isinstance", "(", "time", ",", "Time", ")", ":", "return", "_CYBER_TIME", ".", "PyTime_sleep_until", "(", "self", ".", "time", ",", "cyber_time", ".", "to_nsec", "(", ")", ")", "return", "NotImplemented" ]

[ "generate", "voxels", "/", "indices", "/", "num_point_per_voxel", "/", "pc_voxel_ids", "from", "point", "cloud", ".", "This", "function", "don", "t", "return", "pc_voxel_id", "for", "backward", "compatility", ".", "pc_voxel_id", "will", "be", "added", "in", "spconv", "2", ".", "2", ".", "Args", ":", "pc", ":", "[", "N", "3", "+", "]", "point", "cloud", ".", "clear_voxels", ":", "if", "True", "call", "zero", "on", "voxels", "empty_mean", ":", "if", "True", "full", "empty", "location", "of", "voxels", "with", "mean", ".", "Returns", ":", "voxels", ":", "voxels", "indices", ":", "quantized", "coords", "num_per_voxel", ":", "number", "of", "points", "in", "a", "voxel" ]

[ "def", "__call__", "(", "self", ",", "pc", ":", "torch", ".", "Tensor", ",", "clear_voxels", ":", "bool", "=", "True", ",", "empty_mean", ":", "bool", "=", "False", ")", ":", "res", "=", "self", ".", "generate_voxel_with_id", "(", "pc", ",", "clear_voxels", ",", "empty_mean", ")", "return", "res", "[", "0", "]", ",", "res", "[", "1", "]", ",", "res", "[", "2", "]" ]

[ "Get", "the", "path", "to", "the", "specified", "file", "in", "the", "data", "dependencies", "." ]

[ "def", "get_path_to_datafile", "(", "path", ")", ":", "data_files_path", "=", "_os", ".", "path", ".", "dirname", "(", "_inspect", ".", "getfile", "(", "_sys", ".", "_getframe", "(", "1", ")", ")", ")", "return", "_os", ".", "path", ".", "join", "(", "data_files_path", ",", "path", ")" ]

[ "Extracts", "all", "the", "output", "names", "from", "a", "list", "of", "reduction", "packages", "." ]

[ "def", "get_all_names_to_save", "(", "reduction_packages", ",", "save_can", ")", ":", "def", "get_ws_names_from_group", "(", "ws_group", ")", ":", "return", "[", "ws", ".", "name", "(", ")", "for", "ws", "in", "ws_group", "]", "names_to_save", "=", "[", "]", "for", "reduction_package", "in", "reduction_packages", ":", "reduced_lab", "=", "reduction_package", ".", "reduced_lab", "reduced_hab", "=", "reduction_package", ".", "reduced_hab", "reduced_merged", "=", "reduction_package", ".", "reduced_merged", "reduced_lab_can", "=", "reduction_package", ".", "reduced_lab_can", "reduced_hab_can", "=", "reduction_package", ".", "reduced_hab_can", "reduced_lab_sample", "=", "reduction_package", ".", "reduced_lab_sample", "reduced_hab_sample", "=", "reduction_package", ".", "reduced_hab_sample", "trans_name", "=", "get_transmission_names_to_save", "(", "reduction_package", ",", "False", ")", "trans_can_name", "=", "get_transmission_names_to_save", "(", "reduction_package", ",", "True", ")", "if", "save_can", ":", "if", "reduced_merged", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_merged", ")", ",", "trans_name", ",", "trans_can_name", ")", ")", "if", "reduced_lab", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_lab", ")", ",", "trans_name", ",", "trans_can_name", ")", ")", "if", "reduced_hab", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_hab", ")", ",", "trans_name", ",", "trans_can_name", ")", ")", "if", "reduced_lab_can", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_lab_can", ")", ",", "[", "]", ",", "trans_can_name", ")", ")", "if", "reduced_hab_can", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_hab_can", ")", ",", "[", "]", ",", "trans_can_name", ")", ")", "if", "reduced_lab_sample", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_lab_sample", ")", ",", "trans_name", ",", "[", "]", ")", ")", "if", "reduced_hab_sample", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_hab_sample", ")", ",", "trans_name", ",", "[", "]", ")", ")", "# If we have merged reduction then store the", "elif", "reduced_merged", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_merged", ")", ",", "trans_name", ",", "trans_can_name", ")", ")", "else", ":", "if", "reduced_lab", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_lab", ")", ",", "trans_name", ",", "trans_can_name", ")", ")", "if", "reduced_hab", ":", "names_to_save", ".", "append", "(", "(", "get_ws_names_from_group", "(", "reduced_hab", ")", ",", "trans_name", ",", "trans_can_name", ")", ")", "return", "names_to_save" ]

[ "Check", "mode", "and", "that", "encoding", "and", "newline", "are", "compatible", "." ]

[ "def", "_check_mode", "(", "mode", ",", "encoding", ",", "newline", ")", ":", "if", "\"t\"", "in", "mode", ":", "if", "\"b\"", "in", "mode", ":", "raise", "ValueError", "(", "\"Invalid mode: %r\"", "%", "(", "mode", ",", ")", ")", "else", ":", "if", "encoding", "is", "not", "None", ":", "raise", "ValueError", "(", "\"Argument 'encoding' not supported in binary mode\"", ")", "if", "newline", "is", "not", "None", ":", "raise", "ValueError", "(", "\"Argument 'newline' not supported in binary mode\"", ")" ]

[ "Returns", "the", "variables", "Xcode", "would", "set", "for", "postbuild", "steps", "." ]

[ "def", "GetSortedXcodePostbuildEnv", "(", "self", ")", ":", "postbuild_settings", "=", "{", "}", "# CHROMIUM_STRIP_SAVE_FILE is a chromium-specific hack.", "# TODO(thakis): It would be nice to have some general mechanism instead.", "strip_save_file", "=", "self", ".", "xcode_settings", ".", "GetPerTargetSetting", "(", "\"CHROMIUM_STRIP_SAVE_FILE\"", ")", "if", "strip_save_file", ":", "postbuild_settings", "[", "\"CHROMIUM_STRIP_SAVE_FILE\"", "]", "=", "strip_save_file", "return", "self", ".", "GetSortedXcodeEnv", "(", "additional_settings", "=", "postbuild_settings", ")" ]

[ "Checks", "that", "VLOG", "()", "is", "only", "used", "for", "defining", "a", "logging", "level", "." ]

[ "def", "CheckVlogArguments", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "Search", "(", "r'\\bVLOG\\((INFO|ERROR|WARNING|DFATAL|FATAL)\\)'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/vlog'", ",", "5", ",", "'VLOG() should be used with numeric verbosity level. '", "'Use LOG() if you want symbolic severity levels.'", ")" ]

[ "get", "selective", "search", "roidb", "and", "ground", "truth", "roidb", ":", "param", "gt_roidb", ":", "ground", "truth", "roidb", ":", "param", "append_gt", ":", "append", "ground", "truth", ":", "return", ":", "roidb", "of", "selective", "search" ]

[ "def", "selective_search_roidb", "(", "self", ",", "gt_roidb", ",", "append_gt", "=", "False", ")", ":", "cache_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "cache_path", ",", "self", ".", "name", "+", "'_ss_roidb.pkl'", ")", "if", "os", ".", "path", ".", "exists", "(", "cache_file", ")", ":", "with", "open", "(", "cache_file", ",", "'rb'", ")", "as", "fid", ":", "roidb", "=", "cPickle", ".", "load", "(", "fid", ")", "logger", ".", "info", "(", "'%s ss roidb loaded from %s'", "%", "(", "self", ".", "name", ",", "cache_file", ")", ")", "return", "roidb", "if", "append_gt", ":", "logger", ".", "info", "(", "'%s appending ground truth annotations'", "%", "self", ".", "name", ")", "ss_roidb", "=", "self", ".", "load_selective_search_roidb", "(", "gt_roidb", ")", "roidb", "=", "IMDB", ".", "merge_roidbs", "(", "gt_roidb", ",", "ss_roidb", ")", "else", ":", "roidb", "=", "self", ".", "load_selective_search_roidb", "(", "gt_roidb", ")", "with", "open", "(", "cache_file", ",", "'wb'", ")", "as", "fid", ":", "cPickle", ".", "dump", "(", "roidb", ",", "fid", ",", "cPickle", ".", "HIGHEST_PROTOCOL", ")", "logger", ".", "info", "(", "'%s wrote ss roidb to %s'", "%", "(", "self", ".", "name", ",", "cache_file", ")", ")", "return", "roidb" ]

[ "Test", "whether", "current", "replica", "group", "is", "catalog", "replica", "group", "." ]

[ "def", "is_catalog", "(", "self", ")", ":", "iscatalog", "=", "False", "rc", ",", "is_cata", "=", "sdb", ".", "gp_is_catalog", "(", "self", ".", "_group", ")", "raise_if_error", "(", "rc", ",", "\"Failed to check if is catalog\"", ")", "if", "TRUE", "==", "is_cata", ":", "iscatalog", "=", "True", "return", "iscatalog" ]

[ "Update", "permissions", "." ]

[ "def", "update_permissions", "(", "path", ")", ":", "if", "platform", ".", "system", "(", ")", "==", "\"Windows\"", ":", "return", "for", "dirpath", ",", "dirnames", ",", "filenames", "in", "os", ".", "walk", "(", "path", ")", ":", "for", "dirname", "in", "dirnames", ":", "dir_fullpath", "=", "os", ".", "path", ".", "join", "(", "dirpath", ",", "dirname", ")", "os", ".", "chmod", "(", "dir_fullpath", ",", "stat", ".", "S_IREAD", "|", "stat", ".", "S_IWRITE", "|", "stat", ".", "S_IEXEC", "|", "stat", ".", "S_IRGRP", "|", "stat", ".", "S_IXGRP", ")", "for", "filename", "in", "filenames", ":", "file_fullpath", "=", "os", ".", "path", ".", "join", "(", "dirpath", ",", "filename", ")", "os", ".", "chmod", "(", "file_fullpath", ",", "stat", ".", "S_IREAD", ")" ]

[ "LoadXml", "(", "TUCh", "self", "PXmlTok", "const", "&", "XmlTok", "TStr", "Nm", ")" ]

[ "def", "LoadXml", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TUCh_LoadXml", "(", "self", ",", "*", "args", ")" ]

[ "the", "metadata", "of", "my", "field" ]

[ "def", "metadata", "(", "self", ")", ":", "return", "getattr", "(", "self", ".", "queryables", ".", "get", "(", "self", ".", "lhs", ")", ",", "\"metadata\"", ",", "None", ")" ]

[ "Generates", "a", "series", "of", "temporary", "names", "." ]

[ "def", "_generate_names", "(", "cls", ",", "name", ")", ":", "# type: (str) -> Iterator[str]", "for", "i", "in", "range", "(", "1", ",", "len", "(", "name", ")", ")", ":", "for", "candidate", "in", "itertools", ".", "combinations_with_replacement", "(", "cls", ".", "LEADING_CHARS", ",", "i", "-", "1", ")", ":", "new_name", "=", "'~'", "+", "''", ".", "join", "(", "candidate", ")", "+", "name", "[", "i", ":", "]", "if", "new_name", "!=", "name", ":", "yield", "new_name", "# If we make it this far, we will have to make a longer name", "for", "i", "in", "range", "(", "len", "(", "cls", ".", "LEADING_CHARS", ")", ")", ":", "for", "candidate", "in", "itertools", ".", "combinations_with_replacement", "(", "cls", ".", "LEADING_CHARS", ",", "i", ")", ":", "new_name", "=", "'~'", "+", "''", ".", "join", "(", "candidate", ")", "+", "name", "if", "new_name", "!=", "name", ":", "yield", "new_name" ]

[ "Check", "if", "expression", "looks", "like", "a", "type", "name", "returns", "true", "if", "so", "." ]

[ "def", "_IsType", "(", "clean_lines", ",", "nesting_state", ",", "expr", ")", ":", "# Keep only the last token in the expression", "last_word", "=", "Match", "(", "r'^.*(\\b\\S+)$'", ",", "expr", ")", "if", "last_word", ":", "token", "=", "last_word", ".", "group", "(", "1", ")", "else", ":", "token", "=", "expr", "# Match native types and stdint types", "if", "_TYPES", ".", "match", "(", "token", ")", ":", "return", "True", "# Try a bit harder to match templated types. Walk up the nesting", "# stack until we find something that resembles a typename", "# declaration for what we are looking for.", "typename_pattern", "=", "(", "r'\\b(?:typename|class|struct)\\s+'", "+", "re", ".", "escape", "(", "token", ")", "+", "r'\\b'", ")", "block_index", "=", "len", "(", "nesting_state", ".", "stack", ")", "-", "1", "while", "block_index", ">=", "0", ":", "if", "isinstance", "(", "nesting_state", ".", "stack", "[", "block_index", "]", ",", "_NamespaceInfo", ")", ":", "return", "False", "# Found where the opening brace is. We want to scan from this", "# line up to the beginning of the function, minus a few lines.", "# template <typename Type1, // stop scanning here", "# ...>", "# class C", "# : public ... { // start scanning here", "last_line", "=", "nesting_state", ".", "stack", "[", "block_index", "]", ".", "starting_linenum", "next_block_start", "=", "0", "if", "block_index", ">", "0", ":", "next_block_start", "=", "nesting_state", ".", "stack", "[", "block_index", "-", "1", "]", ".", "starting_linenum", "first_line", "=", "last_line", "while", "first_line", ">=", "next_block_start", ":", "if", "clean_lines", ".", "elided", "[", "first_line", "]", ".", "find", "(", "'template'", ")", ">=", "0", ":", "break", "first_line", "-=", "1", "if", "first_line", "<", "next_block_start", ":", "# Didn't find any \"template\" keyword before reaching the next block,", "# there are probably no template things to check for this block", "block_index", "-=", "1", "continue", "# Look for typename in the specified range", "for", "i", "in", "xrange", "(", "first_line", ",", "last_line", "+", "1", ",", "1", ")", ":", "if", "Search", "(", "typename_pattern", ",", "clean_lines", ".", "elided", "[", "i", "]", ")", ":", "return", "True", "block_index", "-=", "1", "return", "False" ]

[ "GetStyle", "(", "self", "String", "param", "=", "StyleString", "int", "defaults", "=", "0", ")", "-", ">", "int" ]

[ "def", "GetStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_xrc", ".", "XmlResourceHandler_GetStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "a", "duration", "to", "an", "array", "and", "calculate", "the", "mean", "duration", "." ]

[ "def", "get_mean_duration", "(", "accumulated", ",", "duration", ",", "maxAccumulatedEntries", "=", "30", ")", ":", "accumulated", ".", "append", "(", "duration", ")", "if", "(", "len", "(", "accumulated", ")", ">", "maxAccumulatedEntries", ")", ":", "accumulated", ".", "pop", "(", "0", ")", "durations", "=", "np", ".", "array", "(", "accumulated", ")", "mean", "=", "np", ".", "mean", "(", "durations", ")", "return", "mean" ]

[ "block", "until", "messages", "are", "read", "off", "of", "socket" ]

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

[ "Remove", "strings", "(", "presumably", "filenames", ")", "from", "files", "that", "match", "pattern", "." ]

[ "def", "exclude_pattern", "(", "self", ",", "pattern", ",", "anchor", "=", "1", ",", "prefix", "=", "None", ",", "is_regex", "=", "0", ")", ":", "files_found", "=", "0", "pattern_re", "=", "translate_pattern", "(", "pattern", ",", "anchor", ",", "prefix", ",", "is_regex", ")", "self", ".", "debug_print", "(", "\"exclude_pattern: applying regex r'%s'\"", "%", "pattern_re", ".", "pattern", ")", "for", "i", "in", "range", "(", "len", "(", "self", ".", "files", ")", "-", "1", ",", "-", "1", ",", "-", "1", ")", ":", "if", "pattern_re", ".", "search", "(", "self", ".", "files", "[", "i", "]", ")", ":", "self", ".", "debug_print", "(", "\" removing \"", "+", "self", ".", "files", "[", "i", "]", ")", "del", "self", ".", "files", "[", "i", "]", "files_found", "=", "1", "return", "files_found" ]

[ "Create", "a", "base", "class", "with", "a", "metaclass", "." ]

[ "def", "with_metaclass", "(", "meta", ",", "*", "bases", ")", ":", "# This requires a bit of explanation: the basic idea is to make a dummy", "# metaclass for one level of class instantiation that replaces itself with", "# the actual metaclass.", "class", "metaclass", "(", "meta", ")", ":", "def", "__new__", "(", "cls", ",", "name", ",", "this_bases", ",", "d", ")", ":", "return", "meta", "(", "name", ",", "bases", ",", "d", ")", "return", "type", ".", "__new__", "(", "metaclass", ",", "'temporary_class'", ",", "(", ")", ",", "{", "}", ")" ]

[ "Prompt", "user", "with", "upgrade", "suggestion", "message" ]

[ "def", "upgrade_message", "(", "msg", ")", ":", "wait_for_end_of_video", "(", ")", "if", "ADDON", ".", "getSetting", "(", "'lastnotified_version'", ")", "<", "ADDON_VERSION", ":", "xbmcgui", ".", "Dialog", "(", ")", ".", "ok", "(", "ADDON_NAME", ",", "'[CR]'", ".", "join", "(", "[", "localise", "(", "msg", ")", ",", "localise", "(", "32001", ")", ",", "localise", "(", "32002", ")", "]", ")", ")", "else", ":", "log", "(", "'Already notified one time for upgrading.'", ")" ]

[ "Convenience", "accessor", "to", "obtain", "an", "XCBuildConfiguration", "by", "name", "." ]

[ "def", "ConfigurationNamed", "(", "self", ",", "name", ")", ":", "for", "configuration", "in", "self", ".", "_properties", "[", "'buildConfigurations'", "]", ":", "if", "configuration", ".", "_properties", "[", "'name'", "]", "==", "name", ":", "return", "configuration", "raise", "KeyError", ",", "name" ]

[ "Get", "the", "server", "this", "client", "is", "connected", "to", "." ]

[ "def", "client_info", "(", "self", ")", ":", "return", "self", ".", "_options", "[", "'server'", "]" ]

[ "Extract", "all", "the", "necessary", "information" ]

[ "def", "__init__", "(", "self", ",", "val", ")", ":", "# The gdb extension does not support value template arguments - need to extract them by hand", "type", "=", "val", ".", "type", "if", "type", ".", "code", "==", "gdb", ".", "TYPE_CODE_REF", ":", "type", "=", "type", ".", "target", "(", ")", "self", ".", "type", "=", "type", ".", "unqualified", "(", ")", ".", "strip_typedefs", "(", ")", "self", ".", "innerType", "=", "self", ".", "type", ".", "template_argument", "(", "0", ")", "self", ".", "val", "=", "val", "# Quaternions have a struct as their storage, so we need to walk through this", "self", ".", "data", "=", "self", ".", "val", "[", "'m_coeffs'", "]", "[", "'m_storage'", "]", "[", "'m_data'", "]", "[", "'array'", "]", "self", ".", "data", "=", "self", ".", "data", ".", "cast", "(", "self", ".", "innerType", ".", "pointer", "(", ")", ")" ]

[ "Receives", "a", "Response", ".", "Returns", "a", "generator", "of", "Responses", "." ]

[ "def", "resolve_redirects", "(", "self", ",", "resp", ",", "req", ",", "stream", "=", "False", ",", "timeout", "=", "None", ",", "verify", "=", "True", ",", "cert", "=", "None", ",", "proxies", "=", "None", ",", "*", "*", "adapter_kwargs", ")", ":", "i", "=", "0", "hist", "=", "[", "]", "# keep track of history", "while", "resp", ".", "is_redirect", ":", "prepared_request", "=", "req", ".", "copy", "(", ")", "if", "i", ">", "0", ":", "# Update history and keep track of redirects.", "hist", ".", "append", "(", "resp", ")", "new_hist", "=", "list", "(", "hist", ")", "resp", ".", "history", "=", "new_hist", "try", ":", "resp", ".", "content", "# Consume socket so it can be released", "except", "(", "ChunkedEncodingError", ",", "ContentDecodingError", ",", "RuntimeError", ")", ":", "resp", ".", "raw", ".", "read", "(", "decode_content", "=", "False", ")", "if", "i", ">=", "self", ".", "max_redirects", ":", "raise", "TooManyRedirects", "(", "'Exceeded %s redirects.'", "%", "self", ".", "max_redirects", ")", "# Release the connection back into the pool.", "resp", ".", "close", "(", ")", "url", "=", "resp", ".", "headers", "[", "'location'", "]", "method", "=", "req", ".", "method", "# Handle redirection without scheme (see: RFC 1808 Section 4)", "if", "url", ".", "startswith", "(", "'//'", ")", ":", "parsed_rurl", "=", "urlparse", "(", "resp", ".", "url", ")", "url", "=", "'%s:%s'", "%", "(", "parsed_rurl", ".", "scheme", ",", "url", ")", "# The scheme should be lower case...", "parsed", "=", "urlparse", "(", "url", ")", "url", "=", "parsed", ".", "geturl", "(", ")", "# Facilitate relative 'location' headers, as allowed by RFC 7231.", "# (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')", "# Compliant with RFC3986, we percent encode the url.", "if", "not", "parsed", ".", "netloc", ":", "url", "=", "urljoin", "(", "resp", ".", "url", ",", "requote_uri", "(", "url", ")", ")", "else", ":", "url", "=", "requote_uri", "(", "url", ")", "prepared_request", ".", "url", "=", "to_native_string", "(", "url", ")", "# Cache the url, unless it redirects to itself.", "if", "resp", ".", "is_permanent_redirect", "and", "req", ".", "url", "!=", "prepared_request", ".", "url", ":", "self", ".", "redirect_cache", "[", "req", ".", "url", "]", "=", "prepared_request", ".", "url", "# http://tools.ietf.org/html/rfc7231#section-6.4.4", "if", "(", "resp", ".", "status_code", "==", "codes", ".", "see_other", "and", "method", "!=", "'HEAD'", ")", ":", "method", "=", "'GET'", "# Do what the browsers do, despite standards...", "# First, turn 302s into GETs.", "if", "resp", ".", "status_code", "==", "codes", ".", "found", "and", "method", "!=", "'HEAD'", ":", "method", "=", "'GET'", "# Second, if a POST is responded to with a 301, turn it into a GET.", "# This bizarre behaviour is explained in Issue 1704.", "if", "resp", ".", "status_code", "==", "codes", ".", "moved", "and", "method", "==", "'POST'", ":", "method", "=", "'GET'", "prepared_request", ".", "method", "=", "method", "# https://github.com/kennethreitz/requests/issues/1084", "if", "resp", ".", "status_code", "not", "in", "(", "codes", ".", "temporary_redirect", ",", "codes", ".", "permanent_redirect", ")", ":", "if", "'Content-Length'", "in", "prepared_request", ".", "headers", ":", "del", "prepared_request", ".", "headers", "[", "'Content-Length'", "]", "prepared_request", ".", "body", "=", "None", "headers", "=", "prepared_request", ".", "headers", "try", ":", "del", "headers", "[", "'Cookie'", "]", "except", "KeyError", ":", "pass", "# Extract any cookies sent on the response to the cookiejar", "# in the new request. Because we've mutated our copied prepared", "# request, use the old one that we haven't yet touched.", "extract_cookies_to_jar", "(", "prepared_request", ".", "_cookies", ",", "req", ",", "resp", ".", "raw", ")", "prepared_request", ".", "_cookies", ".", "update", "(", "self", ".", "cookies", ")", "prepared_request", ".", "prepare_cookies", "(", "prepared_request", ".", "_cookies", ")", "# Rebuild auth and proxy information.", "proxies", "=", "self", ".", "rebuild_proxies", "(", "prepared_request", ",", "proxies", ")", "self", ".", "rebuild_auth", "(", "prepared_request", ",", "resp", ")", "# Override the original request.", "req", "=", "prepared_request", "resp", "=", "self", ".", "send", "(", "req", ",", "stream", "=", "stream", ",", "timeout", "=", "timeout", ",", "verify", "=", "verify", ",", "cert", "=", "cert", ",", "proxies", "=", "proxies", ",", "allow_redirects", "=", "False", ",", "*", "*", "adapter_kwargs", ")", "extract_cookies_to_jar", "(", "self", ".", "cookies", ",", "prepared_request", ",", "resp", ".", "raw", ")", "i", "+=", "1", "yield", "resp" ]

[ "SetMinSize", "(", "self", "Size", "s", ")" ]

[ "def", "SetMinSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBarItem_SetMinSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Set", "the", "scale", "of", "preprocessed", "inputs", "s", ".", "t", ".", "the", "blob", "=", "blob", "*", "scale", ".", "N", ".", "B", ".", "input_scale", "is", "done", "AFTER", "mean", "subtraction", "and", "other", "preprocessing", "while", "raw_scale", "is", "done", "BEFORE", "." ]

[ "def", "_Net_set_input_scale", "(", "self", ",", "input_", ",", "scale", ")", ":", "if", "input_", "not", "in", "self", ".", "inputs", ":", "raise", "Exception", "(", "'Input not in {}'", ".", "format", "(", "self", ".", "inputs", ")", ")", "self", ".", "input_scale", "[", "input_", "]", "=", "scale" ]