Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Return", "the", "disk", "usage", "in", "a", "directory", "." ]

[ "def", "disk_used", "(", "path", ")", ":", "size", "=", "0", "for", "file", "in", "os", ".", "listdir", "(", "path", ")", "+", "[", "'.'", "]", ":", "stat", "=", "os", ".", "stat", "(", "os", ".", "path", ".", "join", "(", "path", ",", "file", ")", ")", "if", "hasattr", "(", "stat", ",", "'st_blocks'", ")", ":", "size", "+=", "stat", ".", "st_blocks", "*", "512", "else", ":", "# on some platform st_blocks is not available (e.g., Windows)", "# approximate by rounding to next multiple of 512", "size", "+=", "(", "stat", ".", "st_size", "//", "512", "+", "1", ")", "*", "512", "# We need to convert to int to avoid having longs on some systems (we", "# don't want longs to avoid problems we SQLite)", "return", "int", "(", "size", "/", "1024.", ")" ]

[ "True", "if", "the", "included", "file", "is", "the", "input", "file", "." ]

[ "def", "is_input_file", "(", "self", ")", ":", "return", "self", ".", "depth", "==", "0" ]

[ "BeginNumberedBullet", "(", "self", "int", "bulletNumber", "int", "leftIndent", "int", "leftSubIndent", "int", "bulletStyle", "=", "wxTEXT_ATTR_BULLET_STYLE_ARABIC|wxTEXT_ATTR_BULLET_STYLE_PERIOD", ")", "-", ">", "bool" ]

[ "def", "BeginNumberedBullet", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_BeginNumberedBullet", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Iterate", "over", "slices", "of", "a", "string", "." ]

[ "def", "iter_slices", "(", "string", ",", "slice_length", ")", ":", "pos", "=", "0", "if", "slice_length", "is", "None", "or", "slice_length", "<=", "0", ":", "slice_length", "=", "len", "(", "string", ")", "while", "pos", "<", "len", "(", "string", ")", ":", "yield", "string", "[", "pos", ":", "pos", "+", "slice_length", "]", "pos", "+=", "slice_length" ]

[ "Extends", "ComponentProgram", "to", "support", "executables", "with", "platform", "specific", "options", "." ]

[ "def", "App", "(", "env", ",", "*", "*", "kwargs", ")", ":", "if", "'explicit_libs'", "not", "in", "kwargs", ":", "common_app_params", "=", "{", "'win_libs'", ":", "[", "'advapi32'", ",", "'crypt32'", ",", "'iphlpapi'", ",", "'secur32'", ",", "'shell32'", ",", "'shlwapi'", ",", "'user32'", ",", "'wininet'", ",", "'ws2_32'", "]", "}", "params", "=", "CombineDicts", "(", "kwargs", ",", "common_app_params", ")", "else", ":", "params", "=", "kwargs", "return", "ExtendComponent", "(", "env", ",", "'ComponentProgram'", ",", "*", "*", "params", ")" ]

[ "Return", "True", "if", "two", "matrices", "perform", "same", "transformation", "." ]

[ "def", "is_same_transform", "(", "matrix0", ",", "matrix1", ")", ":", "matrix0", "=", "numpy", ".", "array", "(", "matrix0", ",", "dtype", "=", "numpy", ".", "float64", ",", "copy", "=", "True", ")", "matrix0", "/=", "matrix0", "[", "3", ",", "3", "]", "matrix1", "=", "numpy", ".", "array", "(", "matrix1", ",", "dtype", "=", "numpy", ".", "float64", ",", "copy", "=", "True", ")", "matrix1", "/=", "matrix1", "[", "3", ",", "3", "]", "return", "numpy", ".", "allclose", "(", "matrix0", ",", "matrix1", ")" ]

[ "Override", "RPCServer", "method", "for", "IDLE" ]

[ "def", "handle_error", "(", "self", ",", "request", ",", "client_address", ")", ":", "global", "quitting", "try", ":", "raise", "except", "SystemExit", ":", "raise", "except", "EOFError", ":", "global", "exit_now", "exit_now", "=", "True", "thread", ".", "interrupt_main", "(", ")", "except", ":", "erf", "=", "sys", ".", "__stderr__", "print", ">>", "erf", ",", "'\\n'", "+", "'-'", "*", "40", "print", ">>", "erf", ",", "'Unhandled server exception!'", "print", ">>", "erf", ",", "'Thread: %s'", "%", "threading", ".", "currentThread", "(", ")", ".", "getName", "(", ")", "print", ">>", "erf", ",", "'Client Address: '", ",", "client_address", "print", ">>", "erf", ",", "'Request: '", ",", "repr", "(", "request", ")", "traceback", ".", "print_exc", "(", "file", "=", "erf", ")", "print", ">>", "erf", ",", "'\\n*** Unrecoverable, server exiting!'", "print", ">>", "erf", ",", "'-'", "*", "40", "quitting", "=", "True", "thread", ".", "interrupt_main", "(", ")" ]

[ "Internal", ":", "read", "lines", "until", "outerboundary", "." ]

[ "def", "read_lines_to_outerboundary", "(", "self", ")", ":", "next", "=", "\"--\"", "+", "self", ".", "outerboundary", "last", "=", "next", "+", "\"--\"", "delim", "=", "\"\"", "last_line_lfend", "=", "True", "while", "1", ":", "line", "=", "self", ".", "fp", ".", "readline", "(", "1", "<<", "16", ")", "if", "not", "line", ":", "self", ".", "done", "=", "-", "1", "break", "if", "line", "[", ":", "2", "]", "==", "\"--\"", "and", "last_line_lfend", ":", "strippedline", "=", "line", ".", "strip", "(", ")", "if", "strippedline", "==", "next", ":", "break", "if", "strippedline", "==", "last", ":", "self", ".", "done", "=", "1", "break", "odelim", "=", "delim", "if", "line", "[", "-", "2", ":", "]", "==", "\"\\r\\n\"", ":", "delim", "=", "\"\\r\\n\"", "line", "=", "line", "[", ":", "-", "2", "]", "last_line_lfend", "=", "True", "elif", "line", "[", "-", "1", "]", "==", "\"\\n\"", ":", "delim", "=", "\"\\n\"", "line", "=", "line", "[", ":", "-", "1", "]", "last_line_lfend", "=", "True", "else", ":", "delim", "=", "\"\"", "last_line_lfend", "=", "False", "self", ".", "__write", "(", "odelim", "+", "line", ")" ]

[ "Return", "a", "tar", "header", "as", "a", "string", "of", "512", "byte", "blocks", "." ]

[ "def", "tobuf", "(", "self", ",", "format", "=", "DEFAULT_FORMAT", ",", "encoding", "=", "ENCODING", ",", "errors", "=", "\"surrogateescape\"", ")", ":", "info", "=", "self", ".", "get_info", "(", ")", "if", "format", "==", "USTAR_FORMAT", ":", "return", "self", ".", "create_ustar_header", "(", "info", ",", "encoding", ",", "errors", ")", "elif", "format", "==", "GNU_FORMAT", ":", "return", "self", ".", "create_gnu_header", "(", "info", ",", "encoding", ",", "errors", ")", "elif", "format", "==", "PAX_FORMAT", ":", "return", "self", ".", "create_pax_header", "(", "info", ",", "encoding", ")", "else", ":", "raise", "ValueError", "(", "\"invalid format\"", ")" ]

[ "Returns", "data", "from", "#sentid", "command" ]

[ "def", "appid_received", "(", "user", ",", "rec", ",", "data", ")", ":", "rec", ".", "id_sent", "=", "True", "rec", ".", "save", "(", ")", "logger", ".", "debug", "(", "\"Received #sentid confirmation for {0}\"", ".", "format", "(", "rec", ")", ")" ]

[ "Construct", "a", "set", "from", "an", "optional", "iterable", "." ]

[ "def", "__init__", "(", "self", ",", "iterable", "=", "None", ")", ":", "self", ".", "_data", "=", "{", "}", "if", "iterable", "is", "not", "None", ":", "self", ".", "_update", "(", "iterable", ")" ]

[ "Similar", "to", "isValid", "()", "but", "raises", "a", "TypeError", "exception", "if", "not", "valid" ]

[ "def", "validate", "(", "self", ",", "listener", ")", ":", "# check callable", "if", "not", "callable", "(", "listener", ")", ":", "raise", "TypeError", ",", "'Listener '", "+", "`listener`", "+", "' must be a '", "'function, bound method or instance.'", "# ok, callable, but if method, is it bound:", "elif", "ismethod", "(", "listener", ")", "and", "not", "_isbound", "(", "listener", ")", ":", "raise", "TypeError", ",", "'Listener '", "+", "`listener`", "+", "' is a method but it is unbound!'", "# check that it takes the right number of parameters", "min", ",", "d", "=", "_paramMinCount", "(", "listener", ")", "if", "min", ">", "1", ":", "raise", "TypeError", ",", "'Listener '", "+", "`listener`", "+", "\" can't\"", "' require more than one parameter!'", "if", "min", "<=", "0", "and", "d", "==", "0", ":", "raise", "TypeError", ",", "'Listener '", "+", "`listener`", "+", "' lacking arguments!'", "assert", "(", "min", "==", "0", "and", "d", ">", "0", ")", "or", "(", "min", "==", "1", ")" ]

[ "Skip", "to", "the", "node", "following", "the", "current", "one", "in", "document", "order", "while", "avoiding", "the", "subtree", "if", "any", "." ]

[ "def", "Next", "(", "self", ")", ":", "ret", "=", "libxml2mod", ".", "xmlTextReaderNext", "(", "self", ".", "_o", ")", "return", "ret" ]

[ "Check", "whether", "the", "given", "key", "/", "value", "pair", "is", "in", "the", "rhs", "dict", "." ]

[ "def", "equals", "(", "self", ",", "rhs", ")", ":", "try", ":", "return", "rhs", "[", "self", ".", "_key", "]", "==", "self", ".", "_value", "except", "Exception", ":", "return", "False" ]

[ "/", ".", "/" ]

[ "def", "handle_dot", "(", "next", ",", "token", ")", ":", "def", "select", "(", "result", ")", ":", "return", "result", "return", "select" ]

[ "EditToggleOvertype", "(", "self", ")" ]

