Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Derive", "a", "new", "function", "IR", "from", "this", "one", "using", "the", "given", "blocks", "and", "possibly", "modifying", "the", "argument", "count", "and", "generator", "flag", "." ]

[ "def", "derive", "(", "self", ",", "blocks", ",", "arg_count", "=", "None", ",", "arg_names", "=", "None", ",", "force_non_generator", "=", "False", ")", ":", "firstblock", "=", "blocks", "[", "min", "(", "blocks", ")", "]", "new_ir", "=", "copy", ".", "copy", "(", "self", ")", "new_ir", ".", "blocks", "=", "blocks", "new_ir", ".", "loc", "=", "firstblock", ".", "loc", "if", "force_non_generator", ":", "new_ir", ".", "is_generator", "=", "False", "if", "arg_count", "is", "not", "None", ":", "new_ir", ".", "arg_count", "=", "arg_count", "if", "arg_names", "is", "not", "None", ":", "new_ir", ".", "arg_names", "=", "arg_names", "new_ir", ".", "_reset_analysis_variables", "(", ")", "# Make fresh func_id", "new_ir", ".", "func_id", "=", "new_ir", ".", "func_id", ".", "derive", "(", ")", "return", "new_ir" ]

[ "Recursively", "list", "all", "models", "involved", "in", "this", "model", "." ]

[ "def", "traverse_models", "(", "self", ")", ":", "return", "[", "self", ".", "_dmm", "[", "t", "]", "for", "t", "in", "self", ".", "traverse_types", "(", ")", "]" ]

[ "Returns", "the", "current", "task", "context", "." ]

[ "def", "get_current_worker_context", "(", ")", ":", "try", ":", "return", "_worker_context", ".", "current", "except", "AttributeError", ":", "return", "None" ]

[ "Convert", "a", "DNS", "rdata", "type", "to", "text", "." ]

[ "def", "to_text", "(", "value", ")", ":", "if", "value", "<", "0", "or", "value", ">", "65535", ":", "raise", "ValueError", "(", "\"type must be between >= 0 and <= 65535\"", ")", "text", "=", "_by_value", ".", "get", "(", "value", ")", "if", "text", "is", "None", ":", "text", "=", "'TYPE'", "+", "`value`", "return", "text" ]

[ "Convenience", "fluent", "method", "for", ":", "py", ":", "func", ":", "argmax_channel", "." ]

[ "def", "argmax_channel", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "op", ".", "argmax_channel", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Extend", "linecache", ".", "checkcache", "to", "preserve", "the", "<pyshell#", "...", ">", "entries" ]

[ "def", "extended_linecache_checkcache", "(", "filename", "=", "None", ",", "orig_checkcache", "=", "linecache", ".", "checkcache", ")", ":", "cache", "=", "linecache", ".", "cache", "save", "=", "{", "}", "for", "key", "in", "list", "(", "cache", ")", ":", "if", "key", "[", ":", "1", "]", "+", "key", "[", "-", "1", ":", "]", "==", "'<>'", ":", "save", "[", "key", "]", "=", "cache", ".", "pop", "(", "key", ")", "orig_checkcache", "(", "filename", ")", "cache", ".", "update", "(", "save", ")" ]

[ "Returns", "a", "single", "week", "in", "a", "string", "(", "no", "newline", ")", "." ]

[ "def", "formatweek", "(", "self", ",", "theweek", ",", "width", ")", ":", "return", "' '", ".", "join", "(", "self", ".", "formatday", "(", "d", ",", "wd", ",", "width", ")", "for", "(", "d", ",", "wd", ")", "in", "theweek", ")" ]

[ "Returns", "carla", "vehicle", "light", "state", "based", "on", "sumo", "signals", "." ]

[ "def", "get_carla_lights_state", "(", "current_carla_lights", ",", "sumo_lights", ")", ":", "current_lights", "=", "current_carla_lights", "# Blinker right / emergency.", "if", "(", "any", "(", "[", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "BLINKER_RIGHT", ")", ",", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "BLINKER_EMERGENCY", ")", "]", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "RightBlinker", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "RightBlinker", "# Blinker left / emergency.", "if", "(", "any", "(", "[", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "BLINKER_LEFT", ")", ",", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "BLINKER_EMERGENCY", ")", "]", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "LeftBlinker", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "LeftBlinker", "# Break.", "if", "(", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "BRAKELIGHT", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "Brake", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "Brake", "# Front (low beam).", "if", "(", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "FRONTLIGHT", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "LowBeam", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "LowBeam", "# Fog.", "if", "(", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "FOGLIGHT", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "Fog", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "Fog", "# High beam.", "if", "(", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "HIGHBEAM", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "HighBeam", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "HighBeam", "# Backdrive (reverse).", "if", "(", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "BACKDRIVE", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "Reverse", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "Reverse", "# Door open left/right.", "if", "(", "any", "(", "[", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "DOOR_OPEN_LEFT", ")", ",", "bool", "(", "sumo_lights", "&", "SumoVehSignal", ".", "DOOR_OPEN_RIGHT", ")", "]", ")", "!=", "bool", "(", "current_lights", "&", "carla", ".", "VehicleLightState", ".", "Position", ")", ")", ":", "current_lights", "^=", "carla", ".", "VehicleLightState", ".", "Position", "return", "current_lights" ]

[ "Constructs", "a", "variable", "prior", "covariance", "with", "data", "-", "based", "initialization", "." ]

[ "def", "get_prior_covariance", "(", "self", ")", ":", "with", "variable_scope", ".", "variable_scope", "(", "self", ".", "_variable_scope", ")", ":", "state_dimension", "=", "ops", ".", "convert_to_tensor", "(", "self", ".", "get_state_transition", "(", ")", ")", ".", "get_shape", "(", ")", "[", "0", "]", ".", "value", "if", "self", ".", "_configuration", ".", "trainable_start_state", ":", "base_covariance", "=", "math_utils", ".", "variable_covariance_matrix", "(", "state_dimension", ",", "\"prior_state_var\"", ",", "dtype", "=", "self", ".", "dtype", ")", "else", ":", "return", "linalg_ops", ".", "eye", "(", "state_dimension", ",", "dtype", "=", "self", ".", "dtype", ")", "if", "self", ".", "_input_statistics", "is", "not", "None", ":", "# Make sure initial latent value uncertainty is at least on the same", "# scale as noise in the data.", "covariance_multiplier", "=", "math_ops", ".", "reduce_max", "(", "self", ".", "_input_statistics", ".", "series_start_moments", ".", "variance", ")", "return", "base_covariance", "*", "gen_math_ops", ".", "maximum", "(", "covariance_multiplier", ",", "1.0", ")", "else", ":", "return", "base_covariance" ]

[ "_wxPyInitTheBrushList", "()", "-", ">", "BrushList" ]

[ "def", "_wxPyInitTheBrushList", "(", "*", "args", ")", ":", "return", "_gdi_", ".", "_wxPyInitTheBrushList", "(", "*", "args", ")" ]

[ "Checks", "for", "the", "correctness", "of", "various", "spacing", "issues", "in", "the", "code", "." ]

[ "def", "CheckSpacing", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "# Don't use \"elided\" lines here, otherwise we can't check commented lines.", "# Don't want to use \"raw\" either, because we don't want to check inside C++11", "# raw strings,", "raw", "=", "clean_lines", ".", "lines_without_raw_strings", "line", "=", "raw", "[", "linenum", "]", "# Before nixing comments, check if the line is blank for no good", "# reason. This includes the first line after a block is opened, and", "# blank lines at the end of a function (ie, right before a line like '}'", "#", "# Skip all the blank line checks if we are immediately inside a", "# namespace body. In other words, don't issue blank line warnings", "# for this block:", "# namespace {", "#", "# }", "#", "# A warning about missing end of namespace comments will be issued instead.", "#", "# Also skip blank line checks for 'extern \"C\"' blocks, which are formatted", "# like namespaces.", "if", "(", "IsBlankLine", "(", "line", ")", "and", "not", "nesting_state", ".", "InNamespaceBody", "(", ")", "and", "not", "nesting_state", ".", "InExternC", "(", ")", ")", ":", "elided", "=", "clean_lines", ".", "elided", "prev_line", "=", "elided", "[", "linenum", "-", "1", "]", "prevbrace", "=", "prev_line", ".", "rfind", "(", "'{'", ")", "# TODO(unknown): Don't complain if line before blank line, and line after,", "# both start with alnums and are indented the same amount.", "# This ignores whitespace at the start of a namespace block", "# because those are not usually indented.", "if", "prevbrace", "!=", "-", "1", "and", "prev_line", "[", "prevbrace", ":", "]", ".", "find", "(", "'}'", ")", "==", "-", "1", ":", "# OK, we have a blank line at the start of a code block. Before we", "# complain, we check if it is an exception to the rule: The previous", "# non-empty line has the parameters of a function header that are indented", "# 4 spaces (because they did not fit in a 80 column line when placed on", "# the same line as the function name). We also check for the case where", "# the previous line is indented 6 spaces, which may happen when the", "# initializers of a constructor do not fit into a 80 column line.", "exception", "=", "False", "if", "Match", "(", "r' {6}\\w'", ",", "prev_line", ")", ":", "# Initializer list?", "# We are looking for the opening column of initializer list, which", "# should be indented 4 spaces to cause 6 space indentation afterwards.", "search_position", "=", "linenum", "-", "2", "while", "(", "search_position", ">=", "0", "and", "Match", "(", "r' {6}\\w'", ",", "elided", "[", "search_position", "]", ")", ")", ":", "search_position", "-=", "1", "exception", "=", "(", "search_position", ">=", "0", "and", "elided", "[", "search_position", "]", "[", ":", "5", "]", "==", "' :'", ")", "else", ":", "# Search for the function arguments or an initializer list. We use a", "# simple heuristic here: If the line is indented 4 spaces; and we have a", "# closing paren, without the opening paren, followed by an opening brace", "# or colon (for initializer lists) we assume that it is the last line of", "# a function header. If we have a colon indented 4 spaces, it is an", "# initializer list.", "exception", "=", "(", "Match", "(", "r' {4}\\w[^\\(]*\\)\\s*(const\\s*)?(\\{\\s*$|:)'", ",", "prev_line", ")", "or", "Match", "(", "r' {4}:'", ",", "prev_line", ")", ")", "if", "not", "exception", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/blank_line'", ",", "2", ",", "'Redundant blank line at the start of a code block '", "'should be deleted.'", ")", "# Ignore blank lines at the end of a block in a long if-else", "# chain, like this:", "# if (condition1) {", "# // Something followed by a blank line", "#", "# } else if (condition2) {", "# // Something else", "# }", "if", "linenum", "+", "1", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "next_line", "=", "raw", "[", "linenum", "+", "1", "]", "if", "(", "next_line", "and", "Match", "(", "r'\\s*}'", ",", "next_line", ")", "and", "next_line", ".", "find", "(", "'} else '", ")", "==", "-", "1", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/blank_line'", ",", "3", ",", "'Redundant blank line at the end of a code block '", "'should be deleted.'", ")", "matched", "=", "Match", "(", "r'\\s*(public|protected|private):'", ",", "prev_line", ")", "if", "matched", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/blank_line'", ",", "3", ",", "'Do not leave a blank line after \"%s:\"'", "%", "matched", ".", "group", "(", "1", ")", ")", "# Next, check comments", "next_line_start", "=", "0", "if", "linenum", "+", "1", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "next_line", "=", "raw", "[", "linenum", "+", "1", "]", "next_line_start", "=", "len", "(", "next_line", ")", "-", "len", "(", "next_line", ".", "lstrip", "(", ")", ")", "CheckComment", "(", "line", ",", "filename", ",", "linenum", ",", "next_line_start", ",", "error", ")", "# get rid of comments and strings", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# You shouldn't have spaces before your brackets, except maybe after", "# 'delete []' or 'return []() {};'", "if", "Search", "(", "r'\\w\\s+\\['", ",", "line", ")", "and", "not", "Search", "(", "r'(?:delete|return)\\s+\\['", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/braces'", ",", "5", ",", "'Extra space before ['", ")", "# In range-based for, we wanted spaces before and after the colon, but", "# not around \"::\" tokens that might appear.", "if", "(", "Search", "(", "r'for *\\(.*[^:]:[^: ]'", ",", "line", ")", "or", "Search", "(", "r'for *\\(.*[^: ]:[^:]'", ",", "line", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/forcolon'", ",", "2", ",", "'Missing space around colon in range-based for loop'", ")" ]

