Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

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

[ "def", "GetOperatingSystemFamilyName", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "PlatformInformation_GetOperatingSystemFamilyName", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Decorator", "used", "to", "set", "the", "commands", "that", "can", "be", "configured", "automatically" ]

[ "def", "autoconfigure", "(", "execute_method", ")", ":", "def", "execute", "(", "self", ")", ":", "if", "not", "Configure", ".", "autoconfig", ":", "return", "execute_method", "(", "self", ")", "env", "=", "ConfigSet", ".", "ConfigSet", "(", ")", "do_config", "=", "False", "if", "self", ".", "root", ".", "find_node", "(", "self", ".", "cache_dir", ")", "==", "None", ":", "do_config", "=", "True", "else", ":", "try", ":", "env", ".", "load", "(", "os", ".", "path", ".", "join", "(", "Context", ".", "lock_dir", ",", "Options", ".", "lockfile", ")", ")", "except", "Exception", ":", "Logs", ".", "warn", "(", "'Configuring the project'", ")", "do_config", "=", "True", "else", ":", "if", "env", ".", "run_dir", "!=", "Context", ".", "run_dir", ":", "do_config", "=", "True", "else", ":", "h", "=", "0", "for", "f", "in", "env", "[", "'files'", "]", ":", "try", ":", "h", "=", "Utils", ".", "h_list", "(", "(", "h", ",", "Utils", ".", "readf", "(", "f", ",", "'rb'", ")", ")", ")", "except", "(", "IOError", ",", "EOFError", ")", ":", "pass", "# ignore missing files (will cause a rerun cause of the changed hash)", "do_config", "=", "h", "!=", "env", ".", "hash", "if", "do_config", "and", "'configure'", "not", "in", "Options", ".", "commands", ":", "Options", ".", "commands", ".", "insert", "(", "0", ",", "self", ".", "cmd", ")", "Options", ".", "commands", ".", "insert", "(", "0", ",", "'configure'", ")", "self", ".", "skip_finish_message", "=", "True", "return", "return", "execute_method", "(", "self", ")", "return", "execute" ]

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

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

[ "As", "transformers", "may", "return", "lists", "in", "some", "places", "this", "method", "can", "be", "used", "to", "enforce", "a", "list", "as", "return", "value", "." ]

[ "def", "visit_list", "(", "self", ",", "node", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "rv", "=", "self", ".", "visit", "(", "node", ",", "*", "args", ",", "*", "*", "kwargs", ")", "if", "not", "isinstance", "(", "rv", ",", "list", ")", ":", "rv", "=", "[", "rv", "]", "return", "rv" ]

[ "Implement", "an", "in", "-", "place", "binary", "method", "with", "a", "ufunc", "e", ".", "g", ".", "__iadd__", "." ]

[ "def", "_inplace_binary_method", "(", "ufunc", ",", "name", ")", ":", "def", "func", "(", "self", ",", "other", ")", ":", "return", "ufunc", "(", "self", ",", "other", ",", "out", "=", "(", "self", ",", ")", ")", "func", ".", "__name__", "=", "'__i{}__'", ".", "format", "(", "name", ")", "return", "func" ]

[ "Returns", "a", "symbolic", ".", "Expression", "over", "variables", "in", "self", ".", "context", "that", "evaluates", "to", "True", "if", "the", "inequality", "constraint", "is", "met" ]

[ "def", "inequalitySatisfiedSymbolic", "(", "self", ",", "soft", "=", "False", ")", ":", "res", "=", "self", ".", "inequalityResidualSymbolic", "(", "soft", ")", "if", "res", "is", "None", ":", "return", "None", "return", "res", "<=", "0" ]

[ "Drop", "options", "that", "weren", "t", "parsed", "(", "e", ".", "g", ".", "-", "w", ")", "convert", "to", "a", "dict" ]

[ "def", "preprocess_args", "(", "args", ":", "argparse", ".", "Namespace", ")", "->", "Mapping", "[", "AnyStr", ",", "AnyStr", "]", ":", "return", "{", "key", ":", "value", "for", "key", ",", "value", "in", "vars", "(", "args", ")", ".", "items", "(", ")", "if", "value", "}" ]

[ "Logs", "an", "error", "if", "a", "Copyright", "message", "appears", "at", "the", "top", "of", "the", "file", "." ]

[ "def", "CheckForCopyright", "(", "filename", ",", "lines", ",", "error", ")", ":", "# We'll check up to line 10. Don't forget there's a", "# dummy line at the front.", "for", "line", "in", "xrange", "(", "1", ",", "min", "(", "len", "(", "lines", ")", ",", "11", ")", ")", ":", "if", "_RE_COPYRIGHT", ".", "search", "(", "lines", "[", "line", "]", ",", "re", ".", "I", ")", ":", "error", "(", "filename", ",", "0", ",", "'legal/copyright'", ",", "5", ",", "'Copyright message found. '", "'You should not include a copyright line.'", ")" ]

[ "Define", "a", "trace", "callback", "for", "the", "variable", "." ]

[ "def", "trace_variable", "(", "self", ",", "mode", ",", "callback", ")", ":", "# TODO: Add deprecation warning", "cbname", "=", "self", ".", "_register", "(", "callback", ")", "self", ".", "_tk", ".", "call", "(", "\"trace\"", ",", "\"variable\"", ",", "self", ".", "_name", ",", "mode", ",", "cbname", ")", "return", "cbname" ]

[ "Converts", "a", "list", "of", "sequences", "into", "a", "Numpy", "matrix", "." ]

[ "def", "sequences_to_matrix", "(", "self", ",", "sequences", ",", "mode", "=", "'binary'", ")", ":", "if", "not", "self", ".", "num_words", ":", "if", "self", ".", "word_index", ":", "num_words", "=", "len", "(", "self", ".", "word_index", ")", "+", "1", "else", ":", "raise", "ValueError", "(", "'Specify a dimension (num_words argument), '", "'or fit on some text data first.'", ")", "else", ":", "num_words", "=", "self", ".", "num_words", "if", "mode", "==", "'tfidf'", "and", "not", "self", ".", "document_count", ":", "raise", "ValueError", "(", "'Fit the Tokenizer on some data '", "'before using tfidf mode.'", ")", "x", "=", "np", ".", "zeros", "(", "(", "len", "(", "sequences", ")", ",", "num_words", ")", ")", "for", "i", ",", "seq", "in", "enumerate", "(", "sequences", ")", ":", "if", "not", "seq", ":", "continue", "counts", "=", "{", "}", "for", "j", "in", "seq", ":", "if", "j", ">=", "num_words", ":", "continue", "if", "j", "not", "in", "counts", ":", "counts", "[", "j", "]", "=", "1.", "else", ":", "counts", "[", "j", "]", "+=", "1", "for", "j", ",", "c", "in", "list", "(", "counts", ".", "items", "(", ")", ")", ":", "if", "mode", "==", "'count'", ":", "x", "[", "i", "]", "[", "j", "]", "=", "c", "elif", "mode", "==", "'freq'", ":", "x", "[", "i", "]", "[", "j", "]", "=", "c", "/", "len", "(", "seq", ")", "elif", "mode", "==", "'binary'", ":", "x", "[", "i", "]", "[", "j", "]", "=", "1", "elif", "mode", "==", "'tfidf'", ":", "# Use weighting scheme 2 in", "# https://en.wikipedia.org/wiki/Tf%E2%80%93idf", "tf", "=", "1", "+", "np", ".", "log", "(", "c", ")", "idf", "=", "np", ".", "log", "(", "1", "+", "self", ".", "document_count", "/", "(", "1", "+", "self", ".", "index_docs", ".", "get", "(", "j", ",", "0", ")", ")", ")", "x", "[", "i", "]", "[", "j", "]", "=", "tf", "*", "idf", "else", ":", "raise", "ValueError", "(", "'Unknown vectorization mode:'", ",", "mode", ")", "return", "x" ]

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

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

[ "This", "function", "stores", "the", "given", "unsigned", "integer", "array", "in", "a", "minimalist", "binary", "file", "format", ".", "The", "last", "dimension", "is", "interpreted", "as", "corresponding", "to", "the", "channels", "of", "the", "image", ".", "The", "file", "format", "consists", "of", "a", "sequence", "of", "unsigned", "least", "significant", "bit", "first", "32", "-", "bit", "integers", ".", "The", "contained", "data", "is", "described", "below", ":", "-", "Version", ":", "File", "format", "version", "should", "be", "1", ".", "-", "nChannel", ":", "The", "number", "of", "color", "channels", "in", "the", "image", ".", "This", "should", "be", "a", "value", "between", "1", "(", "greyscale", ")", "and", "4", "(", "RGBA", ")", ".", "-", "nDimension", ":", "The", "number", "of", "dimensions", "of", "the", "stored", "array", "i", ".", "e", ".", "the", "number", "of", "indices", "required", "to", "uniquely", "identify", "one", "pixel", "voxel", "etc", "..", "-", "Shape", "[", "nDimension", "]", ":", "nDimension", "integers", "providing", "the", "size", "of", "the", "array", "along", "each", "dimension", ".", "By", "convention", "the", "first", "dimension", "is", "height", "second", "width", "and", "third", "depth", ".", "-", "Data", "[", "Shape", "[", "0", "]", "*", "...", "*", "Shape", "[", "nDimension", "-", "1", "]", "*", "nChannel", "]", ":", "The", "uncompressed", "data", "of", "the", "array", ".", "The", "channels", "are", "unrolled", "first", "followed", "by", "all", "dimensions", "in", "reverse", "order", ".", "Thus", "an", "RG", "image", "of", "size", "3", "*", "2", "would", "be", "stored", "in", "the", "following", "order", ":", "00R", "00G", "01R", "01G", "10R", "10G", "11R", "11G", "20R", "20G", "21R", "21G" ]

[ "def", "StoreNDTextureHDR", "(", "Array", ",", "OutputFilePath", ")", ":", "# Prepare all the meta data and the data itself", "Array", "=", "np", ".", "asarray", "(", "Array", ",", "dtype", "=", "np", ".", "uint32", ")", "Version", "=", "1", "nDimension", "=", "len", "(", "Array", ".", "shape", ")", "-", "1", "nChannel", "=", "Array", ".", "shape", "[", "nDimension", "]", "Shape", "=", "Array", ".", "shape", "[", "0", ":", "nDimension", "]", "Data", "=", "Array", ".", "flatten", "(", "\"C\"", ")", "# Write it to the file", "OutputFile", "=", "open", "(", "OutputFilePath", ",", "\"wb\"", ")", "OutputFile", ".", "write", "(", "struct", ".", "pack", "(", "\"LLL\"", ",", "Version", ",", "nChannel", ",", "nDimension", ")", ")", "OutputFile", ".", "write", "(", "struct", ".", "pack", "(", "\"L\"", "*", "nDimension", ",", "*", "Shape", ")", ")", "OutputFile", ".", "write", "(", "struct", ".", "pack", "(", "\"L\"", "*", "np", ".", "size", "(", "Data", ")", ",", "*", "Data", ")", ")", "OutputFile", ".", "close", "(", ")" ]

[ "Reset", "state" ]

[ "def", "reset", "(", "self", ")", ":", "super", "(", "DataSets", ",", "self", ")", ".", "reset", "(", ")", "self", ".", "background", ".", "reset", "(", ")" ]

[ "Initialize", "a", "dialog", "." ]

[ "def", "__init__", "(", "self", ",", "parent", ",", "title", "=", "None", ")", ":", "Toplevel", ".", "__init__", "(", "self", ",", "parent", ")", "self", ".", "withdraw", "(", ")", "# remain invisible for now", "# If the master is not viewable, don't", "# make the child transient, or else it", "# would be opened withdrawn", "if", "parent", ".", "winfo_viewable", "(", ")", ":", "self", ".", "transient", "(", "parent", ")", "if", "title", ":", "self", ".", "title", "(", "title", ")", "self", ".", "parent", "=", "parent", "self", ".", "result", "=", "None", "body", "=", "Frame", "(", "self", ")", "self", ".", "initial_focus", "=", "self", ".", "body", "(", "body", ")", "body", ".", "pack", "(", "padx", "=", "5", ",", "pady", "=", "5", ")", "self", ".", "buttonbox", "(", ")", "if", "not", "self", ".", "initial_focus", ":", "self", ".", "initial_focus", "=", "self", "self", ".", "protocol", "(", "\"WM_DELETE_WINDOW\"", ",", "self", ".", "cancel", ")", "if", "self", ".", "parent", "is", "not", "None", ":", "self", ".", "geometry", "(", "\"+%d+%d\"", "%", "(", "parent", ".", "winfo_rootx", "(", ")", "+", "50", ",", "parent", ".", "winfo_rooty", "(", ")", "+", "50", ")", ")", "self", ".", "deiconify", "(", ")", "# become visibile now", "self", ".", "initial_focus", ".", "focus_set", "(", ")", "# wait for window to appear on screen before calling grab_set", "self", ".", "wait_visibility", "(", ")", "self", ".", "grab_set", "(", ")", "self", ".", "wait_window", "(", "self", ")" ]

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

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

[ "Modifies", "the", "trainable", "parameters", "of", "the", "network", "layers", "using", "the", "accumulated", "gradients", "and", "previous", "steps", "history", "(", "moment", "etc", ".", ")", "." ]

[ "def", "train", "(", "self", ")", ":", "self", ".", "_internal", ".", "train", "(", ")" ]

[ "Moves", "the", "position", "of", "the", "current", "instance", "to", "the", "attribute", "with", "the", "specified", "qualified", "name", "." ]

[ "def", "MoveToAttribute", "(", "self", ",", "name", ")", ":", "ret", "=", "libxml2mod", ".", "xmlTextReaderMoveToAttribute", "(", "self", ".", "_o", ",", "name", ")", "return", "ret" ]

[ "Overridden", "from", "Function" ]

[ "def", "WriteValidationCode", "(", "self", ",", "file", ")", ":", "self", ".", "type_handler", ".", "WriteImmediateValidationCode", "(", "self", ",", "file", ")" ]

[ "Remove", "the", "data", "item", "before", "the", "current", "one" ]

[ "def", "remove_last_added_data", "(", "self", ")", ":", "self", ".", "remove_nth_last_entry", "(", "2", ")" ]

[ "Load", "tvm", "object", "as", "json", "string", "." ]

[ "def", "save_json", "(", "node", ")", ":", "return", "_api_internal", ".", "_save_json", "(", "node", ")" ]

[ "Downloads", "S3", "objects", "using", "process", "pools" ]

[ "def", "__init__", "(", "self", ",", "client_kwargs", "=", "None", ",", "config", "=", "None", ")", ":", "if", "client_kwargs", "is", "None", ":", "client_kwargs", "=", "{", "}", "self", ".", "_client_factory", "=", "ClientFactory", "(", "client_kwargs", ")", "self", ".", "_transfer_config", "=", "config", "if", "config", "is", "None", ":", "self", ".", "_transfer_config", "=", "ProcessTransferConfig", "(", ")", "self", ".", "_download_request_queue", "=", "multiprocessing", ".", "Queue", "(", "1000", ")", "self", ".", "_worker_queue", "=", "multiprocessing", ".", "Queue", "(", "1000", ")", "self", ".", "_osutil", "=", "OSUtils", "(", ")", "self", ".", "_started", "=", "False", "self", ".", "_start_lock", "=", "threading", ".", "Lock", "(", ")", "# These below are initialized in the start() method", "self", ".", "_manager", "=", "None", "self", ".", "_transfer_monitor", "=", "None", "self", ".", "_submitter", "=", "None", "self", ".", "_workers", "=", "[", "]" ]

[ "Quotes", "a", "string", "if", "it", "is", "not", "already", "quoted" ]

[ "def", "shell_quote", "(", "s", ")", ":", "return", "(", "s", "if", "isinstance", "(", "s", ",", "ShellQuoted", ")", "else", "ShellQuoted", "(", "\"'\"", "+", "str", "(", "s", ")", ".", "replace", "(", "\"'\"", ",", "\"'\\\\''\"", ")", "+", "\"'\"", ")", ")" ]

[ "reset", "=", "-", "1", "---", "initialize", "reset", "=", "0", "---", "crack", "the", "line", "reset", "=", "1", "---", "final", "check", "if", "mismatch", "of", "blocks", "occurred" ]

[ "def", "crackline", "(", "line", ",", "reset", "=", "0", ")", ":", "global", "beginpattern", ",", "groupcounter", ",", "groupname", ",", "groupcache", ",", "grouplist", "global", "filepositiontext", ",", "currentfilename", ",", "neededmodule", ",", "expectbegin", "global", "skipblocksuntil", ",", "skipemptyends", ",", "previous_context", ",", "gotnextfile", "_", ",", "has_semicolon", "=", "split_by_unquoted", "(", "line", ",", "\";\"", ")", "if", "has_semicolon", "and", "not", "(", "f2pyenhancementspattern", "[", "0", "]", ".", "match", "(", "line", ")", "or", "multilinepattern", "[", "0", "]", ".", "match", "(", "line", ")", ")", ":", "# XXX: non-zero reset values need testing", "assert", "reset", "==", "0", ",", "repr", "(", "reset", ")", "# split line on unquoted semicolons", "line", ",", "semicolon_line", "=", "split_by_unquoted", "(", "line", ",", "\";\"", ")", "while", "semicolon_line", ":", "crackline", "(", "line", ",", "reset", ")", "line", ",", "semicolon_line", "=", "split_by_unquoted", "(", "semicolon_line", "[", "1", ":", "]", ",", "\";\"", ")", "crackline", "(", "line", ",", "reset", ")", "return", "if", "reset", "<", "0", ":", "groupcounter", "=", "0", "groupname", "=", "{", "groupcounter", ":", "''", "}", "groupcache", "=", "{", "groupcounter", ":", "{", "}", "}", "grouplist", "=", "{", "groupcounter", ":", "[", "]", "}", "groupcache", "[", "groupcounter", "]", "[", "'body'", "]", "=", "[", "]", "groupcache", "[", "groupcounter", "]", "[", "'vars'", "]", "=", "{", "}", "groupcache", "[", "groupcounter", "]", "[", "'block'", "]", "=", "''", "groupcache", "[", "groupcounter", "]", "[", "'name'", "]", "=", "''", "neededmodule", "=", "-", "1", "skipblocksuntil", "=", "-", "1", "return", "if", "reset", ">", "0", ":", "fl", "=", "0", "if", "f77modulename", "and", "neededmodule", "==", "groupcounter", ":", "fl", "=", "2", "while", "groupcounter", ">", "fl", ":", "outmess", "(", "'crackline: groupcounter=%s groupname=%s\\n'", "%", "(", "repr", "(", "groupcounter", ")", ",", "repr", "(", "groupname", ")", ")", ")", "outmess", "(", "'crackline: Mismatch of blocks encountered. Trying to fix it by assuming \"end\" statement.\\n'", ")", "grouplist", "[", "groupcounter", "-", "1", "]", ".", "append", "(", "groupcache", "[", "groupcounter", "]", ")", "grouplist", "[", "groupcounter", "-", "1", "]", "[", "-", "1", "]", "[", "'body'", "]", "=", "grouplist", "[", "groupcounter", "]", "del", "grouplist", "[", "groupcounter", "]", "groupcounter", "=", "groupcounter", "-", "1", "if", "f77modulename", "and", "neededmodule", "==", "groupcounter", ":", "grouplist", "[", "groupcounter", "-", "1", "]", ".", "append", "(", "groupcache", "[", "groupcounter", "]", ")", "grouplist", "[", "groupcounter", "-", "1", "]", "[", "-", "1", "]", "[", "'body'", "]", "=", "grouplist", "[", "groupcounter", "]", "del", "grouplist", "[", "groupcounter", "]", "groupcounter", "=", "groupcounter", "-", "1", "# end interface", "grouplist", "[", "groupcounter", "-", "1", "]", ".", "append", "(", "groupcache", "[", "groupcounter", "]", ")", "grouplist", "[", "groupcounter", "-", "1", "]", "[", "-", "1", "]", "[", "'body'", "]", "=", "grouplist", "[", "groupcounter", "]", "del", "grouplist", "[", "groupcounter", "]", "groupcounter", "=", "groupcounter", "-", "1", "# end module", "neededmodule", "=", "-", "1", "return", "if", "line", "==", "''", ":", "return", "flag", "=", "0", "for", "pat", "in", "[", "dimensionpattern", ",", "externalpattern", ",", "intentpattern", ",", "optionalpattern", ",", "requiredpattern", ",", "parameterpattern", ",", "datapattern", ",", "publicpattern", ",", "privatepattern", ",", "intrisicpattern", ",", "endifpattern", ",", "endpattern", ",", "formatpattern", ",", "beginpattern", ",", "functionpattern", ",", "subroutinepattern", ",", "implicitpattern", ",", "typespattern", ",", "commonpattern", ",", "callpattern", ",", "usepattern", ",", "containspattern", ",", "entrypattern", ",", "f2pyenhancementspattern", ",", "multilinepattern", "]", ":", "m", "=", "pat", "[", "0", "]", ".", "match", "(", "line", ")", "if", "m", ":", "break", "flag", "=", "flag", "+", "1", "if", "not", "m", ":", "re_1", "=", "crackline_re_1", "if", "0", "<=", "skipblocksuntil", "<=", "groupcounter", ":", "return", "if", "'externals'", "in", "groupcache", "[", "groupcounter", "]", ":", "for", "name", "in", "groupcache", "[", "groupcounter", "]", "[", "'externals'", "]", ":", "if", "name", "in", "invbadnames", ":", "name", "=", "invbadnames", "[", "name", "]", "if", "'interfaced'", "in", "groupcache", "[", "groupcounter", "]", "and", "name", "in", "groupcache", "[", "groupcounter", "]", "[", "'interfaced'", "]", ":", "continue", "m1", "=", "re", ".", "match", "(", "r'(?P<before>[^\"]*)\\b%s\\b\\s*@\\(@(?P<args>[^@]*)@\\)@.*\\Z'", "%", "name", ",", "markouterparen", "(", "line", ")", ",", "re", ".", "I", ")", "if", "m1", ":", "m2", "=", "re_1", ".", "match", "(", "m1", ".", "group", "(", "'before'", ")", ")", "a", "=", "_simplifyargs", "(", "m1", ".", "group", "(", "'args'", ")", ")", "if", "m2", ":", "line", "=", "'callfun %s(%s) result (%s)'", "%", "(", "name", ",", "a", ",", "m2", ".", "group", "(", "'result'", ")", ")", "else", ":", "line", "=", "'callfun %s(%s)'", "%", "(", "name", ",", "a", ")", "m", "=", "callfunpattern", "[", "0", "]", ".", "match", "(", "line", ")", "if", "not", "m", ":", "outmess", "(", "'crackline: could not resolve function call for line=%s.\\n'", "%", "repr", "(", "line", ")", ")", "return", "analyzeline", "(", "m", ",", "'callfun'", ",", "line", ")", "return", "if", "verbose", ">", "1", "or", "(", "verbose", "==", "1", "and", "currentfilename", ".", "lower", "(", ")", ".", "endswith", "(", "'.pyf'", ")", ")", ":", "previous_context", "=", "None", "outmess", "(", "'crackline:%d: No pattern for line\\n'", "%", "(", "groupcounter", ")", ")", "return", "elif", "pat", "[", "1", "]", "==", "'end'", ":", "if", "0", "<=", "skipblocksuntil", "<", "groupcounter", ":", "groupcounter", "=", "groupcounter", "-", "1", "if", "skipblocksuntil", "<=", "groupcounter", ":", "return", "if", "groupcounter", "<=", "0", ":", "raise", "Exception", "(", "'crackline: groupcounter(=%s) is nonpositive. '", "'Check the blocks.'", "%", "(", "groupcounter", ")", ")", "m1", "=", "beginpattern", "[", "0", "]", ".", "match", "(", "(", "line", ")", ")", "if", "(", "m1", ")", "and", "(", "not", "m1", ".", "group", "(", "'this'", ")", "==", "groupname", "[", "groupcounter", "]", ")", ":", "raise", "Exception", "(", "'crackline: End group %s does not match with '", "'previous Begin group %s\\n\\t%s'", "%", "(", "repr", "(", "m1", ".", "group", "(", "'this'", ")", ")", ",", "repr", "(", "groupname", "[", "groupcounter", "]", ")", ",", "filepositiontext", ")", ")", "if", "skipblocksuntil", "==", "groupcounter", ":", "skipblocksuntil", "=", "-", "1", "grouplist", "[", "groupcounter", "-", "1", "]", ".", "append", "(", "groupcache", "[", "groupcounter", "]", ")", "grouplist", "[", "groupcounter", "-", "1", "]", "[", "-", "1", "]", "[", "'body'", "]", "=", "grouplist", "[", "groupcounter", "]", "del", "grouplist", "[", "groupcounter", "]", "groupcounter", "=", "groupcounter", "-", "1", "if", "not", "skipemptyends", ":", "expectbegin", "=", "1", "elif", "pat", "[", "1", "]", "==", "'begin'", ":", "if", "0", "<=", "skipblocksuntil", "<=", "groupcounter", ":", "groupcounter", "=", "groupcounter", "+", "1", "return", "gotnextfile", "=", "0", "analyzeline", "(", "m", ",", "pat", "[", "1", "]", ",", "line", ")", "expectbegin", "=", "0", "elif", "pat", "[", "1", "]", "==", "'endif'", ":", "pass", "elif", "pat", "[", "1", "]", "==", "'contains'", ":", "if", "ignorecontains", ":", "return", "if", "0", "<=", "skipblocksuntil", "<=", "groupcounter", ":", "return", "skipblocksuntil", "=", "groupcounter", "else", ":", "if", "0", "<=", "skipblocksuntil", "<=", "groupcounter", ":", "return", "analyzeline", "(", "m", ",", "pat", "[", "1", "]", ",", "line", ")" ]

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

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

[ "Return", "a", "node", "which", "produces", "a", "ScatterElementsUpdate", "operation", "." ]

[ "def", "scatter_elements_update", "(", "data", ":", "NodeInput", ",", "indices", ":", "NodeInput", ",", "updates", ":", "NodeInput", ",", "axis", ":", "NodeInput", ",", "name", ":", "Optional", "[", "str", "]", "=", "None", ",", ")", "->", "Node", ":", "return", "_get_node_factory_opset3", "(", ")", ".", "create", "(", "\"ScatterElementsUpdate\"", ",", "as_nodes", "(", "data", ",", "indices", ",", "updates", ",", "axis", ")", ")" ]

[ "Replaces", "object", "file", "names", "with", "a", "temporary", "list", "file", "using", "a", "list", "format", "depending", "on", "the", "EXPAND_LIBS_LIST_STYLE", "variable" ]

[ "def", "makelist", "(", "self", ")", ":", "objs", "=", "[", "o", "for", "o", "in", "self", "if", "isObject", "(", "o", ")", "]", "if", "not", "len", "(", "objs", ")", ":", "return", "fd", ",", "tmp", "=", "tempfile", ".", "mkstemp", "(", "suffix", "=", "\".list\"", ",", "dir", "=", "os", ".", "curdir", ")", "if", "conf", ".", "EXPAND_LIBS_LIST_STYLE", "==", "\"linkerscript\"", ":", "content", "=", "[", "'INPUT(\"%s\")\\n'", "%", "obj", "for", "obj", "in", "objs", "]", "ref", "=", "tmp", "elif", "conf", ".", "EXPAND_LIBS_LIST_STYLE", "==", "\"filelist\"", ":", "content", "=", "[", "\"%s\\n\"", "%", "obj", "for", "obj", "in", "objs", "]", "ref", "=", "\"-Wl,-filelist,\"", "+", "tmp", "elif", "conf", ".", "EXPAND_LIBS_LIST_STYLE", "==", "\"list\"", ":", "content", "=", "[", "\"%s\\n\"", "%", "obj", "for", "obj", "in", "objs", "]", "ref", "=", "\"@\"", "+", "tmp", "else", ":", "os", ".", "close", "(", "fd", ")", "os", ".", "remove", "(", "tmp", ")", "return", "self", ".", "tmp", ".", "append", "(", "tmp", ")", "f", "=", "os", ".", "fdopen", "(", "fd", ",", "\"w\"", ")", "f", ".", "writelines", "(", "content", ")", "f", ".", "close", "(", ")", "idx", "=", "self", ".", "index", "(", "objs", "[", "0", "]", ")", "newlist", "=", "self", "[", "0", ":", "idx", "]", "+", "[", "ref", "]", "+", "[", "item", "for", "item", "in", "self", "[", "idx", ":", "]", "if", "item", "not", "in", "objs", "]", "self", "[", "0", ":", "]", "=", "newlist" ]

[ "Sets", "the", "indentation", "for", ":", "class", ":", "CustomTreeCtrl", "." ]

[ "def", "SetIndent", "(", "self", ",", "indent", ")", ":", "self", ".", "_indent", "=", "indent", "self", ".", "_dirty", "=", "True" ]

[ "Recurrently", "independent", "Gated", "Recurrent", "Unit", "(", "GRU", ")", "with", "nunits", "cells", "." ]

[ "def", "call", "(", "self", ",", "inputs", ",", "state", ")", ":", "gate_inputs", "=", "math_ops", ".", "matmul", "(", "inputs", ",", "self", ".", "_gate_kernel_w", ")", "+", "(", "gen_array_ops", ".", "tile", "(", "state", ",", "[", "1", ",", "2", "]", ")", "*", "self", ".", "_gate_kernel_u", ")", "gate_inputs", "=", "nn_ops", ".", "bias_add", "(", "gate_inputs", ",", "self", ".", "_gate_bias", ")", "value", "=", "math_ops", ".", "sigmoid", "(", "gate_inputs", ")", "r", ",", "u", "=", "array_ops", ".", "split", "(", "value", "=", "value", ",", "num_or_size_splits", "=", "2", ",", "axis", "=", "1", ")", "r_state", "=", "r", "*", "state", "candidate", "=", "math_ops", ".", "matmul", "(", "inputs", ",", "self", ".", "_candidate_kernel_w", ")", "+", "(", "r_state", "*", "self", ".", "_candidate_kernel_u", ")", "candidate", "=", "nn_ops", ".", "bias_add", "(", "candidate", ",", "self", ".", "_candidate_bias", ")", "c", "=", "self", ".", "_activation", "(", "candidate", ")", "new_h", "=", "u", "*", "state", "+", "(", "1", "-", "u", ")", "*", "c", "return", "new_h", ",", "new_h" ]

[ "Issue", "the", "warning", "message", "if", "warn", "flag", "is", "on" ]

[ "def", "warning", "(", "self", ",", "warningString", ")", ":", "if", "self", ".", "__warning", ":", "message", "=", "str", "(", "warningString", ")", "if", "Notifier", ".", "showTime", ".", "getValue", "(", ")", ":", "string", "=", "(", "self", ".", "getTime", "(", ")", "+", "self", ".", "__name", "+", "'(warning): '", "+", "message", ")", "else", ":", "string", "=", "(", "\":\"", "+", "self", ".", "__name", "+", "'(warning): '", "+", "message", ")", "self", ".", "__log", "(", "string", ")", "self", ".", "__print", "(", "string", ")", "return", "1" ]

[ "Return", "the", "output", "(", "full", "output", "path", ")", "of", "a", "gyp", "spec", "." ]

[ "def", "ComputeOutput", "(", "self", ",", "spec", ")", ":", "if", "self", ".", "type", "==", "'executable'", "and", "self", ".", "toolset", "==", "'host'", ":", "# We install host executables into shared_intermediate_dir so they can be", "# run by gyp rules that refer to PRODUCT_DIR.", "path", "=", "'$(gyp_shared_intermediate_dir)'", "elif", "self", ".", "type", "==", "'shared_library'", ":", "if", "self", ".", "toolset", "==", "'host'", ":", "path", "=", "'$(HOST_OUT_INTERMEDIATE_LIBRARIES)'", "else", ":", "path", "=", "'$(TARGET_OUT_INTERMEDIATE_LIBRARIES)'", "else", ":", "# Other targets just get built into their intermediate dir.", "if", "self", ".", "toolset", "==", "'host'", ":", "path", "=", "'$(call intermediates-dir-for,%s,%s,true)'", "%", "(", "self", ".", "android_class", ",", "self", ".", "android_module", ")", "else", ":", "path", "=", "'$(call intermediates-dir-for,%s,%s)'", "%", "(", "self", ".", "android_class", ",", "self", ".", "android_module", ")", "assert", "spec", ".", "get", "(", "'product_dir'", ")", "is", "None", "# TODO: not supported?", "return", "os", ".", "path", ".", "join", "(", "path", ",", "self", ".", "ComputeOutputBasename", "(", "spec", ")", ")" ]

[ "Evaluates", "and", "accumulates", "evaluation", "metric", "on", "outputs", "of", "the", "last", "forward", "computation", ".", "Subclass", "should", "override", "this", "method", "if", "needed", "." ]

[ "def", "update_metric", "(", "self", ",", "eval_metric", ",", "labels", ")", ":", "if", "self", ".", "_label_shapes", "is", "None", ":", "# since we do not need labels, we are probably not a module with a loss", "# function or predictions, so just ignore this call", "return", "# by default we expect our outputs are some scores that could be evaluated", "eval_metric", ".", "update", "(", "labels", ",", "self", ".", "get_outputs", "(", ")", ")" ]

[ "Compatibility", "alias", "for", "Remove", "." ]

[ "def", "RemovePos", "(", "self", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "return", "self", ".", "Remove", "(", "*", "args", ",", "*", "*", "kw", ")" ]

[ "If", "capture", "is", "true", "redirect", "all", "warnings", "to", "the", "logging", "package", ".", "If", "capture", "is", "False", "ensure", "that", "warnings", "are", "not", "redirected", "to", "logging", "but", "to", "their", "original", "destinations", "." ]

[ "def", "captureWarnings", "(", "capture", ")", ":", "global", "_warnings_showwarning", "if", "capture", ":", "if", "_warnings_showwarning", "is", "None", ":", "_warnings_showwarning", "=", "warnings", ".", "showwarning", "warnings", ".", "showwarning", "=", "_showwarning", "else", ":", "if", "_warnings_showwarning", "is", "not", "None", ":", "warnings", ".", "showwarning", "=", "_warnings_showwarning", "_warnings_showwarning", "=", "None" ]

[ "Special", "initializations", ".", "To", "be", "overridden", "." ]

[ "def", "_init_special", "(", "self", ",", "*", "*", "kwargs", ")", ":", "pass" ]

[ "Parses", "a", "python", "file", "given", "as", "input", "string", "and", "returns", "the", "doxygen", "-", "compatible", "representation", "." ]

[ "def", "parse", "(", "self", ",", "input", ")", ":", "lines", "=", "input", ".", "split", "(", "\"\\n\"", ")", "for", "line", "in", "lines", ":", "self", ".", "fsm", ".", "makeTransition", "(", "line", ")", "if", "self", ".", "fsm", ".", "current_state", "==", "\"DEFCLASS\"", ":", "self", ".", "__closeComment", "(", ")", "return", "\"\\n\"", ".", "join", "(", "self", ".", "output", ")" ]

[ "The", "absolute", "path", "of", "the", "jar", "file", "required", "to", "enable", "GraphLab", "Create", "s", "integration", "with", "Apache", "Spark", "." ]

[ "def", "get_spark_integration_jar_path", "(", ")", ":", "if", "'RDD_JAR_PATH'", "not", "in", "BINARY_PATHS", ":", "raise", "RuntimeError", "(", "\"Could not find a spark integration jar. \"", "\"Does your version of GraphLab Create support Spark Integration (is it >= 1.0)?\"", ")", "return", "BINARY_PATHS", "[", "'RDD_JAR_PATH'", "]" ]

[ "Add", "v", "to", "the", "hash", "recursively", "if", "needed", "." ]

[ "def", "update", "(", "self", ",", "v", ")", ":", "self", ".", "md5", ".", "update", "(", "to_bytes", "(", "str", "(", "type", "(", "v", ")", ")", ")", ")", "if", "isinstance", "(", "v", ",", "string_class", ")", ":", "self", ".", "md5", ".", "update", "(", "to_bytes", "(", "v", ")", ")", "elif", "isinstance", "(", "v", ",", "(", "int", ",", "float", ")", ")", ":", "self", ".", "update", "(", "str", "(", "v", ")", ")", "elif", "isinstance", "(", "v", ",", "(", "tuple", ",", "list", ")", ")", ":", "for", "e", "in", "v", ":", "self", ".", "update", "(", "e", ")", "elif", "isinstance", "(", "v", ",", "dict", ")", ":", "keys", "=", "v", ".", "keys", "(", ")", "for", "k", "in", "sorted", "(", "keys", ")", ":", "self", ".", "update", "(", "k", ")", "self", ".", "update", "(", "v", "[", "k", "]", ")", "else", ":", "for", "k", "in", "dir", "(", "v", ")", ":", "if", "k", ".", "startswith", "(", "'__'", ")", ":", "continue", "a", "=", "getattr", "(", "v", ",", "k", ")", "if", "inspect", ".", "isroutine", "(", "a", ")", ":", "continue", "self", ".", "update", "(", "k", ")", "self", ".", "update", "(", "a", ")" ]

[ "Create", "an", "empty", "copy", "of", "the", "given", "cache", "." ]

[ "def", "copy_cache", "(", "cache", ")", ":", "if", "cache", "is", "None", ":", "return", "None", "elif", "type", "(", "cache", ")", "is", "dict", ":", "return", "{", "}", "return", "LRUCache", "(", "cache", ".", "capacity", ")" ]

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

[ "def", "GetSelectionAnchor", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_GetSelectionAnchor", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Adds", "the", "Numba", "break", "point", "into", "the", "source" ]

[ "def", "hook_gdb_breakpoint", "(", ")", ":", "if", "not", "sys", ".", "platform", ".", "startswith", "(", "'linux'", ")", ":", "raise", "RuntimeError", "(", "'gdb is only available on linux'", ")", "bp_impl", "=", "gen_bp_impl", "(", ")", "def", "impl", "(", ")", ":", "bp_impl", "(", ")", "return", "impl" ]

[ "End", "Pass", "Notify", "BoxPS", "that", "current", "pass", "ended", "Examples", ":", "..", "code", "-", "block", "::", "python" ]

[ "def", "end_pass", "(", "self", ",", "need_save_delta", ")", ":", "self", ".", "boxps", ".", "end_pass", "(", "need_save_delta", ")" ]

[ "Works", "like", "Argument", "Clinic", "(", "PEP", "436", ")", "to", "validate", "function", "params", "." ]

[ "def", "argument_clinic", "(", "string", ",", "want_obj", "=", "False", ",", "want_context", "=", "False", ",", "want_arguments", "=", "False", ")", ":", "def", "f", "(", "func", ")", ":", "@", "repack_with_argument_clinic", "(", "string", ",", "keep_arguments_param", "=", "True", ")", "def", "wrapper", "(", "evaluator", ",", "obj", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "arguments", "=", "kwargs", ".", "pop", "(", "'arguments'", ")", "assert", "not", "kwargs", "# Python 2...", "debug", ".", "dbg", "(", "'builtin start %s'", "%", "obj", ",", "color", "=", "'MAGENTA'", ")", "result", "=", "NO_CONTEXTS", "if", "want_context", ":", "kwargs", "[", "'context'", "]", "=", "arguments", ".", "context", "if", "want_obj", ":", "kwargs", "[", "'obj'", "]", "=", "obj", "if", "want_arguments", ":", "kwargs", "[", "'arguments'", "]", "=", "arguments", "result", "=", "func", "(", "evaluator", ",", "*", "args", ",", "*", "*", "kwargs", ")", "debug", ".", "dbg", "(", "'builtin end: %s'", ",", "result", ",", "color", "=", "'MAGENTA'", ")", "return", "result", "return", "wrapper", "return", "f" ]

[ "Processes", "a", "single", "line", "in", "the", "file", "." ]

[ "def", "ProcessLine", "(", "filename", ",", "file_extension", ",", "clean_lines", ",", "line", ",", "include_state", ",", "function_state", ",", "nesting_state", ",", "error", ",", "extra_check_functions", "=", "[", "]", ")", ":", "raw_lines", "=", "clean_lines", ".", "raw_lines", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "line", "]", ",", "line", ",", "error", ")", "nesting_state", ".", "Update", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "if", "nesting_state", ".", "stack", "and", "nesting_state", ".", "stack", "[", "-", "1", "]", ".", "inline_asm", "!=", "_NO_ASM", ":", "return", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "line", ",", "function_state", ",", "error", ")", "CheckForMultilineCommentsAndStrings", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckStyle", "(", "filename", ",", "clean_lines", ",", "line", ",", "file_extension", ",", "nesting_state", ",", "error", ")", "CheckLanguage", "(", "filename", ",", "clean_lines", ",", "line", ",", "file_extension", ",", "include_state", ",", "nesting_state", ",", "error", ")", "CheckForNonConstReference", "(", "filename", ",", "clean_lines", ",", "line", ",", "nesting_state", ",", "error", ")", "CheckForNonStandardConstructs", "(", "filename", ",", "clean_lines", ",", "line", ",", "nesting_state", ",", "error", ")", "CheckVlogArguments", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckCaffeAlternatives", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckCaffeDataLayerSetUp", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckCaffeRandom", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckPosixThreading", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckInvalidIncrement", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckMakePairUsesDeduction", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "for", "check_fn", "in", "extra_check_functions", ":", "check_fn", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")" ]

[ "Return", "or", "set", "the", "pen", "s", "attributes", "." ]

[ "def", "pen", "(", "self", ",", "pen", "=", "None", ",", "*", "*", "pendict", ")", ":", "_pd", "=", "{", "\"shown\"", ":", "self", ".", "_shown", ",", "\"pendown\"", ":", "self", ".", "_drawing", ",", "\"pencolor\"", ":", "self", ".", "_pencolor", ",", "\"fillcolor\"", ":", "self", ".", "_fillcolor", ",", "\"pensize\"", ":", "self", ".", "_pensize", ",", "\"speed\"", ":", "self", ".", "_speed", ",", "\"resizemode\"", ":", "self", ".", "_resizemode", ",", "\"stretchfactor\"", ":", "self", ".", "_stretchfactor", ",", "\"outline\"", ":", "self", ".", "_outlinewidth", ",", "\"tilt\"", ":", "self", ".", "_tilt", "}", "if", "not", "(", "pen", "or", "pendict", ")", ":", "return", "_pd", "if", "isinstance", "(", "pen", ",", "dict", ")", ":", "p", "=", "pen", "else", ":", "p", "=", "{", "}", "p", ".", "update", "(", "pendict", ")", "_p_buf", "=", "{", "}", "for", "key", "in", "p", ":", "_p_buf", "[", "key", "]", "=", "_pd", "[", "key", "]", "if", "self", ".", "undobuffer", ":", "self", ".", "undobuffer", ".", "push", "(", "(", "\"pen\"", ",", "_p_buf", ")", ")", "newLine", "=", "False", "if", "\"pendown\"", "in", "p", ":", "if", "self", ".", "_drawing", "!=", "p", "[", "\"pendown\"", "]", ":", "newLine", "=", "True", "if", "\"pencolor\"", "in", "p", ":", "if", "isinstance", "(", "p", "[", "\"pencolor\"", "]", ",", "tuple", ")", ":", "p", "[", "\"pencolor\"", "]", "=", "self", ".", "_colorstr", "(", "(", "p", "[", "\"pencolor\"", "]", ",", ")", ")", "if", "self", ".", "_pencolor", "!=", "p", "[", "\"pencolor\"", "]", ":", "newLine", "=", "True", "if", "\"pensize\"", "in", "p", ":", "if", "self", ".", "_pensize", "!=", "p", "[", "\"pensize\"", "]", ":", "newLine", "=", "True", "if", "newLine", ":", "self", ".", "_newLine", "(", ")", "if", "\"pendown\"", "in", "p", ":", "self", ".", "_drawing", "=", "p", "[", "\"pendown\"", "]", "if", "\"pencolor\"", "in", "p", ":", "self", ".", "_pencolor", "=", "p", "[", "\"pencolor\"", "]", "if", "\"pensize\"", "in", "p", ":", "self", ".", "_pensize", "=", "p", "[", "\"pensize\"", "]", "if", "\"fillcolor\"", "in", "p", ":", "if", "isinstance", "(", "p", "[", "\"fillcolor\"", "]", ",", "tuple", ")", ":", "p", "[", "\"fillcolor\"", "]", "=", "self", ".", "_colorstr", "(", "(", "p", "[", "\"fillcolor\"", "]", ",", ")", ")", "self", ".", "_fillcolor", "=", "p", "[", "\"fillcolor\"", "]", "if", "\"speed\"", "in", "p", ":", "self", ".", "_speed", "=", "p", "[", "\"speed\"", "]", "if", "\"resizemode\"", "in", "p", ":", "self", ".", "_resizemode", "=", "p", "[", "\"resizemode\"", "]", "if", "\"stretchfactor\"", "in", "p", ":", "sf", "=", "p", "[", "\"stretchfactor\"", "]", "if", "isinstance", "(", "sf", ",", "(", "int", ",", "float", ")", ")", ":", "sf", "=", "(", "sf", ",", "sf", ")", "self", ".", "_stretchfactor", "=", "sf", "if", "\"outline\"", "in", "p", ":", "self", ".", "_outlinewidth", "=", "p", "[", "\"outline\"", "]", "if", "\"shown\"", "in", "p", ":", "self", ".", "_shown", "=", "p", "[", "\"shown\"", "]", "if", "\"tilt\"", "in", "p", ":", "self", ".", "_tilt", "=", "p", "[", "\"tilt\"", "]", "self", ".", "_update", "(", ")" ]

[ "returns", "node", "color" ]

[ "def", "get_node_color", "(", "node", ")", ":", "if", "node", "is", "None", ":", "return", "BLACK", "return", "node", ".", "color" ]

[ "r", "Returns", "generator", "yielding", "marked", "up", "from", "/", "to", "side", "by", "side", "differences", "." ]

[ "def", "_mdiff", "(", "fromlines", ",", "tolines", ",", "context", "=", "None", ",", "linejunk", "=", "None", ",", "charjunk", "=", "IS_CHARACTER_JUNK", ")", ":", "import", "re", "# regular expression for finding intraline change indices", "change_re", "=", "re", ".", "compile", "(", "'(\\++|\\-+|\\^+)'", ")", "# create the difference iterator to generate the differences", "diff_lines_iterator", "=", "ndiff", "(", "fromlines", ",", "tolines", ",", "linejunk", ",", "charjunk", ")", "def", "_make_line", "(", "lines", ",", "format_key", ",", "side", ",", "num_lines", "=", "[", "0", ",", "0", "]", ")", ":", "\"\"\"Returns line of text with user's change markup and line formatting.\n\n lines -- list of lines from the ndiff generator to produce a line of\n text from. When producing the line of text to return, the\n lines used are removed from this list.\n format_key -- '+' return first line in list with \"add\" markup around\n the entire line.\n '-' return first line in list with \"delete\" markup around\n the entire line.\n '?' return first line in list with add/delete/change\n intraline markup (indices obtained from second line)\n None return first line in list with no markup\n side -- indice into the num_lines list (0=from,1=to)\n num_lines -- from/to current line number. This is NOT intended to be a\n passed parameter. It is present as a keyword argument to\n maintain memory of the current line numbers between calls\n of this function.\n\n Note, this function is purposefully not defined at the module scope so\n that data it needs from its parent function (within whose context it\n is defined) does not need to be of module scope.\n \"\"\"", "num_lines", "[", "side", "]", "+=", "1", "# Handle case where no user markup is to be added, just return line of", "# text with user's line format to allow for usage of the line number.", "if", "format_key", "is", "None", ":", "return", "(", "num_lines", "[", "side", "]", ",", "lines", ".", "pop", "(", "0", ")", "[", "2", ":", "]", ")", "# Handle case of intraline changes", "if", "format_key", "==", "'?'", ":", "text", ",", "markers", "=", "lines", ".", "pop", "(", "0", ")", ",", "lines", ".", "pop", "(", "0", ")", "# find intraline changes (store change type and indices in tuples)", "sub_info", "=", "[", "]", "def", "record_sub_info", "(", "match_object", ",", "sub_info", "=", "sub_info", ")", ":", "sub_info", ".", "append", "(", "[", "match_object", ".", "group", "(", "1", ")", "[", "0", "]", ",", "match_object", ".", "span", "(", ")", "]", ")", "return", "match_object", ".", "group", "(", "1", ")", "change_re", ".", "sub", "(", "record_sub_info", ",", "markers", ")", "# process each tuple inserting our special marks that won't be", "# noticed by an xml/html escaper.", "for", "key", ",", "(", "begin", ",", "end", ")", "in", "sub_info", "[", ":", ":", "-", "1", "]", ":", "text", "=", "text", "[", "0", ":", "begin", "]", "+", "'\\0'", "+", "key", "+", "text", "[", "begin", ":", "end", "]", "+", "'\\1'", "+", "text", "[", "end", ":", "]", "text", "=", "text", "[", "2", ":", "]", "# Handle case of add/delete entire line", "else", ":", "text", "=", "lines", ".", "pop", "(", "0", ")", "[", "2", ":", "]", "# if line of text is just a newline, insert a space so there is", "# something for the user to highlight and see.", "if", "not", "text", ":", "text", "=", "' '", "# insert marks that won't be noticed by an xml/html escaper.", "text", "=", "'\\0'", "+", "format_key", "+", "text", "+", "'\\1'", "# Return line of text, first allow user's line formatter to do its", "# thing (such as adding the line number) then replace the special", "# marks with what the user's change markup.", "return", "(", "num_lines", "[", "side", "]", ",", "text", ")", "def", "_line_iterator", "(", ")", ":", "\"\"\"Yields from/to lines of text with a change indication.\n\n This function is an iterator. It itself pulls lines from a\n differencing iterator, processes them and yields them. When it can\n it yields both a \"from\" and a \"to\" line, otherwise it will yield one\n or the other. In addition to yielding the lines of from/to text, a\n boolean flag is yielded to indicate if the text line(s) have\n differences in them.\n\n Note, this function is purposefully not defined at the module scope so\n that data it needs from its parent function (within whose context it\n is defined) does not need to be of module scope.\n \"\"\"", "lines", "=", "[", "]", "num_blanks_pending", ",", "num_blanks_to_yield", "=", "0", ",", "0", "while", "True", ":", "# Load up next 4 lines so we can look ahead, create strings which", "# are a concatenation of the first character of each of the 4 lines", "# so we can do some very readable comparisons.", "while", "len", "(", "lines", ")", "<", "4", ":", "try", ":", "lines", ".", "append", "(", "diff_lines_iterator", ".", "next", "(", ")", ")", "except", "StopIteration", ":", "lines", ".", "append", "(", "'X'", ")", "s", "=", "''", ".", "join", "(", "[", "line", "[", "0", "]", "for", "line", "in", "lines", "]", ")", "if", "s", ".", "startswith", "(", "'X'", ")", ":", "# When no more lines, pump out any remaining blank lines so the", "# corresponding add/delete lines get a matching blank line so", "# all line pairs get yielded at the next level.", "num_blanks_to_yield", "=", "num_blanks_pending", "elif", "s", ".", "startswith", "(", "'-?+?'", ")", ":", "# simple intraline change", "yield", "_make_line", "(", "lines", ",", "'?'", ",", "0", ")", ",", "_make_line", "(", "lines", ",", "'?'", ",", "1", ")", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "'--++'", ")", ":", "# in delete block, add block coming: we do NOT want to get", "# caught up on blank lines yet, just process the delete line", "num_blanks_pending", "-=", "1", "yield", "_make_line", "(", "lines", ",", "'-'", ",", "0", ")", ",", "None", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "(", "'--?+'", ",", "'--+'", ",", "'- '", ")", ")", ":", "# in delete block and see a intraline change or unchanged line", "# coming: yield the delete line and then blanks", "from_line", ",", "to_line", "=", "_make_line", "(", "lines", ",", "'-'", ",", "0", ")", ",", "None", "num_blanks_to_yield", ",", "num_blanks_pending", "=", "num_blanks_pending", "-", "1", ",", "0", "elif", "s", ".", "startswith", "(", "'-+?'", ")", ":", "# intraline change", "yield", "_make_line", "(", "lines", ",", "None", ",", "0", ")", ",", "_make_line", "(", "lines", ",", "'?'", ",", "1", ")", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "'-?+'", ")", ":", "# intraline change", "yield", "_make_line", "(", "lines", ",", "'?'", ",", "0", ")", ",", "_make_line", "(", "lines", ",", "None", ",", "1", ")", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "'-'", ")", ":", "# delete FROM line", "num_blanks_pending", "-=", "1", "yield", "_make_line", "(", "lines", ",", "'-'", ",", "0", ")", ",", "None", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "'+--'", ")", ":", "# in add block, delete block coming: we do NOT want to get", "# caught up on blank lines yet, just process the add line", "num_blanks_pending", "+=", "1", "yield", "None", ",", "_make_line", "(", "lines", ",", "'+'", ",", "1", ")", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "(", "'+ '", ",", "'+-'", ")", ")", ":", "# will be leaving an add block: yield blanks then add line", "from_line", ",", "to_line", "=", "None", ",", "_make_line", "(", "lines", ",", "'+'", ",", "1", ")", "num_blanks_to_yield", ",", "num_blanks_pending", "=", "num_blanks_pending", "+", "1", ",", "0", "elif", "s", ".", "startswith", "(", "'+'", ")", ":", "# inside an add block, yield the add line", "num_blanks_pending", "+=", "1", "yield", "None", ",", "_make_line", "(", "lines", ",", "'+'", ",", "1", ")", ",", "True", "continue", "elif", "s", ".", "startswith", "(", "' '", ")", ":", "# unchanged text, yield it to both sides", "yield", "_make_line", "(", "lines", "[", ":", "]", ",", "None", ",", "0", ")", ",", "_make_line", "(", "lines", ",", "None", ",", "1", ")", ",", "False", "continue", "# Catch up on the blank lines so when we yield the next from/to", "# pair, they are lined up.", "while", "(", "num_blanks_to_yield", "<", "0", ")", ":", "num_blanks_to_yield", "+=", "1", "yield", "None", ",", "(", "''", ",", "'\\n'", ")", ",", "True", "while", "(", "num_blanks_to_yield", ">", "0", ")", ":", "num_blanks_to_yield", "-=", "1", "yield", "(", "''", ",", "'\\n'", ")", ",", "None", ",", "True", "if", "s", ".", "startswith", "(", "'X'", ")", ":", "raise", "StopIteration", "else", ":", "yield", "from_line", ",", "to_line", ",", "True", "def", "_line_pair_iterator", "(", ")", ":", "\"\"\"Yields from/to lines of text with a change indication.\n\n This function is an iterator. It itself pulls lines from the line\n iterator. Its difference from that iterator is that this function\n always yields a pair of from/to text lines (with the change\n indication). If necessary it will collect single from/to lines\n until it has a matching pair from/to pair to yield.\n\n Note, this function is purposefully not defined at the module scope so\n that data it needs from its parent function (within whose context it\n is defined) does not need to be of module scope.\n \"\"\"", "line_iterator", "=", "_line_iterator", "(", ")", "fromlines", ",", "tolines", "=", "[", "]", ",", "[", "]", "while", "True", ":", "# Collecting lines of text until we have a from/to pair", "while", "(", "len", "(", "fromlines", ")", "==", "0", "or", "len", "(", "tolines", ")", "==", "0", ")", ":", "from_line", ",", "to_line", ",", "found_diff", "=", "line_iterator", ".", "next", "(", ")", "if", "from_line", "is", "not", "None", ":", "fromlines", ".", "append", "(", "(", "from_line", ",", "found_diff", ")", ")", "if", "to_line", "is", "not", "None", ":", "tolines", ".", "append", "(", "(", "to_line", ",", "found_diff", ")", ")", "# Once we have a pair, remove them from the collection and yield it", "from_line", ",", "fromDiff", "=", "fromlines", ".", "pop", "(", "0", ")", "to_line", ",", "to_diff", "=", "tolines", ".", "pop", "(", "0", ")", "yield", "(", "from_line", ",", "to_line", ",", "fromDiff", "or", "to_diff", ")", "# Handle case where user does not want context differencing, just yield", "# them up without doing anything else with them.", "line_pair_iterator", "=", "_line_pair_iterator", "(", ")", "if", "context", "is", "None", ":", "while", "True", ":", "yield", "line_pair_iterator", ".", "next", "(", ")", "# Handle case where user wants context differencing. We must do some", "# storage of lines until we know for sure that they are to be yielded.", "else", ":", "context", "+=", "1", "lines_to_write", "=", "0", "while", "True", ":", "# Store lines up until we find a difference, note use of a", "# circular queue because we only need to keep around what", "# we need for context.", "index", ",", "contextLines", "=", "0", ",", "[", "None", "]", "*", "(", "context", ")", "found_diff", "=", "False", "while", "(", "found_diff", "is", "False", ")", ":", "from_line", ",", "to_line", ",", "found_diff", "=", "line_pair_iterator", ".", "next", "(", ")", "i", "=", "index", "%", "context", "contextLines", "[", "i", "]", "=", "(", "from_line", ",", "to_line", ",", "found_diff", ")", "index", "+=", "1", "# Yield lines that we have collected so far, but first yield", "# the user's separator.", "if", "index", ">", "context", ":", "yield", "None", ",", "None", ",", "None", "lines_to_write", "=", "context", "else", ":", "lines_to_write", "=", "index", "index", "=", "0", "while", "(", "lines_to_write", ")", ":", "i", "=", "index", "%", "context", "index", "+=", "1", "yield", "contextLines", "[", "i", "]", "lines_to_write", "-=", "1", "# Now yield the context lines after the change", "lines_to_write", "=", "context", "-", "1", "while", "(", "lines_to_write", ")", ":", "from_line", ",", "to_line", ",", "found_diff", "=", "line_pair_iterator", ".", "next", "(", ")", "# If another change within the context, extend the context", "if", "found_diff", ":", "lines_to_write", "=", "context", "-", "1", "else", ":", "lines_to_write", "-=", "1", "yield", "from_line", ",", "to_line", ",", "found_diff" ]

[ "Return", "the", "timezone", "name", "." ]

[ "def", "tzname", "(", "self", ")", ":", "if", "self", ".", "_tzinfo", "is", "None", ":", "return", "None", "name", "=", "self", ".", "_tzinfo", ".", "tzname", "(", "None", ")", "_check_tzname", "(", "name", ")", "return", "name" ]

[ "Check", "for", "non", "-", "const", "references", "." ]

[ "def", "CheckForNonConstReference", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "# Do nothing if there is no '&' on current line.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "'&'", "not", "in", "line", ":", "return", "# If a function is inherited, current function doesn't have much of", "# a choice, so any non-const references should not be blamed on", "# derived function.", "if", "IsDerivedFunction", "(", "clean_lines", ",", "linenum", ")", ":", "return", "# Long type names may be broken across multiple lines, usually in one", "# of these forms:", "# LongType", "# ::LongTypeContinued &identifier", "# LongType::", "# LongTypeContinued &identifier", "# LongType<", "# ...>::LongTypeContinued &identifier", "#", "# If we detected a type split across two lines, join the previous", "# line to current line so that we can match const references", "# accordingly.", "#", "# Note that this only scans back one line, since scanning back", "# arbitrary number of lines would be expensive. If you have a type", "# that spans more than 2 lines, please use a typedef.", "if", "linenum", ">", "1", ":", "previous", "=", "None", "if", "Match", "(", "r'\\s*::(?:[\\w<>]|::)+\\s*&\\s*\\S'", ",", "line", ")", ":", "# previous_line\\n + ::current_line", "previous", "=", "Search", "(", "r'\\b((?:const\\s*)?(?:[\\w<>]|::)+[\\w<>])\\s*$'", ",", "clean_lines", ".", "elided", "[", "linenum", "-", "1", "]", ")", "elif", "Match", "(", "r'\\s*[a-zA-Z_]([\\w<>]|::)+\\s*&\\s*\\S'", ",", "line", ")", ":", "# previous_line::\\n + current_line", "previous", "=", "Search", "(", "r'\\b((?:const\\s*)?(?:[\\w<>]|::)+::)\\s*$'", ",", "clean_lines", ".", "elided", "[", "linenum", "-", "1", "]", ")", "if", "previous", ":", "line", "=", "previous", ".", "group", "(", "1", ")", "+", "line", ".", "lstrip", "(", ")", "else", ":", "# Check for templated parameter that is split across multiple lines", "endpos", "=", "line", ".", "rfind", "(", "'>'", ")", "if", "endpos", ">", "-", "1", ":", "(", "_", ",", "startline", ",", "startpos", ")", "=", "ReverseCloseExpression", "(", "clean_lines", ",", "linenum", ",", "endpos", ")", "if", "startpos", ">", "-", "1", "and", "startline", "<", "linenum", ":", "# Found the matching < on an earlier line, collect all", "# pieces up to current line.", "line", "=", "''", "for", "i", "in", "xrange", "(", "startline", ",", "linenum", "+", "1", ")", ":", "line", "+=", "clean_lines", ".", "elided", "[", "i", "]", ".", "strip", "(", ")", "# Check for non-const references in function parameters. A single '&' may", "# found in the following places:", "# inside expression: binary & for bitwise AND", "# inside expression: unary & for taking the address of something", "# inside declarators: reference parameter", "# We will exclude the first two cases by checking that we are not inside a", "# function body, including one that was just introduced by a trailing '{'.", "# TODO(unknown): Doesn't account for 'catch(Exception& e)' [rare].", "if", "(", "nesting_state", ".", "previous_stack_top", "and", "not", "(", "isinstance", "(", "nesting_state", ".", "previous_stack_top", ",", "_ClassInfo", ")", "or", "isinstance", "(", "nesting_state", ".", "previous_stack_top", ",", "_NamespaceInfo", ")", ")", ")", ":", "# Not at toplevel, not within a class, and not within a namespace", "return", "# Avoid initializer lists. We only need to scan back from the", "# current line for something that starts with ':'.", "#", "# We don't need to check the current line, since the '&' would", "# appear inside the second set of parentheses on the current line as", "# opposed to the first set.", "if", "linenum", ">", "0", ":", "for", "i", "in", "xrange", "(", "linenum", "-", "1", ",", "max", "(", "0", ",", "linenum", "-", "10", ")", ",", "-", "1", ")", ":", "previous_line", "=", "clean_lines", ".", "elided", "[", "i", "]", "if", "not", "Search", "(", "r'[),]\\s*$'", ",", "previous_line", ")", ":", "break", "if", "Match", "(", "r'^\\s*:\\s+\\S'", ",", "previous_line", ")", ":", "return", "# Avoid preprocessors", "if", "Search", "(", "r'\\\\\\s*$'", ",", "line", ")", ":", "return", "# Avoid constructor initializer lists", "if", "IsInitializerList", "(", "clean_lines", ",", "linenum", ")", ":", "return", "# We allow non-const references in a few standard places, like functions", "# called \"swap()\" or iostream operators like \"<<\" or \">>\". Do not check", "# those function parameters.", "#", "# We also accept & in static_assert, which looks like a function but", "# it's actually a declaration expression.", "whitelisted_functions", "=", "(", "r'(?:[sS]wap(?:<\\w:+>)?|'", "r'operator\\s*[<>][<>]|'", "r'static_assert|COMPILE_ASSERT'", "r')\\s*\\('", ")", "if", "Search", "(", "whitelisted_functions", ",", "line", ")", ":", "return", "elif", "not", "Search", "(", "r'\\S+\\([^)]*$'", ",", "line", ")", ":", "# Don't see a whitelisted function on this line. Actually we", "# didn't see any function name on this line, so this is likely a", "# multi-line parameter list. Try a bit harder to catch this case.", "for", "i", "in", "xrange", "(", "2", ")", ":", "if", "(", "linenum", ">", "i", "and", "Search", "(", "whitelisted_functions", ",", "clean_lines", ".", "elided", "[", "linenum", "-", "i", "-", "1", "]", ")", ")", ":", "return", "decls", "=", "ReplaceAll", "(", "r'{[^}]*}'", ",", "' '", ",", "line", ")", "# exclude function body", "for", "parameter", "in", "re", ".", "findall", "(", "_RE_PATTERN_REF_PARAM", ",", "decls", ")", ":", "if", "not", "Match", "(", "_RE_PATTERN_CONST_REF_PARAM", ",", "parameter", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/references'", ",", "2", ",", "'Is this a non-const reference? '", "'If so, make const or use a pointer: '", "+", "ReplaceAll", "(", "' *<'", ",", "'<'", ",", "parameter", ")", ")" ]

[ "Return", "the", "result", "of", "fmt_str", ".", "format", "(", "*", "args", "**", "kwargs", ")", "after", "transforming", "args", "and", "kwargs", "according", "to", "the", "value", "of", "use_color", ".", "If", "use_color", "is", "False", "then", "all", "color", "codes", "in", "args", "and", "kwargs", "are", "replaced", "with", "the", "empty", "string", "." ]

[ "def", "color_format", "(", "use_color", ",", "fmt_str", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "assert", "use_color", "is", "True", "or", "use_color", "is", "False", "if", "not", "use_color", ":", "args", "=", "[", "arg", "if", "not", "isinstance", "(", "arg", ",", "BenchmarkColor", ")", "else", "BC_NONE", "for", "arg", "in", "args", "]", "kwargs", "=", "{", "key", ":", "arg", "if", "not", "isinstance", "(", "arg", ",", "BenchmarkColor", ")", "else", "BC_NONE", "for", "key", ",", "arg", "in", "kwargs", ".", "items", "(", ")", "}", "return", "fmt_str", ".", "format", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Copy", "this", "distribution", "substituting", "in", "any", "changed", "keyword", "args" ]

[ "def", "clone", "(", "self", ",", "*", "*", "kw", ")", ":", "names", "=", "'project_name version py_version platform location precedence'", "for", "attr", "in", "names", ".", "split", "(", ")", ":", "kw", ".", "setdefault", "(", "attr", ",", "getattr", "(", "self", ",", "attr", ",", "None", ")", ")", "kw", ".", "setdefault", "(", "'metadata'", ",", "self", ".", "_provider", ")", "return", "self", ".", "__class__", "(", "*", "*", "kw", ")" ]

[ "Prepend", "shape", "with", "smaller", "length", "with", "1", ".", "Return", "updates", "shapes", ":", "param", "shape_1", ":", "first", "shape", ":", "param", "shape_2", ":", "second", "shape", ":", "return", ":", "tuple", "with", "updated", "shapes" ]

[ "def", "make_equal_rank", "(", "shape_1", ":", "np", ".", "ndarray", ",", "shape_2", ":", "np", ".", "ndarray", ")", ":", "while", "len", "(", "shape_1", ")", "<", "len", "(", "shape_2", ")", ":", "shape_1", "=", "shape_insert", "(", "shape_1", ",", "0", ",", "1", ")", "while", "len", "(", "shape_2", ")", "<", "len", "(", "shape_1", ")", ":", "shape_2", "=", "shape_insert", "(", "shape_2", ",", "0", ",", "1", ")", "return", "shape_1", ",", "shape_2" ]

[ "Discard", "values", "in", "list", "more", "than", "1", ".", "5", "*", "IQR", "outside", "IQR", "." ]

[ "def", "trim", "(", "l", ")", ":", "l_sort", "=", "l", "[", ":", "]", "l_sort", ".", "sort", "(", ")", "# Calculate medianscore (based on stats.py lmedianscore by Gary Strangman)", "if", "len", "(", "l_sort", ")", "%", "2", "==", "0", ":", "# If even number of scores, average middle 2.", "index", "=", "int", "(", "len", "(", "l_sort", ")", "/", "2", ")", "# Integer division correct", "median", "=", "float", "(", "l_sort", "[", "index", "]", "+", "l_sort", "[", "index", "-", "1", "]", ")", "/", "2", "else", ":", "# int division gives mid value when count from 0", "index", "=", "int", "(", "len", "(", "l_sort", ")", "/", "2", ")", "median", "=", "l_sort", "[", "index", "]", "# Calculate IQR.", "q1", "=", "quantile", "(", "l_sort", ",", "0.25", ")", "q3", "=", "quantile", "(", "l_sort", ",", "0.75", ")", "iqr", "=", "q3", "-", "q1", "iqr_extra", "=", "iqr", "*", "1.5", "def", "in_interval", "(", "x", ",", "i", "=", "iqr_extra", ",", "q1", "=", "q1", ",", "q3", "=", "q3", ")", ":", "return", "(", "x", ">=", "q1", "-", "i", "and", "x", "<=", "q3", "+", "i", ")", "l_trimmed", "=", "[", "x", "for", "x", "in", "l_sort", "if", "in_interval", "(", "x", ")", "]", "return", "l_trimmed" ]

[ "Return", "rootObject", "as", "a", "plist", "-", "formatted", "string", "." ]

[ "def", "writePlistToString", "(", "rootObject", ")", ":", "f", "=", "StringIO", "(", ")", "writePlist", "(", "rootObject", ",", "f", ")", "return", "f", ".", "getvalue", "(", ")" ]

[ "return", "total", "memory", "in", "Mbytes" ]

[ "def", "getNodeMemMb", "(", ")", ":", "memMb", "=", "0", "import", "platform", "if", "platform", ".", "system", "(", ")", ".", "find", "(", "\"Linux\"", ")", ">", "-", "1", ":", "#", "# get this from /proc/meminfo", "#", "mname", "=", "\"/proc/meminfo\"", "if", "not", "os", ".", "path", ".", "isfile", "(", "mname", ")", ":", "raise", "EstException", "(", "\"Can't read memory information from %s\"", "%", "(", "mname", ")", ")", "line", "=", "open", "(", "mname", ")", ".", "readline", "(", ")", "splat", "=", "line", ".", "rstrip", "(", ")", ".", "split", "(", ")", "if", "len", "(", "splat", ")", "!=", "3", ":", "raise", "EstException", "(", "\"Unexpected format in %s\"", "%", "(", "mname", ")", ")", "try", ":", "memMb", "=", "1", "+", "(", "(", "int", "(", "splat", "[", "1", "]", ")", "-", "1", ")", "/", "1024", ")", "except", ":", "raise", "EstException", "(", "\"Unexpected format in %s\"", "%", "(", "mname", ")", ")", "elif", "platform", ".", "system", "(", ")", ".", "find", "(", "\"Darwin\"", ")", ">", "-", "1", ":", "import", "subprocess", "cmd", "=", "[", "'sysctl'", ",", "'-n'", ",", "'hw.memsize'", "]", "proc", "=", "subprocess", ".", "Popen", "(", "cmd", ",", "shell", "=", "False", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "for", "line", "in", "proc", ".", "stdout", ":", "memMb", "=", "int", "(", "line", ".", "strip", "(", ")", ")", "/", "(", "1024", "*", "1024", ")", "break", "elif", "platform", ".", "system", "(", ")", ".", "find", "(", "\"Windows\"", ")", ">", "-", "1", ":", "process", "=", "os", ".", "popen", "(", "'wmic memorychip get capacity'", ")", "result", "=", "process", ".", "read", "(", ")", "process", ".", "close", "(", ")", "totalMem", "=", "0", "for", "m", "in", "result", ".", "split", "(", "\" \\r\\n\"", ")", "[", "1", ":", "-", "1", "]", ":", "totalMem", "+=", "int", "(", "m", ")", "memMb", "=", "totalMem", "/", "(", "1024", "**", "2", ")", "else", ":", "raise", "EstException", "(", "\"Can't determine total memory available on OS: '%s'\"", "(", "platform", ".", "system", "(", ")", ")", ")", "return", "memMb" ]

[ "This", "command", "performs", "an", "entire", "mail", "transaction", "." ]

[ "def", "sendmail", "(", "self", ",", "from_addr", ",", "to_addrs", ",", "msg", ",", "mail_options", "=", "[", "]", ",", "rcpt_options", "=", "[", "]", ")", ":", "self", ".", "ehlo_or_helo_if_needed", "(", ")", "esmtp_opts", "=", "[", "]", "if", "self", ".", "does_esmtp", ":", "# Hmmm? what's this? -ddm", "# self.esmtp_features['7bit']=\"\"", "if", "self", ".", "has_extn", "(", "'size'", ")", ":", "esmtp_opts", ".", "append", "(", "\"size=%d\"", "%", "len", "(", "msg", ")", ")", "for", "option", "in", "mail_options", ":", "esmtp_opts", ".", "append", "(", "option", ")", "(", "code", ",", "resp", ")", "=", "self", ".", "mail", "(", "from_addr", ",", "esmtp_opts", ")", "if", "code", "!=", "250", ":", "self", ".", "rset", "(", ")", "raise", "SMTPSenderRefused", "(", "code", ",", "resp", ",", "from_addr", ")", "senderrs", "=", "{", "}", "if", "isinstance", "(", "to_addrs", ",", "basestring", ")", ":", "to_addrs", "=", "[", "to_addrs", "]", "for", "each", "in", "to_addrs", ":", "(", "code", ",", "resp", ")", "=", "self", ".", "rcpt", "(", "each", ",", "rcpt_options", ")", "if", "(", "code", "!=", "250", ")", "and", "(", "code", "!=", "251", ")", ":", "senderrs", "[", "each", "]", "=", "(", "code", ",", "resp", ")", "if", "len", "(", "senderrs", ")", "==", "len", "(", "to_addrs", ")", ":", "# the server refused all our recipients", "self", ".", "rset", "(", ")", "raise", "SMTPRecipientsRefused", "(", "senderrs", ")", "(", "code", ",", "resp", ")", "=", "self", ".", "data", "(", "msg", ")", "if", "code", "!=", "250", ":", "self", ".", "rset", "(", ")", "raise", "SMTPDataError", "(", "code", ",", "resp", ")", "#if we got here then somebody got our mail", "return", "senderrs" ]

[ "Returns", "a", "formatted", "day", "." ]

[ "def", "formatday", "(", "self", ",", "day", ",", "weekday", ",", "width", ")", ":", "if", "day", "==", "0", ":", "s", "=", "''", "else", ":", "s", "=", "'%2i'", "%", "day", "# right-align single-digit days", "return", "s", ".", "center", "(", "width", ")" ]

[ "Prints", "a", "list", "of", "TKey", "s", "and", "some", "information", "." ]

[ "def", "_rootLsPrintLongLs", "(", "keyList", ",", "indent", ",", "treeListing", ")", ":", "# Early return if the keyList is empty", "if", "not", "keyList", ":", "return", "maxCharClass", "=", "max", "(", "[", "len", "(", "key", ".", "GetClassName", "(", ")", ")", "for", "key", "in", "keyList", "]", ")", "maxCharTime", "=", "12", "maxCharName", "=", "max", "(", "[", "len", "(", "key", ".", "GetName", "(", ")", ")", "for", "key", "in", "keyList", "]", ")", "dic", "=", "{", "\"classWidth\"", ":", "maxCharClass", "+", "2", ",", "\"timeWidth\"", ":", "maxCharTime", "+", "2", ",", "\"nameWidth\"", ":", "maxCharName", "+", "2", ",", "\"titleWidth\"", ":", "1", ",", "\"cycleWidth\"", ":", "1", "}", "# Input keyList is a THashList. Convert it to a Python list to make it work", "# with zip_longest later", "keyList", "=", "[", "key", "for", "key", "in", "keyList", "]", "# Mimic the logic used in TDirectoryFile::ls(Option_t *option)", "# For any key in the list, we need to grab the previous one and the next one.", "# To do this, we use the iterator returned by zip_longest. The three input", "# lists to zip_longest can be visualized as follows:", "#", "# a = [\"key_1\",\"key_2\",\"key_3\"]", "# a_lagright = [None] + a[:-1]", "# a_lagleft = a[1:]", "# list(zip_longest(a_lagright, a, a_lagleft))", "# [(None, 'key_1', 'key_2'), ('key_1', 'key_2', 'key_3'), ('key_2', 'key_3', None)]", "#", "# So that for any key, we can have a correct reference to the previous and", "# following keys of `keyList`. The first key has no previous key and the last", "# key has no following key, so the respective elements of the zip_longest", "# iterator are `None`.", "for", "previouskey", ",", "currentkey", ",", "nextkey", "in", "zip_longest", "(", "[", "None", "]", "+", "keyList", "[", ":", "-", "1", "]", ",", "keyList", ",", "keyList", "[", "1", ":", "]", ")", ":", "# If this key is the first one in the list, or if it has a different", "# name than the previous one, it means that it's the first object of", "# that kind in the list.", "if", "previouskey", "is", "None", "or", "currentkey", ".", "GetName", "(", ")", "!=", "previouskey", ".", "GetName", "(", ")", ":", "# Then we check the following key. If the current key is not", "# the last key in the list and if the following key has the same", "# name, then it means it's another cycle of the same object.", "# Thus, it's gonna be a backup cycle of the same object.", "# Otherwise, it's just a key with one cycle so we don't need", "# to print information two distinguish between different cycles", "# of the same key.", "if", "nextkey", "is", "not", "None", "and", "currentkey", ".", "GetName", "(", ")", "==", "nextkey", ".", "GetName", "(", ")", ":", "cyclestr", "=", "\"[current cycle]\"", "else", ":", "cyclestr", "=", "\"\"", "else", ":", "# This key is a subsequent cycle of a previous key", "cyclestr", "=", "\"[backup cycle]\"", "datime", "=", "currentkey", ".", "GetDatime", "(", ")", "time", "=", "datime", ".", "GetTime", "(", ")", "date", "=", "datime", ".", "GetDate", "(", ")", "year", "=", "datime", ".", "GetYear", "(", ")", "time", "=", "_prepareTime", "(", "time", ")", "rec", "=", "[", "currentkey", ".", "GetClassName", "(", ")", ",", "MONTH", "[", "int", "(", "str", "(", "date", ")", "[", "4", ":", "6", "]", ")", "]", "+", "\" \"", "+", "str", "(", "date", ")", "[", "6", ":", "]", "+", "\" \"", "+", "time", "[", ":", "2", "]", "+", "\":\"", "+", "time", "[", "2", ":", "4", "]", "+", "\" \"", "+", "str", "(", "year", ")", "+", "\" \"", ",", "currentkey", ".", "GetName", "(", ")", "+", "\";\"", "+", "str", "(", "currentkey", ".", "GetCycle", "(", ")", ")", ",", "\" \\\"\"", "+", "currentkey", ".", "GetTitle", "(", ")", "+", "\"\\\"\"", ",", "\" \"", "+", "cyclestr", "]", "write", "(", "LONG_TEMPLATE", ".", "format", "(", "*", "rec", ",", "*", "*", "dic", ")", ",", "indent", ",", "end", "=", "\"\\n\"", ")", "if", "treeListing", "and", "isTreeKey", "(", "currentkey", ")", ":", "tree", "=", "currentkey", ".", "ReadObj", "(", ")", "_recursifTreePrinter", "(", "tree", ",", "indent", "+", "2", ")", "tree", "=", "tree", ".", "GetTree", "(", ")", "_printClusters", "(", "tree", ",", "indent", "+", "2", ")", "if", "treeListing", "and", "isTHnSparseKey", "(", "currentkey", ")", ":", "hs", "=", "currentkey", ".", "ReadObj", "(", ")", "hs", ".", "Print", "(", "\"all\"", ")" ]

[ "List", "directory", "contents", "using", "cache", "." ]

[ "def", "listdir", "(", "path", ")", ":", "try", ":", "cached_mtime", ",", "list", "=", "cache", "[", "path", "]", "del", "cache", "[", "path", "]", "except", "KeyError", ":", "cached_mtime", ",", "list", "=", "-", "1", ",", "[", "]", "mtime", "=", "os", ".", "stat", "(", "path", ")", ".", "st_mtime", "if", "mtime", "!=", "cached_mtime", ":", "list", "=", "os", ".", "listdir", "(", "path", ")", "list", ".", "sort", "(", ")", "cache", "[", "path", "]", "=", "mtime", ",", "list", "return", "list" ]

[ "Create", "the", "Z3", "expression", "signed", "remainder", "." ]

[ "def", "SRem", "(", "a", ",", "b", ")", ":", "_check_bv_args", "(", "a", ",", "b", ")", "a", ",", "b", "=", "_coerce_exprs", "(", "a", ",", "b", ")", "return", "BitVecRef", "(", "Z3_mk_bvsrem", "(", "a", ".", "ctx_ref", "(", ")", ",", "a", ".", "as_ast", "(", ")", ",", "b", ".", "as_ast", "(", ")", ")", ",", "a", ".", "ctx", ")" ]

[ "Aggregate", "sparse", "gradients", "." ]

[ "def", "_aggregate_sparse_grad", "(", "self", ",", "grad", ",", "var", ",", "train_ops", ")", ":", "# Sparse gradients have to be inserted as one pair of (value,", "# indice) as an element instead of the whole \"indexedslice\" because", "# their shapes are not deterministic.", "sparse_grad_queue", "=", "(", "data_flow_ops", ".", "FIFOQueue", "(", "-", "1", ",", "(", "grad", ".", "values", ".", "dtype", ",", "grad", ".", "indices", ".", "dtype", ")", ",", "shapes", "=", "(", "var", ".", "get_shape", "(", ")", ".", "as_list", "(", ")", "[", "1", ":", "]", ",", "(", ")", ")", ",", "shared_name", "=", "\"sparse_grad_q_%s\"", "%", "var", ".", "name", ")", ")", "self", ".", "_sparse_grad_queues_and_devs", ".", "append", "(", "(", "sparse_grad_queue", ",", "var", ".", "device", ")", ")", "# Sparse token is inserted after the \"enqueue_many\" finishes. This", "# is needed to make sure enough sparse gradients have been enqueued", "# before applying them to the variables.", "sparse_token_queue", "=", "(", "data_flow_ops", ".", "FIFOQueue", "(", "self", ".", "_replicas_to_aggregate", "*", "2", ",", "types_pb2", ".", "DT_INT32", ",", "shapes", "=", "(", ")", ",", "shared_name", "=", "\"sparse_token_q_%s\"", "%", "var", ".", "name", ")", ")", "self", ".", "_one_element_queue_list", ".", "append", "(", "(", "sparse_token_queue", ",", "var", ".", "device", ")", ")", "enqueue_spares_op", "=", "sparse_grad_queue", ".", "enqueue_many", "(", "[", "grad", ".", "values", ",", "grad", ".", "indices", "]", ")", "with", "ops", ".", "control_dependencies", "(", "[", "enqueue_spares_op", "]", ")", ":", "train_ops", ".", "append", "(", "sparse_token_queue", ".", "enqueue", "(", "(", "1", ",", ")", ")", ")", "with", "ops", ".", "control_dependencies", "(", "[", "sparse_token_queue", ".", "dequeue_many", "(", "self", ".", "_replicas_to_aggregate", ")", "]", ")", ":", "values", ",", "indices", "=", "sparse_grad_queue", ".", "dequeue_many", "(", "sparse_grad_queue", ".", "size", "(", ")", ")", "concat_grad", "=", "ops", ".", "IndexedSlices", "(", "values", ",", "indices", ",", "grad", ".", "dense_shape", ")", "# Sum the gradients of the same variables in the sparse layers so", "# that each variable is only updated once. Note that with 2", "# gradients g1 and g2 from 2 replicas for the same variable,", "# apply(g1+g2) is different from apply(g1) and then apply(g2) when", "# the optimizer is complex like Momentum or Adagrad.", "values", "=", "concat_grad", ".", "values", "indices", "=", "concat_grad", ".", "indices", "new_indices", ",", "indx", "=", "array_ops", ".", "unique", "(", "indices", ")", "num_indices", "=", "array_ops", ".", "shape", "(", "new_indices", ")", "[", "0", "]", "sum_values", "=", "math_ops", ".", "unsorted_segment_sum", "(", "values", ",", "indx", ",", "num_indices", ")", "return", "ops", ".", "IndexedSlices", "(", "sum_values", ",", "new_indices", ",", "concat_grad", ".", "dense_shape", ")" ]

[ "Deletes", "an", "existing", "constrained", "port", "." ]

[ "def", "DeleteConstrainedPort", "(", "config", ")", ":", "_CheckArgsExist", "(", "config", ",", "'interface'", ",", "'port'", ",", "'server_port'", ")", "try", ":", "# Delete filters first so it frees the class.", "_DeleteFilter", "(", "config", "[", "'interface'", "]", ",", "config", "[", "'port'", "]", ")", "finally", ":", "try", ":", "# Deleting the class deletes attached qdisc as well.", "_ConfigureClass", "(", "'del'", ",", "config", ")", "finally", ":", "_DeleteIptableRule", "(", "config", "[", "'interface'", "]", ",", "config", "[", "'port'", "]", ",", "config", "[", "'server_port'", "]", ")" ]

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

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

[ "Finds", "the", "contraction", "for", "a", "given", "set", "of", "input", "and", "output", "sets", "." ]

[ "def", "_find_contraction", "(", "positions", ",", "input_sets", ",", "output_set", ")", ":", "idx_contract", "=", "set", "(", ")", "idx_remain", "=", "output_set", ".", "copy", "(", ")", "remaining", "=", "[", "]", "for", "ind", ",", "value", "in", "enumerate", "(", "input_sets", ")", ":", "if", "ind", "in", "positions", ":", "idx_contract", "|=", "value", "else", ":", "remaining", ".", "append", "(", "value", ")", "idx_remain", "|=", "value", "new_result", "=", "idx_remain", "&", "idx_contract", "idx_removed", "=", "(", "idx_contract", "-", "new_result", ")", "remaining", ".", "append", "(", "new_result", ")", "return", "(", "new_result", ",", "remaining", ",", "idx_removed", ",", "idx_contract", ")" ]

[ "Helper", "method", "that", "actually", "creates", "the", "file", "in", "cloud", "storage", "." ]

[ "def", "_create", "(", "cls", ",", "writer_spec", ",", "filename_suffix", ")", ":", "writer", "=", "cls", ".", "_open_file", "(", "writer_spec", ",", "filename_suffix", ")", "return", "cls", "(", "writer", ",", "writer_spec", "=", "writer_spec", ")" ]

[ "get", "dict", "of", "str", "to", "str" ]

[ "def", "qualifiers", "(", "self", ")", ":", "# TODO: remove duplication", "ret", "=", "{", "}", "for", "i", "in", "range", "(", "self", ".", "qualifiers_list", ".", "count", ")", ":", "q", "=", "self", ".", "qualifiers_list", ".", "qualifiers", "[", "i", "]", "qk", "=", "self", ".", "data", ".", "get_qualifier_key", "(", "q", ")", "qv", "=", "self", ".", "data", ".", "get_qualifier_value", "(", "q", ")", "ret", "[", "str", "(", "qk", ")", "]", "=", "qv", "return", "ret" ]

[ "Add", "an", "item", "to", "the", "shelf" ]

[ "def", "AddItem", "(", "self", ",", "item", ",", "name", ",", "bmp", "=", "wx", ".", "NullBitmap", ")", ":", "self", ".", "_shelf", ".", "AddItem", "(", "item", ",", "name", ",", "bmp", ")" ]

[ "Get", "a", "list", "of", "Property", "objects", "representing", "the", "properties", "of", "a", "class", "." ]

[ "def", "get_class_properties", "(", "cls", ",", "self_name", ")", ":", "props", "=", "inspect", ".", "getmembers", "(", "cls", ",", "predicate", "=", "lambda", "m", ":", "isinstance", "(", "m", ",", "property", ")", ")", "# Any property that should not compiled must be in this list on the Module.", "unused_properties", "=", "getattr", "(", "cls", ",", "\"__jit_unused_properties__\"", ",", "[", "]", ")", "# Create Property TreeView objects from inspected property objects.", "properties", "=", "[", "]", "for", "prop", "in", "props", ":", "if", "prop", "[", "0", "]", "not", "in", "unused_properties", "and", "not", "should_drop", "(", "prop", "[", "1", "]", ".", "fget", ")", ":", "getter", "=", "get_jit_def", "(", "prop", "[", "1", "]", ".", "fget", ",", "f\"__{prop[0]}_getter\"", ",", "self_name", "=", "self_name", ")", "setter", "=", "get_jit_def", "(", "prop", "[", "1", "]", ".", "fset", ",", "f\"__{prop[0]}_setter\"", ",", "self_name", "=", "self_name", ")", "if", "prop", "[", "1", "]", ".", "fset", "else", "None", "properties", ".", "append", "(", "Property", "(", "getter", ".", "range", "(", ")", ",", "Ident", "(", "getter", ".", "range", "(", ")", ",", "prop", "[", "0", "]", ")", ",", "getter", ",", "setter", ")", ")", "return", "properties" ]

[ "Provision", "the", "device", "and", "make", "it", "ready", "to", "trace", "memory", "maps", "." ]

[ "def", "EnableMmapTracing", "(", "self", ",", "enabled", ")", ":", "raise", "NotImplementedError", "(", ")" ]

[ "Iterate", "over", "possible", "selections", "name", "(", "used", "in", "output", "directory", "name", "and", "legend", ")", "from", "the", "name", "of", "PlotterFolder", "and", "a", "return", "value", "of", "translateSubFolder" ]

[ "def", "iterSelectionName", "(", "self", ",", "plotFolderName", ",", "translatedDqmSubFolder", ")", ":", "ret", "=", "\"\"", "if", "plotFolderName", "!=", "\"\"", ":", "ret", "+=", "\"_\"", "+", "plotFolderName", "if", "translatedDqmSubFolder", "is", "not", "None", ":", "ret", "+=", "\"_\"", "+", "translatedDqmSubFolder", "yield", "ret" ]

[ "Helper", "method", "that", "subscribes", "a", "single", "tensor", "to", "a", "list", "of", "side_effects", "." ]

[ "def", "_subscribe", "(", "tensor", ",", "side_effects", ",", "control_cache", ")", ":", "# Check if the given tensor has a numpy compatible type (see dtypes.py).", "# If not, we cannot subscribe it, so we just return the original tensor.", "if", "not", "tensor", ".", "dtype", ".", "is_numpy_compatible", ":", "logging", ".", "debug", "(", "(", "'Tensor {} has an un-supported {} type and cannot be '", "'subscribed.'", ")", ".", "format", "(", "tensor", ".", "name", ",", "tensor", ".", "dtype", ")", ")", "return", "tensor", "if", "_is_subscribed_identity", "(", "tensor", ")", ":", "return", "_subscribe_extend", "(", "tensor", ",", "side_effects", ")", "# Check if the given tensor has already been subscribed by inspecting its", "# outputs.", "name_scope", "=", "tensor", ".", "op", ".", "name", "+", "'/subscription/Identity'", "consumers", "=", "tensor", ".", "consumers", "(", ")", "matching_ops", "=", "[", "op", "for", "op", "in", "consumers", "if", "op", ".", "name", ".", "startswith", "(", "name_scope", ")", "]", "assert", "len", "(", "matching_ops", ")", "<=", "1", ",", "(", "'Op {} must only have one subscription '", "'op connected to it'", ")", ".", "format", "(", "tensor", ".", "op", ".", "name", ")", "if", "len", "(", "matching_ops", ")", "==", "1", ":", "candidate_tensor", "=", "matching_ops", "[", "0", "]", ".", "outputs", "[", "0", "]", "if", "_is_subscribed_identity", "(", "candidate_tensor", ")", ":", "return", "_subscribe_extend", "(", "candidate_tensor", ",", "side_effects", ")", "return", "_subscribe_new", "(", "tensor", ",", "side_effects", ",", "control_cache", ")" ]

[ "Perform", "a", "step", "command", "and", "block", "the", "UI", "for", "eventDelayStep", "seconds", "in", "order", "to", "process", "events", "on", "lldb", "s", "event", "queue", ".", "FIXME", ":", "if", "the", "step", "does", "not", "complete", "in", "eventDelayStep", "seconds", "we", "relinquish", "control", "to", "the", "main", "thread", "to", "avoid", "the", "appearance", "of", "a", "hang", ".", "If", "this", "happens", "the", "UI", "will", "update", "whenever", ";", "usually", "when", "the", "user", "moves", "the", "cursor", ".", "This", "is", "somewhat", "annoying", "." ]

[ "def", "doStep", "(", "self", ",", "stepType", ")", ":", "if", "not", "self", ".", "process", ":", "sys", ".", "stderr", ".", "write", "(", "\"No process to step\"", ")", "return", "t", "=", "self", ".", "process", ".", "GetSelectedThread", "(", ")", "if", "stepType", "==", "StepType", ".", "INSTRUCTION", ":", "t", ".", "StepInstruction", "(", "False", ")", "if", "stepType", "==", "StepType", ".", "INSTRUCTION_OVER", ":", "t", ".", "StepInstruction", "(", "True", ")", "elif", "stepType", "==", "StepType", ".", "INTO", ":", "t", ".", "StepInto", "(", ")", "elif", "stepType", "==", "StepType", ".", "OVER", ":", "t", ".", "StepOver", "(", ")", "elif", "stepType", "==", "StepType", ".", "OUT", ":", "t", ".", "StepOut", "(", ")", "self", ".", "processPendingEvents", "(", "self", ".", "eventDelayStep", ",", "True", ")" ]

[ "Creates", "callback", "to", "get", "demands", "at", "each", "location", "." ]

[ "def", "create_demand_evaluator", "(", "data", ")", ":", "_demands", "=", "data", "[", "'demands'", "]", "def", "demand_evaluator", "(", "manager", ",", "from_node", ")", ":", "\"\"\"Returns the demand of the current node\"\"\"", "return", "_demands", "[", "manager", ".", "IndexToNode", "(", "from_node", ")", "]", "return", "demand_evaluator" ]

[ "SetPrivData", "(", "self", "PyObject", "data", ")" ]

[ "def", "SetPrivData", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PrintData_SetPrivData", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Entry", "point", "for", "analyze", "-", "build", "command", "." ]

[ "def", "analyze_build", "(", ")", ":", "args", "=", "parse_args_for_analyze_build", "(", ")", "# will re-assign the report directory as new output", "with", "report_directory", "(", "args", ".", "output", ",", "args", ".", "keep_empty", ",", "args", ".", "output_format", ")", "as", "args", ".", "output", ":", "# Run the analyzer against a compilation db.", "govern_analyzer_runs", "(", "args", ")", "# Cover report generation and bug counting.", "number_of_bugs", "=", "document", "(", "args", ")", "# Set exit status as it was requested.", "return", "number_of_bugs", "if", "args", ".", "status_bugs", "else", "0" ]

[ "Query", "attribute", "on", "the", "device", "pointer" ]

[ "def", "_device_pointer_attr", "(", "devmem", ",", "attr", ",", "odata", ")", ":", "error", "=", "driver", ".", "cuPointerGetAttribute", "(", "byref", "(", "odata", ")", ",", "attr", ",", "device_ctypes_pointer", "(", "devmem", ")", ")", "driver", ".", "check_error", "(", "error", ",", "\"Failed to query pointer attribute\"", ")" ]

[ "Overrriden", "from", "TypeHandler", "." ]

[ "def", "WriteImmediateCmdHelper", "(", "self", ",", "func", ",", "file", ")", ":", "code", "=", "\"\"\" void %(name)s(%(typed_args)s) {\n const uint32 data_size = strlen(name);\n gles2::%(name)s* c = GetImmediateCmdSpace<gles2::%(name)s>(data_size);\n if (c) {\n c->Init(%(args)s, data_size);\n }\n }\n\n\"\"\"", "file", ".", "Write", "(", "code", "%", "{", "\"name\"", ":", "func", ".", "name", ",", "\"typed_args\"", ":", "func", ".", "MakeTypedOriginalArgString", "(", "\"\"", ")", ",", "\"args\"", ":", "func", ".", "MakeOriginalArgString", "(", "\"\"", ")", ",", "}", ")" ]

[ "Returns", "True", "if", "filename", "names", "a", "valid", "JSON", "output", "file", ".", "False", "otherwise", "." ]

[ "def", "is_json_file", "(", "filename", ")", ":", "try", ":", "with", "open", "(", "filename", ",", "'r'", ")", "as", "f", ":", "json", ".", "load", "(", "f", ")", "return", "True", "except", "BaseException", ":", "pass", "return", "False" ]

[ "Write", "a", "dependencies", "file", "if", "different", "from", "dependencies", "." ]

[ "def", "UpdateDependencies", "(", "filepath", ",", "dependencies", ",", "comment", "=", "\"\"", ")", ":", "FileGenerator", ".", "UpdateFile", "(", "os", ".", "path", ".", "abspath", "(", "filepath", ")", ",", "comment", ".", "rstrip", "(", ")", "+", "os", ".", "linesep", "+", "TextFromDependencies", "(", "dependencies", ")", ")" ]

[ "return", "a", "list", "of", "GPUs" ]

[ "def", "get_gpus", "(", ")", ":", "return", "range", "(", "mx", ".", "util", ".", "get_gpu_count", "(", ")", ")" ]

[ "Host", "architecture", "check", "using", "environ", "vars", "(", "better", "way", "to", "do", "this?", ")" ]

[ "def", "host_arch_win", "(", ")", ":", "observed_arch", "=", "os", ".", "environ", ".", "get", "(", "'PROCESSOR_ARCHITECTURE'", ",", "'x86'", ")", "arch", "=", "os", ".", "environ", ".", "get", "(", "'PROCESSOR_ARCHITEW6432'", ",", "observed_arch", ")", "matchup", "=", "{", "'AMD64'", ":", "'x64'", ",", "'x86'", ":", "'ia32'", ",", "'arm'", ":", "'arm'", ",", "'mips'", ":", "'mips'", ",", "}", "return", "matchup", ".", "get", "(", "arch", ",", "'ia32'", ")" ]

[ "Searches", "a", "list", "of", "filenames", "and", "replaces", "directories", "in", "the", "list", "with", "all", "files", "descending", "from", "those", "directories", ".", "Files", "with", "extensions", "not", "in", "the", "valid", "extensions", "list", "are", "excluded", "." ]

[ "def", "_ExpandDirectories", "(", "filenames", ")", ":", "expanded", "=", "set", "(", ")", "for", "filename", "in", "filenames", ":", "if", "not", "os", ".", "path", ".", "isdir", "(", "filename", ")", ":", "expanded", ".", "add", "(", "filename", ")", "continue", "for", "root", ",", "_", ",", "files", "in", "os", ".", "walk", "(", "filename", ")", ":", "for", "loopfile", "in", "files", ":", "fullname", "=", "os", ".", "path", ".", "join", "(", "root", ",", "loopfile", ")", "if", "fullname", ".", "startswith", "(", "'.'", "+", "os", ".", "path", ".", "sep", ")", ":", "fullname", "=", "fullname", "[", "len", "(", "'.'", "+", "os", ".", "path", ".", "sep", ")", ":", "]", "expanded", ".", "add", "(", "fullname", ")", "filtered", "=", "[", "]", "for", "filename", "in", "expanded", ":", "if", "os", ".", "path", ".", "splitext", "(", "filename", ")", "[", "1", "]", "[", "1", ":", "]", "in", "GetAllExtensions", "(", ")", ":", "filtered", ".", "append", "(", "filename", ")", "return", "filtered" ]

[ "Return", "the", "current", "time", "formatted", "for", "logging", "." ]

[ "def", "log_date_time_string", "(", "self", ")", ":", "now", "=", "time", ".", "time", "(", ")", "year", ",", "month", ",", "day", ",", "hh", ",", "mm", ",", "ss", ",", "x", ",", "y", ",", "z", "=", "time", ".", "localtime", "(", "now", ")", "s", "=", "\"%02d/%3s/%04d %02d:%02d:%02d\"", "%", "(", "day", ",", "self", ".", "monthname", "[", "month", "]", ",", "year", ",", "hh", ",", "mm", ",", "ss", ")", "return", "s" ]

[ "Runs", "the", "preprocessor", "to", "determine", "the", "gcc", "/", "icc", "/", "clang", "version" ]

[ "def", "get_cc_version", "(", "conf", ",", "cc", ",", "gcc", "=", "False", ",", "icc", "=", "False", ",", "clang", "=", "False", ")", ":", "cmd", "=", "cc", "+", "[", "'-dM'", ",", "'-E'", ",", "'-'", "]", "env", "=", "conf", ".", "env", ".", "env", "or", "None", "try", ":", "out", ",", "err", "=", "conf", ".", "cmd_and_log", "(", "cmd", ",", "output", "=", "0", ",", "input", "=", "'\\n'", ".", "encode", "(", ")", ",", "env", "=", "env", ")", "except", "Errors", ".", "WafError", ":", "conf", ".", "fatal", "(", "'Could not determine the compiler version %r'", "%", "cmd", ")", "if", "gcc", ":", "if", "out", ".", "find", "(", "'__INTEL_COMPILER'", ")", ">=", "0", ":", "conf", ".", "fatal", "(", "'The intel compiler pretends to be gcc'", ")", "if", "out", ".", "find", "(", "'__GNUC__'", ")", "<", "0", "and", "out", ".", "find", "(", "'__clang__'", ")", "<", "0", ":", "conf", ".", "fatal", "(", "'Could not determine the compiler type'", ")", "if", "icc", "and", "out", ".", "find", "(", "'__INTEL_COMPILER'", ")", "<", "0", ":", "conf", ".", "fatal", "(", "'Not icc/icpc'", ")", "if", "clang", "and", "out", ".", "find", "(", "'__clang__'", ")", "<", "0", ":", "conf", ".", "fatal", "(", "'Not clang/clang++'", ")", "if", "not", "clang", "and", "out", ".", "find", "(", "'__clang__'", ")", ">=", "0", ":", "conf", ".", "fatal", "(", "'Could not find gcc/g++ (only Clang), if renamed try eg: CC=gcc48 CXX=g++48 waf configure'", ")", "k", "=", "{", "}", "if", "icc", "or", "gcc", "or", "clang", ":", "out", "=", "out", ".", "splitlines", "(", ")", "for", "line", "in", "out", ":", "lst", "=", "shlex", ".", "split", "(", "line", ")", "if", "len", "(", "lst", ")", ">", "2", ":", "key", "=", "lst", "[", "1", "]", "val", "=", "lst", "[", "2", "]", "k", "[", "key", "]", "=", "val", "def", "isD", "(", "var", ")", ":", "return", "var", "in", "k", "# Some documentation is available at http://predef.sourceforge.net", "# The names given to DEST_OS must match what Utils.unversioned_sys_platform() returns.", "if", "not", "conf", ".", "env", ".", "DEST_OS", ":", "conf", ".", "env", ".", "DEST_OS", "=", "''", "for", "i", "in", "MACRO_TO_DESTOS", ":", "if", "isD", "(", "i", ")", ":", "conf", ".", "env", ".", "DEST_OS", "=", "MACRO_TO_DESTOS", "[", "i", "]", "break", "else", ":", "if", "isD", "(", "'__APPLE__'", ")", "and", "isD", "(", "'__MACH__'", ")", ":", "conf", ".", "env", ".", "DEST_OS", "=", "'darwin'", "elif", "isD", "(", "'__unix__'", ")", ":", "# unix must be tested last as it's a generic fallback", "conf", ".", "env", ".", "DEST_OS", "=", "'generic'", "if", "isD", "(", "'__ELF__'", ")", ":", "conf", ".", "env", ".", "DEST_BINFMT", "=", "'elf'", "elif", "isD", "(", "'__WINNT__'", ")", "or", "isD", "(", "'__CYGWIN__'", ")", "or", "isD", "(", "'_WIN32'", ")", ":", "conf", ".", "env", ".", "DEST_BINFMT", "=", "'pe'", "if", "not", "conf", ".", "env", ".", "IMPLIBDIR", ":", "conf", ".", "env", ".", "IMPLIBDIR", "=", "conf", ".", "env", ".", "LIBDIR", "# for .lib or .dll.a files", "conf", ".", "env", ".", "LIBDIR", "=", "conf", ".", "env", ".", "BINDIR", "elif", "isD", "(", "'__APPLE__'", ")", ":", "conf", ".", "env", ".", "DEST_BINFMT", "=", "'mac-o'", "if", "not", "conf", ".", "env", ".", "DEST_BINFMT", ":", "# Infer the binary format from the os name.", "conf", ".", "env", ".", "DEST_BINFMT", "=", "Utils", ".", "destos_to_binfmt", "(", "conf", ".", "env", ".", "DEST_OS", ")", "for", "i", "in", "MACRO_TO_DEST_CPU", ":", "if", "isD", "(", "i", ")", ":", "conf", ".", "env", ".", "DEST_CPU", "=", "MACRO_TO_DEST_CPU", "[", "i", "]", "break", "Logs", ".", "debug", "(", "'ccroot: dest platform: '", "+", "' '", ".", "join", "(", "[", "conf", ".", "env", "[", "x", "]", "or", "'?'", "for", "x", "in", "(", "'DEST_OS'", ",", "'DEST_BINFMT'", ",", "'DEST_CPU'", ")", "]", ")", ")", "if", "icc", ":", "ver", "=", "k", "[", "'__INTEL_COMPILER'", "]", "conf", ".", "env", ".", "CC_VERSION", "=", "(", "ver", "[", ":", "-", "2", "]", ",", "ver", "[", "-", "2", "]", ",", "ver", "[", "-", "1", "]", ")", "else", ":", "if", "isD", "(", "'__clang__'", ")", "and", "isD", "(", "'__clang_major__'", ")", ":", "conf", ".", "env", ".", "CC_VERSION", "=", "(", "k", "[", "'__clang_major__'", "]", ",", "k", "[", "'__clang_minor__'", "]", ",", "k", "[", "'__clang_patchlevel__'", "]", ")", "else", ":", "# older clang versions and gcc", "conf", ".", "env", ".", "CC_VERSION", "=", "(", "k", "[", "'__GNUC__'", "]", ",", "k", "[", "'__GNUC_MINOR__'", "]", ",", "k", ".", "get", "(", "'__GNUC_PATCHLEVEL__'", ",", "'0'", ")", ")", "return", "k" ]

[ "Whether", "to", "update", "training", "parameters", "." ]

[ "def", "_fresh_trainable", "(", "self", ")", ":", "# Make sure that this is not done while gradients are waiting to be reduced (if no_sync context for instance)", "if", "reduce", "(", "lambda", "x", ",", "y", ":", "x", "or", "y", ",", "self", ".", "_grad_reduced", ",", "False", ")", ":", "logging", ".", "warning", "(", "\"Grads waiting to be reduced.\"", ")", "self", ".", "_trainable_params", "=", "list", "(", "filter", "(", "lambda", "x", ":", "x", ".", "trainable", ",", "self", ".", "_all_params", ")", ")", "self", ".", "_trainable_params", ".", "sort", "(", "key", "=", "lambda", "x", ":", "np", ".", "prod", "(", "x", ".", "shape", ")", ")", "self", ".", "_trainable_param2rank", "=", "{", "}", "for", "optim", "in", "self", ".", "_sharding_optimizers", ":", "# Need to be wrappered for Sharding Stage2 Optimizer", "if", "len", "(", "optim", ".", "param_storages", ".", "keys", "(", ")", ")", "==", "0", ":", "optim", ".", "update_opt_status", "(", ")", "# Get the parameters split by the optimizer according to rank", "for", "per_rank_params", "in", "optim", ".", "dtype_rank_params", ".", "values", "(", ")", ":", "# all the params from all ranks", "for", "params", "in", "per_rank_params", ":", "for", "param", "in", "filter", "(", "lambda", "x", ":", "x", ".", "trainable", ",", "params", ")", ":", "self", ".", "_trainable_param2rank", "[", "param", ".", "name", "]", "=", "optim", ".", "param2rank", "[", "param", ".", "name", "]", "self", ".", "_trainable_param2align", "[", "param", ".", "name", "]", "=", "optim", ".", "_param2align", "[", "param", ".", "name", "]", "self", ".", "_setup_use_grad_storage", "(", ")", "# wait next func hook support", "self", ".", "_setup_backward_hooks", "(", ")" ]

[ "The", "2", "-", "norm", "of", "x", "." ]

[ "def", "norm2", "(", "x", ",", "axis", "=", "None", ")", ":", "return", "norm", "(", "x", ",", "p", "=", "2", ",", "axis", "=", "axis", ")" ]

[ "Convert", "input", "to", "tensors", "and", "validate", "shape", "information", "." ]

[ "def", "_prepare_sequence_inputs", "(", "inputs", ",", "states", ")", ":", "# Convert state initial values to tensors", "states", "=", "dict", "(", "(", "k", ",", "ops", ".", "convert_to_tensor", "(", "v", ",", "name", "=", "\"state_%s\"", "%", "k", ")", ")", "for", "k", ",", "v", "in", "states", ".", "items", "(", ")", ")", "def", "_assert_fully_defined", "(", "label", ",", "dict_", ",", "ignore_first_dimension", "=", "False", ")", ":", "start_dimension", "=", "1", "if", "ignore_first_dimension", "else", "0", "for", "k", ",", "v", "in", "dict_", ".", "items", "(", ")", ":", "if", "not", "v", ".", "get_shape", "(", ")", "[", "start_dimension", ":", "]", ".", "is_fully_defined", "(", ")", ":", "raise", "ValueError", "(", "\"Shape for %s %s is not fully defined %s: %s\"", "%", "(", "label", ",", "k", ",", "\"(ignoring first dimension)\"", "if", "ignore_first_dimension", "else", "\"\"", ",", "v", ".", "get_shape", "(", ")", ")", ")", "_assert_fully_defined", "(", "\"state\"", ",", "states", ")", "_assert_fully_defined", "(", "\"context\"", ",", "inputs", ".", "context", ")", "# Sequences' first dimension (time) may be variable", "_assert_fully_defined", "(", "\"sequence\"", ",", "inputs", ".", "sequences", ",", "ignore_first_dimension", "=", "True", ")", "# Get dictionaries' dtypes ordered by name - ordering is important", "# when switching between dicts and tuples for passing to Barrier.", "def", "_sort_by_name", "(", "d", ")", ":", "return", "collections", ".", "OrderedDict", "(", "sorted", "(", "d", ".", "items", "(", ")", ",", "key", "=", "lambda", "k_v", ":", "k_v", "[", "0", "]", ")", ")", "sorted_sequences", "=", "_sort_by_name", "(", "inputs", ".", "sequences", ")", "sorted_context", "=", "_sort_by_name", "(", "inputs", ".", "context", ")", "sorted_states", "=", "_sort_by_name", "(", "states", ")", "length", "=", "_check_rank", "(", "inputs", ".", "length", ",", "0", ")", "key", "=", "_check_rank", "(", "inputs", ".", "key", ",", "0", ")", "if", "length", ".", "dtype", "!=", "dtypes", ".", "int32", ":", "raise", "TypeError", "(", "\"length dtype must be int32, but received: %s\"", "%", "length", ".", "dtype", ")", "if", "key", ".", "dtype", "!=", "dtypes", ".", "string", ":", "raise", "TypeError", "(", "\"key dtype must be string, but received: %s\"", "%", "key", ".", "dtype", ")", "return", "(", "length", ",", "key", ",", "sorted_states", ",", "sorted_sequences", ",", "sorted_context", ")" ]

[ "Simple", "stamp", "command", "." ]

[ "def", "ExecStamp", "(", "self", ",", "path", ")", ":", "open", "(", "path", ",", "'w'", ")", ".", "close", "(", ")" ]

[ "Converts", "Any", "message", "according", "to", "Proto3", "JSON", "Specification", "." ]

[ "def", "_AnyMessageToJsonObject", "(", "self", ",", "message", ")", ":", "if", "not", "message", ".", "ListFields", "(", ")", ":", "return", "{", "}", "# Must print @type first, use OrderedDict instead of {}", "js", "=", "OrderedDict", "(", ")", "type_url", "=", "message", ".", "type_url", "js", "[", "'@type'", "]", "=", "type_url", "sub_message", "=", "_CreateMessageFromTypeUrl", "(", "type_url", ",", "self", ".", "descriptor_pool", ")", "sub_message", ".", "ParseFromString", "(", "message", ".", "value", ")", "message_descriptor", "=", "sub_message", ".", "DESCRIPTOR", "full_name", "=", "message_descriptor", ".", "full_name", "if", "_IsWrapperMessage", "(", "message_descriptor", ")", ":", "js", "[", "'value'", "]", "=", "self", ".", "_WrapperMessageToJsonObject", "(", "sub_message", ")", "return", "js", "if", "full_name", "in", "_WKTJSONMETHODS", ":", "js", "[", "'value'", "]", "=", "methodcaller", "(", "_WKTJSONMETHODS", "[", "full_name", "]", "[", "0", "]", ",", "sub_message", ")", "(", "self", ")", "return", "js", "return", "self", ".", "_RegularMessageToJsonObject", "(", "sub_message", ",", "js", ")" ]

[ "Expand", "(", "self", "PGPropArg", "id", ")", "-", ">", "bool" ]

[ "def", "Expand", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridInterface_Expand", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "GetFont", "(", "self", ")", "-", ">", "Font" ]

[ "def", "GetFont", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "GridCellAttr_GetFont", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Handle", "character", "reference", "no", "need", "to", "override", "." ]

[ "def", "handle_charref", "(", "self", ",", "name", ")", ":", "replacement", "=", "self", ".", "convert_charref", "(", "name", ")", "if", "replacement", "is", "None", ":", "self", ".", "unknown_charref", "(", "name", ")", "else", ":", "self", ".", "handle_data", "(", "replacement", ")" ]

[ "Initialize", "for", "writing", "with", "gzip", "compression", "." ]

[ "def", "_init_write_gz", "(", "self", ")", ":", "self", ".", "cmp", "=", "self", ".", "zlib", ".", "compressobj", "(", "9", ",", "self", ".", "zlib", ".", "DEFLATED", ",", "-", "self", ".", "zlib", ".", "MAX_WBITS", ",", "self", ".", "zlib", ".", "DEF_MEM_LEVEL", ",", "0", ")", "timestamp", "=", "struct", ".", "pack", "(", "\"<L\"", ",", "int", "(", "time", ".", "time", "(", ")", ")", ")", "self", ".", "__write", "(", "b\"\\037\\213\\010\\010\"", "+", "timestamp", "+", "b\"\\002\\377\"", ")", "if", "self", ".", "name", ".", "endswith", "(", "\".gz\"", ")", ":", "self", ".", "name", "=", "self", ".", "name", "[", ":", "-", "3", "]", "# RFC1952 says we must use ISO-8859-1 for the FNAME field.", "self", ".", "__write", "(", "self", ".", "name", ".", "encode", "(", "\"iso-8859-1\"", ",", "\"replace\"", ")", "+", "NUL", ")" ]

[ "shorts", "::", "=", "-", "(", "chars", ")", "*", "[", "[", "]", "chars", "]", ";" ]

[ "def", "parse_shorts", "(", "tokens", ",", "options", ")", ":", "token", "=", "tokens", ".", "move", "(", ")", "assert", "token", ".", "startswith", "(", "'-'", ")", "and", "not", "token", ".", "startswith", "(", "'--'", ")", "left", "=", "token", ".", "lstrip", "(", "'-'", ")", "parsed", "=", "[", "]", "while", "left", "!=", "''", ":", "short", ",", "left", "=", "'-'", "+", "left", "[", "0", "]", ",", "left", "[", "1", ":", "]", "similar", "=", "[", "o", "for", "o", "in", "options", "if", "o", ".", "short", "==", "short", "]", "if", "len", "(", "similar", ")", ">", "1", ":", "raise", "tokens", ".", "error", "(", "'%s is specified ambiguously %d times'", "%", "(", "short", ",", "len", "(", "similar", ")", ")", ")", "elif", "len", "(", "similar", ")", "<", "1", ":", "o", "=", "Option", "(", "short", ",", "None", ",", "0", ")", "options", ".", "append", "(", "o", ")", "if", "tokens", ".", "error", "is", "DocoptExit", ":", "o", "=", "Option", "(", "short", ",", "None", ",", "0", ",", "True", ")", "else", ":", "# why copying is necessary here?", "o", "=", "Option", "(", "short", ",", "similar", "[", "0", "]", ".", "long", ",", "similar", "[", "0", "]", ".", "argcount", ",", "similar", "[", "0", "]", ".", "value", ")", "value", "=", "None", "if", "o", ".", "argcount", "!=", "0", ":", "if", "left", "==", "''", ":", "if", "tokens", ".", "current", "(", ")", "in", "[", "None", ",", "'--'", "]", ":", "raise", "tokens", ".", "error", "(", "'%s requires argument'", "%", "short", ")", "value", "=", "tokens", ".", "move", "(", ")", "else", ":", "value", "=", "left", "left", "=", "''", "if", "tokens", ".", "error", "is", "DocoptExit", ":", "o", ".", "value", "=", "value", "if", "value", "is", "not", "None", "else", "True", "parsed", ".", "append", "(", "o", ")", "return", "parsed" ]

[ "Prepare", "a", "dictionary", "of", "data", "member", "in", "sequence", ".", "1", ".", "Machine", "2", ".", "Architecture", "3", ".", "Operating", "system", "4", ".", "Machine", "name", "5", ".", "Operating", "system", "distribution", "6", ".", "UUID", "Parameters", "----------", "self" ]

[ "def", "get_info", "(", "self", ")", ":", "dict_device", "=", "{", "\"uuid\"", ":", "self", ".", "uuid", ",", "\"machine\"", ":", "self", ".", "machine", ",", "\"arch\"", ":", "self", ".", "arch", ",", "\"os\"", ":", "self", ".", "osname", ",", "\"os distribution\"", ":", "self", ".", "dist", "}", "return", "dict_device" ]

[ "Creates", "linear", "regression", "TensorFlow", "subgraph", "." ]

[ "def", "linear_regression", "(", "x", ",", "y", ",", "init_mean", "=", "None", ",", "init_stddev", "=", "1.0", ")", ":", "with", "vs", ".", "variable_scope", "(", "'linear_regression'", ")", ":", "scope_name", "=", "vs", ".", "get_variable_scope", "(", ")", ".", "name", "summary", ".", "histogram", "(", "'%s.x'", "%", "scope_name", ",", "x", ")", "summary", ".", "histogram", "(", "'%s.y'", "%", "scope_name", ",", "y", ")", "dtype", "=", "x", ".", "dtype", ".", "base_dtype", "y_shape", "=", "y", ".", "get_shape", "(", ")", "if", "len", "(", "y_shape", ")", "==", "1", ":", "output_shape", "=", "1", "else", ":", "output_shape", "=", "y_shape", "[", "1", "]", "# Set up the requested initialization.", "if", "init_mean", "is", "None", ":", "weights", "=", "vs", ".", "get_variable", "(", "'weights'", ",", "[", "x", ".", "get_shape", "(", ")", "[", "1", "]", ",", "output_shape", "]", ",", "dtype", "=", "dtype", ")", "bias", "=", "vs", ".", "get_variable", "(", "'bias'", ",", "[", "output_shape", "]", ",", "dtype", "=", "dtype", ")", "else", ":", "weights", "=", "vs", ".", "get_variable", "(", "'weights'", ",", "[", "x", ".", "get_shape", "(", ")", "[", "1", "]", ",", "output_shape", "]", ",", "initializer", "=", "init_ops", ".", "random_normal_initializer", "(", "init_mean", ",", "init_stddev", ",", "dtype", "=", "dtype", ")", ",", "dtype", "=", "dtype", ")", "bias", "=", "vs", ".", "get_variable", "(", "'bias'", ",", "[", "output_shape", "]", ",", "initializer", "=", "init_ops", ".", "random_normal_initializer", "(", "init_mean", ",", "init_stddev", ",", "dtype", "=", "dtype", ")", ",", "dtype", "=", "dtype", ")", "summary", ".", "histogram", "(", "'%s.weights'", "%", "scope_name", ",", "weights", ")", "summary", ".", "histogram", "(", "'%s.bias'", "%", "scope_name", ",", "bias", ")", "return", "losses_ops", ".", "mean_squared_error_regressor", "(", "x", ",", "y", ",", "weights", ",", "bias", ")" ]

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

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

[ "Create", "a", "new", "property", "tagged", "with", "a", "namespace", "and", "carried", "by", "a", "node", "." ]

[ "def", "newNsProp", "(", "self", ",", "node", ",", "name", ",", "value", ")", ":", "if", "node", "is", "None", ":", "node__o", "=", "None", "else", ":", "node__o", "=", "node", ".", "_o", "ret", "=", "libxml2mod", ".", "xmlNewNsProp", "(", "node__o", ",", "self", ".", "_o", ",", "name", ",", "value", ")", "if", "ret", "is", "None", ":", "raise", "treeError", "(", "'xmlNewNsProp() failed'", ")", "__tmp", "=", "xmlAttr", "(", "_obj", "=", "ret", ")", "return", "__tmp" ]

[ "Returns", "the", "list", "of", "directories", "to", "be", "used", "for", "#include", "directives", "." ]

[ "def", "_GetIncludeDirs", "(", "config", ")", ":", "# TODO(bradnelson): include_dirs should really be flexible enough not to", "# require this sort of thing.", "include_dirs", "=", "(", "config", ".", "get", "(", "'include_dirs'", ",", "[", "]", ")", "+", "config", ".", "get", "(", "'msvs_system_include_dirs'", ",", "[", "]", ")", ")", "midl_include_dirs", "=", "(", "config", ".", "get", "(", "'midl_include_dirs'", ",", "[", "]", ")", "+", "config", ".", "get", "(", "'msvs_system_include_dirs'", ",", "[", "]", ")", ")", "resource_include_dirs", "=", "config", ".", "get", "(", "'resource_include_dirs'", ",", "include_dirs", ")", "include_dirs", "=", "_FixPaths", "(", "include_dirs", ")", "midl_include_dirs", "=", "_FixPaths", "(", "midl_include_dirs", ")", "resource_include_dirs", "=", "_FixPaths", "(", "resource_include_dirs", ")", "return", "include_dirs", ",", "midl_include_dirs", ",", "resource_include_dirs" ]

[ "Disable", "SRP", "server", "." ]

[ "def", "srp_server_disable", "(", "self", ")", ":", "self", ".", "execute_command", "(", "'srp server disable'", ")" ]

[ "Parses", "a", "single", "Breakpad", "symbol", "record", "-", "a", "single", "line", "from", "the", "symbol", "file", "." ]

[ "def", "_ParseRecord", "(", "self", ",", "record", ")", ":", "record_type", "=", "record", ".", "partition", "(", "' '", ")", "[", "0", "]", "if", "record_type", "==", "'FILE'", ":", "return", "self", ".", "_ParseFileRecord", "(", "record", ")", "elif", "self", ".", "_IsLineRecord", "(", "record_type", ")", ":", "return", "self", ".", "_ParseLineRecord", "(", "record", ")", "else", ":", "# Simply pass the record through unaltered.", "return", "record" ]