[ "def", "EditToggleOvertype", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_EditToggleOvertype", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "a", "skey", "to", "the", "list", "of", "skeys" ]

[ "def", "add_skey", "(", "self", ",", "skey", ")", ":", "self", ".", "skeys", ".", "append", "(", "skey", ")" ]

[ "Add", "a", "back", "button", "with", "a", "given", "title", "the", "tab", "-", "next", "button", "its", "name", "in", "the", "Control", "table", "possibly", "initially", "disabled", "." ]

[ "def", "back", "(", "self", ",", "title", ",", "next", ",", "name", "=", "\"Back\"", ",", "active", "=", "1", ")", ":", "if", "active", ":", "flags", "=", "3", "# Visible|Enabled", "else", ":", "flags", "=", "1", "# Visible", "return", "self", ".", "pushbutton", "(", "name", ",", "180", ",", "self", ".", "h", "-", "27", ",", "56", ",", "17", ",", "flags", ",", "title", ",", "next", ")" ]

[ "Retrieve", "a", "container", "for", "the", "non", "-", "variadic", "arguments", "for", "this", "type", "." ]

[ "def", "argument_types", "(", "self", ")", ":", "class", "ArgumentsIterator", "(", "collections_abc", ".", "Sequence", ")", ":", "def", "__init__", "(", "self", ",", "parent", ")", ":", "self", ".", "parent", "=", "parent", "self", ".", "length", "=", "None", "def", "__len__", "(", "self", ")", ":", "if", "self", ".", "length", "is", "None", ":", "self", ".", "length", "=", "conf", ".", "lib", ".", "clang_getNumArgTypes", "(", "self", ".", "parent", ")", "return", "self", ".", "length", "def", "__getitem__", "(", "self", ",", "key", ")", ":", "# FIXME Support slice objects.", "if", "not", "isinstance", "(", "key", ",", "int", ")", ":", "raise", "TypeError", "(", "\"Must supply a non-negative int.\"", ")", "if", "key", "<", "0", ":", "raise", "IndexError", "(", "\"Only non-negative indexes are accepted.\"", ")", "if", "key", ">=", "len", "(", "self", ")", ":", "raise", "IndexError", "(", "\"Index greater than container length: \"", "\"%d > %d\"", "%", "(", "key", ",", "len", "(", "self", ")", ")", ")", "result", "=", "conf", ".", "lib", ".", "clang_getArgType", "(", "self", ".", "parent", ",", "key", ")", "if", "result", ".", "kind", "==", "TypeKind", ".", "INVALID", ":", "raise", "IndexError", "(", "\"Argument could not be retrieved.\"", ")", "return", "result", "assert", "self", ".", "kind", "==", "TypeKind", ".", "FUNCTIONPROTO", "return", "ArgumentsIterator", "(", "self", ")" ]

[ "Determines", "the", "width", "of", "the", "line", "in", "column", "positions", "." ]

[ "def", "get_line_width", "(", "line", ")", ":", "if", "isinstance", "(", "line", ",", "unicode", ")", ":", "width", "=", "0", "for", "c", "in", "unicodedata", ".", "normalize", "(", "'NFC'", ",", "line", ")", ":", "if", "unicodedata", ".", "east_asian_width", "(", "c", ")", "in", "(", "'W'", ",", "'F'", ")", ":", "width", "+=", "2", "elif", "not", "unicodedata", ".", "combining", "(", "c", ")", ":", "width", "+=", "1", "return", "width", "return", "len", "(", "line", ")" ]

[ "Checks", "rules", "from", "the", "C", "++", "language", "rules", "section", "of", "cppguide", ".", "html", "." ]

[ "def", "CheckLanguage", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "file_extension", ",", "include_state", ",", "nesting_state", ",", "error", ")", ":", "# If the line is empty or consists of entirely a comment, no need to", "# check it.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "not", "line", ":", "return", "match", "=", "_RE_PATTERN_INCLUDE", ".", "search", "(", "line", ")", "if", "match", ":", "CheckIncludeLine", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "include_state", ",", "error", ")", "return", "# Reset include state across preprocessor directives. This is meant", "# to silence warnings for conditional includes.", "match", "=", "Match", "(", "r'^\\s*#\\s*(if|ifdef|ifndef|elif|else|endif)\\b'", ",", "line", ")", "if", "match", ":", "include_state", ".", "ResetSection", "(", "match", ".", "group", "(", "1", ")", ")", "# Make Windows paths like Unix.", "fullname", "=", "os", ".", "path", ".", "abspath", "(", "filename", ")", ".", "replace", "(", "'\\\\'", ",", "'/'", ")", "# Perform other checks now that we are sure that this is not an include line", "CheckCasts", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckGlobalStatic", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "CheckPrintf", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "if", "file_extension", "==", "'h'", ":", "# TODO(unknown): check that 1-arg constructors are explicit.", "# How to tell it's a constructor?", "# (handled in CheckForNonStandardConstructs for now)", "# TODO(unknown): check that classes declare or disable copy/assign", "# (level 1 error)", "pass", "# Check if people are using the verboten C basic types. The only exception", "# we regularly allow is \"unsigned short port\" for port.", "if", "Search", "(", "r'\\bshort port\\b'", ",", "line", ")", ":", "if", "not", "Search", "(", "r'\\bunsigned short port\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/int'", ",", "4", ",", "'Use \"unsigned short\" for ports, not \"short\"'", ")", "else", ":", "match", "=", "Search", "(", "r'\\b(short|long(?! +double)|long long)\\b'", ",", "line", ")", "if", "match", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/int'", ",", "4", ",", "'Use int16/int64/etc, rather than the C type %s'", "%", "match", ".", "group", "(", "1", ")", ")", "# Check if some verboten operator overloading is going on", "# TODO(unknown): catch out-of-line unary operator&:", "# class X {};", "# int operator&(const X& x) { return 42; } // unary operator&", "# The trick is it's hard to tell apart from binary operator&:", "# class Y { int operator&(const Y& x) { return 23; } }; // binary operator&", "if", "Search", "(", "r'\\boperator\\s*&\\s*\\(\\s*\\)'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/operator'", ",", "4", ",", "'Unary operator& is dangerous. Do not use it.'", ")", "# Check for suspicious usage of \"if\" like", "# } if (a == b) {", "if", "Search", "(", "r'\\}\\s*if\\s*\\('", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/braces'", ",", "4", ",", "'Did you mean \"else if\"? If not, start a new line for \"if\".'", ")", "# Check for potential format string bugs like printf(foo).", "# We constrain the pattern not to pick things like DocidForPrintf(foo).", "# Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())", "# TODO(unknown): Catch the following case. Need to change the calling", "# convention of the whole function to process multiple line to handle it.", "# printf(", "# boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line);", "printf_args", "=", "_GetTextInside", "(", "line", ",", "r'(?i)\\b(string)?printf\\s*\\('", ")", "if", "printf_args", ":", "match", "=", "Match", "(", "r'([\\w.\\->()]+)$'", ",", "printf_args", ")", "if", "match", "and", "match", ".", "group", "(", "1", ")", "!=", "'__VA_ARGS__'", ":", "function_name", "=", "re", ".", "search", "(", "r'\\b((?:string)?printf)\\s*\\('", ",", "line", ",", "re", ".", "I", ")", ".", "group", "(", "1", ")", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf'", ",", "4", ",", "'Potential format string bug. Do %s(\"%%s\", %s) instead.'", "%", "(", "function_name", ",", "match", ".", "group", "(", "1", ")", ")", ")", "# Check for potential memset bugs like memset(buf, sizeof(buf), 0).", "match", "=", "Search", "(", "r'memset\\s*\\(([^,]*),\\s*([^,]*),\\s*0\\s*\\)'", ",", "line", ")", "if", "match", "and", "not", "Match", "(", "r\"^''|-?[0-9]+|0x[0-9A-Fa-f]$\"", ",", "match", ".", "group", "(", "2", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/memset'", ",", "4", ",", "'Did you mean \"memset(%s, 0, %s)\"?'", "%", "(", "match", ".", "group", "(", "1", ")", ",", "match", ".", "group", "(", "2", ")", ")", ")", "if", "Search", "(", "r'\\busing namespace\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/namespaces'", ",", "5", ",", "'Do not use namespace using-directives. '", "'Use using-declarations instead.'", ")", "# Detect variable-length arrays.", "match", "=", "Match", "(", "r'\\s*(.+::)?(\\w+) [a-z]\\w*\\[(.+)];'", ",", "line", ")", "if", "(", "match", "and", "match", ".", "group", "(", "2", ")", "!=", "'return'", "and", "match", ".", "group", "(", "2", ")", "!=", "'delete'", "and", "match", ".", "group", "(", "3", ")", ".", "find", "(", "']'", ")", "==", "-", "1", ")", ":", "# Split the size using space and arithmetic operators as delimiters.", "# If any of the resulting tokens are not compile time constants then", "# report the error.", "tokens", "=", "re", ".", "split", "(", "r'\\s|\\+|\\-|\\*|\\/|<<|>>]'", ",", "match", ".", "group", "(", "3", ")", ")", "is_const", "=", "True", "skip_next", "=", "False", "for", "tok", "in", "tokens", ":", "if", "skip_next", ":", "skip_next", "=", "False", "continue", "if", "Search", "(", "r'sizeof\\(.+\\)'", ",", "tok", ")", ":", "continue", "if", "Search", "(", "r'arraysize\\(\\w+\\)'", ",", "tok", ")", ":", "continue", "tok", "=", "tok", ".", "lstrip", "(", "'('", ")", "tok", "=", "tok", ".", "rstrip", "(", "')'", ")", "if", "not", "tok", ":", "continue", "if", "Match", "(", "r'\\d+'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'0[xX][0-9a-fA-F]+'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'k[A-Z0-9]\\w*'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'(.+::)?k[A-Z0-9]\\w*'", ",", "tok", ")", ":", "continue", "if", "Match", "(", "r'(.+::)?[A-Z][A-Z0-9_]*'", ",", "tok", ")", ":", "continue", "# A catch all for tricky sizeof cases, including 'sizeof expression',", "# 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'", "# requires skipping the next token because we split on ' ' and '*'.", "if", "tok", ".", "startswith", "(", "'sizeof'", ")", ":", "skip_next", "=", "True", "continue", "is_const", "=", "False", "break", "if", "not", "is_const", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/arrays'", ",", "1", ",", "'Do not use variable-length arrays. Use an appropriately named '", "\"('k' followed by CamelCase) compile-time constant for the size.\"", ")", "# Check for use of unnamed namespaces in header files. Registration", "# macros are typically OK, so we allow use of \"namespace {\" on lines", "# that end with backslashes.", "if", "(", "file_extension", "==", "'h'", "and", "Search", "(", "r'\\bnamespace\\s*{'", ",", "line", ")", "and", "line", "[", "-", "1", "]", "!=", "'\\\\'", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/namespaces'", ",", "4", ",", "'Do not use unnamed namespaces in header files. See '", "'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'", "' for more information.'", ")" ]

[ "Clear", "the", "data", "in", "the", "Tk", "clipboard", "." ]

[ "def", "clipboard_clear", "(", "self", ",", "*", "*", "kw", ")", ":", "if", "'displayof'", "not", "in", "kw", ":", "kw", "[", "'displayof'", "]", "=", "self", ".", "_w", "self", ".", "tk", ".", "call", "(", "(", "'clipboard'", ",", "'clear'", ")", "+", "self", ".", "_options", "(", "kw", ")", ")" ]

[ "Return", "the", "next", "decoded", "line", "from", "the", "input", "stream", "." ]

[ "def", "next", "(", "self", ")", ":", "line", "=", "self", ".", "readline", "(", ")", "if", "line", ":", "return", "line", "raise", "StopIteration" ]

[ "Returns", "the", "timestamp", "in", "seconds", "of", "the", "first", "event", "." ]

[ "def", "FirstEventTimestamp", "(", "self", ")", ":", "if", "self", ".", "_first_event_timestamp", "is", "not", "None", ":", "return", "self", ".", "_first_event_timestamp", "with", "self", ".", "_generator_mutex", ":", "try", ":", "event", "=", "next", "(", "self", ".", "_generator", ".", "Load", "(", ")", ")", "self", ".", "_ProcessEvent", "(", "event", ")", "return", "self", ".", "_first_event_timestamp", "except", "StopIteration", ":", "raise", "ValueError", "(", "'No event timestamp could be found'", ")" ]

[ "Decode", "a", "JSON", "document", "from", "s", "(", "a", "str", "or", "unicode", "beginning", "with", "a", "JSON", "document", ")", "and", "return", "a", "2", "-", "tuple", "of", "the", "Python", "representation", "and", "the", "index", "in", "s", "where", "the", "document", "ended", "." ]

[ "def", "raw_decode", "(", "self", ",", "s", ",", "idx", "=", "0", ")", ":", "try", ":", "obj", ",", "end", "=", "self", ".", "scan_once", "(", "s", ",", "idx", ")", "except", "StopIteration", ":", "raise", "ValueError", "(", "\"No JSON object could be decoded\"", ")", "return", "obj", ",", "end" ]

[ ":", "param", "filename", ":", "you", "may", "have", "to", "define", "it", "(", "at", "least", "once", ")", "to", "create", "a", "controller", "for", "which", "the", "class", "is", "defined", "in", "an", "external", "file", ".", "Be", "aware", "the", "file", "will", "then", "be", "read", "several", "times", "." ]

[ "def", "__new__", "(", "cls", ",", "node", ",", "name", "=", "'pythonScriptController'", ",", "filename", "=", "''", ")", ":", "node", ".", "createObject", "(", "'PythonScriptController'", ",", "filename", "=", "filename", ",", "classname", "=", "cls", ".", "__name__", ",", "name", "=", "name", ")", "try", ":", "res", "=", "Controller", ".", "instance", "del", "Controller", ".", "instance", "return", "res", "except", "AttributeError", ":", "# if this fails, you need to call", "# Controller.onLoaded(self, node) in derived classes", "print", "\"[SofaImage.Controller.__new__] instance not found, did you call 'SofaImage.Controller.onLoaded' on your overloaded 'onLoaded' in {} ?\"", ".", "format", "(", "cls", ")", "raise" ]

[ "Indicates", "whether", "a", "pane", "should", "be", "destroyed", "when", "it", "is", "closed", "." ]

[ "def", "DestroyOnClose", "(", "self", ",", "b", "=", "True", ")", ":", "return", "self", ".", "SetFlag", "(", "self", ".", "optionDestroyOnClose", ",", "b", ")" ]

[ "Unregister", "a", "handler", "with", "an", "event", "." ]

[ "def", "unregister", "(", "self", ",", "event_name", ",", "handler", "=", "None", ",", "unique_id", "=", "None", ",", "unique_id_uses_count", "=", "False", ")", ":", "self", ".", "_events", ".", "unregister", "(", "event_name", ",", "handler", "=", "handler", ",", "unique_id", "=", "unique_id", ",", "unique_id_uses_count", "=", "unique_id_uses_count", ")" ]

[ "Initialize", "Abs" ]

[ "def", "__init__", "(", "self", ")", ":", "self", ".", "init_prim_io_names", "(", "inputs", "=", "[", "'input_x'", "]", ",", "outputs", "=", "[", "'output'", "]", ")" ]

[ "查询委托" ]

[ "def", "reqQryOrder", "(", "self", ")", ":", "qryOrderField", "=", "td", ".", "QryOrderField", "(", ")", "qryOrderField", ".", "brokerID", "=", "self", ".", "_brokerID", "qryOrderField", ".", "investorID", "=", "self", ".", "_userID", "# qryOrderField.instrumentID = \"\"", "self", ".", "_requestId", "+=", "1", "super", "(", "CtpTd", ",", "self", ")", ".", "reqQryOrder", "(", "qryOrderField", ",", "self", ".", "_requestId", ")", "return", "self", ".", "_requestId" ]

[ "Overrides", "SimpleXMLRPCServer", "to", "set", "option", "to", "allow_reuse_address", "." ]

[ "def", "__init__", "(", "self", ",", "addr", ",", "log_requests", "=", "1", ")", ":", "# allow_reuse_address defaults to False in Python 2.4. We set it ", "# to True to allow quick restart on the same port. This is equivalent ", "# to calling setsockopt(SOL_SOCKET,SO_REUSEADDR,1)", "self", ".", "allow_reuse_address", "=", "True", "# Increase request_queue_size to handle issues with many simultaneous", "# connections in OSX 10.11", "self", ".", "request_queue_size", "=", "min", "(", "socket", ".", "SOMAXCONN", ",", "128", ")", "if", "rosgraph", ".", "network", ".", "use_ipv6", "(", ")", ":", "logger", "=", "logging", ".", "getLogger", "(", "'xmlrpc'", ")", "# The XMLRPC library does not support IPv6 out of the box", "# We have to monipulate private members and duplicate", "# code from the constructor.", "# TODO IPV6: Get this into SimpleXMLRPCServer ", "SimpleXMLRPCServer", ".", "__init__", "(", "self", ",", "addr", ",", "SilenceableXMLRPCRequestHandler", ",", "log_requests", ",", "bind_and_activate", "=", "False", ")", "self", ".", "address_family", "=", "socket", ".", "AF_INET6", "self", ".", "socket", "=", "socket", ".", "socket", "(", "self", ".", "address_family", ",", "self", ".", "socket_type", ")", "logger", ".", "info", "(", "'binding ipv6 xmlrpc socket to'", "+", "str", "(", "addr", ")", ")", "# TODO: set IPV6_V6ONLY to 0:", "# self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)", "self", ".", "server_bind", "(", ")", "self", ".", "server_activate", "(", ")", "logger", ".", "info", "(", "'bound to '", "+", "str", "(", "self", ".", "socket", ".", "getsockname", "(", ")", "[", "0", ":", "2", "]", ")", ")", "else", ":", "SimpleXMLRPCServer", ".", "__init__", "(", "self", ",", "addr", ",", "SilenceableXMLRPCRequestHandler", ",", "log_requests", ")" ]

[ "Tuple", "of", "embedded", "teredo", "IPs", "." ]

[ "def", "teredo", "(", "self", ")", ":", "if", "(", "self", ".", "_ip", ">>", "96", ")", "!=", "0x20010000", ":", "return", "None", "return", "(", "IPv4Address", "(", "(", "self", ".", "_ip", ">>", "64", ")", "&", "0xFFFFFFFF", ")", ",", "IPv4Address", "(", "~", "self", ".", "_ip", "&", "0xFFFFFFFF", ")", ")" ]

[ "Adds", "a", "new", "flag", "setting", "with", "the", "specified", "values", ".", "Does", "no", "checking", "." ]

[ "def", "__add_flag", "(", "rule_or_module", ",", "variable_name", ",", "condition", ",", "values", ")", ":", "f", "=", "Flag", "(", "variable_name", ",", "values", ",", "condition", ",", "rule_or_module", ")", "# Grab the name of the module", "m", "=", "__re_first_segment", ".", "match", "(", "rule_or_module", ")", "assert", "m", "module", "=", "m", ".", "group", "(", "1", ")", "__module_flags", ".", "setdefault", "(", "m", ",", "[", "]", ")", ".", "append", "(", "f", ")", "__flags", ".", "setdefault", "(", "rule_or_module", ",", "[", "]", ")", ".", "append", "(", "f", ")" ]

[ "Change", "the", "working", "directory", "or", "cd", "to", "$", "{", "HOME", "}", ".", "You", "can", "also", "issue", "cd", "-", "to", "change", "to", "the", "previous", "working", "directory", "." ]

[ "def", "chdir", "(", "debugger", ",", "args", ",", "result", ",", "dict", ")", ":", "new_dir", "=", "args", ".", "strip", "(", ")", "if", "not", "new_dir", ":", "new_dir", "=", "os", ".", "path", ".", "expanduser", "(", "'~'", ")", "elif", "new_dir", "==", "'-'", ":", "if", "not", "Holder", ".", "prev_dir", "(", ")", ":", "# Bad directory, not changing.", "print", "\"bad directory, not changing\"", "return", "else", ":", "new_dir", "=", "Holder", ".", "prev_dir", "(", ")", "Holder", ".", "swap", "(", "os", ".", "getcwd", "(", ")", ")", "os", ".", "chdir", "(", "new_dir", ")", "print", "\"Current working directory: %s\"", "%", "os", ".", "getcwd", "(", ")" ]

[ "Called", "when", "an", "empty", "line", "is", "entered", "in", "response", "to", "the", "prompt", "." ]

[ "def", "emptyline", "(", "self", ")", ":", "if", "self", ".", "lastcmd", ":", "return", "self", ".", "onecmd", "(", "self", ".", "lastcmd", ")" ]

[ "Initializes", "the", "model", "with", "all", "parameters", "necessary", "for", "performing", "the", "desired", "operation", ".", "Default", "parameters", "do", "not", "pass", "the", "validation", "step", "." ]

[ "def", "__init__", "(", "self", ",", "lhs_scale", "=", "1.0", ",", "lhs_ws", "=", "None", ",", "rhs_scale", "=", "1.0", ",", "rhs_ws", "=", "None", ",", "output_ws", "=", "None", ",", "operation", "=", "'+'", ")", ":", "self", ".", "_lhs_scale", "=", "lhs_scale", "self", ".", "_lhs_ws", "=", "lhs_ws", "self", ".", "_rhs_scale", "=", "rhs_scale", "self", ".", "_rhs_ws", "=", "rhs_ws", "self", ".", "_output_ws", "=", "output_ws", "self", ".", "_operation", "=", "operation", "self", ".", "_md_lhs", "=", "None", "self", ".", "_md_rhs", "=", "None" ]

[ "varname", "ctype", "atype", "init", "init", ".", "r", "init", ".", "i", "pytype", "vardebuginfo", "vardebugshowvalue", "varshowvalue", "varrfromat", "intent" ]

[ "def", "sign2map", "(", "a", ",", "var", ")", ":", "global", "lcb_map", ",", "cb_map", "out_a", "=", "a", "if", "isintent_out", "(", "var", ")", ":", "for", "k", "in", "var", "[", "'intent'", "]", ":", "if", "k", "[", ":", "4", "]", "==", "'out='", ":", "out_a", "=", "k", "[", "4", ":", "]", "break", "ret", "=", "{", "'varname'", ":", "a", ",", "'outvarname'", ":", "out_a", ",", "'ctype'", ":", "getctype", "(", "var", ")", "}", "intent_flags", "=", "[", "]", "for", "f", ",", "s", "in", "isintent_dict", ".", "items", "(", ")", ":", "if", "f", "(", "var", ")", ":", "intent_flags", ".", "append", "(", "'F2PY_%s'", "%", "s", ")", "if", "intent_flags", ":", "# XXX: Evaluate intent_flags here.", "ret", "[", "'intent'", "]", "=", "'|'", ".", "join", "(", "intent_flags", ")", "else", ":", "ret", "[", "'intent'", "]", "=", "'F2PY_INTENT_IN'", "if", "isarray", "(", "var", ")", ":", "ret", "[", "'varrformat'", "]", "=", "'N'", "elif", "ret", "[", "'ctype'", "]", "in", "c2buildvalue_map", ":", "ret", "[", "'varrformat'", "]", "=", "c2buildvalue_map", "[", "ret", "[", "'ctype'", "]", "]", "else", ":", "ret", "[", "'varrformat'", "]", "=", "'O'", "ret", "[", "'init'", "]", ",", "ret", "[", "'showinit'", "]", "=", "getinit", "(", "a", ",", "var", ")", "if", "hasinitvalue", "(", "var", ")", "and", "iscomplex", "(", "var", ")", "and", "not", "isarray", "(", "var", ")", ":", "ret", "[", "'init.r'", "]", ",", "ret", "[", "'init.i'", "]", "=", "markoutercomma", "(", "ret", "[", "'init'", "]", "[", "1", ":", "-", "1", "]", ")", ".", "split", "(", "'@,@'", ")", "if", "isexternal", "(", "var", ")", ":", "ret", "[", "'cbnamekey'", "]", "=", "a", "if", "a", "in", "lcb_map", ":", "ret", "[", "'cbname'", "]", "=", "lcb_map", "[", "a", "]", "ret", "[", "'maxnofargs'", "]", "=", "lcb2_map", "[", "lcb_map", "[", "a", "]", "]", "[", "'maxnofargs'", "]", "ret", "[", "'nofoptargs'", "]", "=", "lcb2_map", "[", "lcb_map", "[", "a", "]", "]", "[", "'nofoptargs'", "]", "ret", "[", "'cbdocstr'", "]", "=", "lcb2_map", "[", "lcb_map", "[", "a", "]", "]", "[", "'docstr'", "]", "ret", "[", "'cblatexdocstr'", "]", "=", "lcb2_map", "[", "lcb_map", "[", "a", "]", "]", "[", "'latexdocstr'", "]", "else", ":", "ret", "[", "'cbname'", "]", "=", "a", "errmess", "(", "'sign2map: Confused: external %s is not in lcb_map%s.\\n'", "%", "(", "a", ",", "list", "(", "lcb_map", ".", "keys", "(", ")", ")", ")", ")", "if", "isstring", "(", "var", ")", ":", "ret", "[", "'length'", "]", "=", "getstrlength", "(", "var", ")", "if", "isarray", "(", "var", ")", ":", "ret", "=", "dictappend", "(", "ret", ",", "getarrdims", "(", "a", ",", "var", ")", ")", "dim", "=", "copy", ".", "copy", "(", "var", "[", "'dimension'", "]", ")", "if", "ret", "[", "'ctype'", "]", "in", "c2capi_map", ":", "ret", "[", "'atype'", "]", "=", "c2capi_map", "[", "ret", "[", "'ctype'", "]", "]", "# Debug info", "if", "debugcapi", "(", "var", ")", ":", "il", "=", "[", "isintent_in", ",", "'input'", ",", "isintent_out", ",", "'output'", ",", "isintent_inout", ",", "'inoutput'", ",", "isrequired", ",", "'required'", ",", "isoptional", ",", "'optional'", ",", "isintent_hide", ",", "'hidden'", ",", "iscomplex", ",", "'complex scalar'", ",", "l_and", "(", "isscalar", ",", "l_not", "(", "iscomplex", ")", ")", ",", "'scalar'", ",", "isstring", ",", "'string'", ",", "isarray", ",", "'array'", ",", "iscomplexarray", ",", "'complex array'", ",", "isstringarray", ",", "'string array'", ",", "iscomplexfunction", ",", "'complex function'", ",", "l_and", "(", "isfunction", ",", "l_not", "(", "iscomplexfunction", ")", ")", ",", "'function'", ",", "isexternal", ",", "'callback'", ",", "isintent_callback", ",", "'callback'", ",", "isintent_aux", ",", "'auxiliary'", ",", "]", "rl", "=", "[", "]", "for", "i", "in", "range", "(", "0", ",", "len", "(", "il", ")", ",", "2", ")", ":", "if", "il", "[", "i", "]", "(", "var", ")", ":", "rl", ".", "append", "(", "il", "[", "i", "+", "1", "]", ")", "if", "isstring", "(", "var", ")", ":", "rl", ".", "append", "(", "'slen(%s)=%s'", "%", "(", "a", ",", "ret", "[", "'length'", "]", ")", ")", "if", "isarray", "(", "var", ")", ":", "ddim", "=", "','", ".", "join", "(", "map", "(", "lambda", "x", ",", "y", ":", "'%s|%s'", "%", "(", "x", ",", "y", ")", ",", "var", "[", "'dimension'", "]", ",", "dim", ")", ")", "rl", ".", "append", "(", "'dims(%s)'", "%", "ddim", ")", "if", "isexternal", "(", "var", ")", ":", "ret", "[", "'vardebuginfo'", "]", "=", "'debug-capi:%s=>%s:%s'", "%", "(", "a", ",", "ret", "[", "'cbname'", "]", ",", "','", ".", "join", "(", "rl", ")", ")", "else", ":", "ret", "[", "'vardebuginfo'", "]", "=", "'debug-capi:%s %s=%s:%s'", "%", "(", "ret", "[", "'ctype'", "]", ",", "a", ",", "ret", "[", "'showinit'", "]", ",", "','", ".", "join", "(", "rl", ")", ")", "if", "isscalar", "(", "var", ")", ":", "if", "ret", "[", "'ctype'", "]", "in", "cformat_map", ":", "ret", "[", "'vardebugshowvalue'", "]", "=", "'debug-capi:%s=%s'", "%", "(", "a", ",", "cformat_map", "[", "ret", "[", "'ctype'", "]", "]", ")", "if", "isstring", "(", "var", ")", ":", "ret", "[", "'vardebugshowvalue'", "]", "=", "'debug-capi:slen(%s)=%%d %s=\\\\\"%%s\\\\\"'", "%", "(", "a", ",", "a", ")", "if", "isexternal", "(", "var", ")", ":", "ret", "[", "'vardebugshowvalue'", "]", "=", "'debug-capi:%s=%%p'", "%", "(", "a", ")", "if", "ret", "[", "'ctype'", "]", "in", "cformat_map", ":", "ret", "[", "'varshowvalue'", "]", "=", "'#name#:%s=%s'", "%", "(", "a", ",", "cformat_map", "[", "ret", "[", "'ctype'", "]", "]", ")", "ret", "[", "'showvalueformat'", "]", "=", "'%s'", "%", "(", "cformat_map", "[", "ret", "[", "'ctype'", "]", "]", ")", "if", "isstring", "(", "var", ")", ":", "ret", "[", "'varshowvalue'", "]", "=", "'#name#:slen(%s)=%%d %s=\\\\\"%%s\\\\\"'", "%", "(", "a", ",", "a", ")", "ret", "[", "'pydocsign'", "]", ",", "ret", "[", "'pydocsignout'", "]", "=", "getpydocsign", "(", "a", ",", "var", ")", "if", "hasnote", "(", "var", ")", ":", "ret", "[", "'note'", "]", "=", "var", "[", "'note'", "]", "return", "ret" ]

[ "Get", "the", "correct", "color", "for", "the", "token", "from", "the", "style", "." ]

[ "def", "_get_text_color", "(", "self", ",", "style", ")", ":", "if", "style", "[", "'color'", "]", "is", "not", "None", ":", "fill", "=", "'#'", "+", "style", "[", "'color'", "]", "else", ":", "fill", "=", "'#000'", "return", "fill" ]

[ "Returns", "the", "qualified", "path", "to", "the", "bundle", "s", "resource", "folder", ".", "E", ".", "g", ".", "Chromium", ".", "app", "/", "Contents", "/", "Resources", ".", "Only", "valid", "for", "bundles", "." ]

[ "def", "GetBundleResourceFolder", "(", "self", ")", ":", "assert", "self", ".", "_IsBundle", "(", ")", "return", "os", ".", "path", ".", "join", "(", "self", ".", "GetBundleContentsFolderPath", "(", ")", ",", "'Resources'", ")" ]

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

[ "def", "hIndex", "(", "self", ",", "citations", ")", ":", "return", "sum", "(", "x", ">=", "i", "+", "1", "for", "i", ",", "x", "in", "enumerate", "(", "sorted", "(", "citations", ",", "reverse", "=", "True", ")", ")", ")" ]

[ "Enables", "or", "disables", "the", "item", "." ]

[ "def", "Enable", "(", "self", ",", "enable", "=", "True", ")", ":", "self", ".", "Attributes", "(", ")", ".", "Enable", "(", "enable", ")" ]

[ "SetSameMargins", "(", "self", "int", "margin", ")" ]

[ "def", "SetSameMargins", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextObject_SetSameMargins", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Add", "Nodes", "from", "Plain", "Text", "File", "(", "s", ")", "in", "Selected", "Folder" ]

[ "def", "nodes_add_from_plain_text_folder", "(", "self", ",", "action", ")", ":", "if", "not", "hasattr", "(", "self", ",", "\"ext_plain_import\"", ")", ":", "self", ".", "ext_plain_import", "=", "\"txt\"", "if", "cons", ".", "IS_WIN_OS", ":", "ext_plain_import", "=", "support", ".", "dialog_img_n_entry", "(", "self", ".", "window", ",", "_", "(", "\"Plain Text Document\"", ")", ",", "self", ".", "ext_plain_import", ",", "gtk", ".", "STOCK_FILE", ")", "if", "not", "ext_plain_import", ":", "return", "self", ".", "ext_plain_import", "=", "ext_plain_import", "folderpath", "=", "support", ".", "dialog_folder_select", "(", "curr_folder", "=", "self", ".", "pick_dir_import", ",", "parent", "=", "self", ".", "window", ")", "if", "not", "folderpath", ":", "return", "self", ".", "pick_dir_import", "=", "os", ".", "path", ".", "dirname", "(", "folderpath", ")", "plain", "=", "imports", ".", "PlainTextHandler", "(", "self", ")", "cherrytree_string", "=", "plain", ".", "get_cherrytree_xml", "(", "folderpath", "=", "folderpath", ")", "self", ".", "nodes_add_from_cherrytree_data", "(", "cherrytree_string", ")" ]

[ "NOTE", ":", "This", "method", "uses", "the", "old", "-", "style", "request", "parameters", "that", "did", "not", "allow", "a", "port", "to", "be", "specified", "when", "authorizing", "a", "group", "." ]

[ "def", "revoke_security_group_deprecated", "(", "self", ",", "group_name", ",", "src_security_group_name", "=", "None", ",", "src_security_group_owner_id", "=", "None", ",", "ip_protocol", "=", "None", ",", "from_port", "=", "None", ",", "to_port", "=", "None", ",", "cidr_ip", "=", "None", ",", "dry_run", "=", "False", ")", ":", "params", "=", "{", "'GroupName'", ":", "group_name", "}", "if", "src_security_group_name", ":", "params", "[", "'SourceSecurityGroupName'", "]", "=", "src_security_group_name", "if", "src_security_group_owner_id", ":", "params", "[", "'SourceSecurityGroupOwnerId'", "]", "=", "src_security_group_owner_id", "if", "ip_protocol", ":", "params", "[", "'IpProtocol'", "]", "=", "ip_protocol", "if", "from_port", ":", "params", "[", "'FromPort'", "]", "=", "from_port", "if", "to_port", ":", "params", "[", "'ToPort'", "]", "=", "to_port", "if", "cidr_ip", ":", "params", "[", "'CidrIp'", "]", "=", "cidr_ip", "if", "dry_run", ":", "params", "[", "'DryRun'", "]", "=", "'true'", "return", "self", ".", "get_status", "(", "'RevokeSecurityGroupIngress'", ",", "params", ")" ]

[ "Does", "google", "-", "lint", "on", "a", "single", "file", "." ]

[ "def", "ProcessFile", "(", "filename", ",", "vlevel", ",", "extra_check_functions", "=", "[", "]", ")", ":", "_SetVerboseLevel", "(", "vlevel", ")", "try", ":", "# Support the UNIX convention of using \"-\" for stdin. Note that", "# we are not opening the file with universal newline support", "# (which codecs doesn't support anyway), so the resulting lines do", "# contain trailing '\\r' characters if we are reading a file that", "# has CRLF endings.", "# If after the split a trailing '\\r' is present, it is removed", "# below. If it is not expected to be present (i.e. os.linesep !=", "# '\\r\\n' as in Windows), a warning is issued below if this file", "# is processed.", "if", "filename", "==", "'-'", ":", "lines", "=", "codecs", ".", "StreamReaderWriter", "(", "sys", ".", "stdin", ",", "codecs", ".", "getreader", "(", "'utf8'", ")", ",", "codecs", ".", "getwriter", "(", "'utf8'", ")", ",", "'replace'", ")", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "else", ":", "lines", "=", "codecs", ".", "open", "(", "filename", ",", "'r'", ",", "'utf8'", ",", "'replace'", ")", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "carriage_return_found", "=", "False", "# Remove trailing '\\r'.", "for", "linenum", "in", "range", "(", "len", "(", "lines", ")", ")", ":", "if", "lines", "[", "linenum", "]", ".", "endswith", "(", "'\\r'", ")", ":", "lines", "[", "linenum", "]", "=", "lines", "[", "linenum", "]", ".", "rstrip", "(", "'\\r'", ")", "carriage_return_found", "=", "True", "except", "IOError", ":", "sys", ".", "stderr", ".", "write", "(", "\"Skipping input '%s': Can't open for reading\\n\"", "%", "filename", ")", "return", "# Note, if no dot is found, this will give the entire filename as the ext.", "file_extension", "=", "filename", "[", "filename", ".", "rfind", "(", "'.'", ")", "+", "1", ":", "]", "# When reading from stdin, the extension is unknown, so no cpplint tests", "# should rely on the extension.", "if", "filename", "!=", "'-'", "and", "file_extension", "not", "in", "_valid_extensions", ":", "sys", ".", "stderr", ".", "write", "(", "'Ignoring %s; not a valid file name '", "'(%s)\\n'", "%", "(", "filename", ",", "', '", ".", "join", "(", "_valid_extensions", ")", ")", ")", "else", ":", "ProcessFileData", "(", "filename", ",", "file_extension", ",", "lines", ",", "Error", ",", "extra_check_functions", ")", "if", "carriage_return_found", "and", "os", ".", "linesep", "!=", "'\\r\\n'", ":", "# Use 0 for linenum since outputting only one error for potentially", "# several lines.", "Error", "(", "filename", ",", "0", ",", "'whitespace/newline'", ",", "1", ",", "'One or more unexpected \\\\r (^M) found;'", "'better to use only a \\\\n'", ")", "sys", ".", "stderr", ".", "write", "(", "'Done processing %s\\n'", "%", "filename", ")" ]

[ "Search", "for", "-", "g", "in", "args", ".", "If", "it", "exists", "then", "return", "args", "without", ".", "If", "not", "then", "add", "it", "." ]

[ "def", "flip_dash_g", "(", "args", ")", ":", "if", "'-g'", "in", "args", ":", "# Return args without any -g", "return", "[", "x", "for", "x", "in", "args", "if", "x", "!=", "'-g'", "]", "else", ":", "# No -g, add one", "return", "args", "+", "[", "'-g'", "]" ]

[ "Return", "homogeneous", "rotation", "matrix", "from", "quaternion", "." ]

[ "def", "quaternion_matrix", "(", "quaternion", ")", ":", "q", "=", "numpy", ".", "array", "(", "quaternion", "[", ":", "4", "]", ",", "dtype", "=", "numpy", ".", "float64", ",", "copy", "=", "True", ")", "nq", "=", "numpy", ".", "dot", "(", "q", ",", "q", ")", "if", "nq", "<", "_EPS", ":", "return", "numpy", ".", "identity", "(", "4", ")", "q", "*=", "math", ".", "sqrt", "(", "2.0", "/", "nq", ")", "q", "=", "numpy", ".", "outer", "(", "q", ",", "q", ")", "return", "numpy", ".", "array", "(", "(", "(", "1.0", "-", "q", "[", "1", ",", "1", "]", "-", "q", "[", "2", ",", "2", "]", ",", "q", "[", "0", ",", "1", "]", "-", "q", "[", "2", ",", "3", "]", ",", "q", "[", "0", ",", "2", "]", "+", "q", "[", "1", ",", "3", "]", ",", "0.0", ")", ",", "(", "q", "[", "0", ",", "1", "]", "+", "q", "[", "2", ",", "3", "]", ",", "1.0", "-", "q", "[", "0", ",", "0", "]", "-", "q", "[", "2", ",", "2", "]", ",", "q", "[", "1", ",", "2", "]", "-", "q", "[", "0", ",", "3", "]", ",", "0.0", ")", ",", "(", "q", "[", "0", ",", "2", "]", "-", "q", "[", "1", ",", "3", "]", ",", "q", "[", "1", ",", "2", "]", "+", "q", "[", "0", ",", "3", "]", ",", "1.0", "-", "q", "[", "0", ",", "0", "]", "-", "q", "[", "1", ",", "1", "]", ",", "0.0", ")", ",", "(", "0.0", ",", "0.0", ",", "0.0", ",", "1.0", ")", ")", ",", "dtype", "=", "numpy", ".", "float64", ")" ]

[ "count", ":", "return", "the", "number", "of", "elements", "of", "a", "particular", "class", "within", "an", "object", "Required", "argument", ":", "the", "object", "whose", "elements", "are", "to", "be", "counted", "Keyword", "argument", "each", ":", "the", "class", "of", "the", "elements", "to", "be", "counted", ".", "Keyword", "each", "is", "optional", "in", "AppleScript", "Keyword", "argument", "_attributes", ":", "AppleEvent", "attribute", "dictionary", "Returns", ":", "the", "number", "of", "elements" ]

[ "def", "count", "(", "self", ",", "_object", ",", "_attributes", "=", "{", "}", ",", "*", "*", "_arguments", ")", ":", "_code", "=", "'core'", "_subcode", "=", "'cnte'", "aetools", ".", "keysubst", "(", "_arguments", ",", "self", ".", "_argmap_count", ")", "_arguments", "[", "'----'", "]", "=", "_object", "_reply", ",", "_arguments", ",", "_attributes", "=", "self", ".", "send", "(", "_code", ",", "_subcode", ",", "_arguments", ",", "_attributes", ")", "if", "_arguments", ".", "get", "(", "'errn'", ",", "0", ")", ":", "raise", "aetools", ".", "Error", ",", "aetools", ".", "decodeerror", "(", "_arguments", ")", "# XXXX Optionally decode result", "if", "_arguments", ".", "has_key", "(", "'----'", ")", ":", "return", "_arguments", "[", "'----'", "]" ]

[ "Construct", "an", "Autoregressive", "distribution", "." ]

[ "def", "__init__", "(", "self", ",", "distribution_fn", ",", "sample0", "=", "None", ",", "num_steps", "=", "None", ",", "validate_args", "=", "False", ",", "allow_nan_stats", "=", "True", ",", "name", "=", "\"Autoregressive\"", ")", ":", "parameters", "=", "dict", "(", "locals", "(", ")", ")", "with", "ops", ".", "name_scope", "(", "name", ")", "as", "name", ":", "self", ".", "_distribution_fn", "=", "distribution_fn", "self", ".", "_sample0", "=", "sample0", "self", ".", "_distribution0", "=", "(", "distribution_fn", "(", ")", "if", "sample0", "is", "None", "else", "distribution_fn", "(", "sample0", ")", ")", "if", "num_steps", "is", "None", ":", "num_steps", "=", "self", ".", "_distribution0", ".", "event_shape", ".", "num_elements", "(", ")", "if", "num_steps", "is", "None", ":", "raise", "ValueError", "(", "\"distribution_fn must generate a distribution \"", "\"with fully known `event_shape`.\"", ")", "if", "num_steps", "<", "1", ":", "raise", "ValueError", "(", "\"num_steps ({}) must be at least 1.\"", ".", "format", "(", "num_steps", ")", ")", "self", ".", "_num_steps", "=", "num_steps", "super", "(", "Autoregressive", ",", "self", ")", ".", "__init__", "(", "dtype", "=", "self", ".", "_distribution0", ".", "dtype", ",", "reparameterization_type", "=", "self", ".", "_distribution0", ".", "reparameterization_type", ",", "validate_args", "=", "validate_args", ",", "allow_nan_stats", "=", "allow_nan_stats", ",", "parameters", "=", "parameters", ",", "graph_parents", "=", "self", ".", "_distribution0", ".", "_graph_parents", ",", "# pylint: disable=protected-access", "name", "=", "name", ")" ]

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

[ "def", "Realize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ToolBarBase_Realize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Reports", "for", "long", "function", "bodies", "." ]

[ "def", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "function_state", ",", "error", ")", ":", "lines", "=", "clean_lines", ".", "lines", "line", "=", "lines", "[", "linenum", "]", "raw", "=", "clean_lines", ".", "raw_lines", "raw_line", "=", "raw", "[", "linenum", "]", "joined_line", "=", "''", "starting_func", "=", "False", "regexp", "=", "r'(\\w(\\w|::|\\*|\\&|\\s)*)\\('", "# decls * & space::name( ...", "match_result", "=", "Match", "(", "regexp", ",", "line", ")", "if", "match_result", ":", "# If the name is all caps and underscores, figure it's a macro and", "# ignore it, unless it's TEST or TEST_F.", "function_name", "=", "match_result", ".", "group", "(", "1", ")", ".", "split", "(", ")", "[", "-", "1", "]", "if", "function_name", "==", "'TEST'", "or", "function_name", "==", "'TEST_F'", "or", "(", "not", "Match", "(", "r'[A-Z_]+$'", ",", "function_name", ")", ")", ":", "starting_func", "=", "True", "if", "starting_func", ":", "body_found", "=", "False", "for", "start_linenum", "in", "xrange", "(", "linenum", ",", "clean_lines", ".", "NumLines", "(", ")", ")", ":", "start_line", "=", "lines", "[", "start_linenum", "]", "joined_line", "+=", "' '", "+", "start_line", ".", "lstrip", "(", ")", "if", "Search", "(", "r'(;|})'", ",", "start_line", ")", ":", "# Declarations and trivial functions", "body_found", "=", "True", "break", "# ... ignore", "elif", "Search", "(", "r'{'", ",", "start_line", ")", ":", "body_found", "=", "True", "function", "=", "Search", "(", "r'((\\w|:)*)\\('", ",", "line", ")", ".", "group", "(", "1", ")", "if", "Match", "(", "r'TEST'", ",", "function", ")", ":", "# Handle TEST... macros", "parameter_regexp", "=", "Search", "(", "r'(\\(.*\\))'", ",", "joined_line", ")", "if", "parameter_regexp", ":", "# Ignore bad syntax", "function", "+=", "parameter_regexp", ".", "group", "(", "1", ")", "else", ":", "function", "+=", "'()'", "function_state", ".", "Begin", "(", "function", ")", "break", "if", "not", "body_found", ":", "# No body for the function (or evidence of a non-function) was found.", "error", "(", "filename", ",", "linenum", ",", "'readability/fn_size'", ",", "5", ",", "'Lint failed to find start of function body.'", ")", "elif", "Match", "(", "r'^\\}\\s*$'", ",", "line", ")", ":", "# function end", "function_state", ".", "Check", "(", "error", ",", "filename", ",", "linenum", ")", "function_state", ".", "End", "(", ")", "elif", "not", "Match", "(", "r'^\\s*$'", ",", "line", ")", ":", "function_state", ".", "Count", "(", ")" ]

[ "Adding", "features", "to", "translation", "pairs" ]

[ "def", "add_features_to_word_pair", "(", "self", ",", "pair", ")", ":", "# article of the word exists", "if", "pair", "[", "3", "]", "in", "self", ".", "titles", ":", "pair", ".", "append", "(", "\"has_article\"", ")", "return", "pair" ]

[ "Constructor", "." ]

[ "def", "__init__", "(", "self", ",", "name", ",", "package", ",", "options", "=", "None", ",", "serialized_pb", "=", "None", ")", ":", "super", "(", "FileDescriptor", ",", "self", ")", ".", "__init__", "(", "options", ",", "'FileOptions'", ")", "self", ".", "message_types_by_name", "=", "{", "}", "self", ".", "name", "=", "name", "self", ".", "package", "=", "package", "self", ".", "serialized_pb", "=", "serialized_pb", "if", "(", "api_implementation", ".", "Type", "(", ")", "==", "'cpp'", "and", "self", ".", "serialized_pb", "is", "not", "None", ")", ":", "if", "api_implementation", ".", "Version", "(", ")", "==", "2", ":", "_message", ".", "BuildFile", "(", "self", ".", "serialized_pb", ")", "else", ":", "cpp_message", ".", "BuildFile", "(", "self", ".", "serialized_pb", ")" ]

[ "Return", "the", "visitor", "function", "for", "this", "node", "or", "None", "if", "no", "visitor", "exists", "for", "this", "node", ".", "In", "that", "case", "the", "generic", "visit", "function", "is", "used", "instead", "." ]

[ "def", "get_visitor", "(", "self", ",", "node", ")", ":", "method", "=", "\"visit_\"", "+", "node", ".", "__class__", ".", "__name__", "return", "getattr", "(", "self", ",", "method", ",", "None", ")" ]

[ ":", "param", "client", ":", "The", "client", "to", "use", "when", "calling", "PutObject", ":", "param", "copy_source", ":", "The", "CopySource", "parameter", "to", "use", ":", "param", "bucket", ":", "The", "name", "of", "the", "bucket", "to", "copy", "to", ":", "param", "key", ":", "The", "name", "of", "the", "key", "to", "copy", "to", ":", "param", "extra_args", ":", "A", "dictionary", "of", "any", "extra", "arguments", "that", "may", "be", "used", "in", "the", "upload", ".", ":", "param", "callbacks", ":", "List", "of", "callbacks", "to", "call", "after", "copy", ":", "param", "size", ":", "The", "size", "of", "the", "transfer", ".", "This", "value", "is", "passed", "into", "the", "callbacks" ]

[ "def", "_main", "(", "self", ",", "client", ",", "copy_source", ",", "bucket", ",", "key", ",", "extra_args", ",", "callbacks", ",", "size", ")", ":", "client", ".", "copy_object", "(", "CopySource", "=", "copy_source", ",", "Bucket", "=", "bucket", ",", "Key", "=", "key", ",", "*", "*", "extra_args", ")", "for", "callback", "in", "callbacks", ":", "callback", "(", "bytes_transferred", "=", "size", ")" ]

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

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

[ "Sort", "an", "iterable", ".", "If", "the", "iterable", "is", "made", "of", "strings", "the", "second", "parameter", "can", "be", "used", "to", "control", "the", "case", "sensitiveness", "of", "the", "comparison", "which", "is", "disabled", "by", "default", "." ]

[ "def", "do_sort", "(", "value", ",", "case_sensitive", "=", "False", ")", ":", "if", "not", "case_sensitive", ":", "def", "sort_func", "(", "item", ")", ":", "if", "isinstance", "(", "item", ",", "basestring", ")", ":", "item", "=", "item", ".", "lower", "(", ")", "return", "item", "else", ":", "sort_func", "=", "None", "return", "sorted", "(", "seq", ",", "key", "=", "sort_func", ")" ]

[ "Add", "a", "minibatch", "SparseTensor", "to", "a", "SparseTensorsMap", "return", "N", "handles", "." ]

[ "def", "_add_many_sparse_to_tensors_map", "(", "sp_input", ",", "container", "=", "None", ",", "shared_name", "=", "None", ",", "name", "=", "None", ")", ":", "sp_input", "=", "_convert_to_sparse_tensor", "(", "sp_input", ")", "return", "gen_sparse_ops", ".", "_add_many_sparse_to_tensors_map", "(", "sp_input", ".", "indices", ",", "sp_input", ".", "values", ",", "sp_input", ".", "dense_shape", ",", "container", "=", "container", ",", "shared_name", "=", "shared_name", ",", "name", "=", "name", ")" ]

[ "Initializes", "a", "new", "PrimitiveWrapper", "with", "wrapped", "." ]

[ "def", "__init__", "(", "self", ",", "wrapped", ":", "message", ".", "Message", ",", "unused_context", ":", "Context", ")", "->", "None", ":", "self", ".", "wrapped", "=", "wrapped" ]

[ "SetRect", "(", "self", "Rect", "rect", "int", "sizeFlags", "=", "SIZE_AUTO", ")" ]

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

[ "Construct", "a", "new", "AGN", "optimizer", "." ]

[ "def", "__init__", "(", "self", ",", "optimizer", ",", "num_worker", ",", "custom_getter", ",", "communication_period", "=", "10", ",", "use_locking", "=", "True", ",", "name", "=", "'AGNOptimizer'", ")", ":", "super", "(", "AGNOptimizer", ",", "self", ")", ".", "__init__", "(", "use_locking", ",", "name", ")", "self", ".", "_opt", "=", "optimizer", "self", ".", "_num_worker", "=", "num_worker", "self", ".", "_period", "=", "communication_period", "self", ".", "_global_map", "=", "custom_getter", ".", "_global_map", "self", ".", "_grad_map", "=", "custom_getter", ".", "_grad_map", "self", ".", "_local_step", "=", "variable_scope", ".", "get_variable", "(", "initializer", "=", "0", ",", "trainable", "=", "False", ",", "collections", "=", "[", "ops", ".", "GraphKeys", ".", "LOCAL_VARIABLES", "]", ",", "name", "=", "'local_step'", ")", "self", ".", "_opt", ".", "_prepare", "(", ")" ]

[ "If", "there", "were", "any", "non", "-", "global", "display", "-", "only", "options", "(", "--", "help", "-", "commands", "or", "the", "metadata", "display", "options", ")", "on", "the", "command", "line", "display", "the", "requested", "info", "and", "return", "true", ";", "else", "return", "false", "." ]

[ "def", "handle_display_options", "(", "self", ",", "option_order", ")", ":", "from", "distutils", ".", "core", "import", "gen_usage", "# User just wants a list of commands -- we'll print it out and stop", "# processing now (ie. if they ran \"setup --help-commands foo bar\",", "# we ignore \"foo bar\").", "if", "self", ".", "help_commands", ":", "self", ".", "print_commands", "(", ")", "print", "(", "''", ")", "print", "(", "gen_usage", "(", "self", ".", "script_name", ")", ")", "return", "1", "# If user supplied any of the \"display metadata\" options, then", "# display that metadata in the order in which the user supplied the", "# metadata options.", "any_display_options", "=", "0", "is_display_option", "=", "{", "}", "for", "option", "in", "self", ".", "display_options", ":", "is_display_option", "[", "option", "[", "0", "]", "]", "=", "1", "for", "(", "opt", ",", "val", ")", "in", "option_order", ":", "if", "val", "and", "is_display_option", ".", "get", "(", "opt", ")", ":", "opt", "=", "translate_longopt", "(", "opt", ")", "value", "=", "getattr", "(", "self", ".", "metadata", ",", "\"get_\"", "+", "opt", ")", "(", ")", "if", "opt", "in", "[", "'keywords'", ",", "'platforms'", "]", ":", "print", "(", "','", ".", "join", "(", "value", ")", ")", "elif", "opt", "in", "(", "'classifiers'", ",", "'provides'", ",", "'requires'", ",", "'obsoletes'", ")", ":", "print", "(", "'\\n'", ".", "join", "(", "value", ")", ")", "else", ":", "print", "(", "value", ")", "any_display_options", "=", "1", "return", "any_display_options" ]

[ "Documents", "a", "the", "wait", "method", "of", "a", "waiter" ]

[ "def", "document_wait_method", "(", "section", ",", "waiter_name", ",", "event_emitter", ",", "service_model", ",", "service_waiter_model", ",", "include_signature", "=", "True", ")", ":", "waiter_model", "=", "service_waiter_model", ".", "get_waiter", "(", "waiter_name", ")", "operation_model", "=", "service_model", ".", "operation_model", "(", "waiter_model", ".", "operation", ")", "waiter_config_members", "=", "OrderedDict", "(", ")", "waiter_config_members", "[", "'Delay'", "]", "=", "DocumentedShape", "(", "name", "=", "'Delay'", ",", "type_name", "=", "'integer'", ",", "documentation", "=", "(", "'<p>The amount of time in seconds to wait between '", "'attempts. Default: {0}</p>'", ".", "format", "(", "waiter_model", ".", "delay", ")", ")", ")", "waiter_config_members", "[", "'MaxAttempts'", "]", "=", "DocumentedShape", "(", "name", "=", "'MaxAttempts'", ",", "type_name", "=", "'integer'", ",", "documentation", "=", "(", "'<p>The maximum number of attempts to be made. '", "'Default: {0}</p>'", ".", "format", "(", "waiter_model", ".", "max_attempts", ")", ")", ")", "botocore_waiter_params", "=", "[", "DocumentedShape", "(", "name", "=", "'WaiterConfig'", ",", "type_name", "=", "'structure'", ",", "documentation", "=", "(", "'<p>A dictionary that provides parameters to control '", "'waiting behavior.</p>'", ")", ",", "members", "=", "waiter_config_members", ")", "]", "wait_description", "=", "(", "'Polls :py:meth:`{0}.Client.{1}` every {2} '", "'seconds until a successful state is reached. An error is '", "'returned after {3} failed checks.'", ".", "format", "(", "get_service_module_name", "(", "service_model", ")", ",", "xform_name", "(", "waiter_model", ".", "operation", ")", ",", "waiter_model", ".", "delay", ",", "waiter_model", ".", "max_attempts", ")", ")", "document_model_driven_method", "(", "section", ",", "'wait'", ",", "operation_model", ",", "event_emitter", "=", "event_emitter", ",", "method_description", "=", "wait_description", ",", "example_prefix", "=", "'waiter.wait'", ",", "include_input", "=", "botocore_waiter_params", ",", "document_output", "=", "False", ",", "include_signature", "=", "include_signature", ")" ]

[ "Assign", "the", "value", "in", "input", "to", "ref", "and", "return", "the", "new", "value", "ref", "need", "to", "be", "the", "same", "layout", "as", "input", ".", "Both", "ref", "and", "input", "can", "t", "have", "dynamic", "axis", "and", "broadcast", "isn", "t", "supported", "for", "the", "assign", "operator", ".", "During", "forward", "pass", "ref", "will", "get", "the", "new", "value", "after", "the", "forward", "or", "backward", "pass", "finish", "so", "that", "any", "part", "of", "the", "graph", "that", "depend", "on", "ref", "will", "get", "the", "old", "value", ".", "To", "get", "the", "new", "value", "use", "the", "one", "returned", "by", "the", "assign", "node", ".", "The", "reason", "for", "that", "is", "to", "make", "assign", "have", "a", "deterministic", "behavior", "." ]

[ "def", "assign", "(", "ref", ",", "input", ",", "name", "=", "''", ")", ":", "from", "cntk", ".", "cntk_py", "import", "assign", "dtype", "=", "get_data_type", "(", "input", ")", "operand", "=", "sanitize_input", "(", "input", ",", "dtype", ")", "ref_operand", "=", "sanitize_input", "(", "ref", ",", "dtype", ")", "return", "assign", "(", "ref_operand", ",", "operand", ",", "name", ")" ]

[ "Set", "from", "a", "value", "casted", "as", "a", "bool", "." ]

[ "def", "set", "(", "self", ",", "value", ")", ":", "super", "(", "BooleanPref", ",", "self", ")", ".", "set", "(", "'true'", "if", "value", "else", "'false'", ")" ]

[ "Prepare", "list", "of", "sources", "and", "excluded", "sources", "." ]

[ "def", "_PrepareListOfSources", "(", "spec", ",", "generator_flags", ",", "gyp_file", ")", ":", "sources", "=", "OrderedSet", "(", ")", "_AddNormalizedSources", "(", "sources", ",", "spec", ".", "get", "(", "'sources'", ",", "[", "]", ")", ")", "excluded_sources", "=", "OrderedSet", "(", ")", "# Add in the gyp file.", "if", "not", "generator_flags", ".", "get", "(", "'standalone'", ")", ":", "sources", ".", "add", "(", "gyp_file", ")", "# Add in 'action' inputs and outputs.", "for", "a", "in", "spec", ".", "get", "(", "'actions'", ",", "[", "]", ")", ":", "inputs", "=", "a", "[", "'inputs'", "]", "inputs", "=", "[", "_NormalizedSource", "(", "i", ")", "for", "i", "in", "inputs", "]", "# Add all inputs to sources and excluded sources.", "inputs", "=", "OrderedSet", "(", "inputs", ")", "sources", ".", "update", "(", "inputs", ")", "if", "not", "spec", ".", "get", "(", "'msvs_external_builder'", ")", ":", "excluded_sources", ".", "update", "(", "inputs", ")", "if", "int", "(", "a", ".", "get", "(", "'process_outputs_as_sources'", ",", "False", ")", ")", ":", "_AddNormalizedSources", "(", "sources", ",", "a", ".", "get", "(", "'outputs'", ",", "[", "]", ")", ")", "# Add in 'copies' inputs and outputs.", "for", "cpy", "in", "spec", ".", "get", "(", "'copies'", ",", "[", "]", ")", ":", "_AddNormalizedSources", "(", "sources", ",", "cpy", ".", "get", "(", "'files'", ",", "[", "]", ")", ")", "return", "(", "sources", ",", "excluded_sources", ")" ]

[ "Find", "and", "return", "a", "cell", "magic", "by", "name", "." ]

[ "def", "find_cell_magic", "(", "self", ",", "magic_name", ")", ":", "return", "self", ".", "magics_manager", ".", "magics", "[", "'cell'", "]", ".", "get", "(", "magic_name", ")" ]

[ "Integers", "are", "their", "own", "numerators", "." ]

[ "def", "numerator", "(", "self", ")", ":", "return", "+", "self" ]

[ "Converts", "an", "XML", "string", "into", "a", "ProfileEntry", "object", "." ]

[ "def", "ProfileEntryFromString", "(", "xml_string", ")", ":", "return", "atom", ".", "CreateClassFromXMLString", "(", "ProfileEntry", ",", "xml_string", ")" ]

[ "Check", "if", "current", "position", "is", "inside", "template", "argument", "list", "." ]

[ "def", "InTemplateArgumentList", "(", "self", ",", "clean_lines", ",", "linenum", ",", "pos", ")", ":", "while", "linenum", "<", "clean_lines", ".", "NumLines", "(", ")", ":", "# Find the earliest character that might indicate a template argument", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "match", "=", "Match", "(", "r'^[^{};=\\[\\]\\.<>]*(.)'", ",", "line", "[", "pos", ":", "]", ")", "if", "not", "match", ":", "linenum", "+=", "1", "pos", "=", "0", "continue", "token", "=", "match", ".", "group", "(", "1", ")", "pos", "+=", "len", "(", "match", ".", "group", "(", "0", ")", ")", "# These things do not look like template argument list:", "# class Suspect {", "# class Suspect x; }", "if", "token", "in", "(", "'{'", ",", "'}'", ",", "';'", ")", ":", "return", "False", "# These things look like template argument list:", "# template <class Suspect>", "# template <class Suspect = default_value>", "# template <class Suspect[]>", "# template <class Suspect...>", "if", "token", "in", "(", "'>'", ",", "'='", ",", "'['", ",", "']'", ",", "'.'", ")", ":", "return", "True", "# Check if token is an unmatched '<'.", "# If not, move on to the next character.", "if", "token", "!=", "'<'", ":", "pos", "+=", "1", "if", "pos", ">=", "len", "(", "line", ")", ":", "linenum", "+=", "1", "pos", "=", "0", "continue", "# We can't be sure if we just find a single '<', and need to", "# find the matching '>'.", "(", "_", ",", "end_line", ",", "end_pos", ")", "=", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", "-", "1", ")", "if", "end_pos", "<", "0", ":", "# Not sure if template argument list or syntax error in file", "return", "False", "linenum", "=", "end_line", "pos", "=", "end_pos", "return", "False" ]

[ "Check", "if", "an", "element", "exists", "between", "the", "end", "of", "the", "active", "formatting", "elements", "and", "the", "last", "marker", ".", "If", "it", "does", "return", "it", "else", "return", "false" ]

[ "def", "elementInActiveFormattingElements", "(", "self", ",", "name", ")", ":", "for", "item", "in", "self", ".", "activeFormattingElements", "[", ":", ":", "-", "1", "]", ":", "# Check for Marker first because if it's a Marker it doesn't have a", "# name attribute.", "if", "item", "==", "Marker", ":", "break", "elif", "item", ".", "name", "==", "name", ":", "return", "item", "return", "False" ]

[ "Returns", "a", "generic", "could", "not", "<foo", ">", "failure", "message", "specialized", "for", "the", "action" ]

[ "def", "make_failure_description", "(", "self", ",", "state", ",", "name", ",", "runlevel", ")", ":", "if", "state", "==", "\"add\"", ":", "description", "=", "_", "(", "\"Cannot add service {name!s} to run-level {level!s}.\"", ")", "elif", "state", "==", "\"del\"", ":", "description", "=", "_", "(", "\"Cannot remove service {name!s} from run-level {level!s}.\"", ")", "else", ":", "description", "=", "_", "(", "\"Unknown service-action <code>{arg!s}</code> for service {name!s} in run-level {level!s}.\"", ")", "return", "description", ".", "format", "(", "arg", "=", "state", ",", "name", "=", "name", ",", "level", "=", "runlevel", ")" ]

[ "Draw", "panes", "on", "screen", ".", "If", "empty", "list", "is", "provided", "show", "all", "." ]

[ "def", "prepare", "(", "self", ",", "panes", "=", "[", "]", ")", ":", "# If we can't select a window contained in the layout, we are doing a", "# first draw", "first_draw", "=", "not", "self", ".", "selectWindow", "(", "True", ")", "did_first_draw", "=", "False", "# Prepare each registered pane", "for", "name", "in", "self", ".", "panes", ":", "if", "name", "in", "panes", "or", "len", "(", "panes", ")", "==", "0", ":", "if", "first_draw", ":", "# First window in layout will be created with :vsp, and", "# closed later", "vim", ".", "command", "(", "\":vsp\"", ")", "first_draw", "=", "False", "did_first_draw", "=", "True", "self", ".", "panes", "[", "name", "]", ".", "prepare", "(", ")", "if", "did_first_draw", ":", "# Close the split window", "vim", ".", "command", "(", "\":q\"", ")", "self", ".", "selectWindow", "(", "False", ")" ]

[ "PyApp_GetMacExitMenuItemId", "()", "-", ">", "long" ]

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

[ "TFDecorator", "-", "aware", "replacement", "for", "inspect", ".", "isgenerator", "." ]

[ "def", "isgenerator", "(", "object", ")", ":", "# pylint: disable=redefined-builtin", "return", "_inspect", ".", "isgenerator", "(", "tf_decorator", ".", "unwrap", "(", "object", ")", "[", "1", "]", ")" ]

[ "return", "the", "base", "repr", "for", "the", "categories" ]

[ "def", "_repr_categories", "(", "self", ")", ":", "max_categories", "=", "(", "10", "if", "get_option", "(", "\"display.max_categories\"", ")", "==", "0", "else", "get_option", "(", "\"display.max_categories\"", ")", ")", "from", "pandas", ".", "io", ".", "formats", "import", "format", "as", "fmt", "if", "len", "(", "self", ".", "categories", ")", ">", "max_categories", ":", "num", "=", "max_categories", "//", "2", "head", "=", "fmt", ".", "format_array", "(", "self", ".", "categories", "[", ":", "num", "]", ",", "None", ")", "tail", "=", "fmt", ".", "format_array", "(", "self", ".", "categories", "[", "-", "num", ":", "]", ",", "None", ")", "category_strs", "=", "head", "+", "[", "\"...\"", "]", "+", "tail", "else", ":", "category_strs", "=", "fmt", ".", "format_array", "(", "self", ".", "categories", ",", "None", ")", "# Strip all leading spaces, which format_array adds for columns...", "category_strs", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "category_strs", "]", "return", "category_strs" ]

[ "Create", "and", "keep", "track", "of", "a", "new", "colonization", "plan", "for", "a", "target", "planet", "." ]

[ "def", "create_new_plan", "(", "self", ",", "target_id", ":", "int", ",", "source_id", ":", "int", ")", ":", "if", "target_id", "in", "self", ".", "_colonization_plans", ":", "warning", "(", "\"Already have a colonization plan for this planet. Doing nothing.\"", ")", "return", "self", ".", "_colonization_plans", "[", "target_id", "]", "=", "OrbitalColonizationPlan", "(", "target_id", ",", "source_id", ")" ]

[ "Detach", "node", "in", "a", "given", "replica", "group", "." ]

[ "def", "detach_node", "(", "self", ",", "hostname", ",", "servicename", ",", "config", "=", "None", ")", ":", "if", "not", "isinstance", "(", "hostname", ",", "str_type", ")", ":", "raise", "SDBTypeError", "(", "\"host must be an instance of str_type\"", ")", "if", "not", "isinstance", "(", "servicename", ",", "str_type", ")", ":", "raise", "SDBTypeError", "(", "\"service name must be an instance of str_type\"", ")", "if", "config", "is", "not", "None", "and", "not", "isinstance", "(", "config", ",", "dict", ")", ":", "raise", "SDBTypeError", "(", "\"config must be an instance of dict\"", ")", "if", "config", "is", "None", ":", "config", "=", "{", "}", "bson_options", "=", "bson", ".", "BSON", ".", "encode", "(", "config", ")", "rc", "=", "sdb", ".", "gp_detach_node", "(", "self", ".", "_group", ",", "hostname", ",", "servicename", ",", "bson_options", ")", "raise_if_error", "(", "rc", ",", "\"Failed to detach node\"", ")" ]

[ "Called", "by", "Weave", "to", "close", "the", "BLE", "connection", "." ]

[ "def", "CloseBle", "(", "self", ",", "connObj", ")", ":", "return" ]

[ "Sparse", "coding" ]

[ "def", "sparse_encode", "(", "X", ",", "dictionary", ",", "gram", "=", "None", ",", "cov", "=", "None", ",", "algorithm", "=", "'lasso_lars'", ",", "n_nonzero_coefs", "=", "None", ",", "alpha", "=", "None", ",", "copy_cov", "=", "True", ",", "init", "=", "None", ",", "max_iter", "=", "1000", ",", "n_jobs", "=", "1", ",", "check_input", "=", "True", ",", "verbose", "=", "0", ")", ":", "if", "check_input", ":", "if", "algorithm", "==", "'lasso_cd'", ":", "dictionary", "=", "check_array", "(", "dictionary", ",", "order", "=", "'C'", ",", "dtype", "=", "'float64'", ")", "X", "=", "check_array", "(", "X", ",", "order", "=", "'C'", ",", "dtype", "=", "'float64'", ")", "else", ":", "dictionary", "=", "check_array", "(", "dictionary", ")", "X", "=", "check_array", "(", "X", ")", "n_samples", ",", "n_features", "=", "X", ".", "shape", "n_components", "=", "dictionary", ".", "shape", "[", "0", "]", "if", "gram", "is", "None", "and", "algorithm", "!=", "'threshold'", ":", "gram", "=", "np", ".", "dot", "(", "dictionary", ",", "dictionary", ".", "T", ")", "if", "cov", "is", "None", "and", "algorithm", "!=", "'lasso_cd'", ":", "copy_cov", "=", "False", "cov", "=", "np", ".", "dot", "(", "dictionary", ",", "X", ".", "T", ")", "if", "algorithm", "in", "(", "'lars'", ",", "'omp'", ")", ":", "regularization", "=", "n_nonzero_coefs", "if", "regularization", "is", "None", ":", "regularization", "=", "min", "(", "max", "(", "n_features", "/", "10", ",", "1", ")", ",", "n_components", ")", "else", ":", "regularization", "=", "alpha", "if", "regularization", "is", "None", ":", "regularization", "=", "1.", "if", "n_jobs", "==", "1", "or", "algorithm", "==", "'threshold'", ":", "code", "=", "_sparse_encode", "(", "X", ",", "dictionary", ",", "gram", ",", "cov", "=", "cov", ",", "algorithm", "=", "algorithm", ",", "regularization", "=", "regularization", ",", "copy_cov", "=", "copy_cov", ",", "init", "=", "init", ",", "max_iter", "=", "max_iter", ",", "check_input", "=", "False", ",", "verbose", "=", "verbose", ")", "# This ensure that dimensionality of code is always 2,", "# consistant with the case n_jobs > 1", "if", "code", ".", "ndim", "==", "1", ":", "code", "=", "code", "[", "np", ".", "newaxis", ",", ":", "]", "return", "code", "# Enter parallel code block", "code", "=", "np", ".", "empty", "(", "(", "n_samples", ",", "n_components", ")", ")", "slices", "=", "list", "(", "gen_even_slices", "(", "n_samples", ",", "_get_n_jobs", "(", "n_jobs", ")", ")", ")", "code_views", "=", "Parallel", "(", "n_jobs", "=", "n_jobs", ",", "verbose", "=", "verbose", ")", "(", "delayed", "(", "_sparse_encode", ")", "(", "X", "[", "this_slice", "]", ",", "dictionary", ",", "gram", ",", "cov", "[", ":", ",", "this_slice", "]", "if", "cov", "is", "not", "None", "else", "None", ",", "algorithm", ",", "regularization", "=", "regularization", ",", "copy_cov", "=", "copy_cov", ",", "init", "=", "init", "[", "this_slice", "]", "if", "init", "is", "not", "None", "else", "None", ",", "max_iter", "=", "max_iter", ",", "check_input", "=", "False", ")", "for", "this_slice", "in", "slices", ")", "for", "this_slice", ",", "this_view", "in", "zip", "(", "slices", ",", "code_views", ")", ":", "code", "[", "this_slice", "]", "=", "this_view", "return", "code" ]

[ "Get", "a", "wrap", "node", "from", "the", "selected", "geometry", "." ]

[ "def", "get_wrap_node_from_selected", "(", ")", ":", "sel", "=", "cmds", ".", "ls", "(", "sl", "=", "True", ")", "or", "[", "]", "if", "not", "sel", ":", "raise", "RuntimeError", "(", "'No cvWrap found on selected.'", ")", "if", "cmds", ".", "nodeType", "(", "sel", "[", "0", "]", ")", "==", "'cvWrap'", ":", "return", "sel", "[", "0", "]", "history", "=", "cmds", ".", "listHistory", "(", "sel", "[", "0", "]", ",", "pdo", "=", "0", ")", "or", "[", "]", "wrap_nodes", "=", "[", "node", "for", "node", "in", "history", "if", "cmds", ".", "nodeType", "(", "node", ")", "==", "'cvWrap'", "]", "if", "not", "wrap_nodes", ":", "raise", "RuntimeError", "(", "'No cvWrap node found on {0}.'", ".", "format", "(", "sel", "[", "0", "]", ")", ")", "if", "len", "(", "wrap_nodes", ")", "==", "1", ":", "return", "wrap_nodes", "[", "0", "]", "else", ":", "# Multiple wrap nodes are deforming the mesh. Let the user choose which one", "# to use.", "return", "QtGui", ".", "QInputDialog", ".", "getItem", "(", "None", ",", "'Select cvWrap node'", ",", "'cvWrap node:'", ",", "wrap_nodes", ")" ]

[ "Same", "as", "traceback", "but", "includes", "start", "line", "of", "function", "definition", "." ]

[ "def", "traceback_with_start_lines", "(", "self", ")", ":", "return", "self", ".", "_graph", ".", "_convert_stack", "(", "# pylint: disable=protected-access", "self", ".", "_traceback", ",", "include_func_start_lineno", "=", "True", ")" ]

[ ":", "type", "A", ":", "List", "[", "int", "]", ":", "type", "B", ":", "List", "[", "int", "]", ":", "rtype", ":", "List", "[", "int", "]" ]

[ "def", "advantageCount", "(", "self", ",", "A", ",", "B", ")", ":", "sortedA", "=", "sorted", "(", "A", ")", "sortedB", "=", "sorted", "(", "B", ")", "candidates", "=", "{", "b", ":", "[", "]", "for", "b", "in", "B", "}", "others", "=", "[", "]", "j", "=", "0", "for", "a", "in", "sortedA", ":", "if", "a", ">", "sortedB", "[", "j", "]", ":", "candidates", "[", "sortedB", "[", "j", "]", "]", ".", "append", "(", "a", ")", "j", "+=", "1", "else", ":", "others", ".", "append", "(", "a", ")", "return", "[", "candidates", "[", "b", "]", ".", "pop", "(", ")", "if", "candidates", "[", "b", "]", "else", "others", ".", "pop", "(", ")", "for", "b", "in", "B", "]" ]

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

[ "def", "GetDocumentsDir", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "StandardPaths_GetDocumentsDir", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Get", "the", "count", "of", "events", "for", "the", "given", "histograms", "." ]

[ "def", "GetHistogramCount", "(", "histogram_type", ",", "histogram_name", ",", "tab", ")", ":", "histogram_json", "=", "GetHistogram", "(", "histogram_type", ",", "histogram_name", ",", "tab", ")", "histogram", "=", "json", ".", "loads", "(", "histogram_json", ")", "if", "'count'", "in", "histogram", ":", "return", "histogram", "[", "'count'", "]", "else", ":", "return", "0" ]

[ "Return", "the", "number", "of", "bits", "necessary", "to", "represent", "integer", "intval", "." ]

[ "def", "bit_length", "(", "intval", ")", ":", "assert", "isinstance", "(", "intval", ",", "INT_TYPES", ")", "if", "intval", ">=", "0", ":", "return", "len", "(", "bin", "(", "intval", ")", ")", "-", "2", "else", ":", "return", "len", "(", "bin", "(", "-", "intval", "-", "1", ")", ")", "-", "2" ]

[ "get", "variables", "from", "stream", "as", "dictionary" ]

[ "def", "get_variables", "(", "self", ",", "variable_names", "=", "None", ")", ":", "if", "isinstance", "(", "variable_names", ",", "string_types", ")", ":", "variable_names", "=", "[", "variable_names", "]", "elif", "variable_names", "is", "not", "None", ":", "variable_names", "=", "list", "(", "variable_names", ")", "self", ".", "mat_stream", ".", "seek", "(", "0", ")", "# Here we pass all the parameters in self to the reading objects", "self", ".", "initialize_read", "(", ")", "mdict", "=", "self", ".", "read_file_header", "(", ")", "mdict", "[", "'__globals__'", "]", "=", "[", "]", "while", "not", "self", ".", "end_of_stream", "(", ")", ":", "hdr", ",", "next_position", "=", "self", ".", "read_var_header", "(", ")", "name", "=", "asstr", "(", "hdr", ".", "name", ")", "if", "name", "in", "mdict", ":", "warnings", ".", "warn", "(", "'Duplicate variable name \"%s\" in stream'", "' - replacing previous with new\\n'", "'Consider mio5.varmats_from_mat to split '", "'file into single variable files'", "%", "name", ",", "MatReadWarning", ",", "stacklevel", "=", "2", ")", "if", "name", "==", "''", ":", "# can only be a matlab 7 function workspace", "name", "=", "'__function_workspace__'", "# We want to keep this raw because mat_dtype processing", "# will break the format (uint8 as mxDOUBLE_CLASS)", "process", "=", "False", "else", ":", "process", "=", "True", "if", "variable_names", "is", "not", "None", "and", "name", "not", "in", "variable_names", ":", "self", ".", "mat_stream", ".", "seek", "(", "next_position", ")", "continue", "try", ":", "res", "=", "self", ".", "read_var_array", "(", "hdr", ",", "process", ")", "except", "MatReadError", "as", "err", ":", "warnings", ".", "warn", "(", "'Unreadable variable \"%s\", because \"%s\"'", "%", "(", "name", ",", "err", ")", ",", "Warning", ",", "stacklevel", "=", "2", ")", "res", "=", "\"Read error: %s\"", "%", "err", "self", ".", "mat_stream", ".", "seek", "(", "next_position", ")", "mdict", "[", "name", "]", "=", "res", "if", "hdr", ".", "is_global", ":", "mdict", "[", "'__globals__'", "]", ".", "append", "(", "name", ")", "if", "variable_names", "is", "not", "None", ":", "variable_names", ".", "remove", "(", "name", ")", "if", "len", "(", "variable_names", ")", "==", "0", ":", "break", "return", "mdict" ]

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

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

[ "Sets", "the", "id", "of", "this", "Announcement", "." ]

[ "def", "id", "(", "self", ",", "id", ")", ":", "if", "id", "is", "None", ":", "raise", "ValueError", "(", "\"Invalid value for `id`, must not be `None`\"", ")", "# noqa: E501", "self", ".", "_id", "=", "id" ]

[ "FBX", "files", "to", "convert", "to", "fplmesh", "." ]

[ "def", "fbx_files_to_convert", "(", ")", ":", "return", "glob", ".", "glob", "(", "os", ".", "path", ".", "join", "(", "RAW_MESH_PATH", ",", "'*.fbx'", ")", ")" ]

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

[ "def", "GetLength", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextEvent_GetLength", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "a", "target", "variable", "." ]

[ "def", "set_target_variable", "(", "self", ",", "targets", ",", "variable", ",", "value", ",", "append", "=", "0", ")", ":", "if", "isinstance", "(", "targets", ",", "str", ")", ":", "targets", "=", "[", "targets", "]", "if", "isinstance", "(", "value", ",", "str", ")", ":", "value", "=", "[", "value", "]", "assert", "is_iterable", "(", "targets", ")", "assert", "isinstance", "(", "variable", ",", "basestring", ")", "assert", "is_iterable", "(", "value", ")", "if", "targets", ":", "if", "append", ":", "bjam_interface", ".", "call", "(", "\"set-target-variable\"", ",", "targets", ",", "variable", ",", "value", ",", "\"true\"", ")", "else", ":", "bjam_interface", ".", "call", "(", "\"set-target-variable\"", ",", "targets", ",", "variable", ",", "value", ")" ]

[ "Downloads", "a", "document", "from", "the", "Document", "List", "." ]

[ "def", "Download", "(", "self", ",", "entry_or_id_or_url", ",", "file_path", ",", "export_format", "=", "None", ",", "gid", "=", "None", ",", "extra_params", "=", "None", ")", ":", "if", "isinstance", "(", "entry_or_id_or_url", ",", "gdata", ".", "docs", ".", "DocumentListEntry", ")", ":", "url", "=", "entry_or_id_or_url", ".", "content", ".", "src", "else", ":", "if", "self", ".", "__RESOURCE_ID_PATTERN", ".", "match", "(", "entry_or_id_or_url", ")", ":", "url", "=", "self", ".", "_MakeContentLinkFromId", "(", "entry_or_id_or_url", ")", "else", ":", "url", "=", "entry_or_id_or_url", "if", "export_format", "is", "not", "None", ":", "if", "url", ".", "find", "(", "'/Export?'", ")", "==", "-", "1", ":", "raise", "gdata", ".", "service", ".", "Error", ",", "(", "'This entry cannot be exported '", "'as a different format'", ")", "url", "+=", "'&exportFormat=%s'", "%", "export_format", "if", "gid", "is", "not", "None", ":", "if", "url", ".", "find", "(", "'spreadsheets'", ")", "==", "-", "1", ":", "raise", "gdata", ".", "service", ".", "Error", ",", "'grid id param is not valid for this entry'", "url", "+=", "'&gid=%s'", "%", "gid", "if", "extra_params", ":", "url", "+=", "'&'", "+", "urllib", ".", "urlencode", "(", "extra_params", ")", "self", ".", "_DownloadFile", "(", "url", ",", "file_path", ")" ]

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

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

[ "Find", "an", "archive", "member", "by", "name", "from", "bottom", "to", "top", ".", "If", "tarinfo", "is", "given", "it", "is", "used", "as", "the", "starting", "point", "." ]

[ "def", "_getmember", "(", "self", ",", "name", ",", "tarinfo", "=", "None", ",", "normalize", "=", "False", ")", ":", "# Ensure that all members have been loaded.", "members", "=", "self", ".", "getmembers", "(", ")", "# Limit the member search list up to tarinfo.", "if", "tarinfo", "is", "not", "None", ":", "members", "=", "members", "[", ":", "members", ".", "index", "(", "tarinfo", ")", "]", "if", "normalize", ":", "name", "=", "os", ".", "path", ".", "normpath", "(", "name", ")", "for", "member", "in", "reversed", "(", "members", ")", ":", "if", "normalize", ":", "member_name", "=", "os", ".", "path", ".", "normpath", "(", "member", ".", "name", ")", "else", ":", "member_name", "=", "member", ".", "name", "if", "name", "==", "member_name", ":", "return", "member" ]

[ "Indicates", "that", "a", "pane", "caption", "should", "be", "visible", ".", "If", "visible", "is", "False", "no", "pane", "caption", "is", "drawn", "." ]

[ "def", "CaptionVisible", "(", "self", ",", "visible", "=", "True", ",", "left", "=", "False", ")", ":", "if", "left", ":", "self", ".", "SetFlag", "(", "self", ".", "optionCaption", ",", "False", ")", "return", "self", ".", "SetFlag", "(", "self", ".", "optionCaptionLeft", ",", "visible", ")", "self", ".", "SetFlag", "(", "self", ".", "optionCaptionLeft", ",", "False", ")", "return", "self", ".", "SetFlag", "(", "self", ".", "optionCaption", ",", "visible", ")" ]

[ "GetDefaultConfigPath", "()", "-", ">", "String" ]

[ "def", "GetDefaultConfigPath", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "FontMapper_GetDefaultConfigPath", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Determines", "the", "width", "of", "the", "line", "in", "column", "positions", "." ]

[ "def", "GetLineWidth", "(", "line", ")", ":", "if", "isinstance", "(", "line", ",", "unicode", ")", ":", "width", "=", "0", "for", "uc", "in", "unicodedata", ".", "normalize", "(", "'NFC'", ",", "line", ")", ":", "if", "unicodedata", ".", "east_asian_width", "(", "uc", ")", "in", "(", "'W'", ",", "'F'", ")", ":", "width", "+=", "2", "elif", "not", "unicodedata", ".", "combining", "(", "uc", ")", ":", "width", "+=", "1", "return", "width", "else", ":", "return", "len", "(", "line", ")" ]

[ "Calculate", "additional", "variables", "for", "use", "in", "the", "build", "(", "called", "by", "gyp", ")", "." ]

[ "def", "CalculateVariables", "(", "default_variables", ",", "params", ")", ":", "flavor", "=", "gyp", ".", "common", ".", "GetFlavor", "(", "params", ")", "if", "flavor", "==", "'mac'", ":", "default_variables", ".", "setdefault", "(", "'OS'", ",", "'mac'", ")", "elif", "flavor", "==", "'win'", ":", "default_variables", ".", "setdefault", "(", "'OS'", ",", "'win'", ")", "# Copy additional generator configuration data from VS, which is shared", "# by the Windows Ninja generator.", "import", "gyp", ".", "generator", ".", "msvs", "as", "msvs_generator", "generator_additional_non_configuration_keys", "=", "getattr", "(", "msvs_generator", ",", "'generator_additional_non_configuration_keys'", ",", "[", "]", ")", "generator_additional_path_sections", "=", "getattr", "(", "msvs_generator", ",", "'generator_additional_path_sections'", ",", "[", "]", ")", "gyp", ".", "msvs_emulation", ".", "CalculateCommonVariables", "(", "default_variables", ",", "params", ")", "else", ":", "operating_system", "=", "flavor", "if", "flavor", "==", "'android'", ":", "operating_system", "=", "'linux'", "# Keep this legacy behavior for now.", "default_variables", ".", "setdefault", "(", "'OS'", ",", "operating_system", ")" ]

[ "Logs", "an", "error", "if", "we", "see", "/", "*", "...", "*", "/", "or", "...", "that", "extend", "past", "one", "line", "." ]

[ "def", "CheckForMultilineCommentsAndStrings", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# Remove all \\\\ (escaped backslashes) from the line. They are OK, and the", "# second (escaped) slash may trigger later \\\" detection erroneously.", "line", "=", "line", ".", "replace", "(", "'\\\\\\\\'", ",", "''", ")", "if", "line", ".", "count", "(", "'/*'", ")", ">", "line", ".", "count", "(", "'*/'", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/multiline_comment'", ",", "5", ",", "'Complex multi-line /*...*/-style comment found. '", "'Lint may give bogus warnings. '", "'Consider replacing these with //-style comments, '", "'with #if 0...#endif, '", "'or with more clearly structured multi-line comments.'", ")", "if", "(", "line", ".", "count", "(", "'\"'", ")", "-", "line", ".", "count", "(", "'\\\\\"'", ")", ")", "%", "2", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/multiline_string'", ",", "5", ",", "'Multi-line string (\"...\") found. This lint script doesn\\'t '", "'do well with such strings, and may give bogus warnings. '", "'Use C++11 raw strings or concatenation instead.'", ")" ]