Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Saves", "the", "current", "filter", "list", "to", "backup", "storage", "." ]

[ "def", "_BackupFilters", "(", ")", ":", "_cpplint_state", ".", "BackupFilters", "(", ")" ]

[ "Sets", "the", "maximum", "value", "of", "the", "control", ".", "If", "a", "value", "of", "None", "is", "provided", "then", "the", "control", "will", "have", "no", "explicit", "maximum", "value", ".", "If", "the", "value", "specified", "is", "less", "than", "the", "current", "minimum", "value", "then", "the", "function", "returns", "False", "and", "the", "maximum", "will", "not", "change", "from", "its", "current", "setting", ".", "On", "success", "the", "function", "returns", "True", "." ]

[ "def", "SetMax", "(", "self", ",", "max", "=", "None", ")", ":", "if", "(", "self", ".", "_min", "is", "None", "or", "max", "is", "None", "or", "(", "self", ".", "_min", "is", "not", "None", "and", "self", ".", "_min", "<=", "max", ")", ")", ":", "try", ":", "self", ".", "SetParameters", "(", "max", "=", "max", ")", "bRet", "=", "True", "except", "ValueError", ":", "bRet", "=", "False", "else", ":", "bRet", "=", "False", "return", "bRet" ]

[ "Run", "frame", "analyzer", "to", "compare", "the", "videos", "and", "print", "output", "." ]

[ "def", "_RunFrameAnalyzer", "(", "options", ",", "yuv_directory", "=", "None", ")", ":", "cmd", "=", "[", "options", ".", "frame_analyzer", ",", "'--label=%s'", "%", "options", ".", "label", ",", "'--reference_file=%s'", "%", "options", ".", "ref_video", ",", "'--test_file=%s'", "%", "options", ".", "test_video", ",", "'--width=%d'", "%", "options", ".", "yuv_frame_width", ",", "'--height=%d'", "%", "options", ".", "yuv_frame_height", ",", "]", "if", "options", ".", "chartjson_result_file", ":", "cmd", ".", "append", "(", "'--chartjson_result_file=%s'", "%", "options", ".", "chartjson_result_file", ")", "if", "options", ".", "aligned_output_file", ":", "cmd", ".", "append", "(", "'--aligned_output_file=%s'", "%", "options", ".", "aligned_output_file", ")", "if", "yuv_directory", ":", "cmd", ".", "append", "(", "'--yuv_directory=%s'", "%", "yuv_directory", ")", "frame_analyzer", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "stdin", "=", "_DevNull", "(", ")", ",", "stdout", "=", "sys", ".", "stdout", ",", "stderr", "=", "sys", ".", "stderr", ")", "frame_analyzer", ".", "wait", "(", ")", "if", "frame_analyzer", ".", "returncode", "!=", "0", ":", "print", "(", "'Failed to run frame analyzer.'", ")", "return", "frame_analyzer", ".", "returncode" ]

[ "Initiate", "cancellation", "." ]

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

[ "Assemble", "description", "block", "(", "help", "text", ")" ]

[ "def", "_build_description", "(", "self", ",", "backticks", ":", "bool", "=", "True", ",", "indent", ":", "int", "=", "3", ")", "->", "str", ":", "if", "not", "backticks", ":", "# Help text, wrapped and indented", "self", ".", "set_wrapper_indent", "(", "indent", ")", "out", "=", "self", ".", "wrapper", ".", "wrap", "(", "re", ".", "sub", "(", "r\"\\s+\"", ",", "\" \"", ",", "self", ".", "description", ")", ")", "return", "\"\\n\"", ".", "join", "(", "out", ")", "+", "\"\\n\"", "# assemble description", "linebreak", "=", "\"\\n\"", "+", "\" \"", "*", "indent", "description", "=", "linebreak", ".", "join", "(", "self", ".", "description", ".", "split", "(", "\"\\n\"", ")", ")", "pat", "=", "r'\"([a-zA-Z0-9\\-\\+\\*$_.,: =/\\'\\\\]+)\"'", "double_quoted", "=", "[", "]", "for", "item", "in", "re", ".", "findall", "(", "pat", ",", "description", ")", ":", "# enclose double-quoted strings in '``'", "found", "=", "f'\"{item}\"'", "double_quoted", "+=", "[", "found", "]", "replacement", "=", "f\"``{found}``\"", "description", "=", "description", ".", "replace", "(", "found", ",", "replacement", ")", "pat", "=", "r\"\\'([a-zA-Z0-9\\-\\+\\*$_.,:=/\\\\]+)\\'\"", "for", "item", "in", "re", ".", "findall", "(", "pat", ",", "description", ")", ":", "# replace \"'\" for single-quoted words by '``'; do not replace \"'\" when", "# whitespace is enclosed or if word is part of double-quoted string", "if", "any", "(", "[", "item", "in", "dq", "for", "dq", "in", "double_quoted", "]", ")", ":", "continue", "found", "=", "f\"'{item}'\"", "replacement", "=", "found", ".", "replace", "(", "\"'\"", ",", "\"``\"", ")", "description", "=", "description", ".", "replace", "(", "found", ",", "replacement", ")", "pat", "=", "r\"\\*([^\\*]+)\"", "asterisks", "=", "re", ".", "findall", "(", "pat", ",", "description", ")", "if", "len", "(", "asterisks", ")", "==", "1", ":", "# catch unbalanced '*', for example in '*nix'", "found", "=", "f\"*{asterisks[0]}\"", "replacement", "=", "f\"\\{found}\"", "description", "=", "description", ".", "replace", "(", "found", ",", "replacement", ")", "return", "f\"{'':<{indent}}{description}\\n\"" ]

[ "Return", "a", "callback", "function", "that", "gives", "the", "demands", "." ]

[ "def", "return_dem_callback", "(", "self", ")", ":", "def", "dem_return", "(", "from_index", ")", ":", "# Convert from routing variable Index to distance matrix NodeIndex.", "from_node", "=", "self", ".", "manager", ".", "IndexToNode", "(", "from_index", ")", "return", "(", "self", ".", "customers", "[", "from_node", "]", ".", "demand", ")", "return", "dem_return" ]

[ "Loads", "a", "template", ".", "This", "method", "looks", "up", "the", "template", "in", "the", "cache", "or", "loads", "one", "by", "calling", ":", "meth", ":", "get_source", ".", "Subclasses", "should", "not", "override", "this", "method", "as", "loaders", "working", "on", "collections", "of", "other", "loaders", "(", "such", "as", ":", "class", ":", "PrefixLoader", "or", ":", "class", ":", "ChoiceLoader", ")", "will", "not", "call", "this", "method", "but", "get_source", "directly", "." ]

[ "def", "load", "(", "self", ",", "environment", ",", "name", ",", "globals", "=", "None", ")", ":", "code", "=", "None", "if", "globals", "is", "None", ":", "globals", "=", "{", "}", "# first we try to get the source for this template together", "# with the filename and the uptodate function.", "source", ",", "filename", ",", "uptodate", "=", "self", ".", "get_source", "(", "environment", ",", "name", ")", "# try to load the code from the bytecode cache if there is a", "# bytecode cache configured.", "bcc", "=", "environment", ".", "bytecode_cache", "if", "bcc", "is", "not", "None", ":", "bucket", "=", "bcc", ".", "get_bucket", "(", "environment", ",", "name", ",", "filename", ",", "source", ")", "code", "=", "bucket", ".", "code", "# if we don't have code so far (not cached, no longer up to", "# date) etc. we compile the template", "if", "code", "is", "None", ":", "code", "=", "environment", ".", "compile", "(", "source", ",", "name", ",", "filename", ")", "# if the bytecode cache is available and the bucket doesn't", "# have a code so far, we give the bucket the new code and put", "# it back to the bytecode cache.", "if", "bcc", "is", "not", "None", "and", "bucket", ".", "code", "is", "None", ":", "bucket", ".", "code", "=", "code", "bcc", ".", "set_bucket", "(", "bucket", ")", "return", "environment", ".", "template_class", ".", "from_code", "(", "environment", ",", "code", ",", "globals", ",", "uptodate", ")" ]

[ "Draw", "random", "samples", "from", "O", "(", "N", ")", "." ]

[ "def", "rvs", "(", "self", ",", "dim", ",", "size", "=", "1", ",", "random_state", "=", "None", ")", ":", "random_state", "=", "self", ".", "_get_random_state", "(", "random_state", ")", "size", "=", "int", "(", "size", ")", "if", "size", ">", "1", ":", "return", "np", ".", "array", "(", "[", "self", ".", "rvs", "(", "dim", ",", "size", "=", "1", ",", "random_state", "=", "random_state", ")", "for", "i", "in", "range", "(", "size", ")", "]", ")", "dim", "=", "self", ".", "_process_parameters", "(", "dim", ")", "H", "=", "np", ".", "eye", "(", "dim", ")", "for", "n", "in", "range", "(", "dim", ")", ":", "x", "=", "random_state", ".", "normal", "(", "size", "=", "(", "dim", "-", "n", ",", ")", ")", "# random sign, 50/50, but chosen carefully to avoid roundoff error", "D", "=", "np", ".", "sign", "(", "x", "[", "0", "]", ")", "if", "x", "[", "0", "]", "!=", "0", "else", "1", "x", "[", "0", "]", "+=", "D", "*", "np", ".", "sqrt", "(", "(", "x", "*", "x", ")", ".", "sum", "(", ")", ")", "# Householder transformation", "Hx", "=", "-", "D", "*", "(", "np", ".", "eye", "(", "dim", "-", "n", ")", "-", "2.", "*", "np", ".", "outer", "(", "x", ",", "x", ")", "/", "(", "x", "*", "x", ")", ".", "sum", "(", ")", ")", "mat", "=", "np", ".", "eye", "(", "dim", ")", "mat", "[", "n", ":", ",", "n", ":", "]", "=", "Hx", "H", "=", "np", ".", "dot", "(", "H", ",", "mat", ")", "return", "H" ]

[ "Returns", "the", "useful", "(", "!", "=", "comments", "etc", ")", "lines", "from", "a", "file", "with", "flags", "." ]

[ "def", "__GetFlagFileLines", "(", "self", ",", "filename", ",", "parsed_file_list", ")", ":", "line_list", "=", "[", "]", "# All line from flagfile.", "flag_line_list", "=", "[", "]", "# Subset of lines w/o comments, blanks, flagfile= tags.", "try", ":", "file_obj", "=", "open", "(", "filename", ",", "'r'", ")", "except", "IOError", ",", "e_msg", ":", "raise", "CantOpenFlagFileError", "(", "'ERROR:: Unable to open flagfile: %s'", "%", "e_msg", ")", "line_list", "=", "file_obj", ".", "readlines", "(", ")", "file_obj", ".", "close", "(", ")", "parsed_file_list", ".", "append", "(", "filename", ")", "# This is where we check each line in the file we just read.", "for", "line", "in", "line_list", ":", "if", "line", ".", "isspace", "(", ")", ":", "pass", "# Checks for comment (a line that starts with '#').", "elif", "line", ".", "startswith", "(", "'#'", ")", "or", "line", ".", "startswith", "(", "'//'", ")", ":", "pass", "# Checks for a nested \"--flagfile=<bar>\" flag in the current file.", "# If we find one, recursively parse down into that file.", "elif", "self", ".", "__IsFlagFileDirective", "(", "line", ")", ":", "sub_filename", "=", "self", ".", "ExtractFilename", "(", "line", ")", "# We do a little safety check for reparsing a file we've already done.", "if", "not", "sub_filename", "in", "parsed_file_list", ":", "included_flags", "=", "self", ".", "__GetFlagFileLines", "(", "sub_filename", ",", "parsed_file_list", ")", "flag_line_list", ".", "extend", "(", "included_flags", ")", "else", ":", "# Case of hitting a circularly included file.", "sys", ".", "stderr", ".", "write", "(", "'Warning: Hit circular flagfile dependency: %s\\n'", "%", "(", "sub_filename", ",", ")", ")", "else", ":", "# Any line that's not a comment or a nested flagfile should get", "# copied into 2nd position. This leaves earlier arguments", "# further back in the list, thus giving them higher priority.", "flag_line_list", ".", "append", "(", "line", ".", "strip", "(", ")", ")", "return", "flag_line_list" ]