[ "Adds", "multiple", "columns", "to", "this", "SFrame", ".", "The", "number", "of", "elements", "in", "all", "columns", "must", "match", "the", "length", "of", "every", "other", "column", "of", "the", "SFrame", ".", "This", "operation", "modifies", "the", "current", "SFrame", "in", "place", "and", "returns", "self", "." ]

[ "def", "add_columns", "(", "self", ",", "data", ",", "namelist", "=", "None", ")", ":", "datalist", "=", "data", "if", "isinstance", "(", "data", ",", "SFrame", ")", ":", "other", "=", "data", "datalist", "=", "[", "other", ".", "select_column", "(", "name", ")", "for", "name", "in", "other", ".", "column_names", "(", ")", "]", "namelist", "=", "other", ".", "column_names", "(", ")", "my_columns", "=", "set", "(", "self", ".", "column_names", "(", ")", ")", "for", "name", "in", "namelist", ":", "if", "name", "in", "my_columns", ":", "raise", "ValueError", "(", "\"Column '\"", "+", "name", "+", "\"' already exists in current SFrame\"", ")", "else", ":", "if", "not", "_is_non_string_iterable", "(", "datalist", ")", ":", "raise", "TypeError", "(", "\"datalist must be an iterable\"", ")", "if", "not", "_is_non_string_iterable", "(", "namelist", ")", ":", "raise", "TypeError", "(", "\"namelist must be an iterable\"", ")", "if", "not", "all", "(", "[", "isinstance", "(", "x", ",", "SArray", ")", "for", "x", "in", "datalist", "]", ")", ":", "raise", "TypeError", "(", "\"Must give column as SArray\"", ")", "if", "not", "all", "(", "[", "isinstance", "(", "x", ",", "str", ")", "for", "x", "in", "namelist", "]", ")", ":", "raise", "TypeError", "(", "\"Invalid column name in list : must all be str\"", ")", "with", "cython_context", "(", ")", ":", "self", ".", "__proxy__", ".", "add_columns", "(", "[", "x", ".", "__proxy__", "for", "x", "in", "datalist", "]", ",", "namelist", ")", "self", ".", "_cache", "=", "None", "return", "self" ]

[ "Adds", "a", "block", "to", "the", "out", "-", "of", "-", "tree", "module", "." ]

[ "def", "cli", "(", "*", "*", "kwargs", ")", ":", "kwargs", "[", "'cli'", "]", "=", "True", "self", "=", "ModToolAdd", "(", "*", "*", "kwargs", ")", "click", ".", "secho", "(", "\"GNU Radio module name identified: \"", "+", "self", ".", "info", "[", "'modname'", "]", ",", "fg", "=", "'green'", ")", "get_blockname", "(", "self", ")", "get_blocktype", "(", "self", ")", "get_lang", "(", "self", ")", "info_lang", "=", "{", "'cpp'", ":", "'C++'", ",", "'python'", ":", "'Python'", "}", "[", "self", ".", "info", "[", "'lang'", "]", "]", "click", ".", "secho", "(", "f\"Language: {info_lang}\"", ",", "fg", "=", "'green'", ")", "if", "(", "(", "self", ".", "skip_subdirs", "[", "'lib'", "]", "and", "self", ".", "info", "[", "'lang'", "]", "==", "'cpp'", ")", "or", "(", "self", ".", "skip_subdirs", "[", "'python'", "]", "and", "self", ".", "info", "[", "'lang'", "]", "==", "'python'", ")", ")", ":", "raise", "ModToolException", "(", "'Missing or skipping relevant subdir.'", ")", "click", ".", "secho", "(", "\"Block/code identifier: \"", "+", "self", ".", "info", "[", "'blockname'", "]", ",", "fg", "=", "'green'", ")", "if", "not", "self", ".", "license_file", ":", "get_copyrightholder", "(", "self", ")", "self", ".", "info", "[", "'license'", "]", "=", "self", ".", "setup_choose_license", "(", ")", "get_arglist", "(", "self", ")", "get_py_qa", "(", "self", ")", "get_cpp_qa", "(", "self", ")", "if", "self", ".", "info", "[", "'version'", "]", "==", "'autofoo'", "and", "not", "self", ".", "skip_cmakefiles", ":", "click", ".", "secho", "(", "\"Warning: Autotools modules are not supported. \"", "+", "\"Files will be created, but Makefiles will not be edited.\"", ",", "fg", "=", "'yellow'", ")", "self", ".", "skip_cmakefiles", "=", "True", "run", "(", "self", ")" ]

[ "Gets", "the", "language", "Id", "that", "is", "associated", "with", "the", "file", "extension", ".", "@param", "ext", ":", "extension", "to", "get", "lang", "id", "for" ]

[ "def", "GetLangId", "(", "self", ",", "ext", ")", ":", "ftype", "=", "self", ".", "_extreg", ".", "FileTypeFromExt", "(", "ext", ")", "return", "synglob", ".", "LANG_MAP", "[", "ftype", "]", "[", "LANG_ID", "]" ]

[ "StyleSetWeight", "(", "self", "int", "style", "int", "weight", ")" ]

[ "def", "StyleSetWeight", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_StyleSetWeight", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

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

[ "def", "HasGripperTop", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiPaneInfo_HasGripperTop", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Determine", "the", "name", "of", "the", "produced", "target", "from", "the", "names", "of", "the", "sources", "." ]

[ "def", "determine_output_name", "(", "self", ",", "sources", ")", ":", "assert", "is_iterable_typed", "(", "sources", ",", "virtual_target", ".", "VirtualTarget", ")", "# The simple case if when a name", "# of source has single dot. Then, we take the part before", "# dot. Several dots can be caused by:", "# - Using source file like a.host.cpp", "# - A type which suffix has a dot. Say, we can", "# type 'host_cpp' with extension 'host.cpp'.", "# In the first case, we want to take the part till the last", "# dot. In the second case -- no sure, but for now take", "# the part till the last dot too.", "name", "=", "os", ".", "path", ".", "splitext", "(", "sources", "[", "0", "]", ".", "name", "(", ")", ")", "[", "0", "]", "for", "s", "in", "sources", "[", "1", ":", "]", ":", "n2", "=", "os", ".", "path", ".", "splitext", "(", "s", ".", "name", "(", ")", ")", "if", "n2", "!=", "name", ":", "get_manager", "(", ")", ".", "errors", "(", ")", "(", "\"%s: source targets have different names: cannot determine target name\"", "%", "(", "self", ".", "id_", ")", ")", "# Names of sources might include directory. We should strip it.", "return", "self", ".", "determine_target_name", "(", "sources", "[", "0", "]", ".", "name", "(", ")", ")" ]

[ "Look", "for", "empty", "loop", "/", "conditional", "body", "with", "only", "a", "single", "semicolon", "." ]

[ "def", "CheckEmptyBlockBody", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "# Search for loop keywords at the beginning of the line. Because only", "# whitespaces are allowed before the keywords, this will also ignore most", "# do-while-loops, since those lines should start with closing brace.", "#", "# We also check \"if\" blocks here, since an empty conditional block", "# is likely an error.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "matched", "=", "Match", "(", "r'\\s*(for|while|if)\\s*\\('", ",", "line", ")", "if", "matched", ":", "# Find the end of the conditional expression.", "(", "end_line", ",", "end_linenum", ",", "end_pos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "line", ".", "find", "(", "'('", ")", ")", "# Output warning if what follows the condition expression is a semicolon.", "# No warning for all other cases, including whitespace or newline, since we", "# have a separate check for semicolons preceded by whitespace.", "if", "end_pos", ">=", "0", "and", "Match", "(", "r';'", ",", "end_line", "[", "end_pos", ":", "]", ")", ":", "if", "matched", ".", "group", "(", "1", ")", "==", "'if'", ":", "error", "(", "filename", ",", "end_linenum", ",", "'whitespace/empty_conditional_body'", ",", "5", ",", "'Empty conditional bodies should use {}'", ")", "else", ":", "error", "(", "filename", ",", "end_linenum", ",", "'whitespace/empty_loop_body'", ",", "5", ",", "'Empty loop bodies should use {} or continue'", ")", "# Check for if statements that have completely empty bodies (no comments)", "# and no else clauses.", "if", "end_pos", ">=", "0", "and", "matched", ".", "group", "(", "1", ")", "==", "'if'", ":", "# Find the position of the opening { for the if statement.", "# Return without logging an error if it has no brackets.", "opening_linenum", "=", "end_linenum", "opening_line_fragment", "=", "end_line", "[", "end_pos", ":", "]", "# Loop until EOF or find anything that's not whitespace or opening {.", "while", "not", "Search", "(", "r'^\\s*\\{'", ",", "opening_line_fragment", ")", ":", "if", "Search", "(", "r'^(?!\\s*$)'", ",", "opening_line_fragment", ")", ":", "# Conditional has no brackets.", "return", "opening_linenum", "+=", "1", "if", "opening_linenum", "==", "len", "(", "clean_lines", ".", "elided", ")", ":", "# Couldn't find conditional's opening { or any code before EOF.", "return", "opening_line_fragment", "=", "clean_lines", ".", "elided", "[", "opening_linenum", "]", "# Set opening_line (opening_line_fragment may not be entire opening line).", "opening_line", "=", "clean_lines", ".", "elided", "[", "opening_linenum", "]", "# Find the position of the closing }.", "opening_pos", "=", "opening_line_fragment", ".", "find", "(", "'{'", ")", "if", "opening_linenum", "==", "end_linenum", ":", "# We need to make opening_pos relative to the start of the entire line.", "opening_pos", "+=", "end_pos", "(", "closing_line", ",", "closing_linenum", ",", "closing_pos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "opening_linenum", ",", "opening_pos", ")", "if", "closing_pos", "<", "0", ":", "return", "# Now construct the body of the conditional. This consists of the portion", "# of the opening line after the {, all lines until the closing line,", "# and the portion of the closing line before the }.", "if", "(", "clean_lines", ".", "raw_lines", "[", "opening_linenum", "]", "!=", "CleanseComments", "(", "clean_lines", ".", "raw_lines", "[", "opening_linenum", "]", ")", ")", ":", "# Opening line ends with a comment, so conditional isn't empty.", "return", "if", "closing_linenum", ">", "opening_linenum", ":", "# Opening line after the {. Ignore comments here since we checked above.", "bodylist", "=", "list", "(", "opening_line", "[", "opening_pos", "+", "1", ":", "]", ")", "# All lines until closing line, excluding closing line, with comments.", "bodylist", ".", "extend", "(", "clean_lines", ".", "raw_lines", "[", "opening_linenum", "+", "1", ":", "closing_linenum", "]", ")", "# Closing line before the }. Won't (and can't) have comments.", "bodylist", ".", "append", "(", "clean_lines", ".", "elided", "[", "closing_linenum", "]", "[", ":", "closing_pos", "-", "1", "]", ")", "body", "=", "'\\n'", ".", "join", "(", "bodylist", ")", "else", ":", "# If statement has brackets and fits on a single line.", "body", "=", "opening_line", "[", "opening_pos", "+", "1", ":", "closing_pos", "-", "1", "]", "# Check if the body is empty", "if", "not", "_EMPTY_CONDITIONAL_BODY_PATTERN", ".", "search", "(", "body", ")", ":", "return", "# The body is empty. Now make sure there's not an else clause.", "current_linenum", "=", "closing_linenum", "current_line_fragment", "=", "closing_line", "[", "closing_pos", ":", "]", "# Loop until EOF or find anything that's not whitespace or else clause.", "while", "Search", "(", "r'^\\s*$|^(?=\\s*else)'", ",", "current_line_fragment", ")", ":", "if", "Search", "(", "r'^(?=\\s*else)'", ",", "current_line_fragment", ")", ":", "# Found an else clause, so don't log an error.", "return", "current_linenum", "+=", "1", "if", "current_linenum", "==", "len", "(", "clean_lines", ".", "elided", ")", ":", "break", "current_line_fragment", "=", "clean_lines", ".", "elided", "[", "current_linenum", "]", "# The body is empty and there's no else clause until EOF or other code.", "error", "(", "filename", ",", "end_linenum", ",", "'whitespace/empty_if_body'", ",", "4", ",", "(", "'If statement had no body and no else clause'", ")", ")" ]

[ "Return", "the", "Unified", "Symbol", "Resultion", "(", "USR", ")", "for", "the", "entity", "referenced", "by", "the", "given", "cursor", "(", "or", "None", ")", "." ]

[ "def", "get_usr", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_getCursorUSR", "(", "self", ")" ]

[ "Return", "an", "argument", "from", "a", "name", "." ]

[ "def", "GetArgument", "(", "self", ",", "name", ")", ":", "return", "self", ".", "arg_dict", "[", "name", ".", "lower", "(", ")", "]" ]

[ "Check", "if", "the", "token", "ending", "on", "(", "linenum", "column", ")", "is", "a", "type", "." ]

[ "def", "IsRValueType", "(", "clean_lines", ",", "nesting_state", ",", "linenum", ",", "column", ")", ":", "prefix", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "[", "0", ":", "column", "]", "# Get one word to the left. If we failed to do so, this is most", "# likely not a type, since it's unlikely that the type name and \"&&\"", "# would be split across multiple lines.", "match", "=", "Match", "(", "r'^(.*)(\\b\\w+|[>*)&])\\s*$'", ",", "prefix", ")", "if", "not", "match", ":", "return", "False", "# Check text following the token. If it's \"&&>\" or \"&&,\" or \"&&...\", it's", "# most likely a rvalue reference used inside a template.", "suffix", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "[", "column", ":", "]", "if", "Match", "(", "r'&&\\s*(?:[>,]|\\.\\.\\.)'", ",", "suffix", ")", ":", "return", "True", "# Check for simple type and end of templates:", "# int&& variable", "# vector<int>&& variable", "#", "# Because this function is called recursively, we also need to", "# recognize pointer and reference types:", "# int* Function()", "# int& Function()", "if", "match", ".", "group", "(", "2", ")", "in", "[", "'char'", ",", "'char16_t'", ",", "'char32_t'", ",", "'wchar_t'", ",", "'bool'", ",", "'short'", ",", "'int'", ",", "'long'", ",", "'signed'", ",", "'unsigned'", ",", "'float'", ",", "'double'", ",", "'void'", ",", "'auto'", ",", "'>'", ",", "'*'", ",", "'&'", "]", ":", "return", "True", "# If we see a close parenthesis, look for decltype on the other side.", "# decltype would unambiguously identify a type, anything else is", "# probably a parenthesized expression and not a type.", "if", "match", ".", "group", "(", "2", ")", "==", "')'", ":", "return", "IsDecltype", "(", "clean_lines", ",", "linenum", ",", "len", "(", "match", ".", "group", "(", "1", ")", ")", "+", "len", "(", "match", ".", "group", "(", "2", ")", ")", "-", "1", ")", "# Check for casts and cv-qualifiers.", "# match.group(1) remainder", "# -------------- ---------", "# const_cast< type&&", "# const type&&", "# type const&&", "if", "Search", "(", "r'\\b(?:const_cast\\s*<|static_cast\\s*<|dynamic_cast\\s*<|'", "r'reinterpret_cast\\s*<|\\w+\\s)\\s*$'", ",", "match", ".", "group", "(", "1", ")", ")", ":", "return", "True", "# Look for a preceding symbol that might help differentiate the context.", "# These are the cases that would be ambiguous:", "# match.group(1) remainder", "# -------------- ---------", "# Call ( expression &&", "# Declaration ( type&&", "# sizeof ( type&&", "# if ( expression &&", "# while ( expression &&", "# for ( type&&", "# for( ; expression &&", "# statement ; type&&", "# block { type&&", "# constructor { expression &&", "start", "=", "linenum", "line", "=", "match", ".", "group", "(", "1", ")", "match_symbol", "=", "None", "while", "start", ">=", "0", ":", "# We want to skip over identifiers and commas to get to a symbol.", "# Commas are skipped so that we can find the opening parenthesis", "# for function parameter lists.", "match_symbol", "=", "Match", "(", "r'^(.*)([^\\w\\s,])[\\w\\s,]*$'", ",", "line", ")", "if", "match_symbol", ":", "break", "start", "-=", "1", "line", "=", "clean_lines", ".", "elided", "[", "start", "]", "if", "not", "match_symbol", ":", "# Probably the first statement in the file is an rvalue reference", "return", "True", "if", "match_symbol", ".", "group", "(", "2", ")", "==", "'}'", ":", "# Found closing brace, probably an indicate of this:", "# block{} type&&", "return", "True", "if", "match_symbol", ".", "group", "(", "2", ")", "==", "';'", ":", "# Found semicolon, probably one of these:", "# for(; expression &&", "# statement; type&&", "# Look for the previous 'for(' in the previous lines.", "before_text", "=", "match_symbol", ".", "group", "(", "1", ")", "for", "i", "in", "xrange", "(", "start", "-", "1", ",", "max", "(", "start", "-", "6", ",", "0", ")", ",", "-", "1", ")", ":", "before_text", "=", "clean_lines", ".", "elided", "[", "i", "]", "+", "before_text", "if", "Search", "(", "r'for\\s*\\([^{};]*$'", ",", "before_text", ")", ":", "# This is the condition inside a for-loop", "return", "False", "# Did not find a for-init-statement before this semicolon, so this", "# is probably a new statement and not a condition.", "return", "True", "if", "match_symbol", ".", "group", "(", "2", ")", "==", "'{'", ":", "# Found opening brace, probably one of these:", "# block{ type&& = ... ; }", "# constructor{ expression && expression }", "# Look for a closing brace or a semicolon. If we see a semicolon", "# first, this is probably a rvalue reference.", "line", "=", "clean_lines", ".", "elided", "[", "start", "]", "[", "0", ":", "len", "(", "match_symbol", ".", "group", "(", "1", ")", ")", "+", "1", "]", "end", "=", "start", "depth", "=", "1", "while", "True", ":", "for", "ch", "in", "line", ":", "if", "ch", "==", "';'", ":", "return", "True", "elif", "ch", "==", "'{'", ":", "depth", "+=", "1", "elif", "ch", "==", "'}'", ":", "depth", "-=", "1", "if", "depth", "==", "0", ":", "return", "False", "end", "+=", "1", "if", "end", ">=", "clean_lines", ".", "NumLines", "(", ")", ":", "break", "line", "=", "clean_lines", ".", "elided", "[", "end", "]", "# Incomplete program?", "return", "False", "if", "match_symbol", ".", "group", "(", "2", ")", "==", "'('", ":", "# Opening parenthesis. Need to check what's to the left of the", "# parenthesis. Look back one extra line for additional context.", "before_text", "=", "match_symbol", ".", "group", "(", "1", ")", "if", "linenum", ">", "1", ":", "before_text", "=", "clean_lines", ".", "elided", "[", "linenum", "-", "1", "]", "+", "before_text", "before_text", "=", "match_symbol", ".", "group", "(", "1", ")", "# Patterns that are likely to be types:", "# [](type&&", "# for (type&&", "# sizeof(type&&", "# operator=(type&&", "#", "if", "Search", "(", "r'(?:\\]|\\bfor|\\bsizeof|\\boperator\\s*\\S+\\s*)\\s*$'", ",", "before_text", ")", ":", "return", "True", "# Patterns that are likely to be expressions:", "# if (expression &&", "# while (expression &&", "# : initializer(expression &&", "# , initializer(expression &&", "# ( FunctionCall(expression &&", "# + FunctionCall(expression &&", "# + (expression &&", "#", "# The last '+' represents operators such as '+' and '-'.", "if", "Search", "(", "r'(?:\\bif|\\bwhile|[-+=%^(<!?:,&*]\\s*)$'", ",", "before_text", ")", ":", "return", "False", "# Something else. Check that tokens to the left look like", "# return_type function_name", "match_func", "=", "Match", "(", "r'^(.*)\\s+\\w(?:\\w|::)*(?:<[^<>]*>)?\\s*$'", ",", "match_symbol", ".", "group", "(", "1", ")", ")", "if", "match_func", ":", "# Check for constructors, which don't have return types.", "if", "Search", "(", "r'\\b(?:explicit|inline)$'", ",", "match_func", ".", "group", "(", "1", ")", ")", ":", "return", "True", "implicit_constructor", "=", "Match", "(", "r'\\s*(\\w+)\\((?:const\\s+)?(\\w+)'", ",", "prefix", ")", "if", "(", "implicit_constructor", "and", "implicit_constructor", ".", "group", "(", "1", ")", "==", "implicit_constructor", ".", "group", "(", "2", ")", ")", ":", "return", "True", "return", "IsRValueType", "(", "clean_lines", ",", "nesting_state", ",", "linenum", ",", "len", "(", "match_func", ".", "group", "(", "1", ")", ")", ")", "# Nothing before the function name. If this is inside a block scope,", "# this is probably a function call.", "return", "not", "(", "nesting_state", ".", "previous_stack_top", "and", "nesting_state", ".", "previous_stack_top", ".", "IsBlockInfo", "(", ")", ")", "if", "match_symbol", ".", "group", "(", "2", ")", "==", "'>'", ":", "# Possibly a closing bracket, check that what's on the other side", "# looks like the start of a template.", "return", "IsTemplateParameterList", "(", "clean_lines", ",", "start", ",", "len", "(", "match_symbol", ".", "group", "(", "1", ")", ")", ")", "# Some other symbol, usually something like \"a=b&&c\". This is most", "# likely not a type.", "return", "False" ]

[ "Function", "that", "scales", "point", "coordinates" ]

[ "def", "cvt", "(", "pt", ",", "scale", ")", ":", "out", "=", "[", "pt", "[", "0", "]", "*", "scale", "[", "0", "]", ",", "pt", "[", "1", "]", "*", "scale", "[", "1", "]", "]", "return", "out" ]

[ "Clean", "up", "and", "re", "-", "create", "the", "scratch", "directory", "." ]

[ "def", "clean_scratch_dir", "(", "scratch_dir", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "scratch_dir", ")", ":", "logging", ".", "info", "(", "\"Removing scratch dir %s...\"", ",", "scratch_dir", ")", "shutil", ".", "rmtree", "(", "scratch_dir", ")", "logging", ".", "info", "(", "\"Creating empty scratch dir %s...\"", ",", "scratch_dir", ")", "os", ".", "makedirs", "(", "scratch_dir", ")" ]

[ "SetSelectedFrame", "(", "SBThread", "self", "uint32_t", "frame_idx", ")", "-", ">", "SBFrame" ]

[ "def", "SetSelectedFrame", "(", "self", ",", "frame_idx", ")", ":", "return", "_lldb", ".", "SBThread_SetSelectedFrame", "(", "self", ",", "frame_idx", ")" ]

[ "Return", "any", "remaining", "buffered", "data", "not", "yet", "returned", "by", "decompress", "." ]

[ "def", "flush", "(", "self", ")", "->", "bytes", ":", "return", "self", ".", "decompressobj", ".", "flush", "(", ")" ]

[ "Returns", "the", "level", "that", "stdout", "runs", "at" ]

[ "def", "_stdout_level", "(", "self", ")", ":", "for", "level", ",", "consumer", "in", "self", ".", "consumers", ":", "if", "consumer", "is", "sys", ".", "stdout", ":", "return", "level", "return", "self", ".", "FATAL" ]

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

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

[ "atan", "(", "x", ")", "Return", "the", "arctan", "(", "x", ")", "element", "-", "wise", ".", "alias", "name", ":", "arctan", "." ]

[ "def", "atan", "(", "x", ")", ":", "x", "=", "_to_var", "(", "x", ")", "return", "_F", ".", "atan", "(", "x", ")" ]

[ "Return", "the", "width", "for", "this", "margin", ".", "(", "Calculate", "only", "once", "per", "render", "time", ".", ")" ]

[ "def", "_get_margin_width", "(", "self", ",", "margin", ":", "Margin", ")", "->", "int", ":", "# Margin.get_width, needs to have a UIContent instance.", "def", "get_ui_content", "(", ")", "->", "UIContent", ":", "return", "self", ".", "_get_ui_content", "(", "width", "=", "0", ",", "height", "=", "0", ")", "def", "get_width", "(", ")", "->", "int", ":", "return", "margin", ".", "get_width", "(", "get_ui_content", ")", "key", "=", "(", "margin", ",", "get_app", "(", ")", ".", "render_counter", ")", "return", "self", ".", "_margin_width_cache", ".", "get", "(", "key", ",", "get_width", ")" ]

[ "SetUseAntiAliasing", "(", "self", "bool", "useAA", ")" ]

[ "def", "SetUseAntiAliasing", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetUseAntiAliasing", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Append", "a", "value", "to", "the", "end", "of", "a", "tf", ".", "TensorArray", "." ]

[ "def", "_ta_append", "(", "tensor_array", ",", "value", ")", ":", "return", "tensor_array", ".", "write", "(", "tensor_array", ".", "size", "(", ")", ",", "value", ")" ]

[ "Send", "data", "to", "remote", "." ]

[ "def", "send", "(", "self", ",", "data", ")", ":", "self", ".", "writefile", ".", "write", "(", "data", ")", "self", ".", "writefile", ".", "flush", "(", ")" ]

[ "Takes", "an", "XMLNode", "and", "convert", "it", "into", "the", "AST", "structured", "used", "by", "PSL", "Engine", "." ]

[ "def", "toAst", "(", "xmlnode", ")", ":", "childList", "=", "[", "]", "for", "k", "in", "xmlnode", ".", "attrib", ":", "v", "=", "xmlnode", ".", "attrib", "[", "k", "]", "if", "len", "(", "v", ")", ">", "2", "and", "v", "[", "0", "]", "==", "\"p\"", "and", "v", "[", "1", "]", "==", "\"'\"", "and", "v", "[", "-", "1", "]", "==", "\"'\"", ":", "childList", ".", "append", "(", "(", "k", ",", "(", "'p'", ",", "v", "[", "2", ":", "-", "1", "]", ")", ")", ")", "else", ":", "childList", ".", "append", "(", "(", "k", ",", "(", "'s'", ",", "v", ")", ")", ")", "childList", ".", "reverse", "(", ")", "for", "child", "in", "xmlnode", ":", "for", "j", "in", "toAst", "(", "child", ")", ":", "childList", ".", "append", "(", "j", ")", "if", "len", "(", "childList", ")", "==", "0", ":", "if", "xmlnode", ".", "text", "==", "None", ":", "return", "[", "(", "xmlnode", ".", "tag", ",", "[", "]", ")", "]", "else", ":", "return", "[", "(", "xmlnode", ".", "tag", ",", "xmlnode", ".", "text", ")", "]", "return", "[", "(", "xmlnode", ".", "tag", ",", "childList", ")", "]" ]

[ "Write", "a", "sub", "-", "project", "Makefile", "." ]

[ "def", "WriteSubMake", "(", "self", ",", "output_filename", ",", "makefile_path", ",", "targets", ",", "build_dir", ")", ":", "ensure_directory_exists", "(", "output_filename", ")", "self", ".", "fp", "=", "open", "(", "output_filename", ",", "'w'", ")", "self", ".", "fp", ".", "write", "(", "header", ")", "# For consistency with other builders, put sub-project build output in the", "# sub-project dir (see test/subdirectory/gyptest-subdir-all.py).", "self", ".", "WriteLn", "(", "'export builddir_name ?= %s'", "%", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "output_filename", ")", ",", "build_dir", ")", ")", "self", ".", "WriteLn", "(", "'.PHONY: all'", ")", "self", ".", "WriteLn", "(", "'all:'", ")", "if", "makefile_path", ":", "makefile_path", "=", "' -C '", "+", "makefile_path", "self", ".", "WriteLn", "(", "'\\t$(MAKE)%s %s'", "%", "(", "makefile_path", ",", "' '", ".", "join", "(", "targets", ")", ")", ")", "self", ".", "fp", ".", "close", "(", ")" ]

[ "Trains", "a", "model", "given", "training", "data", "x", "predictions", "and", "y", "labels", "." ]

[ "def", "fit", "(", "self", ",", "x", "=", "None", ",", "y", "=", "None", ",", "input_fn", "=", "None", ",", "steps", "=", "None", ",", "batch_size", "=", "None", ",", "monitors", "=", "None", ",", "max_steps", "=", "None", ")", ":", "raise", "NotImplementedError" ]

[ "Swap", "system", "memory", "as", "a", "(", "total", "used", "free", "sin", "sout", ")", "tuple", "." ]

[ "def", "swap_memory", "(", ")", ":", "total", ",", "free", ",", "sin", ",", "sout", "=", "cext", ".", "swap_mem", "(", ")", "used", "=", "total", "-", "free", "percent", "=", "usage_percent", "(", "used", ",", "total", ",", "round_", "=", "1", ")", "return", "_common", ".", "sswap", "(", "total", ",", "used", ",", "free", ",", "percent", ",", "sin", ",", "sout", ")" ]

[ "r", "..", "math", "::", "H", "(", "U", ")", "=", "\\", "log", "(", "high", "-", "low", ")", "." ]

[ "def", "_entropy", "(", "self", ",", "low", "=", "None", ",", "high", "=", "None", ")", ":", "low", ",", "high", "=", "self", ".", "_check_param_type", "(", "low", ",", "high", ")", "return", "self", ".", "log", "(", "high", "-", "low", ")" ]

[ "Converts", "the", "argument", "to", "a", "boolean", ";", "raise", "ValueError", "on", "errors", "." ]

[ "def", "Convert", "(", "self", ",", "argument", ")", ":", "if", "type", "(", "argument", ")", "==", "str", ":", "if", "argument", ".", "lower", "(", ")", "in", "[", "'true'", ",", "'t'", ",", "'1'", "]", ":", "return", "True", "elif", "argument", ".", "lower", "(", ")", "in", "[", "'false'", ",", "'f'", ",", "'0'", "]", ":", "return", "False", "bool_argument", "=", "bool", "(", "argument", ")", "if", "argument", "==", "bool_argument", ":", "# The argument is a valid boolean (True, False, 0, or 1), and not just", "# something that always converts to bool (list, string, int, etc.).", "return", "bool_argument", "raise", "ValueError", "(", "'Non-boolean argument to boolean flag'", ",", "argument", ")" ]

[ "Check", "whether", "the", "character", "is", "part", "of", "TaiXuanJingSymbols", "UCS", "Block" ]

[ "def", "uCSIsTaiXuanJingSymbols", "(", "code", ")", ":", "ret", "=", "libxml2mod", ".", "xmlUCSIsTaiXuanJingSymbols", "(", "code", ")", "return", "ret" ]

[ "Gives", "us", "a", "chance", "to", "update", "with", "new", "nonces", "or", "such", "returned", "from", "the", "last", "authorized", "response", ".", "Over", "-", "rise", "this", "in", "sub", "-", "classes", "if", "necessary", "." ]

[ "def", "response", "(", "self", ",", "response", ",", "content", ")", ":", "return", "False" ]

[ "Shape", "function", "for", "the", "ReadFile", "op", "." ]

[ "def", "_ReadFileShape", "(", "op", ")", ":", "return", "[", "op", ".", "inputs", "[", "0", "]", ".", "get_shape", "(", ")", ".", "merge_with", "(", "tensor_shape", ".", "scalar", "(", ")", ")", "]" ]

[ "Command", "line", "entry", "point", "." ]

[ "def", "main", "(", ")", ":", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "__doc__", ")", "parser", ".", "add_argument", "(", "'--dir'", ",", "'-d'", ",", "metavar", "=", "'DIR'", ",", "default", "=", "'ChangeLog.d'", ",", "help", "=", "'Directory to read entries from'", "' (default: ChangeLog.d)'", ")", "parser", ".", "add_argument", "(", "'--input'", ",", "'-i'", ",", "metavar", "=", "'FILE'", ",", "default", "=", "'ChangeLog'", ",", "help", "=", "'Existing changelog file to read from and augment'", "' (default: ChangeLog)'", ")", "parser", ".", "add_argument", "(", "'--keep-entries'", ",", "action", "=", "'store_true'", ",", "dest", "=", "'keep_entries'", ",", "default", "=", "None", ",", "help", "=", "'Keep the files containing entries'", "' (default: remove them if --output/-o is not specified)'", ")", "parser", ".", "add_argument", "(", "'--no-keep-entries'", ",", "action", "=", "'store_false'", ",", "dest", "=", "'keep_entries'", ",", "help", "=", "'Remove the files containing entries after they are merged'", "' (default: remove them if --output/-o is not specified)'", ")", "parser", ".", "add_argument", "(", "'--output'", ",", "'-o'", ",", "metavar", "=", "'FILE'", ",", "help", "=", "'Output changelog file'", "' (default: overwrite the input)'", ")", "parser", ".", "add_argument", "(", "'--list-files-only'", ",", "action", "=", "'store_true'", ",", "help", "=", "(", "'Only list the files that would be processed '", "'(with some debugging information)'", ")", ")", "options", "=", "parser", ".", "parse_args", "(", ")", "set_defaults", "(", "options", ")", "if", "options", ".", "list_files_only", ":", "show_file_timestamps", "(", "options", ")", "return", "merge_entries", "(", "options", ")" ]

[ "Write", "the", "given", "buffer", "to", "the", "IO", "stream", "." ]

[ "def", "write", "(", "self", ",", "b", ")", ":", "self", ".", "_unsupported", "(", "\"write\"", ")" ]

[ "Adds", "a", "cubic", "Bezier", "curve", "from", "the", "current", "point", "using", "two", "control", "points", "and", "an", "end", "point", "." ]

[ "def", "AddCurveToPoint", "(", "self", ",", "cx1", ",", "cy1", ",", "cx2", ",", "cy2", ",", "x", ",", "y", ")", ":", "self", ".", "_pathContext", ".", "curve_to", "(", "cx1", ",", "cy1", ",", "cx2", ",", "cy2", ",", "x", ",", "y", ")", "return", "self" ]

[ "Constructor", "for", "_ColumnHistory", "." ]

[ "def", "__init__", "(", "self", ",", "path", ":", "Tuple", "[", "Union", "[", "str", ",", "int", "]", ",", "...", "]", ",", "buffer_size", ":", "int", ",", "history_padding", ":", "int", "=", "0", ")", ":", "self", ".", "_path", "=", "path", "self", ".", "_buffer_size", "=", "buffer_size", "self", ".", "_data_references", ":", "List", "[", "Optional", "[", "pybind", ".", "WeakCellRef", "]", "]", "=", "(", "[", "None", "]", "*", "min", "(", "buffer_size", ",", "history_padding", ")", ")", "self", ".", "_offset", "=", "history_padding", "-", "len", "(", "self", ".", "_data_references", ")" ]

[ "Initialize", "a", "FixtureNodeLogger", "." ]

[ "def", "__init__", "(", "self", ",", "fixture_class", ",", "job_num", ",", "node_name", ",", "fixture_logger", ")", ":", "BaseLogger", ".", "__init__", "(", "self", ",", "\"%s:job%d:%s\"", "%", "(", "fixture_class", ",", "job_num", ",", "node_name", ")", ",", "parent", "=", "fixture_logger", ")", "self", ".", "fixture_class", "=", "fixture_class", "self", ".", "job_num", "=", "job_num", "self", ".", "node_name", "=", "node_name" ]

[ "Replaces", "occurrences", "of", "a", "match", "string", "in", "a", "given", "list", "of", "strings", "and", "returns", "a", "list", "of", "new", "strings", ".", "The", "match", "string", "can", "be", "a", "regex", "expression", "." ]

[ "def", "replace_list", "(", "items", ",", "match", ",", "replacement", ")", ":", "return", "[", "replace", "(", "item", ",", "match", ",", "replacement", ")", "for", "item", "in", "items", "]" ]

[ "r", "glu", "(", "input", "dim", "=", "-", "1", ")", "-", ">", "Tensor" ]

[ "def", "glu", "(", "input", ":", "Tensor", ",", "dim", ":", "int", "=", "-", "1", ")", "->", "Tensor", ":", "if", "has_torch_function_unary", "(", "input", ")", ":", "return", "handle_torch_function", "(", "glu", ",", "(", "input", ",", ")", ",", "input", ",", "dim", "=", "dim", ")", "if", "input", ".", "dim", "(", ")", "==", "0", ":", "raise", "RuntimeError", "(", "\"glu does not support scalars because halving size must be even\"", ")", "return", "torch", ".", "_C", ".", "_nn", ".", "glu", "(", "input", ",", "dim", ")" ]

[ "save", "cache", "model" ]

[ "def", "save_cache_model", "(", "self", ",", "output_path", ",", "day", ",", "pass_id", ",", "mode", "=", "1", ",", "*", "*", "kwargs", ")", ":", "day", "=", "str", "(", "day", ")", "pass_id", "=", "str", "(", "pass_id", ")", "mode", "=", "int", "(", "mode", ")", "table_id", "=", "kwargs", ".", "get", "(", "\"table_id\"", ",", "0", ")", "suffix_name", "=", "\"/%s/delta-%s\"", "%", "(", "day", ",", "pass_id", ")", "model_path", "=", "output_path", ".", "rstrip", "(", "\"/\"", ")", "+", "suffix_name", "self", ".", "rank0_print", "(", "\"going to save_cache_model %s\"", "%", "model_path", ")", "key_num", "=", "fleet", ".", "save_cache_model", "(", "None", ",", "model_path", ",", "mode", "=", "mode", ",", "table_id", "=", "table_id", ")", "self", ".", "rank0_print", "(", "\"save_cache_model done\"", ")", "return", "key_num" ]

[ "Checks", "for", "common", "mistakes", "in", "TODO", "comments", "." ]

[ "def", "CheckComment", "(", "comment", ",", "filename", ",", "linenum", ",", "error", ")", ":", "match", "=", "_RE_PATTERN_TODO", ".", "match", "(", "comment", ")", "if", "match", ":", "# One whitespace is correct; zero whitespace is handled elsewhere.", "leading_whitespace", "=", "match", ".", "group", "(", "1", ")", "if", "len", "(", "leading_whitespace", ")", ">", "1", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/todo'", ",", "2", ",", "'Too many spaces before TODO'", ")", "username", "=", "match", ".", "group", "(", "2", ")", "if", "not", "username", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/todo'", ",", "2", ",", "'Missing username in TODO; it should look like '", "'\"// TODO(my_username): Stuff.\"'", ")", "middle_whitespace", "=", "match", ".", "group", "(", "3", ")", "# Comparisons made explicit for correctness -- pylint: disable=g-explicit-bool-comparison", "if", "middle_whitespace", "!=", "' '", "and", "middle_whitespace", "!=", "''", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/todo'", ",", "2", ",", "'TODO(my_username) should be followed by a space'", ")" ]

[ "The", "default", "Caffe", "to", "CNTK", "uniform", "model", "setup" ]

[ "def", "default", "(", "caffe_parameters", ",", "inputs_info", ",", "cntk_layer_def", ",", "tensor_check", "=", "True", ")", ":", "if", "caffe_parameters", ":", "pass", "# tensor align check", "if", "not", "tensor_check", ":", "cntk_layer_def", ".", "parameters", "=", "cntkmodel", ".", "CntkParameters", "(", ")", "return", "try", ":", "identity_check", "=", "inputs_info", "[", "0", "]", ".", "tensor", "[", ":", "]", "for", "input_info", "in", "inputs_info", ":", "if", "not", "input_info", ".", "tensor", "==", "identity_check", ":", "raise", "AttributeError", "(", "'Non-align input tensor %s'", ",", "cntk_layer_def", ".", "op_name", ")", "except", "OverflowError", ":", "raise", "AttributeError", "(", "'Non-align input tensor %s'", ",", "cntk_layer_def", ".", "op_name", ")", "cntk_layer_def", ".", "tensor", "=", "identity_check", "if", "not", "cntk_layer_def", ".", "parameters", ":", "cntk_layer_def", ".", "parameters", "=", "cntkmodel", ".", "CntkParameters", "(", ")" ]

[ "Adds", "a", "property", "/", "conditional", "value", "pair", "to", "a", "dictionary", "." ]

[ "def", "_AddConditionalProperty", "(", "properties", ",", "condition", ",", "name", ",", "value", ")", ":", "if", "name", "not", "in", "properties", ":", "properties", "[", "name", "]", "=", "{", "}", "values", "=", "properties", "[", "name", "]", "if", "value", "not", "in", "values", ":", "values", "[", "value", "]", "=", "[", "]", "conditions", "=", "values", "[", "value", "]", "conditions", ".", "append", "(", "condition", ")" ]

[ "Find", "rel", "=", "homepage", "and", "rel", "=", "download", "links", "in", "page", "yielding", "URLs" ]

[ "def", "find_external_links", "(", "url", ",", "page", ")", ":", "for", "match", "in", "REL", ".", "finditer", "(", "page", ")", ":", "tag", ",", "rel", "=", "match", ".", "groups", "(", ")", "rels", "=", "set", "(", "map", "(", "str", ".", "strip", ",", "rel", ".", "lower", "(", ")", ".", "split", "(", "','", ")", ")", ")", "if", "'homepage'", "in", "rels", "or", "'download'", "in", "rels", ":", "for", "match", "in", "HREF", ".", "finditer", "(", "tag", ")", ":", "yield", "urllib", ".", "parse", ".", "urljoin", "(", "url", ",", "htmldecode", "(", "match", ".", "group", "(", "1", ")", ")", ")", "for", "tag", "in", "(", "\"<th>Home Page\"", ",", "\"<th>Download URL\"", ")", ":", "pos", "=", "page", ".", "find", "(", "tag", ")", "if", "pos", "!=", "-", "1", ":", "match", "=", "HREF", ".", "search", "(", "page", ",", "pos", ")", "if", "match", ":", "yield", "urllib", ".", "parse", ".", "urljoin", "(", "url", ",", "htmldecode", "(", "match", ".", "group", "(", "1", ")", ")", ")" ]

[ "Remove", "a", "distribution", "from", "the", "finder", ".", "This", "will", "update", "internal", "information", "about", "who", "provides", "what", ".", ":", "param", "dist", ":", "The", "distribution", "to", "remove", "." ]

[ "def", "remove_distribution", "(", "self", ",", "dist", ")", ":", "logger", ".", "debug", "(", "'removing distribution %s'", ",", "dist", ")", "name", "=", "dist", ".", "key", "del", "self", ".", "dists_by_name", "[", "name", "]", "del", "self", ".", "dists", "[", "(", "name", ",", "dist", ".", "version", ")", "]", "for", "p", "in", "dist", ".", "provides", ":", "name", ",", "version", "=", "parse_name_and_version", "(", "p", ")", "logger", ".", "debug", "(", "'Remove from provided: %s, %s, %s'", ",", "name", ",", "version", ",", "dist", ")", "s", "=", "self", ".", "provided", "[", "name", "]", "s", ".", "remove", "(", "(", "version", ",", "dist", ")", ")", "if", "not", "s", ":", "del", "self", ".", "provided", "[", "name", "]" ]

[ "Generate", "redis", "backend" ]

[ "def", "generate_redis_backend_conf", "(", "fout", ")", ":", "with", "open", "(", "'./conf_templates/redis_backend.template'", ")", "as", "fin", ":", "template", "=", "ConfTemplate", "(", "fin", ".", "read", "(", ")", ")", "print", "(", "template", ".", "substitute", "(", "options", ")", ",", "file", "=", "fout", ")" ]

[ "Returns", "True", "if", "the", "given", "option", "has", "been", "deprecated" ]

[ "def", "_is_deprecated", "(", "key", ")", ":", "key", "=", "key", ".", "lower", "(", ")", "return", "key", "in", "_deprecated_options" ]

[ "Consumes", "a", "string", "value", "." ]

[ "def", "ConsumeString", "(", "self", ")", ":", "the_bytes", "=", "self", ".", "ConsumeByteString", "(", ")", "try", ":", "return", "str", "(", "the_bytes", ",", "'utf-8'", ")", "except", "UnicodeDecodeError", "as", "e", ":", "raise", "self", ".", "_StringParseError", "(", "e", ")" ]

[ "Deterministically", "radomize", "jpeg", "encoding", "quality", "for", "inducing", "jpeg", "noise", "." ]

[ "def", "stateless_random_jpeg_quality", "(", "image", ",", "min_jpeg_quality", ",", "max_jpeg_quality", ",", "seed", ")", ":", "if", "(", "min_jpeg_quality", "<", "0", "or", "max_jpeg_quality", "<", "0", "or", "min_jpeg_quality", ">", "100", "or", "max_jpeg_quality", ">", "100", ")", ":", "raise", "ValueError", "(", "'jpeg encoding range must be between 0 and 100.'", ")", "if", "min_jpeg_quality", ">=", "max_jpeg_quality", ":", "raise", "ValueError", "(", "'`min_jpeg_quality` must be less than `max_jpeg_quality`.'", ")", "jpeg_quality", "=", "stateless_random_ops", ".", "stateless_random_uniform", "(", "shape", "=", "[", "]", ",", "minval", "=", "min_jpeg_quality", ",", "maxval", "=", "max_jpeg_quality", ",", "seed", "=", "seed", ",", "dtype", "=", "dtypes", ".", "int32", ")", "return", "adjust_jpeg_quality", "(", "image", ",", "jpeg_quality", ")" ]

[ "Return", "a", "reference", "to", "the", "payload", "." ]

[ "def", "get_payload", "(", "self", ",", "i", "=", "None", ",", "decode", "=", "False", ")", ":", "# Here is the logic table for this code, based on the email5.0.0 code:", "# i decode is_multipart result", "# ------ ------ ------------ ------------------------------", "# None True True None", "# i True True None", "# None False True _payload (a list)", "# i False True _payload element i (a Message)", "# i False False error (not a list)", "# i True False error (not a list)", "# None False False _payload", "# None True False _payload decoded (bytes)", "# Note that Barry planned to factor out the 'decode' case, but that", "# isn't so easy now that we handle the 8 bit data, which needs to be", "# converted in both the decode and non-decode path.", "if", "self", ".", "is_multipart", "(", ")", ":", "if", "decode", ":", "return", "None", "if", "i", "is", "None", ":", "return", "self", ".", "_payload", "else", ":", "return", "self", ".", "_payload", "[", "i", "]", "# For backward compatibility, Use isinstance and this error message", "# instead of the more logical is_multipart test.", "if", "i", "is", "not", "None", "and", "not", "isinstance", "(", "self", ".", "_payload", ",", "list", ")", ":", "raise", "TypeError", "(", "'Expected list, got %s'", "%", "type", "(", "self", ".", "_payload", ")", ")", "payload", "=", "self", ".", "_payload", "# cte might be a Header, so for now stringify it.", "cte", "=", "str", "(", "self", ".", "get", "(", "'content-transfer-encoding'", ",", "''", ")", ")", ".", "lower", "(", ")", "# payload may be bytes here.", "if", "isinstance", "(", "payload", ",", "str", ")", ":", "if", "utils", ".", "_has_surrogates", "(", "payload", ")", ":", "bpayload", "=", "payload", ".", "encode", "(", "'ascii'", ",", "'surrogateescape'", ")", "if", "not", "decode", ":", "try", ":", "payload", "=", "bpayload", ".", "decode", "(", "self", ".", "get_param", "(", "'charset'", ",", "'ascii'", ")", ",", "'replace'", ")", "except", "LookupError", ":", "payload", "=", "bpayload", ".", "decode", "(", "'ascii'", ",", "'replace'", ")", "elif", "decode", ":", "try", ":", "bpayload", "=", "payload", ".", "encode", "(", "'ascii'", ")", "except", "UnicodeError", ":", "# This won't happen for RFC compliant messages (messages", "# containing only ASCII code points in the unicode input).", "# If it does happen, turn the string into bytes in a way", "# guaranteed not to fail.", "bpayload", "=", "payload", ".", "encode", "(", "'raw-unicode-escape'", ")", "if", "not", "decode", ":", "return", "payload", "if", "cte", "==", "'quoted-printable'", ":", "return", "quopri", ".", "decodestring", "(", "bpayload", ")", "elif", "cte", "==", "'base64'", ":", "# XXX: this is a bit of a hack; decode_b should probably be factored", "# out somewhere, but I haven't figured out where yet.", "value", ",", "defects", "=", "decode_b", "(", "b''", ".", "join", "(", "bpayload", ".", "splitlines", "(", ")", ")", ")", "for", "defect", "in", "defects", ":", "self", ".", "policy", ".", "handle_defect", "(", "self", ",", "defect", ")", "return", "value", "elif", "cte", "in", "(", "'x-uuencode'", ",", "'uuencode'", ",", "'uue'", ",", "'x-uue'", ")", ":", "in_file", "=", "BytesIO", "(", "bpayload", ")", "out_file", "=", "BytesIO", "(", ")", "try", ":", "uu", ".", "decode", "(", "in_file", ",", "out_file", ",", "quiet", "=", "True", ")", "return", "out_file", ".", "getvalue", "(", ")", "except", "uu", ".", "Error", ":", "# Some decoding problem", "return", "bpayload", "if", "isinstance", "(", "payload", ",", "str", ")", ":", "return", "bpayload", "return", "payload" ]

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

[ "Return", "urllib3", "ProxyManager", "for", "the", "given", "proxy", "." ]

[ "def", "proxy_manager_for", "(", "self", ",", "proxy", ",", "*", "*", "proxy_kwargs", ")", ":", "if", "not", "proxy", "in", "self", ".", "proxy_manager", ":", "proxy_headers", "=", "self", ".", "proxy_headers", "(", "proxy", ")", "self", ".", "proxy_manager", "[", "proxy", "]", "=", "proxy_from_url", "(", "proxy", ",", "proxy_headers", "=", "proxy_headers", ",", "num_pools", "=", "self", ".", "_pool_connections", ",", "maxsize", "=", "self", ".", "_pool_maxsize", ",", "block", "=", "self", ".", "_pool_block", ",", "*", "*", "proxy_kwargs", ")", "return", "self", ".", "proxy_manager", "[", "proxy", "]" ]

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

[ "def", "IsOk", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_xrc", ".", "XmlDocument_IsOk", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "info", "message" ]

[ "def", "info", "(", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "logging", ".", "info", "(", "msg", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Get", "a", "PluginMenu", "object", "for", "the", "submenu", "with", "the", "given", "name", ".", "If", "no", "submenu", "with", "the", "given", "name", "exists", "it", "is", "created", "." ]

[ "def", "findOrCreateSubmenu", "(", "self", ",", "menuName", ")", ":", "if", "menuName", "in", "self", ".", "_submenus", ":", "return", "self", ".", "_submenus", "[", "menuName", "]", "else", ":", "subQMenu", "=", "self", ".", "_qMenu", ".", "addMenu", "(", "menuName", ")", "subQMenu", ".", "setToolTipsVisible", "(", "True", ")", "submenu", "=", "PluginMenu", "(", "subQMenu", ")", "self", ".", "_submenus", "[", "menuName", "]", "=", "submenu", "return", "submenu" ]

[ "__str__", "(", "self", ")", "-", ">", "PyObject" ]

[ "def", "__str__", "(", "self", ")", ":", "return", "_lldb", ".", "SBModuleSpecList___str__", "(", "self", ")" ]

[ "Task", "generator", "customising", "the", "options", "etc", ".", "to", "call", "R", "in", "batch", "mode", "for", "running", "a", "R", "script", "." ]

[ "def", "apply_run_r_script", "(", "tg", ")", ":", "# Convert sources and targets to nodes", "src_node", "=", "tg", ".", "path", ".", "find_resource", "(", "tg", ".", "source", ")", "tgt_nodes", "=", "[", "tg", ".", "path", ".", "find_or_declare", "(", "t", ")", "for", "t", "in", "tg", ".", "to_list", "(", "tg", ".", "target", ")", "]", "tsk", "=", "tg", ".", "create_task", "(", "'run_r_script'", ",", "src", "=", "src_node", ",", "tgt", "=", "tgt_nodes", ")", "tsk", ".", "env", ".", "LOGFILEPATH", "=", "os", ".", "path", ".", "join", "(", "tg", ".", "bld", ".", "bldnode", ".", "abspath", "(", ")", ",", "'%s_%d.log'", "%", "(", "os", ".", "path", ".", "splitext", "(", "src_node", ".", "name", ")", "[", "0", "]", ",", "tg", ".", "idx", ")", ")", "# dependencies (if the attribute 'deps' changes, trigger a recompilation)", "for", "x", "in", "tg", ".", "to_list", "(", "getattr", "(", "tg", ",", "'deps'", ",", "[", "]", ")", ")", ":", "node", "=", "tg", ".", "path", ".", "find_resource", "(", "x", ")", "if", "not", "node", ":", "tg", ".", "bld", ".", "fatal", "(", "'Could not find dependency %r for running %r'", "%", "(", "x", ",", "src_node", ".", "nice_path", "(", ")", ")", ")", "tsk", ".", "dep_nodes", ".", "append", "(", "node", ")", "Logs", ".", "debug", "(", "'deps: found dependencies %r for running %r'", "%", "(", "tsk", ".", "dep_nodes", ",", "src_node", ".", "nice_path", "(", ")", ")", ")", "# Bypass the execution of process_source by setting the source to an empty list", "tg", ".", "source", "=", "[", "]" ]

[ "Check", "if", "test", "is", "below", "base", "in", "a", "URI", "tree" ]

[ "def", "is_suburi", "(", "self", ",", "base", ",", "test", ")", ":", "if", "base", "==", "test", ":", "return", "True", "if", "base", "[", "0", "]", "!=", "test", "[", "0", "]", ":", "return", "False", "common", "=", "posixpath", ".", "commonprefix", "(", "(", "base", "[", "1", "]", ",", "test", "[", "1", "]", ")", ")", "if", "len", "(", "common", ")", "==", "len", "(", "base", "[", "1", "]", ")", ":", "return", "True", "return", "False" ]

[ "Returns", "the", "final", "component", "of", "a", "pathname" ]

[ "def", "basename", "(", "p", ")", ":", "return", "split", "(", "p", ")", "[", "1", "]" ]

[ "Shape", "function", "for", "the", "SparseApplyProximalAdagrad", "op", "." ]

[ "def", "_SparseApplyProximalAdagradShape", "(", "op", ")", ":", "var_shape", "=", "op", ".", "inputs", "[", "0", "]", ".", "get_shape", "(", ")", "accum_shape", "=", "op", ".", "inputs", "[", "1", "]", ".", "get_shape", "(", ")", ".", "merge_with", "(", "var_shape", ")", "_AssertInputIsScalar", "(", "op", ",", "2", ")", "# lr", "_AssertInputIsScalar", "(", "op", ",", "3", ")", "# l1", "_AssertInputIsScalar", "(", "op", ",", "4", ")", "# l2", "grad_shape", "=", "op", ".", "inputs", "[", "5", "]", ".", "get_shape", "(", ")", ".", "merge_with", "(", "tensor_shape", ".", "TensorShape", "(", "[", "None", "]", ")", ".", "concatenate", "(", "accum_shape", "[", "1", ":", "]", ")", ")", "unused_indices_shape", "=", "op", ".", "inputs", "[", "6", "]", ".", "get_shape", "(", ")", ".", "merge_with", "(", "tensor_shape", ".", "vector", "(", "grad_shape", "[", "0", "]", ")", ")", "return", "[", "accum_shape", "]" ]

[ "Construct", "a", "new", "section", "instance", "." ]

[ "def", "__init__", "(", "self", ",", "ptr", ")", ":", "LLVMObject", ".", "__init__", "(", "self", ",", "ptr", ")", "self", ".", "expired", "=", "False" ]

[ "Optional", ".", "Allows", "precomputation", "of", "rulebooks", "in", "data", "loading", "threads", ".", "Use", "size", "==", "2", "if", "downsizing", "with", "size", "-", "2", "stride", "-", "2", "operations", "Use", "size", "==", "3", "if", "downsizing", "with", "size", "-", "3", "stride", "-", "2", "operations" ]

[ "def", "precompute_metadata", "(", "self", ",", "size", ")", ":", "if", "size", "==", "2", ":", "self", ".", "metadata", ".", "generateRuleBooks2s2", "(", ")", "if", "size", "==", "3", ":", "self", ".", "metadata", ".", "generateRuleBooks3s2", "(", ")" ]

[ "Get", "the", "foster", "parent", "element", "and", "sibling", "to", "insert", "before", "(", "or", "None", ")", "when", "inserting", "a", "misnested", "table", "node" ]

[ "def", "getTableMisnestedNodePosition", "(", "self", ")", ":", "# The foster parent element is the one which comes before the most", "# recently opened table element", "# XXX - this is really inelegant", "lastTable", "=", "None", "fosterParent", "=", "None", "insertBefore", "=", "None", "for", "elm", "in", "self", ".", "openElements", "[", ":", ":", "-", "1", "]", ":", "if", "elm", ".", "name", "==", "\"table\"", ":", "lastTable", "=", "elm", "break", "if", "lastTable", ":", "# XXX - we should really check that this parent is actually a", "# node here", "if", "lastTable", ".", "parent", ":", "fosterParent", "=", "lastTable", ".", "parent", "insertBefore", "=", "lastTable", "else", ":", "fosterParent", "=", "self", ".", "openElements", "[", "self", ".", "openElements", ".", "index", "(", "lastTable", ")", "-", "1", "]", "else", ":", "fosterParent", "=", "self", ".", "openElements", "[", "0", "]", "return", "fosterParent", ",", "insertBefore" ]

[ "Append", "a", "sub", "-", "namespace", "(", "suffix", ")", "to", "the", "input", "namespace" ]

[ "def", "_append_ns", "(", "in_ns", ",", "suffix", ")", ":", "ns", "=", "in_ns", "if", "ns", "[", "-", "1", "]", "!=", "'/'", ":", "ns", "+=", "'/'", "ns", "+=", "suffix", "return", "ns" ]

[ "Creates", "an", "ACL", "editor", "dialog", "based", "on", "parameters", "returned", "by", "interface", "methods" ]

[ "def", "EditSecurity", "(", "self", ",", "owner_hwnd", "=", "0", ")", ":", "isi", "=", "pythoncom", ".", "WrapObject", "(", "self", ",", "authorization", ".", "IID_ISecurityInformation", ",", "pythoncom", ".", "IID_IUnknown", ")", "authorization", ".", "EditSecurity", "(", "owner_hwnd", ",", "isi", ")" ]

[ "Make", "a", "link", "for", "an", "identifier", "given", "name", "-", "to", "-", "URL", "mappings", "." ]

[ "def", "namelink", "(", "self", ",", "name", ",", "*", "dicts", ")", ":", "for", "dict", "in", "dicts", ":", "if", "name", "in", "dict", ":", "return", "'<a href=\"%s\">%s</a>'", "%", "(", "dict", "[", "name", "]", ",", "name", ")", "return", "name" ]

[ "Adds", "a", "collection", "to", "MetaGraphDef", "protocol", "buffer", "." ]

[ "def", "add_collection_def", "(", "meta_graph_def", ",", "key", ",", "graph", "=", "None", ",", "export_scope", "=", "None", ",", "exclude_nodes", "=", "None", ",", "override_contents", "=", "None", ")", ":", "if", "graph", "and", "not", "isinstance", "(", "graph", ",", "ops", ".", "Graph", ")", ":", "raise", "TypeError", "(", "\"graph must be of type Graph, not %s\"", ",", "type", "(", "graph", ")", ")", "if", "not", "isinstance", "(", "key", ",", "six", ".", "string_types", ")", "and", "not", "isinstance", "(", "key", ",", "bytes", ")", ":", "logging", ".", "warning", "(", "\"Only collections with string type keys will be \"", "\"serialized. This key has %s\"", ",", "type", "(", "key", ")", ")", "return", "# Sets graph to default graph if it's not passed in.", "graph", "=", "graph", "or", "ops", ".", "get_default_graph", "(", ")", "if", "override_contents", ":", "collection_list", "=", "override_contents", "else", ":", "collection_list", "=", "graph", ".", "get_collection", "(", "key", ")", "# Remove nodes that should not be exported from the collection list.", "collection_list", "=", "[", "x", "for", "x", "in", "collection_list", "if", "_should_include_node", "(", "x", ",", "export_scope", ",", "exclude_nodes", ")", "]", "if", "not", "collection_list", ":", "return", "try", ":", "col_def", "=", "meta_graph_def", ".", "collection_def", "[", "key", "]", "to_proto", "=", "ops", ".", "get_to_proto_function", "(", "key", ")", "proto_type", "=", "ops", ".", "get_collection_proto_type", "(", "key", ")", "if", "to_proto", ":", "kind", "=", "\"bytes_list\"", "for", "x", "in", "collection_list", ":", "# Additional type check to make sure the returned proto is indeed", "# what we expect.", "proto", "=", "to_proto", "(", "x", ",", "export_scope", "=", "export_scope", ")", "if", "proto", ":", "assert", "isinstance", "(", "proto", ",", "proto_type", ")", "getattr", "(", "col_def", ",", "kind", ")", ".", "value", ".", "append", "(", "proto", ".", "SerializeToString", "(", ")", ")", "else", ":", "kind", "=", "_get_kind_name", "(", "collection_list", "[", "0", "]", ")", "if", "kind", "==", "\"node_list\"", ":", "for", "x", "in", "collection_list", ":", "if", "not", "export_scope", "or", "x", ".", "name", ".", "startswith", "(", "export_scope", ")", ":", "getattr", "(", "col_def", ",", "kind", ")", ".", "value", ".", "append", "(", "ops", ".", "strip_name_scope", "(", "x", ".", "name", ",", "export_scope", ")", ")", "elif", "kind", "==", "\"bytes_list\"", ":", "# NOTE(opensource): This force conversion is to work around the fact", "# that Python3 distinguishes between bytes and strings.", "getattr", "(", "col_def", ",", "kind", ")", ".", "value", ".", "extend", "(", "[", "compat", ".", "as_bytes", "(", "x", ")", "for", "x", "in", "collection_list", "]", ")", "else", ":", "getattr", "(", "col_def", ",", "kind", ")", ".", "value", ".", "extend", "(", "[", "x", "for", "x", "in", "collection_list", "]", ")", "except", "Exception", "as", "e", ":", "# pylint: disable=broad-except", "logging", ".", "warning", "(", "\"Issue encountered when serializing %s.\\n\"", "\"Type is unsupported, or the types of the items don't \"", "\"match field type in CollectionDef. Note this is a warning \"", "\"and probably safe to ignore.\\n%s\"", ",", "key", ",", "str", "(", "e", ")", ")", "if", "key", "in", "meta_graph_def", ".", "collection_def", ":", "del", "meta_graph_def", ".", "collection_def", "[", "key", "]", "return" ]

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

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

[ "Resets", "the", "placeholder", "name", "and", "values" ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "_name_count", "=", "0", "self", ".", "_value_count", "=", "0" ]

[ "see", "list_modules" ]

[ "def", "do_lm", "(", "self", ",", "arg", ")", ":", "return", "self", ".", "do_list_modules", "(", "arg", ")" ]

[ "Checks", "whether", "the", "provided", "export", "directory", "could", "contain", "a", "SavedModel", "." ]

[ "def", "contains_saved_model", "(", "export_dir", ")", ":", "return", "maybe_saved_model_directory", "(", "export_dir", ")" ]

[ "Get", "a", "list", "of", "sub", "-", "resources", "." ]

[ "def", "subresources", "(", "self", ")", ":", "return", "self", ".", "_get_related_resources", "(", "True", ")" ]

[ "Load", "ASCII", "data", "stored", "in", "a", "comma", "-", "separated", "file", "." ]

[ "def", "recfromcsv", "(", "fname", ",", "*", "*", "kwargs", ")", ":", "# Set default kwargs for genfromtxt as relevant to csv import.", "kwargs", ".", "setdefault", "(", "\"case_sensitive\"", ",", "\"lower\"", ")", "kwargs", ".", "setdefault", "(", "\"names\"", ",", "True", ")", "kwargs", ".", "setdefault", "(", "\"delimiter\"", ",", "\",\"", ")", "kwargs", ".", "setdefault", "(", "\"dtype\"", ",", "None", ")", "output", "=", "genfromtxt", "(", "fname", ",", "*", "*", "kwargs", ")", "usemask", "=", "kwargs", ".", "get", "(", "\"usemask\"", ",", "False", ")", "if", "usemask", ":", "from", "numpy", ".", "ma", ".", "mrecords", "import", "MaskedRecords", "output", "=", "output", ".", "view", "(", "MaskedRecords", ")", "else", ":", "output", "=", "output", ".", "view", "(", "np", ".", "recarray", ")", "return", "output" ]

[ "Get", "Token", "at", "current", "input", "pointer", "+", "i", "ahead", "where", "i", "=", "1", "is", "next", "Token", ".", "i<0", "indicates", "tokens", "in", "the", "past", ".", "So", "-", "1", "is", "previous", "token", "and", "-", "2", "is", "two", "tokens", "ago", ".", "LT", "(", "0", ")", "is", "undefined", ".", "For", "i", ">", "=", "n", "return", "Token", ".", "EOFToken", ".", "Return", "null", "for", "LT", "(", "0", ")", "and", "any", "index", "that", "results", "in", "an", "absolute", "address", "that", "is", "negative", "." ]

[ "def", "LT", "(", "self", ",", "k", ")", ":", "raise", "NotImplementedError" ]

[ "This", "calculates", "a", "revised", "video", "bitrate", "given", "the", "video_bitrate", "used", "the", "actual", "size", "that", "resulted", "and", "the", "video_target_size", ".", "This", "can", "be", "used", "if", "you", "want", "to", "compress", "the", "video", "all", "over", "again", "in", "an", "attempt", "to", "get", "closer", "to", "the", "video_target_size", "." ]

[ "def", "calculate_revised_bitrate", "(", "video_bitrate", ",", "video_target_size", ",", "video_actual_size", ")", ":", "return", "int", "(", "math", ".", "floor", "(", "video_bitrate", "*", "(", "float", "(", "video_target_size", ")", "/", "float", "(", "video_actual_size", ")", ")", ")", ")" ]

[ "Add", "an", "integral", "*", "offset", "*", "to", "pointer", "*", "ptr", "*", "and", "return", "a", "pointer", "of", "*", "return_type", "*", "(", "or", "if", "omitted", "the", "same", "type", "as", "*", "ptr", "*", ")", "." ]

[ "def", "pointer_add", "(", "builder", ",", "ptr", ",", "offset", ",", "return_type", "=", "None", ")", ":", "intptr", "=", "builder", ".", "ptrtoint", "(", "ptr", ",", "intp_t", ")", "if", "isinstance", "(", "offset", ",", "utils", ".", "INT_TYPES", ")", ":", "offset", "=", "intp_t", "(", "offset", ")", "intptr", "=", "builder", ".", "add", "(", "intptr", ",", "offset", ")", "return", "builder", ".", "inttoptr", "(", "intptr", ",", "return_type", "or", "ptr", ".", "type", ")" ]

[ "builds", "OpenCV", "for", "device", "or", "simulator" ]

[ "def", "build_opencv", "(", "srcroot", ",", "buildroot", ",", "target", ",", "arch", ")", ":", "builddir", "=", "os", ".", "path", ".", "join", "(", "buildroot", ",", "target", "+", "'-'", "+", "arch", ")", "if", "not", "os", ".", "path", ".", "isdir", "(", "builddir", ")", ":", "os", ".", "makedirs", "(", "builddir", ")", "currdir", "=", "os", ".", "getcwd", "(", ")", "os", ".", "chdir", "(", "builddir", ")", "# for some reason, if you do not specify CMAKE_BUILD_TYPE, it puts libs to \"RELEASE\" rather than \"Release\"", "cmakeargs", "=", "(", "\"-GXcode \"", "+", "\"-DCMAKE_BUILD_TYPE=Release \"", "+", "\"-DCMAKE_TOOLCHAIN_FILE=%s/platforms/ios/cmake/Toolchains/Toolchain-%s_Xcode.cmake \"", "+", "\"-DBUILD_opencv_world=ON \"", "+", "\"-DCMAKE_C_FLAGS=\\\"-Wno-implicit-function-declaration\\\" \"", "+", "\"-DCMAKE_INSTALL_PREFIX=install\"", ")", "%", "(", "srcroot", ",", "target", ")", "# if cmake cache exists, just rerun cmake to update OpenCV.xproj if necessary", "if", "os", ".", "path", ".", "isfile", "(", "os", ".", "path", ".", "join", "(", "builddir", ",", "\"CMakeCache.txt\"", ")", ")", ":", "os", ".", "system", "(", "\"cmake %s .\"", "%", "(", "cmakeargs", ",", ")", ")", "else", ":", "os", ".", "system", "(", "\"cmake %s %s\"", "%", "(", "cmakeargs", ",", "srcroot", ")", ")", "for", "wlib", "in", "[", "builddir", "+", "\"/modules/world/UninstalledProducts/libopencv_world.a\"", ",", "builddir", "+", "\"/lib/Release/libopencv_world.a\"", "]", ":", "if", "os", ".", "path", ".", "isfile", "(", "wlib", ")", ":", "os", ".", "remove", "(", "wlib", ")", "os", ".", "system", "(", "\"xcodebuild IPHONEOS_DEPLOYMENT_TARGET=6.0 -parallelizeTargets ARCHS=%s -jobs 8 -sdk %s -configuration Release -target ALL_BUILD\"", "%", "(", "arch", ",", "target", ".", "lower", "(", ")", ")", ")", "os", ".", "system", "(", "\"xcodebuild IPHONEOS_DEPLOYMENT_TARGET=6.0 ARCHS=%s -sdk %s -configuration Release -target install install\"", "%", "(", "arch", ",", "target", ".", "lower", "(", ")", ")", ")", "os", ".", "chdir", "(", "currdir", ")" ]

[ "updates", "the", "cells", "with", "the", "contents", "of", "the", "spreadsheet" ]

[ "def", "update", "(", "self", ")", ":", "if", "self", ".", "spreadsheet", ":", "controlled", "=", "self", ".", "spreadsheet", ".", "Proxy", ".", "getControlledCells", "(", "self", ".", "spreadsheet", ")", "controlling", "=", "self", ".", "spreadsheet", ".", "Proxy", ".", "getControllingCells", "(", "self", ".", "spreadsheet", ")", "for", "cell", "in", "self", ".", "spreadsheet", ".", "Proxy", ".", "_cells", ".", "keys", "(", ")", ":", "if", "not", "cell", "in", "[", "\"Type\"", ",", "\"Object\"", "]", ":", "c", ",", "r", "=", "self", ".", "spreadsheet", ".", "Proxy", ".", "splitKey", "(", "cell", ")", "c", "=", "\"abcdefghijklmnopqrstuvwxyz\"", ".", "index", "(", "c", ")", "r", "=", "int", "(", "str", "(", "r", ")", ")", "-", "1", "content", "=", "getattr", "(", "self", ".", "spreadsheet", ".", "Proxy", ",", "cell", ")", "if", "self", ".", "spreadsheet", ".", "Proxy", ".", "isFunction", "(", "cell", ")", ":", "self", ".", "doNotChange", "=", "True", "if", "content", "is", "None", ":", "content", "=", "\"\"", "if", "DEBUG", ":", "print", "(", "\"Updating \"", ",", "cell", ",", "\" to \"", ",", "content", ")", "if", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ":", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ".", "setText", "(", "str", "(", "content", ")", ")", "else", ":", "self", ".", "table", ".", "setItem", "(", "r", ",", "c", ",", "QtGui", ".", "QTableWidgetItem", "(", "str", "(", "content", ")", ")", ")", "if", "cell", "in", "controlled", ":", "brush", "=", "QtGui", ".", "QBrush", "(", "QtGui", ".", "QColor", "(", "255", ",", "0", ",", "0", ")", ")", "brush", ".", "setStyle", "(", "QtCore", ".", "Qt", ".", "Dense6Pattern", ")", "if", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ":", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ".", "setBackground", "(", "brush", ")", "elif", "cell", "in", "controlling", ":", "brush", "=", "QtGui", ".", "QBrush", "(", "QtGui", ".", "QColor", "(", "0", ",", "0", ",", "255", ")", ")", "brush", ".", "setStyle", "(", "QtCore", ".", "Qt", ".", "Dense6Pattern", ")", "if", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ":", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ".", "setBackground", "(", "brush", ")", "else", ":", "brush", "=", "QtGui", ".", "QBrush", "(", ")", "if", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ":", "self", ".", "table", ".", "item", "(", "r", ",", "c", ")", ".", "setBackground", "(", "brush", ")" ]

[ "Returns", "a", "MainTarget", "class", "instance", "corresponding", "to", "the", "name", "." ]

[ "def", "create_main_target", "(", "self", ",", "name", ")", ":", "assert", "isinstance", "(", "name", ",", "basestring", ")", "if", "not", "self", ".", "built_main_targets_", ":", "self", ".", "build_main_targets", "(", ")", "return", "self", ".", "main_targets_", ".", "get", "(", "name", ",", "None", ")" ]

[ "Get", "this", "buffers", "completer", "object", "@return", ":", "Completer" ]

[ "def", "GetCompleter", "(", "self", ")", ":", "return", "self", ".", "_code", "[", "'compsvc'", "]" ]

[ "Gradient", "function", "for", "the", "DebugIdentity", "op", "." ]

[ "def", "_identify_gradient_grad", "(", "op", ",", "dy", ")", ":", "# TODO(cais): Allow overriding gradient.", "grad_debugger_uuid", ",", "orig_tensor_name", "=", "_parse_grad_debug_op_name", "(", "op", ".", "name", ")", "grad_debugger", "=", "_gradient_debuggers", "[", "grad_debugger_uuid", "]", "grad_debugger", ".", "register_gradient_tensor", "(", "orig_tensor_name", ",", "dy", ")", "return", "dy" ]

[ "Set", "the", "update", "frequency", "@param", "milli", ":", "int", "(", "milliseconds", ")" ]

[ "def", "SetFrequency", "(", "self", ",", "milli", ")", ":", "self", ".", "_freq", "=", "float", "(", "milli", ")" ]

[ "Generate", "a", "minibatch", "with", "the", "number", "of", "samples", "specified", "by", "the", "size", "parameter", "." ]

[ "def", "minibatch", "(", "self", ",", "size", ")", ":", "indexes", "=", "self", ".", "sample", "(", "size", ")", "pre_states", "=", "np", ".", "array", "(", "[", "self", ".", "get_state", "(", "index", ")", "for", "index", "in", "indexes", "]", ",", "dtype", "=", "np", ".", "float32", ")", "post_states", "=", "np", ".", "array", "(", "[", "self", ".", "get_state", "(", "index", "+", "1", ")", "for", "index", "in", "indexes", "]", ",", "dtype", "=", "np", ".", "float32", ")", "actions", "=", "self", ".", "_actions", "[", "indexes", "]", "rewards", "=", "self", ".", "_rewards", "[", "indexes", "]", "dones", "=", "self", ".", "_terminals", "[", "indexes", "]", "return", "pre_states", ",", "actions", ",", "post_states", ",", "rewards", ",", "dones" ]

[ "Mean", "of", "this", "distribution", "." ]

[ "def", "mean", "(", "self", ",", "name", "=", "\"mean\"", ")", ":", "with", "ops", ".", "name_scope", "(", "self", ".", "name", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "self", ".", "_sigma", ",", "self", ".", "_mu", "]", ",", "name", ")", ":", "return", "self", ".", "_mu", "*", "array_ops", ".", "ones_like", "(", "self", ".", "_sigma", ")" ]

[ ":", "type", "nums", ":", "List", "[", "int", "]", ":", "rtype", ":", "void", "Do", "not", "return", "anything", "modify", "nums", "in", "-", "place", "instead", "." ]

[ "def", "moveZeroes", "(", "self", ",", "nums", ")", ":", "nonZero", "=", "0", "for", "i", "in", "range", "(", "len", "(", "nums", ")", ")", ":", "if", "nums", "[", "i", "]", "!=", "0", ":", "nums", "[", "nonZero", "]", "=", "nums", "[", "i", "]", "nonZero", "+=", "1", "for", "i", "in", "range", "(", "nonZero", ",", "len", "(", "nums", ")", ")", ":", "nums", "[", "i", "]", "=", "0" ]

[ "Sets", "the", "list", "of", "old", "checkpoint", "filenames", "and", "timestamps", "." ]

[ "def", "set_last_checkpoints_with_time", "(", "self", ",", "last_checkpoints_with_time", ")", ":", "assert", "isinstance", "(", "last_checkpoints_with_time", ",", "list", ")", "self", ".", "_last_checkpoints", "=", "last_checkpoints_with_time" ]

[ "Helper", "method", "for", "defining", "space", "-", "delimited", "indentation", "blocks", "such", "as", "those", "used", "to", "define", "block", "statements", "in", "Python", "source", "code", "." ]

[ "def", "indentedBlock", "(", "blockStatementExpr", ",", "indentStack", ",", "indent", "=", "True", ")", ":", "def", "checkPeerIndent", "(", "s", ",", "l", ",", "t", ")", ":", "if", "l", ">=", "len", "(", "s", ")", ":", "return", "curCol", "=", "col", "(", "l", ",", "s", ")", "if", "curCol", "!=", "indentStack", "[", "-", "1", "]", ":", "if", "curCol", ">", "indentStack", "[", "-", "1", "]", ":", "raise", "ParseFatalException", "(", "s", ",", "l", ",", "\"illegal nesting\"", ")", "raise", "ParseException", "(", "s", ",", "l", ",", "\"not a peer entry\"", ")", "def", "checkSubIndent", "(", "s", ",", "l", ",", "t", ")", ":", "curCol", "=", "col", "(", "l", ",", "s", ")", "if", "curCol", ">", "indentStack", "[", "-", "1", "]", ":", "indentStack", ".", "append", "(", "curCol", ")", "else", ":", "raise", "ParseException", "(", "s", ",", "l", ",", "\"not a subentry\"", ")", "def", "checkUnindent", "(", "s", ",", "l", ",", "t", ")", ":", "if", "l", ">=", "len", "(", "s", ")", ":", "return", "curCol", "=", "col", "(", "l", ",", "s", ")", "if", "not", "(", "indentStack", "and", "curCol", "<", "indentStack", "[", "-", "1", "]", "and", "curCol", "<=", "indentStack", "[", "-", "2", "]", ")", ":", "raise", "ParseException", "(", "s", ",", "l", ",", "\"not an unindent\"", ")", "indentStack", ".", "pop", "(", ")", "NL", "=", "OneOrMore", "(", "LineEnd", "(", ")", ".", "setWhitespaceChars", "(", "\"\\t \"", ")", ".", "suppress", "(", ")", ")", "INDENT", "=", "(", "Empty", "(", ")", "+", "Empty", "(", ")", ".", "setParseAction", "(", "checkSubIndent", ")", ")", ".", "setName", "(", "'INDENT'", ")", "PEER", "=", "Empty", "(", ")", ".", "setParseAction", "(", "checkPeerIndent", ")", ".", "setName", "(", "''", ")", "UNDENT", "=", "Empty", "(", ")", ".", "setParseAction", "(", "checkUnindent", ")", ".", "setName", "(", "'UNINDENT'", ")", "if", "indent", ":", "smExpr", "=", "Group", "(", "Optional", "(", "NL", ")", "+", "#~ FollowedBy(blockStatementExpr) +", "INDENT", "+", "(", "OneOrMore", "(", "PEER", "+", "Group", "(", "blockStatementExpr", ")", "+", "Optional", "(", "NL", ")", ")", ")", "+", "UNDENT", ")", "else", ":", "smExpr", "=", "Group", "(", "Optional", "(", "NL", ")", "+", "(", "OneOrMore", "(", "PEER", "+", "Group", "(", "blockStatementExpr", ")", "+", "Optional", "(", "NL", ")", ")", ")", ")", "blockStatementExpr", ".", "ignore", "(", "_bslash", "+", "LineEnd", "(", ")", ")", "return", "smExpr", ".", "setName", "(", "'indented block'", ")" ]

[ "Retrieve", "a", "date", "field", "from", "a", "header", "as", "a", "10", "-", "tuple", "." ]

[ "def", "getdate_tz", "(", "self", ",", "name", ")", ":", "try", ":", "data", "=", "self", "[", "name", "]", "except", "KeyError", ":", "return", "None", "return", "parsedate_tz", "(", "data", ")" ]

[ "getTypeID", "(", "string", ")", "-", ">", "string" ]

[ "def", "getTypeID", "(", "self", ",", "vehID", ")", ":", "return", "self", ".", "_getUniversal", "(", "tc", ".", "VAR_TYPE", ",", "vehID", ")" ]

[ "GetKey", "(", "TIntHI", "self", ")", "-", ">", "TInt" ]

[ "def", "GetKey", "(", "self", ")", ":", "return", "_snap", ".", "TIntHI_GetKey", "(", "self", ")" ]

[ "expression", ":", "LPAREN", "expression", "RPAREN" ]

[ "def", "p_expression_group", "(", "p", ")", ":", "p", "[", "0", "]", "=", "p", "[", "2", "]" ]