[ "Return", "a", "new", "environ", "dict", "targeting", "the", "given", "wsgi", ".", "version" ]

[ "def", "get_environ", "(", "self", ")", ":", "raise", "NotImplemented" ]

[ "Read", "a", "tensor", "i", ".", "e", ".", "numpy", "array", "from", "HDF5", "." ]

[ "def", "read_hdf5", "(", "file", ",", "key", "=", "'tensor'", ")", ":", "assert", "os", ".", "path", ".", "exists", "(", "file", ")", ",", "'file %s not found'", "%", "file", "h5f", "=", "h5py", ".", "File", "(", "file", ",", "'r'", ")", "assert", "key", "in", "h5f", ".", "keys", "(", ")", ",", "'key %s not found in file %s'", "%", "(", "key", ",", "file", ")", "tensor", "=", "h5f", "[", "key", "]", "[", "(", ")", "]", "h5f", ".", "close", "(", ")", "return", "tensor" ]

[ "设置scan操作的超时时长，单位ms", "服务端在scan操作达到约", "interval", "毫秒后尽快返回给client结果" ]

[ "def", "SetPackInterval", "(", "self", ",", "interval", ")", ":", "lib", ".", "tera_scan_descriptor_set_pack_interval", "(", "self", ".", "desc", ",", "interval", ")" ]

[ "Update", "the", "actual", "position", "(", "using", "angular", "and", "linear", "velocities", ")", "of", "all", "the", "vehicles", "in", "Webots", "." ]

[ "def", "update_vehicles_position_and_velocity", "(", "self", ",", "step", ",", "rotateWheels", ")", ":", "for", "i", "in", "range", "(", "0", ",", "self", ".", "vehicleNumber", ")", ":", "if", "self", ".", "vehicles", "[", "i", "]", ".", "inUse", ":", "self", ".", "vehicles", "[", "i", "]", ".", "translation", ".", "setSFVec3f", "(", "self", ".", "vehicles", "[", "i", "]", ".", "currentPos", ")", "self", ".", "vehicles", "[", "i", "]", ".", "rotation", ".", "setSFRotation", "(", "self", ".", "vehicles", "[", "i", "]", ".", "currentRot", ")", "velocity", "=", "[", "]", "velocity", ".", "append", "(", "self", ".", "vehicles", "[", "i", "]", ".", "targetPos", "[", "0", "]", "-", "self", ".", "vehicles", "[", "i", "]", ".", "currentPos", "[", "0", "]", ")", "velocity", ".", "append", "(", "self", ".", "vehicles", "[", "i", "]", ".", "targetPos", "[", "1", "]", "-", "self", ".", "vehicles", "[", "i", "]", ".", "currentPos", "[", "1", "]", ")", "velocity", ".", "append", "(", "self", ".", "vehicles", "[", "i", "]", ".", "targetPos", "[", "2", "]", "-", "self", ".", "vehicles", "[", "i", "]", ".", "currentPos", "[", "2", "]", ")", "for", "j", "in", "range", "(", "0", ",", "3", ")", ":", "diffAngle", "=", "self", ".", "vehicles", "[", "i", "]", ".", "currentAngles", "[", "j", "]", "-", "self", ".", "vehicles", "[", "i", "]", ".", "targetAngles", "[", "j", "]", "diffAngle", "=", "(", "diffAngle", "+", "2", "*", "math", ".", "pi", ")", "%", "(", "2", "*", "math", ".", "pi", ")", "if", "(", "diffAngle", ">", "math", ".", "pi", ")", ":", "diffAngle", "-=", "2", "*", "math", ".", "pi", "velocity", ".", "append", "(", "diffAngle", ")", "velocity", "[", ":", "]", "=", "[", "1000", "*", "x", "/", "step", "for", "x", "in", "velocity", "]", "self", ".", "vehicles", "[", "i", "]", ".", "node", ".", "setVelocity", "(", "velocity", ")", "if", "rotateWheels", ":", "angularVelocity", "=", "[", "0", ",", "self", ".", "vehicles", "[", "i", "]", ".", "speed", "/", "self", ".", "vehicles", "[", "i", "]", ".", "wheelRadius", ",", "0", "]", "for", "wheelAngularVelocity", "in", "self", ".", "vehicles", "[", "i", "]", ".", "wheelsAngularVelocity", ":", "wheelAngularVelocity", ".", "setSFVec3f", "(", "angularVelocity", ")" ]

[ "Link", "the", "supplied", "variant", "directory", "to", "the", "source", "directory", "for", "purposes", "of", "building", "files", "." ]

[ "def", "VariantDir", "(", "self", ",", "variant_dir", ",", "src_dir", ",", "duplicate", "=", "1", ")", ":", "if", "not", "isinstance", "(", "src_dir", ",", "SCons", ".", "Node", ".", "Node", ")", ":", "src_dir", "=", "self", ".", "Dir", "(", "src_dir", ")", "if", "not", "isinstance", "(", "variant_dir", ",", "SCons", ".", "Node", ".", "Node", ")", ":", "variant_dir", "=", "self", ".", "Dir", "(", "variant_dir", ")", "if", "src_dir", ".", "is_under", "(", "variant_dir", ")", ":", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "\"Source directory cannot be under variant directory.\"", ")", "if", "variant_dir", ".", "srcdir", ":", "if", "variant_dir", ".", "srcdir", "==", "src_dir", ":", "return", "# We already did this.", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "\"'%s' already has a source directory: '%s'.\"", "%", "(", "variant_dir", ",", "variant_dir", ".", "srcdir", ")", ")", "variant_dir", ".", "link", "(", "src_dir", ",", "duplicate", ")" ]

[ "Create", "a", "reader", "that", "yield", "element", "from", "the", "given", "files", "select", "a", "file", "set", "according", "trainer", "count", "and", "trainer_id" ]

[ "def", "cluster_files_reader", "(", "files_pattern", ",", "trainer_count", ",", "trainer_id", ",", "loader", "=", "pickle", ".", "load", ")", ":", "def", "reader", "(", ")", ":", "if", "not", "callable", "(", "loader", ")", ":", "raise", "TypeError", "(", "\"loader should be callable.\"", ")", "file_list", "=", "glob", ".", "glob", "(", "files_pattern", ")", "file_list", ".", "sort", "(", ")", "my_file_list", "=", "[", "]", "for", "idx", ",", "fn", "in", "enumerate", "(", "file_list", ")", ":", "if", "idx", "%", "trainer_count", "==", "trainer_id", ":", "print", "(", "\"append file: %s\"", "%", "fn", ")", "my_file_list", ".", "append", "(", "fn", ")", "for", "fn", "in", "my_file_list", ":", "with", "open", "(", "fn", ",", "\"r\"", ")", "as", "f", ":", "lines", "=", "loader", "(", "f", ")", "for", "line", "in", "lines", ":", "yield", "line", "return", "reader" ]

[ "all_indices_partitioned", "property", "." ]

[ "def", "all_indices_partitioned", "(", "self", ")", ":", "return", "self", ".", "_all_indices_partitioned" ]

[ "Get", "list", "of", "items", "from", "FIRST", "to", "LAST", "(", "not", "included", ")", "." ]

[ "def", "get", "(", "self", ",", "first", ",", "last", "=", "None", ")", ":", "if", "last", ":", "return", "self", ".", "tk", ".", "splitlist", "(", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'get'", ",", "first", ",", "last", ")", ")", "else", ":", "return", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'get'", ",", "first", ")" ]

[ "This", "module", "is", "in", "charge", "of", "warning", "in", "case", "of", "a", "collision", "with", "any", "pedestrian", "." ]

[ "def", "pedestrian_avoid_manager", "(", "self", ",", "waypoint", ")", ":", "walker_list", "=", "self", ".", "_world", ".", "get_actors", "(", ")", ".", "filter", "(", "\"*walker.pedestrian*\"", ")", "def", "dist", "(", "w", ")", ":", "return", "w", ".", "get_location", "(", ")", ".", "distance", "(", "waypoint", ".", "transform", ".", "location", ")", "walker_list", "=", "[", "w", "for", "w", "in", "walker_list", "if", "dist", "(", "w", ")", "<", "10", "]", "if", "self", ".", "_direction", "==", "RoadOption", ".", "CHANGELANELEFT", ":", "walker_state", ",", "walker", ",", "distance", "=", "self", ".", "_vehicle_obstacle_detected", "(", "walker_list", ",", "max", "(", "self", ".", "_behavior", ".", "min_proximity_threshold", ",", "self", ".", "_speed_limit", "/", "2", ")", ",", "up_angle_th", "=", "90", ",", "lane_offset", "=", "-", "1", ")", "elif", "self", ".", "_direction", "==", "RoadOption", ".", "CHANGELANERIGHT", ":", "walker_state", ",", "walker", ",", "distance", "=", "self", ".", "_vehicle_obstacle_detected", "(", "walker_list", ",", "max", "(", "self", ".", "_behavior", ".", "min_proximity_threshold", ",", "self", ".", "_speed_limit", "/", "2", ")", ",", "up_angle_th", "=", "90", ",", "lane_offset", "=", "1", ")", "else", ":", "walker_state", ",", "walker", ",", "distance", "=", "self", ".", "_vehicle_obstacle_detected", "(", "walker_list", ",", "max", "(", "self", ".", "_behavior", ".", "min_proximity_threshold", ",", "self", ".", "_speed_limit", "/", "3", ")", ",", "up_angle_th", "=", "60", ")", "return", "walker_state", ",", "walker", ",", "distance" ]

[ "supported", "attributes", "by", "name", "are", ":", "-", "lineno", "-", "returns", "the", "line", "number", "of", "the", "exception", "text", "-", "col", "-", "returns", "the", "column", "number", "of", "the", "exception", "text", "-", "line", "-", "returns", "the", "line", "containing", "the", "exception", "text" ]

[ "def", "__getattr__", "(", "self", ",", "aname", ")", ":", "if", "aname", "==", "\"lineno\"", ":", "return", "lineno", "(", "self", ".", "loc", ",", "self", ".", "pstr", ")", "elif", "aname", "in", "(", "\"col\"", ",", "\"column\"", ")", ":", "return", "col", "(", "self", ".", "loc", ",", "self", ".", "pstr", ")", "elif", "aname", "==", "\"line\"", ":", "return", "line", "(", "self", ".", "loc", ",", "self", ".", "pstr", ")", "else", ":", "raise", "AttributeError", "(", "aname", ")" ]

[ "Prepares", "a", "fmatch_pattern", "for", "use", "with", "FastPath", ".", "__fnmatch", ".", "pattern", "-", "A", "filename", "pattern", "with", "wildcards", "for", "example", "*", ".", "py", ".", "If", "the", "pattern", "contains", "a", "normcase", "attribute", "it", "is", "applied", "to", "the", "name", "and", "path", "prior", "to", "comparison", ".", "normcase", "-", "(", "optional", ")", "A", "function", "used", "to", "normalize", "the", "pattern", "and", "filename", "before", "matching", ".", "Defaults", "to", ":", "meth", ":", "self", ".", "module", "which", "defaults", "to", ":", "meth", ":", "os", ".", "path", ".", "normcase", ".", "..", "seealso", "::", ":", "func", ":", "FastPath", ".", "__fnmatch" ]

[ "def", "__prepare", "(", "self", ",", "pattern", ",", "normcase", "=", "None", ")", ":", "if", "not", "normcase", ":", "normcase", "=", "getattr", "(", "pattern", ",", "'normcase'", ",", "self", ".", "module", ".", "normcase", ")", "pattern", "=", "normcase", "(", "pattern", ")", "return", "pattern", ",", "normcase" ]

[ "Infers", "the", "table", "signature", "from", "the", "configs", "that", "generate", "its", "items", "." ]

[ "def", "infer_signature", "(", "configs", ":", "Sequence", "[", "Config", "]", ",", "step_spec", ":", "reverb_types", ".", "SpecNest", ")", "->", "reverb_types", ".", "SpecNest", ":", "if", "not", "configs", ":", "raise", "ValueError", "(", "'At least one config must be provided.'", ")", "if", "any", "(", "c", ".", "pattern_structure", "!=", "configs", "[", "0", "]", ".", "pattern_structure", "for", "c", "in", "configs", ")", ":", "raise", "ValueError", "(", "'All configs must have exactly the same pattern_structure.'", ")", "if", "any", "(", "c", ".", "table", "!=", "configs", "[", "0", "]", ".", "table", "for", "c", "in", "configs", ")", ":", "raise", "ValueError", "(", "f'All configs must target the same table but provided configs '", "f'included {\", \".join(sorted(set(c.table for c in configs)))}.'", ")", "flat_step_spec", "=", "tree", ".", "flatten", "(", "step_spec", ")", "def", "_validate_and_convert_to_spec", "(", "path", ",", "*", "nodes", ")", ":", "# Check that all nodes share the same dtype.", "dtypes", "=", "[", "flat_step_spec", "[", "node", ".", "flat_source_index", "]", ".", "dtype", "for", "node", "in", "nodes", "]", "if", "any", "(", "dtype", "!=", "dtypes", "[", "0", "]", "for", "dtype", "in", "dtypes", ")", ":", "raise", "ValueError", "(", "f'Configs produce trajectories with multiple dtypes at {path}. '", "f'Got {dtypes}.'", ")", "# Create shapes for all nodes.", "shapes", "=", "[", "]", "for", "node", "in", "nodes", ":", "shape", "=", "list", "(", "flat_step_spec", "[", "node", ".", "flat_source_index", "]", ".", "shape", ")", "if", "node", ".", "HasField", "(", "'start'", ")", ":", "length", "=", "(", "node", ".", "stop", "-", "node", ".", "start", ")", "//", "(", "node", ".", "step", "or", "1", ")", "shape", "=", "[", "length", ",", "*", "shape", "]", "shapes", ".", "append", "(", "tensor_shape", ".", "TensorShape", "(", "shape", ")", ")", "# Check that all shapes are either completely identical or at least", "# identical in all dimensions but the first.", "if", "(", "any", "(", "shape", ".", "rank", "!=", "shapes", "[", "0", "]", ".", "rank", "for", "shape", "in", "shapes", ")", "or", "(", "shapes", "[", "0", "]", ".", "rank", ">", "1", "and", "any", "(", "shape", "[", "1", ":", "]", "!=", "shapes", "[", "0", "]", "[", "1", ":", "]", "for", "shape", "in", "shapes", ")", ")", ")", ":", "raise", "ValueError", "(", "f'Configs produce trajectories with incompatible shapes at {path}. '", "f'Got {shapes}.'", ")", "# Merge the shapes into a single shape. If the first dimension varies then", "# we set the leading dimension as undefined.", "if", "all", "(", "shape", "==", "shapes", "[", "0", "]", "for", "shape", "in", "shapes", ")", ":", "merged_shape", "=", "shapes", "[", "0", "]", "else", ":", "merged_shape", "=", "[", "None", ",", "*", "shapes", "[", "0", "]", "[", "1", ":", "]", "]", "return", "tensor_spec", ".", "TensorSpec", "(", "shape", "=", "merged_shape", ",", "dtype", "=", "dtypes", "[", "0", "]", ",", "name", "=", "'/'", ".", "join", "(", "str", "(", "x", ")", "for", "x", "in", "path", ")", ")", "patterns", "=", "[", "unpack_pattern", "(", "config", ")", "for", "config", "in", "configs", "]", "return", "tree", ".", "map_structure_with_path", "(", "_validate_and_convert_to_spec", ",", "*", "patterns", ")" ]

[ "AlexNet", "version", "2", "." ]

[ "def", "alexnet_v2", "(", "inputs", ",", "num_classes", "=", "1000", ",", "is_training", "=", "True", ",", "dropout_keep_prob", "=", "0.5", ",", "spatial_squeeze", "=", "True", ",", "scope", "=", "'alexnet_v2'", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "scope", ",", "'alexnet_v2'", ",", "[", "inputs", "]", ")", "as", "sc", ":", "end_points_collection", "=", "sc", ".", "original_name_scope", "+", "'_end_points'", "# Collect outputs for conv2d, fully_connected and max_pool2d.", "with", "arg_scope", "(", "[", "layers", ".", "conv2d", ",", "layers_lib", ".", "fully_connected", ",", "layers_lib", ".", "max_pool2d", "]", ",", "outputs_collections", "=", "[", "end_points_collection", "]", ")", ":", "net", "=", "layers", ".", "conv2d", "(", "inputs", ",", "64", ",", "[", "11", ",", "11", "]", ",", "4", ",", "padding", "=", "'VALID'", ",", "scope", "=", "'conv1'", ")", "net", "=", "layers_lib", ".", "max_pool2d", "(", "net", ",", "[", "3", ",", "3", "]", ",", "2", ",", "scope", "=", "'pool1'", ")", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "192", ",", "[", "5", ",", "5", "]", ",", "scope", "=", "'conv2'", ")", "net", "=", "layers_lib", ".", "max_pool2d", "(", "net", ",", "[", "3", ",", "3", "]", ",", "2", ",", "scope", "=", "'pool2'", ")", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "384", ",", "[", "3", ",", "3", "]", ",", "scope", "=", "'conv3'", ")", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "384", ",", "[", "3", ",", "3", "]", ",", "scope", "=", "'conv4'", ")", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "256", ",", "[", "3", ",", "3", "]", ",", "scope", "=", "'conv5'", ")", "net", "=", "layers_lib", ".", "max_pool2d", "(", "net", ",", "[", "3", ",", "3", "]", ",", "2", ",", "scope", "=", "'pool5'", ")", "# Use conv2d instead of fully_connected layers.", "with", "arg_scope", "(", "[", "layers", ".", "conv2d", "]", ",", "weights_initializer", "=", "trunc_normal", "(", "0.005", ")", ",", "biases_initializer", "=", "init_ops", ".", "constant_initializer", "(", "0.1", ")", ")", ":", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "4096", ",", "[", "5", ",", "5", "]", ",", "padding", "=", "'VALID'", ",", "scope", "=", "'fc6'", ")", "net", "=", "layers_lib", ".", "dropout", "(", "net", ",", "dropout_keep_prob", ",", "is_training", "=", "is_training", ",", "scope", "=", "'dropout6'", ")", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "4096", ",", "[", "1", ",", "1", "]", ",", "scope", "=", "'fc7'", ")", "net", "=", "layers_lib", ".", "dropout", "(", "net", ",", "dropout_keep_prob", ",", "is_training", "=", "is_training", ",", "scope", "=", "'dropout7'", ")", "net", "=", "layers", ".", "conv2d", "(", "net", ",", "num_classes", ",", "[", "1", ",", "1", "]", ",", "activation_fn", "=", "None", ",", "normalizer_fn", "=", "None", ",", "biases_initializer", "=", "init_ops", ".", "zeros_initializer", "(", ")", ",", "scope", "=", "'fc8'", ")", "# Convert end_points_collection into a end_point dict.", "end_points", "=", "utils", ".", "convert_collection_to_dict", "(", "end_points_collection", ")", "if", "spatial_squeeze", ":", "net", "=", "array_ops", ".", "squeeze", "(", "net", ",", "[", "1", ",", "2", "]", ",", "name", "=", "'fc8/squeezed'", ")", "end_points", "[", "sc", ".", "name", "+", "'/fc8'", "]", "=", "net", "return", "net", ",", "end_points" ]

[ "Simulate", "a", "mouse", "button", "press", "or", "release", "at", "the", "current", "mouse", "location", "." ]

[ "def", "PressButton", "(", "down", ",", "button", "=", "'left'", ")", ":", "# Put the mouse_event flags in a convenient dictionary by button", "flags", "=", "{", "'left'", ":", "(", "win32con", ".", "MOUSEEVENTF_LEFTUP", ",", "win32con", ".", "MOUSEEVENTF_LEFTDOWN", ")", ",", "'middle'", ":", "(", "win32con", ".", "MOUSEEVENTF_MIDDLEUP", ",", "win32con", ".", "MOUSEEVENTF_MIDDLEDOWN", ")", ",", "'right'", ":", "(", "win32con", ".", "MOUSEEVENTF_RIGHTUP", ",", "win32con", ".", "MOUSEEVENTF_RIGHTDOWN", ")", "}", "# hit the button", "win32api", ".", "mouse_event", "(", "flags", "[", "button", "]", "[", "down", "]", ",", "0", ",", "0", ")" ]

[ "Closes", "the", "faceInfo", "user", "interface" ]

[ "def", "faceInfo_UI_Cancel", "(", "self", ",", "*", "args", ")", ":", "cmds", ".", "deleteUI", "(", "\"faceInfo_UI\"", ")" ]

[ "Add", "a", "k", "-", "shift", "vector", ":", "param", "k_x", ":", ":", "param", "k_y", ":", ":", "param", "k_z", ":", ":", "return", ":", "k_index", "of", "the", "(", "k_x", "k_y", "k_z", ")" ]

[ "def", "add_k_shift_vector", "(", "self", ",", "k_x", ",", "k_y", ",", "k_z", ")", ":", "# check", "assert", "isinstance", "(", "k_x", ",", "float", ")", ",", "'Kx is wrong'", "assert", "isinstance", "(", "k_y", ",", "float", ")", ",", "'Ky is wrong'", "assert", "isinstance", "(", "k_z", ",", "float", ")", ",", "'Kz is wrong'", "k_shift_vector", "=", "(", "k_x", ",", "k_y", ",", "k_z", ")", "self", ".", "_kShiftDict", "[", "self", ".", "_kVectorIndex", "]", "=", "[", "k_shift_vector", ",", "[", "]", "]", "# make progress", "return_k_index", "=", "self", ".", "_kVectorIndex", "self", ".", "_kVectorIndex", "+=", "1", "return", "return_k_index" ]

[ "RowChanged", "(", "self", "unsigned", "int", "row", ")" ]

[ "def", "RowChanged", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewIndexListModel_RowChanged", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "value", "of", "the", "environment", "variable", "named", "v", "or", "None", "if", "it", "s", "unset", "(", "or", "empty", ")", "." ]

[ "def", "OptionalEnvironmentVariable", "(", "v", ")", ":", "if", "v", "in", "os", ".", "environ", "and", "os", ".", "environ", "[", "v", "]", "!=", "\"\"", ":", "return", "os", ".", "environ", "[", "v", "]", "return", "None" ]

[ "Get", "LineStyle", "parameters", "." ]

[ "def", "_GetLineStyles", "(", "self", ",", "chart", ")", ":", "styles", "=", "[", "]", "for", "series", "in", "chart", ".", "data", ":", "style", "=", "series", ".", "style", "if", "style", ":", "styles", ".", "append", "(", "'%s,%s,%s'", "%", "(", "style", ".", "width", ",", "style", ".", "on", ",", "style", ".", "off", ")", ")", "else", ":", "# If one style is missing, they must all be missing", "# TODO: Add a test for this; throw a more meaningful exception", "assert", "(", "not", "styles", ")", "return", "util", ".", "JoinLists", "(", "line_style", "=", "styles", ")" ]

[ "Returns", "the", "arrays", "of", "capabilities", "." ]

[ "def", "generate_capability_arrays", "(", "caps", ")", ":", "caps", "=", "sorted", "(", "set", "(", "[", "tuple", "(", "c", ")", "for", "c", "in", "caps", "if", "c", "]", ")", ")", "arrays", "=", "[", "'static const SpvCapability {}[] = {};'", ".", "format", "(", "get_capability_array_name", "(", "c", ")", ",", "compose_capability_list", "(", "c", ")", ")", "for", "c", "in", "caps", "]", "return", "'\\n'", ".", "join", "(", "arrays", ")" ]

[ "Return", "environment", "dict", "." ]

[ "def", "return_env", "(", "self", ",", "exists", "=", "True", ")", ":", "env", "=", "dict", "(", "include", "=", "self", ".", "_build_paths", "(", "'include'", ",", "[", "self", ".", "VCIncludes", ",", "self", ".", "OSIncludes", ",", "self", ".", "UCRTIncludes", ",", "self", ".", "NetFxSDKIncludes", "]", ",", "exists", ")", ",", "lib", "=", "self", ".", "_build_paths", "(", "'lib'", ",", "[", "self", ".", "VCLibraries", ",", "self", ".", "OSLibraries", ",", "self", ".", "FxTools", ",", "self", ".", "UCRTLibraries", ",", "self", ".", "NetFxSDKLibraries", "]", ",", "exists", ")", ",", "libpath", "=", "self", ".", "_build_paths", "(", "'libpath'", ",", "[", "self", ".", "VCLibraries", ",", "self", ".", "FxTools", ",", "self", ".", "VCStoreRefs", ",", "self", ".", "OSLibpath", "]", ",", "exists", ")", ",", "path", "=", "self", ".", "_build_paths", "(", "'path'", ",", "[", "self", ".", "VCTools", ",", "self", ".", "VSTools", ",", "self", ".", "VsTDb", ",", "self", ".", "SdkTools", ",", "self", ".", "SdkSetup", ",", "self", ".", "FxTools", ",", "self", ".", "MSBuild", ",", "self", ".", "HTMLHelpWorkshop", ",", "self", ".", "FSharp", "]", ",", "exists", ")", ",", ")", "if", "self", ".", "vs_ver", ">=", "14", "and", "isfile", "(", "self", ".", "VCRuntimeRedist", ")", ":", "env", "[", "'py_vcruntime_redist'", "]", "=", "self", ".", "VCRuntimeRedist", "return", "env" ]

[ "Get", "the", "hardware", "address", "on", "Windows", "using", "ctypes", "." ]

[ "def", "_windll_getnode", "(", ")", ":", "import", "ctypes", "_load_system_functions", "(", ")", "_buffer", "=", "ctypes", ".", "create_string_buffer", "(", "16", ")", "if", "_UuidCreate", "(", "_buffer", ")", "==", "0", ":", "return", "UUID", "(", "bytes", "=", "bytes_", "(", "_buffer", ".", "raw", ")", ")", ".", "node" ]

[ "Returns", "the", "alternative", "condition", "for", "this", "alternative", "if", "the", "condition", "is", "satisfied", "by", "property_set", "." ]

[ "def", "match", "(", "self", ",", "property_set_", ",", "debug", ")", ":", "# The condition is composed of all base non-conditional properties.", "# It's not clear if we should expand 'self.requirements_' or not.", "# For one thing, it would be nice to be able to put", "# <toolset>msvc-6.0", "# in requirements.", "# On the other hand, if we have <variant>release in condition it", "# does not make sense to require <optimization>full to be in", "# build request just to select this variant.", "assert", "isinstance", "(", "property_set_", ",", "property_set", ".", "PropertySet", ")", "bcondition", "=", "self", ".", "requirements_", ".", "base", "(", ")", "ccondition", "=", "self", ".", "requirements_", ".", "conditional", "(", ")", "condition", "=", "b2", ".", "util", ".", "set", ".", "difference", "(", "bcondition", ",", "ccondition", ")", "if", "debug", ":", "print", "\" next alternative: required properties:\"", ",", "[", "str", "(", "p", ")", "for", "p", "in", "condition", "]", "if", "b2", ".", "util", ".", "set", ".", "contains", "(", "condition", ",", "property_set_", ".", "all", "(", ")", ")", ":", "if", "debug", ":", "print", "\" matched\"", "return", "condition", "else", ":", "return", "None" ]

[ "If", "s", "ends", "with", "a", "newline", "drop", "it", ";", "else", "return", "s", "intact" ]

[ "def", "strip_trailing_nl", "(", "s", ")", ":", "return", "s", "[", ":", "-", "1", "]", "if", "s", ".", "endswith", "(", "'\\n'", ")", "else", "s" ]

[ "Converts", "the", "given", "value", "to", "a", "Dimension", "." ]

[ "def", "as_dimension", "(", "value", ")", ":", "if", "isinstance", "(", "value", ",", "Dimension", ")", ":", "return", "value", "else", ":", "return", "Dimension", "(", "value", ")" ]

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

[ "def", "GetPollingMin", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "Joystick_GetPollingMin", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "__init__", "(", "self", "String", "label", "String", "name", "wxChar", "labels", "long", "values", "String", "value", ")", "-", ">", "EditEnumProperty", "__init__", "(", "self", "String", "label", "=", "(", "*", "wxPGProperty", "::", "sm_wxPG_LABEL", ")", "String", "name", "=", "(", "*", "wxPGProperty", "::", "sm_wxPG_LABEL", ")", "wxArrayString", "labels", "=", "wxArrayString", "()", "wxArrayInt", "values", "=", "wxArrayInt", "()", "String", "value", "=", "wxEmptyString", ")", "-", ">", "EditEnumProperty", "__init__", "(", "self", "String", "label", "String", "name", "PGChoices", "choices", "String", "value", "=", "wxEmptyString", ")", "-", ">", "EditEnumProperty", "__init__", "(", "self", "String", "label", "String", "name", "wxChar", "labels", "long", "values", "PGChoices", "choicesCache", "String", "value", ")", "-", ">", "EditEnumProperty" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ")", ":", "_propgrid", ".", "EditEnumProperty_swiginit", "(", "self", ",", "_propgrid", ".", "new_EditEnumProperty", "(", "*", "args", ")", ")" ]

[ "A", "dict", "representation", "of", "this", "twitter", ".", "Status", "instance", "." ]

[ "def", "AsDict", "(", "self", ")", ":", "data", "=", "{", "}", "if", "self", ".", "created_at", ":", "data", "[", "'created_at'", "]", "=", "self", ".", "created_at", "if", "self", ".", "id", ":", "data", "[", "'id'", "]", "=", "self", ".", "id", "if", "self", ".", "text", ":", "data", "[", "'text'", "]", "=", "self", ".", "text", "if", "self", ".", "user", ":", "data", "[", "'user'", "]", "=", "self", ".", "user", ".", "AsDict", "(", ")", "return", "data" ]

[ "__init__", "(", "self", ")", "-", ">", "XmlSubclassFactory" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_xrc", ".", "XmlSubclassFactory_swiginit", "(", "self", ",", "_xrc", ".", "new_XmlSubclassFactory", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "XmlSubclassFactory", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "XmlSubclassFactory", ")" ]

[ "Return", "the", "value", "associated", "with", "properties", "or", "any", "subset", "of", "it", ".", "If", "more", "than", "one", "subset", "has", "value", "assigned", "to", "it", "return", "the", "value", "for", "the", "longest", "subset", "if", "it", "s", "unique", "." ]

[ "def", "find", "(", "self", ",", "properties", ")", ":", "assert", "is_iterable_typed", "(", "properties", ",", "basestring", ")", "return", "self", ".", "find_replace", "(", "properties", ")" ]

[ "Stop", "moving", "." ]

[ "def", "mouse_move_stop", "(", "self", ")", ":", "self", ".", "is_moving", "=", "False" ]

[ "Find", "out", "what", "shirt", "we", "are", "already", "wearing", "-", "returns", "index" ]

[ "def", "IWhatShirtAmIWearing", "(", "self", ",", "avatar", ")", ":", "global", "ShirtNames", "worn", "=", "avatar", ".", "avatar", ".", "getAvatarClothingList", "(", ")", "#PtDebugPrint(\"xDialogClothingBB: I am currently wearing \",worn)", "for", "item", "in", "worn", ":", "try", ":", "shirtIdx", "=", "ShirtNames", ".", "index", "(", "item", ")", "return", "shirtIdx", "except", "ValueError", ":", "# see if its a shirt... maybe they are wearing something that is not in their closet", "if", "item", "[", "-", "len", "(", "kShirtIdentifier", ")", ":", "]", "==", "kShirtIdentifier", ":", "ShirtNames", ".", "append", "(", "item", ")", "try", ":", "shirtIdx", "=", "ShirtNames", ".", "index", "(", "item", ")", "return", "shirtIdx", "except", "ValueError", ":", "pass", "return", "kNoShirtIdx" ]

[ "Insert", "new_token", "after", "token", "." ]

[ "def", "InsertTokenAfter", "(", "new_token", ",", "token", ")", ":", "new_token", ".", "previous", "=", "token", "new_token", ".", "next", "=", "token", ".", "next", "new_token", ".", "metadata", "=", "copy", ".", "copy", "(", "token", ".", "metadata", ")", "if", "token", ".", "IsCode", "(", ")", ":", "new_token", ".", "metadata", ".", "last_code", "=", "token", "if", "new_token", ".", "IsCode", "(", ")", ":", "following_token", "=", "token", ".", "next", "while", "following_token", "and", "following_token", ".", "metadata", ".", "last_code", "==", "token", ":", "following_token", ".", "metadata", ".", "last_code", "=", "new_token", "following_token", "=", "following_token", ".", "next", "token", ".", "next", "=", "new_token", "if", "new_token", ".", "next", ":", "new_token", ".", "next", ".", "previous", "=", "new_token", "if", "new_token", ".", "start_index", "is", "None", ":", "if", "new_token", ".", "line_number", "==", "token", ".", "line_number", ":", "new_token", ".", "start_index", "=", "token", ".", "start_index", "+", "len", "(", "token", ".", "string", ")", "else", ":", "new_token", ".", "start_index", "=", "0", "iterator", "=", "new_token", ".", "next", "while", "iterator", "and", "iterator", ".", "line_number", "==", "new_token", ".", "line_number", ":", "iterator", ".", "start_index", "+=", "len", "(", "new_token", ".", "string", ")", "iterator", "=", "iterator", ".", "next" ]

[ "Generate", "specialization", "code", "and", "the", "conditionals", "to", "instantiate", "it", "." ]

[ "def", "Specialize", "(", ")", ":", "f", "=", "open", "(", "\"schur_eliminator.cc\"", ",", "\"w\"", ")", "f", ".", "write", "(", "HEADER", ")", "f", ".", "write", "(", "FACTORY_FILE_HEADER", ")", "for", "row_block_size", ",", "e_block_size", ",", "f_block_size", "in", "SPECIALIZATIONS", ":", "output", "=", "SpecializationFilename", "(", "\"generated/schur_eliminator\"", ",", "row_block_size", ",", "e_block_size", ",", "f_block_size", ")", "+", "\".cc\"", "fptr", "=", "open", "(", "output", ",", "\"w\"", ")", "fptr", ".", "write", "(", "HEADER", ")", "template", "=", "SPECIALIZATION_FILE", "if", "(", "row_block_size", "==", "\"Eigen::Dynamic\"", "and", "e_block_size", "==", "\"Eigen::Dynamic\"", "and", "f_block_size", "==", "\"Eigen::Dynamic\"", ")", ":", "template", "=", "DYNAMIC_FILE", "fptr", ".", "write", "(", "template", "%", "(", "row_block_size", ",", "e_block_size", ",", "f_block_size", ")", ")", "fptr", ".", "close", "(", ")", "f", ".", "write", "(", "FACTORY_CONDITIONAL", "%", "(", "row_block_size", ",", "e_block_size", ",", "f_block_size", ",", "row_block_size", ",", "e_block_size", ",", "f_block_size", ")", ")", "f", ".", "write", "(", "FACTORY_FOOTER", ")", "f", ".", "close", "(", ")" ]

[ "Monkey", "-", "patch", "tempfile", ".", "tempdir", "with", "replacement", "ensuring", "it", "exists" ]

[ "def", "override_temp", "(", "replacement", ")", ":", "pkg_resources", ".", "py31compat", ".", "makedirs", "(", "replacement", ",", "exist_ok", "=", "True", ")", "saved", "=", "tempfile", ".", "tempdir", "tempfile", ".", "tempdir", "=", "replacement", "try", ":", "yield", "finally", ":", "tempfile", ".", "tempdir", "=", "saved" ]

[ "GetPermissions", "(", "SBSection", "self", ")", "-", ">", "uint32_t" ]

[ "def", "GetPermissions", "(", "self", ")", ":", "return", "_lldb", ".", "SBSection_GetPermissions", "(", "self", ")" ]

[ "Enable", "peer", "access", "between", "the", "current", "context", "and", "the", "peer", "context" ]

[ "def", "enable_peer_access", "(", "self", ",", "peer_context", ",", "flags", "=", "0", ")", ":", "assert", "flags", "==", "0", ",", "'*flags* is reserved and MUST be zero'", "driver", ".", "cuCtxEnablePeerAccess", "(", "peer_context", ",", "flags", ")" ]

[ "Returns", "a", "new", "instance", "of", "MimeWriter", "which", "represents", "an", "individual", "part", "in", "a", "multipart", "message", "." ]

[ "def", "nextpart", "(", "self", ")", ":", "self", ".", "_fp", ".", "write", "(", "\"\\n--\"", "+", "self", ".", "_boundary", "+", "\"\\n\"", ")", "return", "self", ".", "__class__", "(", "self", ".", "_fp", ")" ]

[ "Checks", "for", "calls", "to", "C", "random", "functions", "(", "rand", "rand_r", "random", "...", ")", "." ]

[ "def", "CheckCaffeRandom", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "for", "function", "in", "c_random_function_list", ":", "ix", "=", "line", ".", "find", "(", "function", ")", "# Comparisons made explicit for clarity -- pylint: disable=g-explicit-bool-comparison", "if", "ix", ">=", "0", "and", "(", "ix", "==", "0", "or", "(", "not", "line", "[", "ix", "-", "1", "]", ".", "isalnum", "(", ")", "and", "line", "[", "ix", "-", "1", "]", "not", "in", "(", "'_'", ",", "'.'", ",", "'>'", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'caffe/random_fn'", ",", "2", ",", "'Use caffe_rng_rand() (or other caffe_rng_* function) instead of '", "+", "function", "+", "') to ensure results are deterministic for a fixed Caffe seed.'", ")" ]

[ "Reduce", "the", "sum", "and", "square", "-", "sum", "compute", "the", "statistics", "and", "broadcast", "it", "." ]

[ "def", "_data_parallel_master", "(", "self", ",", "intermediates", ")", ":", "# Always using same \"device order\" makes the ReduceAdd operation faster.", "# Thanks to:: Tete Xiao (http://tetexiao.com/)", "intermediates", "=", "sorted", "(", "intermediates", ",", "key", "=", "lambda", "i", ":", "i", "[", "1", "]", ".", "sum", ".", "get_device", "(", ")", ")", "to_reduce", "=", "[", "i", "[", "1", "]", "[", ":", "2", "]", "for", "i", "in", "intermediates", "]", "to_reduce", "=", "[", "j", "for", "i", "in", "to_reduce", "for", "j", "in", "i", "]", "# flatten", "target_gpus", "=", "[", "i", "[", "1", "]", ".", "sum", ".", "get_device", "(", ")", "for", "i", "in", "intermediates", "]", "sum_size", "=", "sum", "(", "[", "i", "[", "1", "]", ".", "sum_size", "for", "i", "in", "intermediates", "]", ")", "sum_", ",", "ssum", "=", "ReduceAddCoalesced", ".", "apply", "(", "target_gpus", "[", "0", "]", ",", "2", ",", "*", "to_reduce", ")", "mean", ",", "inv_std", "=", "self", ".", "_compute_mean_std", "(", "sum_", ",", "ssum", ",", "sum_size", ")", "broadcasted", "=", "Broadcast", ".", "apply", "(", "target_gpus", ",", "mean", ",", "inv_std", ")", "outputs", "=", "[", "]", "for", "i", ",", "rec", "in", "enumerate", "(", "intermediates", ")", ":", "outputs", ".", "append", "(", "(", "rec", "[", "0", "]", ",", "_MasterMessage", "(", "*", "broadcasted", "[", "i", "*", "2", ":", "i", "*", "2", "+", "2", "]", ")", ")", ")", "return", "outputs" ]

[ "Utility", "method", "to", "list", "all", "the", "domains", "in", "the", "jar", "." ]

[ "def", "list_domains", "(", "self", ")", ":", "domains", "=", "[", "]", "for", "cookie", "in", "iter", "(", "self", ")", ":", "if", "cookie", ".", "domain", "not", "in", "domains", ":", "domains", ".", "append", "(", "cookie", ".", "domain", ")", "return", "domains" ]

[ "Applies", "nms", "to", "the", "results", "of", "multiple", "images", "." ]

[ "def", "apply_nms_to_test_set_results", "(", "all_boxes", ",", "nms_threshold", ",", "conf_threshold", ",", "use_gpu_nms", ",", "device_id", ")", ":", "num_classes", "=", "len", "(", "all_boxes", ")", "num_images", "=", "len", "(", "all_boxes", "[", "0", "]", ")", "nms_boxes", "=", "[", "[", "[", "]", "for", "_", "in", "range", "(", "num_images", ")", "]", "for", "_", "in", "range", "(", "num_classes", ")", "]", "nms_keepIndices", "=", "[", "[", "[", "]", "for", "_", "in", "range", "(", "num_images", ")", "]", "for", "_", "in", "range", "(", "num_classes", ")", "]", "for", "cls_ind", "in", "range", "(", "num_classes", ")", ":", "for", "im_ind", "in", "range", "(", "num_images", ")", ":", "dets", "=", "all_boxes", "[", "cls_ind", "]", "[", "im_ind", "]", "if", "len", "(", "dets", ")", "==", "0", ":", "continue", "if", "len", "(", "dets", ")", "==", "1", ":", "keep", "=", "[", "0", "]", "else", ":", "keep", "=", "nms", "(", "dets", ".", "astype", "(", "np", ".", "float32", ")", ",", "nms_threshold", ",", "use_gpu_nms", ",", "device_id", ")", "# also filter out low confidences", "if", "conf_threshold", ">", "0", ":", "keep_conf_idx", "=", "np", ".", "where", "(", "dets", "[", ":", ",", "-", "1", "]", ">", "conf_threshold", ")", "keep", "=", "list", "(", "set", "(", "keep_conf_idx", "[", "0", "]", ")", ".", "intersection", "(", "keep", ")", ")", "if", "len", "(", "keep", ")", "==", "0", ":", "continue", "nms_boxes", "[", "cls_ind", "]", "[", "im_ind", "]", "=", "dets", "[", "keep", ",", ":", "]", ".", "copy", "(", ")", "nms_keepIndices", "[", "cls_ind", "]", "[", "im_ind", "]", "=", "keep", "return", "nms_boxes", ",", "nms_keepIndices" ]

[ "Yield", "the", "DOT", "source", "code", "line", "by", "line", "(", "as", "graph", "or", "subgraph", ")", "." ]

[ "def", "__iter__", "(", "self", ",", "subgraph", "=", "False", ")", ":", "if", "self", ".", "comment", ":", "yield", "self", ".", "_comment", "%", "self", ".", "comment", "if", "subgraph", ":", "if", "self", ".", "strict", ":", "raise", "ValueError", "(", "'subgraphs cannot be strict'", ")", "head", "=", "self", ".", "_subgraph", "if", "self", ".", "name", "else", "self", ".", "_subgraph_plain", "else", ":", "head", "=", "self", ".", "_head_strict", "if", "self", ".", "strict", "else", "self", ".", "_head", "yield", "head", "%", "(", "self", ".", "_quote", "(", "self", ".", "name", ")", "+", "' '", "if", "self", ".", "name", "else", "''", ")", "for", "kw", "in", "(", "'graph'", ",", "'node'", ",", "'edge'", ")", ":", "attrs", "=", "getattr", "(", "self", ",", "f'{kw}_attr'", ")", "if", "attrs", ":", "yield", "self", ".", "_attr", "%", "(", "kw", ",", "self", ".", "_attr_list", "(", "None", ",", "attrs", ")", ")", "for", "line", "in", "self", ".", "body", ":", "yield", "line", "yield", "self", ".", "_tail" ]

[ "Molecule", "method", "returns", "bond", "by", "index" ]

[ "def", "getBond", "(", "self", ",", "idx", ")", ":", "self", ".", "dispatcher", ".", "_setSessionId", "(", ")", "return", "self", ".", "dispatcher", ".", "IndigoObject", "(", "self", ".", "dispatcher", ",", "self", ".", "dispatcher", ".", "_checkResult", "(", "Indigo", ".", "_lib", ".", "indigoGetBond", "(", "self", ".", "id", ",", "idx", ")", ")", ",", ")" ]

[ "Return", "DYLIB_INSTALL_NAME_BASE", "for", "this", "target", "." ]

[ "def", "GetInstallNameBase", "(", "self", ")", ":", "# Xcode sets this for shared_libraries, and for nonbundled loadable_modules.", "if", "(", "self", ".", "spec", "[", "'type'", "]", "!=", "'shared_library'", "and", "(", "self", ".", "spec", "[", "'type'", "]", "!=", "'loadable_module'", "or", "self", ".", "_IsBundle", "(", ")", ")", ")", ":", "return", "None", "install_base", "=", "self", ".", "GetPerTargetSetting", "(", "'DYLIB_INSTALL_NAME_BASE'", ",", "default", "=", "'/Library/Frameworks'", "if", "self", ".", "_IsBundle", "(", ")", "else", "'/usr/local/lib'", ")", "return", "install_base" ]

[ "Creates", "a", "new", "server", "with", "the", "given", "definition", "." ]

[ "def", "__init__", "(", "self", ",", "server_or_cluster_def", ",", "job_name", "=", "None", ",", "task_index", "=", "None", ",", "protocol", "=", "None", ",", "config", "=", "None", ",", "start", "=", "True", ")", ":", "self", ".", "_server_def", "=", "_make_server_def", "(", "server_or_cluster_def", ",", "job_name", ",", "task_index", ",", "protocol", ",", "config", ")", "with", "errors", ".", "raise_exception_on_not_ok_status", "(", ")", "as", "status", ":", "self", ".", "_server", "=", "pywrap_tensorflow", ".", "PyServer_New", "(", "self", ".", "_server_def", ".", "SerializeToString", "(", ")", ",", "status", ")", "if", "start", ":", "self", ".", "start", "(", ")" ]

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

[ "def", "EndBold", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextBuffer_EndBold", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Augmenter", "implementation", "body" ]

[ "def", "__call__", "(", "self", ",", "src", ",", "label", ")", ":", "crop", "=", "self", ".", "_random_crop_proposal", "(", "label", ",", "src", ".", "shape", "[", "0", "]", ",", "src", ".", "shape", "[", "1", "]", ")", "if", "crop", ":", "x", ",", "y", ",", "w", ",", "h", ",", "label", "=", "crop", "src", "=", "fixed_crop", "(", "src", ",", "x", ",", "y", ",", "w", ",", "h", ",", "None", ")", "return", "(", "src", ",", "label", ")" ]

[ "Pack", "tensors", "." ]

[ "def", "pack", "(", "self", ",", "grouped_grads_and_vars", ")", ":", "self", ".", "grouped_grads_and_vars", "=", "grouped_grads_and_vars", "self", ".", "all_device_shapes", "=", "[", "]", "self", ".", "all_device_sizes", "=", "[", "]", "device_grad_packs", "=", "[", "]", "for", "device_grads_and_vars", "in", "grouped_grads_and_vars", ":", "with", "ops", ".", "colocate_with", "(", "device_grads_and_vars", "[", "0", "]", "[", "0", "]", ")", ":", "# Flatten all the grads.", "flat_grads", "=", "[", "array_ops", ".", "reshape", "(", "g", ",", "[", "-", "1", "]", ")", "for", "g", ",", "_", "in", "device_grads_and_vars", "]", "# Remember the original shape of all the grads.", "device_shapes", "=", "[", "array_ops", ".", "shape", "(", "g", ")", "for", "g", ",", "_", "in", "device_grads_and_vars", "]", "# Remember the original sizes of all the grads.", "device_sizes", "=", "[", "array_ops", ".", "size", "(", "g", ")", "for", "g", ",", "_", "in", "device_grads_and_vars", "]", "# Concat all the flat grads into a big flat tensor.", "concat_grads", "=", "array_ops", ".", "concat", "(", "flat_grads", ",", "0", ")", "# Split the big tensor into num_splits packs. In cases where the", "# total size is not divisible num_splits, the last pack gets", "# more elements.", "# TODO(zhengxq): it is also possible to optimize away all the concat", "# as well.", "num_splits", "=", "self", ".", "num_packs", "# The array_ops.size function will sometimes remove static shapes. So if", "# all gradient shapes are defined, we use another method to get the", "# total size.", "# TODO(yuefengz): move this logic to array_ops.size.", "if", "all", "(", "g", ".", "shape", ".", "is_fully_defined", "(", ")", "for", "g", ",", "_", "in", "device_grads_and_vars", ")", ":", "total_grad_size", "=", "sum", "(", "[", "g", ".", "shape", ".", "num_elements", "(", ")", "for", "g", ",", "_", "in", "device_grads_and_vars", "]", ")", "else", ":", "total_grad_size", "=", "array_ops", ".", "size", "(", "concat_grads", ")", "split_size", "=", "total_grad_size", "//", "num_splits", "split_size_last", "=", "total_grad_size", "-", "split_size", "*", "(", "num_splits", "-", "1", ")", "split_sizes", "=", "[", "split_size", "]", "*", "(", "num_splits", "-", "1", ")", "+", "[", "split_size_last", "]", "grad_packs", "=", "array_ops", ".", "split", "(", "concat_grads", ",", "split_sizes", ")", "# Ready to aggregate the repacked gradients, with fake variables.", "# TODO(zhengxq): It is hacky to have to use fake variables.", "# We should remove the need for variables in", "# aggregate_gradients_using*.", "device_grad_packs", ".", "append", "(", "zip", "(", "grad_packs", ",", "[", "None", "]", "*", "num_splits", ")", ")", "self", ".", "all_device_shapes", ".", "append", "(", "device_shapes", ")", "self", ".", "all_device_sizes", ".", "append", "(", "device_sizes", ")", "return", "device_grad_packs" ]

[ "Initializer", "." ]

[ "def", "__init__", "(", "self", ",", "content", "=", "None", ",", "min", "=", "0", ",", "max", "=", "HUGE", ",", "name", "=", "None", ")", ":", "assert", "0", "<=", "min", "<=", "max", "<=", "HUGE", ",", "(", "min", ",", "max", ")", "if", "content", "is", "not", "None", ":", "content", "=", "tuple", "(", "map", "(", "tuple", ",", "content", ")", ")", "# Protect against alterations", "# Check sanity of alternatives", "assert", "len", "(", "content", ")", ",", "repr", "(", "content", ")", "# Can't have zero alternatives", "for", "alt", "in", "content", ":", "assert", "len", "(", "alt", ")", ",", "repr", "(", "alt", ")", "# Can have empty alternatives", "self", ".", "content", "=", "content", "self", ".", "min", "=", "min", "self", ".", "max", "=", "max", "self", ".", "name", "=", "name" ]

[ "Check", "if", "we", "are", "currently", "one", "level", "inside", "an", "extern", "C", "block", "." ]

[ "def", "InExternC", "(", "self", ")", ":", "return", "self", ".", "stack", "and", "isinstance", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "_ExternCInfo", ")" ]

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

[ "def", "ParseNolintSuppressions", "(", "filename", ",", "raw_line", ",", "linenum", ",", "error", ")", ":", "matched", "=", "Search", "(", "r'\\bNOLINT(NEXTLINE)?\\b(\\([^)]+\\))?'", ",", "raw_line", ")", "if", "matched", ":", "if", "matched", ".", "group", "(", "1", ")", ":", "suppressed_line", "=", "linenum", "+", "1", "else", ":", "suppressed_line", "=", "linenum", "category", "=", "matched", ".", "group", "(", "2", ")", "if", "category", "in", "(", "None", ",", "'(*)'", ")", ":", "# => \"suppress all\"", "_error_suppressions", ".", "setdefault", "(", "None", ",", "set", "(", ")", ")", ".", "add", "(", "suppressed_line", ")", "else", ":", "if", "category", ".", "startswith", "(", "'('", ")", "and", "category", ".", "endswith", "(", "')'", ")", ":", "category", "=", "category", "[", "1", ":", "-", "1", "]", "if", "category", "in", "_ERROR_CATEGORIES", ":", "_error_suppressions", ".", "setdefault", "(", "category", ",", "set", "(", ")", ")", ".", "add", "(", "suppressed_line", ")", "elif", "category", "not", "in", "_LEGACY_ERROR_CATEGORIES", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/nolint'", ",", "5", ",", "'Unknown NOLINT error category: %s'", "%", "category", ")" ]

[ "Calculates", "pdf", "from", "cf", "using", "fft", ".", "Using", "region", "around", "0", "with", "N", "=", "2", "**", "q", "points", "separated", "by", "distance", "h", ".", "As", "suggested", "by", "[", "MS", "]", "." ]

[ "def", "_pdf_from_cf_with_fft", "(", "cf", ",", "h", "=", "0.01", ",", "q", "=", "9", ")", ":", "N", "=", "2", "**", "q", "n", "=", "np", ".", "arange", "(", "1", ",", "N", "+", "1", ")", "density", "=", "(", "(", "-", "1", ")", "**", "(", "n", "-", "1", "-", "N", "/", "2", ")", ")", "*", "np", ".", "fft", ".", "fft", "(", "(", "(", "-", "1", ")", "**", "(", "n", "-", "1", ")", ")", "*", "cf", "(", "2", "*", "np", ".", "pi", "*", "(", "n", "-", "1", "-", "N", "/", "2", ")", "/", "h", "/", "N", ")", ")", "/", "h", "/", "N", "x", "=", "(", "n", "-", "1", "-", "N", "/", "2", ")", "*", "h", "return", "(", "x", ",", "density", ")" ]

[ "Paths", "in", "Windows", "can", "get", "a", "little", "weird" ]

[ "def", "fixpath", "(", "path", ")", ":", "if", "len", "(", "path", ")", ">", "2", "and", "path", "[", "1", "]", "!=", "':'", "and", "platform", ".", "system", "(", ")", "==", "'Windows'", "and", "path", "[", "2", "]", "==", "'/'", ":", "return", "path", "[", "1", "]", "+", "':'", "+", "path", "[", "2", ":", "]", "return", "path" ]

[ "Start", "recording", "the", "vertices", "of", "a", "polygon", "." ]

[ "def", "begin_poly", "(", "self", ")", ":", "self", ".", "_poly", "=", "[", "self", ".", "_position", "]", "self", ".", "_creatingPoly", "=", "True" ]

[ "r", "Unquotes", "a", "header", "value", ".", "(", "Reversal", "of", ":", "func", ":", "quote_header_value", ")", ".", "This", "does", "not", "use", "the", "real", "unquoting", "but", "what", "browsers", "are", "actually", "using", "for", "quoting", "." ]

[ "def", "unquote_header_value", "(", "value", ",", "is_filename", "=", "False", ")", ":", "if", "value", "and", "value", "[", "0", "]", "==", "value", "[", "-", "1", "]", "==", "'\"'", ":", "# this is not the real unquoting, but fixing this so that the", "# RFC is met will result in bugs with internet explorer and", "# probably some other browsers as well. IE for example is", "# uploading files with \"C:\\foo\\bar.txt\" as filename", "value", "=", "value", "[", "1", ":", "-", "1", "]", "# if this is a filename and the starting characters look like", "# a UNC path, then just return the value without quotes. Using the", "# replace sequence below on a UNC path has the effect of turning", "# the leading double slash into a single slash and then", "# _fix_ie_filename() doesn't work correctly. See #458.", "if", "not", "is_filename", "or", "value", "[", ":", "2", "]", "!=", "'\\\\\\\\'", ":", "return", "value", ".", "replace", "(", "'\\\\\\\\'", ",", "'\\\\'", ")", ".", "replace", "(", "'\\\\\"'", ",", "'\"'", ")", "return", "value" ]

[ "r", "Densenet", "-", "BC", "161", "-", "layer", "model", "from", "the", "Densely", "Connected", "Convolutional", "Networks", "<https", ":", "//", "arxiv", ".", "org", "/", "pdf", "/", "1608", ".", "06993", ".", "pdf", ">", "_", "paper", "." ]

[ "def", "densenet161", "(", "*", "*", "kwargs", ")", ":", "return", "get_densenet", "(", "161", ",", "*", "*", "kwargs", ")" ]

[ "Compute", "the", "trimmed", "minimum" ]

[ "def", "tmin", "(", "a", ",", "lowerlimit", "=", "None", ",", "axis", "=", "0", ",", "inclusive", "=", "True", ",", "nan_policy", "=", "'propagate'", ")", ":", "a", ",", "axis", "=", "_chk_asarray", "(", "a", ",", "axis", ")", "am", "=", "_mask_to_limits", "(", "a", ",", "(", "lowerlimit", ",", "None", ")", ",", "(", "inclusive", ",", "False", ")", ")", "contains_nan", ",", "nan_policy", "=", "_contains_nan", "(", "am", ",", "nan_policy", ")", "if", "contains_nan", "and", "nan_policy", "==", "'omit'", ":", "am", "=", "ma", ".", "masked_invalid", "(", "am", ")", "res", "=", "ma", ".", "minimum", ".", "reduce", "(", "am", ",", "axis", ")", ".", "data", "if", "res", ".", "ndim", "==", "0", ":", "return", "res", "[", "(", ")", "]", "return", "res" ]

[ "Returns", "whether", "the", "service", "sets", "class", "allocators", "." ]

[ "def", "sets_allocators", "(", "self", ")", ":", "return", "\"sets-allocators\"", "in", "self", ".", "__flags", "(", ")" ]

[ "Return", "True", "if", "the", "NPY_NO_SIGNAL", "symbol", "must", "be", "defined", "in", "configuration", "header", "." ]

[ "def", "is_npy_no_signal", "(", ")", ":", "return", "sys", ".", "platform", "==", "'win32'" ]

[ "Execute", "a", "statement", "." ]

[ "def", "Exec", "(", "self", ",", "exp", ")", ":", "if", "type", "(", "exp", ")", "!=", "str", ":", "raise", "Exception", "(", "desc", "=", "\"Must be a string\"", ",", "scode", "=", "winerror", ".", "DISP_E_TYPEMISMATCH", ")", "exec", "(", "str", "(", "exp", ")", ",", "self", ".", "dict", ")" ]

[ "Write", "the", "unicode", "string", "s", "to", "the", "pseudoterminal", "." ]

[ "def", "write", "(", "self", ",", "s", ")", ":", "b", "=", "s", ".", "encode", "(", "self", ".", "encoding", ")", "return", "super", "(", "PtyProcessUnicode", ",", "self", ")", ".", "write", "(", "b", ")" ]

[ "Installs", "a", "target", "somewhere", "so", "that", "it", "is", "ready", "to", "run", "." ]

[ "def", "Install", "(", "self", ",", "context", ",", "targets", ",", "arguments", ")", ":", "raise", "NotImplementedError", "(", "'Must be overridden.'", ")" ]

[ "Parse", "a", "template", "." ]

[ "def", "parse", "(", "self", ",", "template", ")", ":", "self", ".", "_includestack", "=", "[", "(", "None", ",", "template", ")", "]", "# for error-messages (_errpos)", "return", "self", ".", "_parse", "(", "template", ")" ]

[ "GetCaretPositionForDefaultStyle", "(", "self", ")", "-", ">", "long" ]

[ "def", "GetCaretPositionForDefaultStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_GetCaretPositionForDefaultStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "expression", ":", "expression", "PLUS", "expression", "|", "expression", "MINUS", "expression", "|", "expression", "TIMES", "expression", "|", "expression", "DIVIDE", "expression" ]

[ "def", "p_expression_binop", "(", "p", ")", ":", "if", "p", "[", "2", "]", "==", "u'+'", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "+", "p", "[", "3", "]", "elif", "p", "[", "2", "]", "==", "u'-'", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "-", "p", "[", "3", "]", "elif", "p", "[", "2", "]", "==", "u'*'", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "*", "p", "[", "3", "]", "elif", "p", "[", "2", "]", "==", "u'/'", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "/", "p", "[", "3", "]" ]

[ "ToGMT", "(", "self", "bool", "noDST", "=", "False", ")", "-", ">", "DateTime" ]

[ "def", "ToGMT", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "DateTime_ToGMT", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Reset", "file", "that", "contains", "customized", "config", "settings", "." ]

[ "def", "reset_configure_bazelrc", "(", ")", ":", "open", "(", "_REVERB_BAZELRC", ",", "'w'", ")", ".", "close", "(", ")" ]

[ "Creates", "an", "application", "version", "for", "the", "specified", "application", "." ]

[ "def", "create_application_version", "(", "self", ",", "application_name", ",", "version_label", ",", "description", "=", "None", ",", "s3_bucket", "=", "None", ",", "s3_key", "=", "None", ",", "auto_create_application", "=", "None", ")", ":", "params", "=", "{", "'ApplicationName'", ":", "application_name", ",", "'VersionLabel'", ":", "version_label", "}", "if", "description", ":", "params", "[", "'Description'", "]", "=", "description", "if", "s3_bucket", "and", "s3_key", ":", "params", "[", "'SourceBundle.S3Bucket'", "]", "=", "s3_bucket", "params", "[", "'SourceBundle.S3Key'", "]", "=", "s3_key", "if", "auto_create_application", ":", "params", "[", "'AutoCreateApplication'", "]", "=", "self", ".", "_encode_bool", "(", "auto_create_application", ")", "return", "self", ".", "_get_response", "(", "'CreateApplicationVersion'", ",", "params", ")" ]

[ "Return", "True", "for", "leap", "years", "False", "for", "non", "-", "leap", "years", "." ]

[ "def", "isleap", "(", "year", ")", ":", "return", "year", "%", "4", "==", "0", "and", "(", "year", "%", "100", "!=", "0", "or", "year", "%", "400", "==", "0", ")" ]

[ "Constructs", "a", "dataset", "from", "the", "given", "variant", "and", "(", "nested", ")", "structure", "." ]

[ "def", "from_variant", "(", "variant", ",", "structure", ")", ":", "return", "_VariantDataset", "(", "variant", ",", "structure", ")" ]

[ "Iter", "." ]

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

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

[ "def", "ParseNolintSuppressions", "(", "filename", ",", "raw_line", ",", "linenum", ",", "error", ")", ":", "# FIXME(adonovan): \"NOLINT(\" is misparsed as NOLINT(*).", "matched", "=", "_RE_SUPPRESSION", ".", "search", "(", "raw_line", ")", "if", "matched", ":", "category", "=", "matched", ".", "group", "(", "1", ")", "if", "category", "in", "(", "None", ",", "'(*)'", ")", ":", "# => \"suppress all\"", "_error_suppressions", ".", "setdefault", "(", "None", ",", "set", "(", ")", ")", ".", "add", "(", "linenum", ")", "else", ":", "if", "category", ".", "startswith", "(", "'('", ")", "and", "category", ".", "endswith", "(", "')'", ")", ":", "category", "=", "category", "[", "1", ":", "-", "1", "]", "if", "category", "in", "_ERROR_CATEGORIES", ":", "_error_suppressions", ".", "setdefault", "(", "category", ",", "set", "(", ")", ")", ".", "add", "(", "linenum", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/nolint'", ",", "5", ",", "'Unknown NOLINT error category: %s'", "%", "category", ")" ]

[ "r", "A", "helper", "method", "that", "records", "a", "straggler", "metric", "for", "the", "given", "key", ".", "A", "user", "should", "call", "this", "when", "the", "first", "gradient", "for", "the", "param", "location", "is", "received", ".", "Args", ":", "key", "(", "str", ")", ":", "unique", "id", "for", "metric", "within", "a", "group", "cuda", "(", "bool", ")", ":", "indicator", "to", "determine", "if", "this", "is", "a", "CUDA", "metric" ]

[ "def", "record_straggler_start", "(", "self", ",", "key", ",", "cuda", "=", "True", ")", ":", "self", ".", "__metrics_logger", ".", "record_start", "(", "self", ".", "PARAMETER_SERVER_STRAGGLER_METRIC", ",", "key", ",", "self", ".", "PARAM_INDEX_STRAGGLER", ",", "cuda", ")" ]

[ "Store", "FUNC", "SUBST", "and", "WIDGET", "as", "members", "." ]

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

[ "Returns", "the", "C", "++", "type", "to", "be", "used", "in", "the", "JitBuilder", "implementation", "for", "a", "given", "type", "name", "prefixing", "with", "a", "given", "namespace", "if", "needed", "." ]

[ "def", "get_impl_type", "(", "self", ",", "c", ")", ":", "return", "\"{} *\"", ".", "format", "(", "self", ".", "get_impl_class_name", "(", "c", ".", "as_class", "(", ")", ")", ")", "if", "c", ".", "is_class", "(", ")", "else", "self", ".", "builtin_type_map", "[", "c", ".", "name", "(", ")", "]" ]

[ "Attempts", "to", "extract", "the", "average", "gradient", "from", "the", "accumulator", "." ]

[ "def", "take_indexed_slices_grad", "(", "self", ",", "num_required", ",", "name", "=", "None", ")", ":", "return_val", "=", "gen_data_flow_ops", ".", "sparse_accumulator_take_gradient", "(", "self", ".", "_accumulator_ref", ",", "num_required", ",", "dtype", "=", "self", ".", "_dtype", ",", "name", "=", "name", ")", "return", "ops", ".", "IndexedSlices", "(", "indices", "=", "return_val", ".", "indices", ",", "values", "=", "return_val", ".", "values", ",", "dense_shape", "=", "return_val", ".", "shape", ")" ]

[ "direct_declarator", ":", "direct_declarator", "LPAREN", "identifier_list", "RPAREN" ]

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

[ "Whether", "each", "element", "in", "the", "DataFrame", "is", "contained", "in", "values", "." ]

[ "def", "isin", "(", "self", ",", "values", ")", ":", "if", "isinstance", "(", "values", ",", "dict", ")", ":", "result_df", "=", "DataFrame", "(", ")", "for", "col", "in", "self", ".", "_data", ".", "names", ":", "if", "col", "in", "values", ":", "val", "=", "values", "[", "col", "]", "result_df", "[", "col", "]", "=", "self", ".", "_data", "[", "col", "]", ".", "isin", "(", "val", ")", "else", ":", "result_df", "[", "col", "]", "=", "column", ".", "full", "(", "size", "=", "len", "(", "self", ")", ",", "fill_value", "=", "False", ",", "dtype", "=", "\"bool\"", ")", "result_df", ".", "index", "=", "self", ".", "index", "return", "result_df", "elif", "isinstance", "(", "values", ",", "Series", ")", ":", "values", "=", "values", ".", "reindex", "(", "self", ".", "index", ")", "result", "=", "DataFrame", "(", ")", "# TODO: propagate nulls through isin", "# https://github.com/rapidsai/cudf/issues/7556", "for", "col", "in", "self", ".", "_data", ".", "names", ":", "if", "isinstance", "(", "self", "[", "col", "]", ".", "_column", ",", "cudf", ".", "core", ".", "column", ".", "CategoricalColumn", ")", "and", "isinstance", "(", "values", ".", "_column", ",", "cudf", ".", "core", ".", "column", ".", "CategoricalColumn", ")", ":", "res", "=", "(", "self", ".", "_data", "[", "col", "]", "==", "values", ".", "_column", ")", ".", "fillna", "(", "False", ")", "result", "[", "col", "]", "=", "res", "elif", "(", "isinstance", "(", "self", "[", "col", "]", ".", "_column", ",", "cudf", ".", "core", ".", "column", ".", "CategoricalColumn", ")", "or", "np", ".", "issubdtype", "(", "self", "[", "col", "]", ".", "dtype", ",", "cudf", ".", "dtype", "(", "\"object\"", ")", ")", ")", "or", "(", "isinstance", "(", "values", ".", "_column", ",", "cudf", ".", "core", ".", "column", ".", "CategoricalColumn", ")", "or", "np", ".", "issubdtype", "(", "values", ".", "dtype", ",", "cudf", ".", "dtype", "(", "\"object\"", ")", ")", ")", ":", "result", "[", "col", "]", "=", "utils", ".", "scalar_broadcast_to", "(", "False", ",", "len", "(", "self", ")", ")", "else", ":", "result", "[", "col", "]", "=", "(", "self", ".", "_data", "[", "col", "]", "==", "values", ".", "_column", ")", ".", "fillna", "(", "False", ")", "result", ".", "index", "=", "self", ".", "index", "return", "result", "elif", "isinstance", "(", "values", ",", "DataFrame", ")", ":", "values", "=", "values", ".", "reindex", "(", "self", ".", "index", ")", "result", "=", "DataFrame", "(", ")", "for", "col", "in", "self", ".", "_data", ".", "names", ":", "if", "col", "in", "values", ".", "columns", ":", "result", "[", "col", "]", "=", "(", "self", ".", "_data", "[", "col", "]", "==", "values", "[", "col", "]", ".", "_column", ")", ".", "fillna", "(", "False", ")", "else", ":", "result", "[", "col", "]", "=", "utils", ".", "scalar_broadcast_to", "(", "False", ",", "len", "(", "self", ")", ")", "result", ".", "index", "=", "self", ".", "index", "return", "result", "else", ":", "if", "not", "is_list_like", "(", "values", ")", ":", "raise", "TypeError", "(", "f\"only list-like or dict-like objects are \"", "f\"allowed to be passed to DataFrame.isin(), \"", "f\"you passed a \"", "f\"'{type(values).__name__}'\"", ")", "result_df", "=", "DataFrame", "(", ")", "for", "col", "in", "self", ".", "_data", ".", "names", ":", "result_df", "[", "col", "]", "=", "self", ".", "_data", "[", "col", "]", ".", "isin", "(", "values", ")", "result_df", ".", "index", "=", "self", ".", "index", "return", "result_df" ]

[ "check", "for", "inGlobalId", "and", "set", "outXyz", "if", "present", "\\", "n", "\\", "n", "utility", "function", "called", "by", "GetXyzForNodeOrElementParallelRecurse1", "this", "\\", "n", "takes", "one", "unstructured", "grid", "as", "input", "and", "sees", "if", "it", "has", "the", "node", "or", "element", "\\", "n", "with", "id", "inGlobalId", ".", "If", "it", "does", "the", "method", "sets", "outXyz", "to", "the", "geometric", "\\", "n", "location", "of", "the", "node", "(", "xyz", ")", "or", "center", "of", "the", "element", "bounding", "box", "(", "xyz", ")", "and", "\\", "n", "returns", "true", "otherwise", "it", "returns", "false", "without", "changing", "outXyz", "\\", "n" ]

[ "def", "GetXyzForNodeOrElementParallelOneBlock", "(", "inInputCsData", ",", "inIdIsNode", ",", "inGlobalId", ",", "outXyz", ")", ":", "if", "PhactoriDbg", "(", "100", ")", ":", "myDebugPrint3", "(", "'GetXyzForNodeOrElementParallelOneBlock entered\\n'", ",", "100", ")", "globalIdArray", "=", "None", "if", "inIdIsNode", ":", "ptOrElData", "=", "inInputCsData", ".", "GetPointData", "(", ")", "globalIdArray", "=", "ptOrElData", ".", "GetArray", "(", "'GlobalNodeId'", ")", "else", ":", "ptOrElData", "=", "inInputCsData", ".", "GetCellData", "(", ")", "globalIdArray", "=", "ptOrElData", ".", "GetArray", "(", "'GlobalElementId'", ")", "if", "globalIdArray", "==", "None", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\" this process/block has no Global Node or Element Id array to contain \"", "+", "str", "(", "inGlobalId", ")", "+", "\"\\n\"", ")", "return", "False", "numTuples", "=", "globalIdArray", ".", "GetNumberOfTuples", "(", ")", "thisProcessHasTheId", "=", "False", "idIndex", "=", "-", "1", "for", "ii", "in", "range", "(", "0", ",", "numTuples", ")", ":", "#myDebugPrint3(\" testing \" + str(ii) + \" against \" + str(inGlobalNodeId) + \"\\n\")", "#myDebugPrint3(\" type array: \" + str(type(globalNodeIdArray)) + \" type ii:\" + str(type(ii)) + \"\\n\")", "vv", "=", "globalIdArray", ".", "GetTuple1", "(", "ii", ")", "if", "vv", "==", "inGlobalId", ":", "thisProcessHasTheId", "=", "True", "idIndex", "=", "ii", "break", "if", "not", "thisProcessHasTheId", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\" this process/block doesn't contain id\"", "+", "str", "(", "inGlobalId", ")", "+", "\"\\n\"", ")", "return", "False", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\" this process/block contains id \"", "+", "str", "(", "inGlobalId", ")", "+", "\"\\n\"", ")", "if", "inIdIsNode", ":", "pointsArray", "=", "inInputCsData", ".", "GetPoints", "(", ")", "numPoints", "=", "pointsArray", ".", "GetNumberOfPoints", "(", ")", "if", "idIndex", ">=", "numPoints", ":", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\" this process/block has problem with index, setting xyz 0\\n\"", ")", "outXyz", "[", "0", "]", "=", "0.0", "outXyz", "[", "1", "]", "=", "0.0", "outXyz", "[", "2", "]", "=", "0.0", "return", "False", "thePoint", "=", "pointsArray", ".", "GetPoint", "(", "idIndex", ",", "outXyz", ")", "if", "PhactoriDbg", "(", ")", ":", "myDebugPrint3", "(", "\" outXyz set to: \"", "+", "str", "(", "outXyz", ")", "+", "\"\\n\"", ")", "return", "True", "else", ":", "myBounds", "=", "[", "0.0", ",", "0.0", ",", "0.0", ",", "0.0", ",", "0.0", ",", "0.0", "]", "#myCells = inInputCsData.GetCells()", "#oneCell = myCells.GetCell(idIndex)", "oneCell", "=", "inInputCsData", ".", "GetCell", "(", "idIndex", ")", "oneCell", ".", "GetBounds", "(", "myBounds", ")", "#myCells.GetCellBounds(idIndex, myBounds)", "#ptOrElData.GetCellBounds(idIndex, myBounds)", "outXyz", "[", "0", "]", "=", "0.5", "*", "(", "myBounds", "[", "0", "]", "+", "myBounds", "[", "1", "]", ")", "outXyz", "[", "1", "]", "=", "0.5", "*", "(", "myBounds", "[", "2", "]", "+", "myBounds", "[", "3", "]", ")", "outXyz", "[", "2", "]", "=", "0.5", "*", "(", "myBounds", "[", "4", "]", "+", "myBounds", "[", "5", "]", ")", "#xmin, xmax, ymin, ymax, zmin, zmax = myCells.GetCellBounds(idIndex)", "#outXyz[0] = 0.5 * (xmin + xmax)", "#outXyz[1] = 0.5 * (ymin + ymax)", "#outXyz[2] = 0.5 * (zmin + zmax)", "return", "True" ]

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

[ "def", "GetDefaultCellTextColour", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "Grid_GetDefaultCellTextColour", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Check", "we", "have", "complex", "conjugates", "pairs", "and", "reorder", "P", "according", "to", "YT", "ie", "real_poles", "complex_i", "conjugate", "complex_i", "....", "The", "lexicographic", "sort", "on", "the", "complex", "poles", "is", "added", "to", "help", "the", "user", "to", "compare", "sets", "of", "poles", "." ]

[ "def", "_order_complex_poles", "(", "poles", ")", ":", "ordered_poles", "=", "np", ".", "sort", "(", "poles", "[", "np", ".", "isreal", "(", "poles", ")", "]", ")", "im_poles", "=", "[", "]", "for", "p", "in", "np", ".", "sort", "(", "poles", "[", "np", ".", "imag", "(", "poles", ")", "<", "0", "]", ")", ":", "if", "np", ".", "conj", "(", "p", ")", "in", "poles", ":", "im_poles", ".", "extend", "(", "(", "p", ",", "np", ".", "conj", "(", "p", ")", ")", ")", "ordered_poles", "=", "np", ".", "hstack", "(", "(", "ordered_poles", ",", "im_poles", ")", ")", "if", "poles", ".", "shape", "[", "0", "]", "!=", "len", "(", "ordered_poles", ")", ":", "raise", "ValueError", "(", "\"Complex poles must come with their conjugates\"", ")", "return", "ordered_poles" ]

[ "Check", "for", "rvalue", "references", "." ]

[ "def", "CheckRValueReference", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "# Find lines missing spaces around &&.", "# TODO(unknown): currently we don't check for rvalue references", "# with spaces surrounding the && to avoid false positives with", "# boolean expressions.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "match", "=", "Match", "(", "r\"^(.*\\S)&&\"", ",", "line", ")", "if", "not", "match", ":", "match", "=", "Match", "(", "r\"(.*)&&\\S\"", ",", "line", ")", "if", "(", "not", "match", ")", "or", "\"(&&)\"", "in", "line", "or", "Search", "(", "r\"\\boperator\\s*$\"", ",", "match", ".", "group", "(", "1", ")", ")", ":", "return", "# Either poorly formed && or an rvalue reference, check the context", "# to get a more accurate error message. Mostly we want to determine", "# if what's to the left of \"&&\" is a type or not.", "and_pos", "=", "len", "(", "match", ".", "group", "(", "1", ")", ")", "if", "IsRValueType", "(", "clean_lines", ",", "nesting_state", ",", "linenum", ",", "and_pos", ")", ":", "if", "not", "IsRValueAllowed", "(", "clean_lines", ",", "linenum", ")", ":", "error", "(", "filename", ",", "linenum", ",", "\"build/c++11\"", ",", "3", ",", "\"RValue references are an unapproved C++ feature.\"", ",", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "\"whitespace/operators\"", ",", "3", ",", "\"Missing spaces around &&\"", ")" ]

[ "Release", "a", "file", "name", "." ]

[ "def", "release_filename", "(", "self", ",", "id_", ")", ":", "entry", "=", "self", ".", "__entries", ".", "get", "(", "id_", ")", "if", "entry", "is", "None", ":", "raise", "ValueError", "(", "\"Invalid filename id (%d)\"", "%", "id_", ")", "# Decrease reference count and check if the entry has to be removed...", "if", "entry", ".", "dec_ref_count", "(", ")", "==", "0", ":", "del", "self", ".", "__entries", "[", "id_", "]", "del", "self", ".", "__id_lut", "[", "entry", ".", "filename", "]" ]

[ "Reset", "the", "ego", "-", "vehicle" ]

[ "def", "reset_vehicle", "(", "self", ")", ":", "self", ".", "_vehicle", "=", "None" ]

[ "Return", "a", "Message", "representation", "or", "raise", "a", "KeyError", "." ]

[ "def", "get_message", "(", "self", ",", "key", ")", ":", "raise", "NotImplementedError", "(", "'Method must be implemented by subclass'", ")" ]

[ "Generate", "a", "zero", "filled", "tensor", "with", "shape", "[", "batch_size", "state_size", "]", "." ]

[ "def", "_generate_zero_filled_state", "(", "batch_size_tensor", ",", "state_size", ",", "dtype", ")", ":", "if", "batch_size_tensor", "is", "None", "or", "dtype", "is", "None", ":", "raise", "ValueError", "(", "'batch_size and dtype cannot be None while constructing initial state: '", "'batch_size={}, dtype={}'", ".", "format", "(", "batch_size_tensor", ",", "dtype", ")", ")", "def", "create_zeros", "(", "unnested_state_size", ")", ":", "flat_dims", "=", "tensor_shape", ".", "as_shape", "(", "unnested_state_size", ")", ".", "as_list", "(", ")", "init_state_size", "=", "[", "batch_size_tensor", "]", "+", "flat_dims", "return", "array_ops", ".", "zeros", "(", "init_state_size", ",", "dtype", "=", "dtype", ")", "if", "nest", ".", "is_sequence", "(", "state_size", ")", ":", "return", "nest", ".", "map_structure", "(", "create_zeros", ",", "state_size", ")", "else", ":", "return", "create_zeros", "(", "state_size", ")" ]

[ "Check", "if", "the", "input", "parameter", "is", "a", "list", "of", "tuple", "or", "numpy", ".", "ndarray", "." ]

[ "def", "check_gnn_list_of_pair_or_ndarray", "(", "param", ",", "param_name", ")", ":", "type_check", "(", "param", ",", "(", "list", ",", "np", ".", "ndarray", ")", ",", "param_name", ")", "if", "isinstance", "(", "param", ",", "list", ")", ":", "param_names", "=", "[", "\"node_list[{0}]\"", ".", "format", "(", "i", ")", "for", "i", "in", "range", "(", "len", "(", "param", ")", ")", "]", "type_check_list", "(", "param", ",", "(", "tuple", ",", ")", ",", "param_names", ")", "for", "idx", ",", "pair", "in", "enumerate", "(", "param", ")", ":", "if", "not", "len", "(", "pair", ")", "==", "2", ":", "raise", "ValueError", "(", "\"Each member in {0} must be a pair which means length == 2. Got length {1}\"", ".", "format", "(", "param_names", "[", "idx", "]", ",", "len", "(", "pair", ")", ")", ")", "column_names", "=", "[", "\"node_list[{0}], number #{1} element\"", ".", "format", "(", "idx", ",", "i", "+", "1", ")", "for", "i", "in", "range", "(", "len", "(", "pair", ")", ")", "]", "type_check_list", "(", "pair", ",", "(", "int", ",", ")", ",", "column_names", ")", "elif", "isinstance", "(", "param", ",", "np", ".", "ndarray", ")", ":", "if", "param", ".", "ndim", "!=", "2", ":", "raise", "ValueError", "(", "\"Input ndarray must be in dimension 2. Got {0}\"", ".", "format", "(", "param", ".", "ndim", ")", ")", "if", "param", ".", "shape", "[", "1", "]", "!=", "2", ":", "raise", "ValueError", "(", "\"Each member in {0} must be a pair which means length == 2. Got length {1}\"", ".", "format", "(", "param_name", ",", "param", ".", "shape", "[", "1", "]", ")", ")", "if", "not", "param", ".", "dtype", "==", "np", ".", "int32", ":", "raise", "TypeError", "(", "\"Each member in {0} should be of type int32. Got {1}.\"", ".", "format", "(", "param_name", ",", "param", ".", "dtype", ")", ")" ]

[ "TpmMarshaller", "method" ]

[ "def", "toTpm", "(", "self", ",", "buf", ")", ":", "buf", ".", "writeSizedByteBuf", "(", "self", ".", "integrityOuter", ")", "buf", ".", "writeSizedByteBuf", "(", "self", ".", "integrityInner", ")", "buf", ".", "writeSizedObj", "(", "self", ".", "sensitive", ")" ]

[ "Hash", "functions" ]

[ "def", "h_fun", "(", "fun", ")", ":", "try", ":", "return", "fun", ".", "code", "except", "AttributeError", ":", "if", "isinstance", "(", "fun", ",", "functools", ".", "partial", ")", ":", "code", "=", "list", "(", "fun", ".", "args", ")", "# The method items() provides a sequence of tuples where the first element", "# represents an optional argument of the partial function application", "#", "# The sorting result outcome will be consistent because:", "# 1. tuples are compared in order of their elements", "# 2. optional argument namess are unique", "code", ".", "extend", "(", "sorted", "(", "fun", ".", "keywords", ".", "items", "(", ")", ")", ")", "code", ".", "append", "(", "h_fun", "(", "fun", ".", "func", ")", ")", "fun", ".", "code", "=", "h_list", "(", "code", ")", "return", "fun", ".", "code", "try", ":", "h", "=", "inspect", ".", "getsource", "(", "fun", ")", "except", "EnvironmentError", ":", "h", "=", "'nocode'", "try", ":", "fun", ".", "code", "=", "h", "except", "AttributeError", ":", "pass", "return", "h" ]

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

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