Datasets:

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "A", "special", "case", "for", "_generate_range_overflow_safe", "where", "periods", "*", "stride", "can", "be", "calculated", "without", "overflowing", "int64", "bounds", "." ]

[ "def", "_generate_range_overflow_safe_signed", "(", "endpoint", ":", "int", ",", "periods", ":", "int", ",", "stride", ":", "int", ",", "side", ":", "str", ")", "->", "int", ":", "assert", "side", "in", "[", "\"start\"", ",", "\"end\"", "]", "if", "side", "==", "\"end\"", ":", "stride", "*=", "-", "1", "with", "np", ".", "errstate", "(", "over", "=", "\"raise\"", ")", ":", "addend", "=", "np", ".", "int64", "(", "periods", ")", "*", "np", ".", "int64", "(", "stride", ")", "try", ":", "# easy case with no overflows", "return", "np", ".", "int64", "(", "endpoint", ")", "+", "addend", "except", "(", "FloatingPointError", ",", "OverflowError", ")", ":", "# with endpoint negative and addend positive we risk", "# FloatingPointError; with reversed signed we risk OverflowError", "pass", "# if stride and endpoint had opposite signs, then endpoint + addend", "# should never overflow. so they must have the same signs", "assert", "(", "stride", ">", "0", "and", "endpoint", ">=", "0", ")", "or", "(", "stride", "<", "0", "and", "endpoint", "<=", "0", ")", "if", "stride", ">", "0", ":", "# watch out for very special case in which we just slightly", "# exceed implementation bounds, but when passing the result to", "# np.arange will get a result slightly within the bounds", "result", "=", "np", ".", "uint64", "(", "endpoint", ")", "+", "np", ".", "uint64", "(", "addend", ")", "i64max", "=", "np", ".", "uint64", "(", "np", ".", "iinfo", "(", "np", ".", "int64", ")", ".", "max", ")", "assert", "result", ">", "i64max", "if", "result", "<=", "i64max", "+", "np", ".", "uint64", "(", "stride", ")", ":", "return", "result", "raise", "OutOfBoundsDatetime", "(", "f\"Cannot generate range with {side}={endpoint} and periods={periods}\"", ")" ]

[ "Use", "TOC", "to", "return", "subpath", "for", "given", "key", "or", "raise", "a", "KeyError", "." ]

[ "def", "_lookup", "(", "self", ",", "key", ")", ":", "try", ":", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "self", ".", "_path", ",", "self", ".", "_toc", "[", "key", "]", ")", ")", ":", "return", "self", ".", "_toc", "[", "key", "]", "except", "KeyError", ":", "pass", "self", ".", "_refresh", "(", ")", "try", ":", "return", "self", ".", "_toc", "[", "key", "]", "except", "KeyError", ":", "raise", "KeyError", "(", "'No message with key: %s'", "%", "key", ")", "from", "None" ]

[ "Build", "the", "groups", "relation", "table", "." ]

[ "def", "buildRelGroups", "(", "ifcfile", ")", ":", "groups", "=", "{", "}", "# { host:[child,...], ... } # used in structural IFC", "for", "r", "in", "ifcfile", ".", "by_type", "(", "\"IfcRelAssignsToGroup\"", ")", ":", "groups", ".", "setdefault", "(", "r", ".", "RelatingGroup", ".", "id", "(", ")", ",", "[", "]", ")", ".", "extend", "(", "[", "e", ".", "id", "(", ")", "for", "e", "in", "r", ".", "RelatedObjects", "]", ")", "return", "groups" ]

[ "Returns", "true", "if", "the", "node", "is", "an", "import", "statement", "." ]

[ "def", "is_import", "(", "node", ")", ":", "return", "node", ".", "type", "in", "(", "syms", ".", "import_name", ",", "syms", ".", "import_from", ")" ]

[ "GetCurrentPage", "(", "self", ")", "-", ">", "PropertyGridPage" ]

[ "def", "GetCurrentPage", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGridManager_GetCurrentPage", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "file", "extension", "for", "an", "abi3", "-", "compliant", "Extension", "()" ]

[ "def", "get_abi3_suffix", "(", ")", ":", "for", "suffix", "in", "EXTENSION_SUFFIXES", ":", "if", "'.abi3'", "in", "suffix", ":", "# Unix", "return", "suffix", "elif", "suffix", "==", "'.pyd'", ":", "# Windows", "return", "suffix" ]

[ "SaveFile", "(", "self", "String", "name", "int", "type", ")", "-", ">", "bool" ]

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

[ "Select", "strings", "(", "presumably", "filenames", ")", "from", "self", ".", "files", "that", "match", "pattern", "a", "Unix", "-", "style", "wildcard", "(", "glob", ")", "pattern", "." ]

[ "def", "include_pattern", "(", "self", ",", "pattern", ",", "anchor", "=", "1", ",", "prefix", "=", "None", ",", "is_regex", "=", "0", ")", ":", "# XXX docstring lying about what the special chars are?", "files_found", "=", "0", "pattern_re", "=", "translate_pattern", "(", "pattern", ",", "anchor", ",", "prefix", ",", "is_regex", ")", "self", ".", "debug_print", "(", "\"include_pattern: applying regex r'%s'\"", "%", "pattern_re", ".", "pattern", ")", "# delayed loading of allfiles list", "if", "self", ".", "allfiles", "is", "None", ":", "self", ".", "findall", "(", ")", "for", "name", "in", "self", ".", "allfiles", ":", "if", "pattern_re", ".", "search", "(", "name", ")", ":", "self", ".", "debug_print", "(", "\" adding \"", "+", "name", ")", "self", ".", "files", ".", "append", "(", "name", ")", "files_found", "=", "1", "return", "files_found" ]

[ "Returns", "a", "key", "/", "value", "dictionary", "from", "a", "CookieJar", "." ]

[ "def", "dict_from_cookiejar", "(", "cj", ")", ":", "cookie_dict", "=", "{", "}", "for", "cookie", "in", "cj", ":", "cookie_dict", "[", "cookie", ".", "name", "]", "=", "cookie", ".", "value", "return", "cookie_dict" ]

[ "A", "general", "quantization", "scheme", "is", "being", "developed", "in", "tf", ".", "contrib", ".", "quantize", "." ]

[ "def", "do_quantize_training_on_graphdef", "(", "input_graph", ",", "num_bits", ")", ":", "graph", "=", "graph_pb2", ".", "GraphDef", "(", ")", "result_graph_string", "=", "DoQuantizeTrainingOnGraphDefHelper", "(", "input_graph", ".", "SerializeToString", "(", ")", ",", "num_bits", ")", "graph", ".", "ParseFromString", "(", "result_graph_string", ")", "return", "graph" ]

[ "r", "Chebyshev", "polynomial", "of", "the", "second", "kind", "on", ":", "math", ":", "[", "-", "2", "2", "]", "." ]

[ "def", "chebys", "(", "n", ",", "monic", "=", "False", ")", ":", "if", "n", "<", "0", ":", "raise", "ValueError", "(", "\"n must be nonnegative.\"", ")", "if", "n", "==", "0", ":", "n1", "=", "n", "+", "1", "else", ":", "n1", "=", "n", "x", ",", "w", ",", "mu0", "=", "roots_chebys", "(", "n1", ",", "mu", "=", "True", ")", "if", "n", "==", "0", ":", "x", ",", "w", "=", "[", "]", ",", "[", "]", "hn", "=", "pi", "kn", "=", "1.0", "p", "=", "orthopoly1d", "(", "x", ",", "w", ",", "hn", ",", "kn", ",", "wfunc", "=", "lambda", "x", ":", "sqrt", "(", "1", "-", "x", "*", "x", "/", "4.0", ")", ",", "limits", "=", "(", "-", "2", ",", "2", ")", ",", "monic", "=", "monic", ")", "if", "not", "monic", ":", "factor", "=", "(", "n", "+", "1.0", ")", "/", "p", "(", "2", ")", "p", ".", "_scale", "(", "factor", ")", "p", ".", "__dict__", "[", "'_eval_func'", "]", "=", "lambda", "x", ":", "eval_chebys", "(", "n", ",", "x", ")", "return", "p" ]

[ "Normalizes", "the", "docstring", "." ]

[ "def", "_normalize_docstring", "(", "docstring", ")", ":", "if", "not", "docstring", ":", "return", "''", "# Convert tabs to spaces (following the normal Python rules)", "# and split into a list of lines:", "lines", "=", "docstring", ".", "expandtabs", "(", ")", ".", "splitlines", "(", ")", "# Determine minimum indentation (first line doesn't count):", "# (we use sys.maxsize because sys.maxint doesn't exist in Python 3)", "indent", "=", "sys", ".", "maxsize", "for", "line", "in", "lines", "[", "1", ":", "]", ":", "stripped", "=", "line", ".", "lstrip", "(", ")", "if", "stripped", ":", "indent", "=", "min", "(", "indent", ",", "len", "(", "line", ")", "-", "len", "(", "stripped", ")", ")", "# Remove indentation (first line is special):", "trimmed", "=", "[", "lines", "[", "0", "]", ".", "strip", "(", ")", "]", "if", "indent", "<", "sys", ".", "maxsize", ":", "for", "line", "in", "lines", "[", "1", ":", "]", ":", "trimmed", ".", "append", "(", "line", "[", "indent", ":", "]", ".", "rstrip", "(", ")", ")", "# Strip off trailing and leading blank lines:", "while", "trimmed", "and", "not", "trimmed", "[", "-", "1", "]", ":", "trimmed", ".", "pop", "(", ")", "while", "trimmed", "and", "not", "trimmed", "[", "0", "]", ":", "trimmed", ".", "pop", "(", "0", ")", "# Return a single string:", "return", "'\\n'", ".", "join", "(", "trimmed", ")" ]

[ "words", "=", "{}", "convert", "an", "integer", "number", "into", "words" ]

[ "def", "n2words", "(", "num", ",", "join", "=", "True", ")", ":", "units", "=", "[", "''", ",", "'One'", ",", "'Two'", ",", "'Three'", ",", "'Four'", ",", "'Five'", ",", "'Six'", ",", "'Seven'", ",", "'Eight'", ",", "'Nine'", "]", "teens", "=", "[", "''", ",", "'Eleven'", ",", "'Twelve'", ",", "'Thirteen'", ",", "'Fourteen'", ",", "'Fifteen'", ",", "'Sixteen'", ",", "'Seventeen'", ",", "'Eighteen'", ",", "'Nineteen'", "]", "tens", "=", "[", "''", ",", "'Ten'", ",", "'Twenty'", ",", "'Thirty'", ",", "'Forty'", ",", "'Fifty'", ",", "'Sixty'", ",", "'Seventy'", ",", "'Eighty'", ",", "'Ninety'", "]", "thousands", "=", "[", "''", ",", "'Thousand'", ",", "'Million'", ",", "'Billion'", ",", "'Trillion'", ",", "'Quadrillion'", ",", "'Quintillion'", ",", "'Sextillion'", ",", "'Septillion'", ",", "'Octillion'", ",", "'Nonillion'", ",", "'Decillion'", ",", "'Undecillion'", ",", "'Duodecillion'", ",", "'Tredecillion'", ",", "'Quattuordecillion'", ",", "'Sexdecillion'", ",", "'Septendecillion'", ",", "'Octodecillion'", ",", "'Novemdecillion'", ",", "'Vigintillion'", "]", "words", "=", "[", "]", "if", "num", "==", "0", ":", "words", ".", "append", "(", "'zero'", ")", "else", ":", "numStr", "=", "'%d'", "%", "num", "numStrLen", "=", "len", "(", "numStr", ")", "groups", "=", "(", "numStrLen", "+", "2", ")", "/", "3", "numStr", "=", "numStr", ".", "zfill", "(", "groups", "*", "3", ")", "for", "i", "in", "range", "(", "0", ",", "groups", "*", "3", ",", "3", ")", ":", "h", ",", "t", ",", "u", "=", "int", "(", "numStr", "[", "i", "]", ")", ",", "int", "(", "numStr", "[", "i", "+", "1", "]", ")", ",", "int", "(", "numStr", "[", "i", "+", "2", "]", ")", "g", "=", "groups", "-", "(", "i", "/", "3", "+", "1", ")", "if", "h", ">=", "1", ":", "words", ".", "append", "(", "units", "[", "h", "]", ")", "words", ".", "append", "(", "'Hundred'", ")", "if", "t", ">", "1", ":", "words", ".", "append", "(", "tens", "[", "t", "]", ")", "if", "u", ">=", "1", ":", "words", ".", "append", "(", "units", "[", "u", "]", ")", "elif", "t", "==", "1", ":", "if", "u", ">=", "1", ":", "words", ".", "append", "(", "teens", "[", "u", "]", ")", "else", ":", "words", ".", "append", "(", "tens", "[", "t", "]", ")", "else", ":", "if", "u", ">=", "1", ":", "words", ".", "append", "(", "units", "[", "u", "]", ")", "if", "(", "g", ">=", "1", ")", "and", "(", "(", "h", "+", "t", "+", "u", ")", ">", "0", ")", ":", "words", ".", "append", "(", "thousands", "[", "g", "]", "+", "''", ")", "if", "join", ":", "return", "' '", ".", "join", "(", "words", ")", "return", "words" ]

[ "Returns", "the", "role", "of", "the", "corresponing", "task", "." ]

[ "def", "task_type", "(", "self", ")", ":", "return", "self", ".", "_task_type" ]

[ "Live", "update", "of", "the", "ticker", "text" ]

[ "def", "OnText", "(", "self", ",", "evt", ")", ":", "self", ".", "ticker", ".", "SetText", "(", "self", ".", "txt", ".", "GetValue", "(", ")", ")" ]

[ "Find", "[", "Conditional", "]", "interface", "extended", "attribute", "." ]

[ "def", "extract_conditional", "(", "idl_contents", ")", ":", "match", "=", "CONDITIONAL_PATTERN", ".", "search", "(", "idl_contents", ")", "if", "not", "match", ":", "return", "None", "return", "match", ".", "group", "(", "1", ")" ]

[ "Initialize", "each", "attributes", "with", "the", "corresponding", "keyword", "arg", "value", "or", "a", "default", "of", "None" ]

[ "def", "_init_attrs", "(", "self", ",", "*", "*", "kwargs", ")", ":", "attrs", "=", "self", ".", "__class__", ".", "__slots__", "public_attrs", "=", "[", "attr", "[", "1", ":", "]", "for", "attr", "in", "attrs", "]", "invalid_keys", "=", "set", "(", "kwargs", ".", "keys", "(", ")", ")", "-", "set", "(", "public_attrs", ")", "if", "invalid_keys", ":", "raise", "ValueError", "(", "'''found %s invalid keyword arguments, please only\n use %s'''", "%", "(", "tuple", "(", "invalid_keys", ")", ",", "public_attrs", ")", ")", "for", "attr", "in", "attrs", ":", "setattr", "(", "self", ",", "attr", ",", "kwargs", ".", "get", "(", "attr", "[", "1", ":", "]", ",", "None", ")", ")" ]

[ "Sets", "key", "parameters", "for", "SORT" ]

[ "def", "__init__", "(", "self", ",", "max_age", "=", "1", ",", "min_hits", "=", "3", ")", ":", "self", ".", "max_age", "=", "max_age", "self", ".", "min_hits", "=", "min_hits", "self", ".", "trackers", "=", "[", "]", "self", ".", "frame_count", "=", "0" ]

[ "Add", "actions", "reported", "by", "non", "-", "Chrome", "processes", "in", "Chrome", "OS", "." ]

[ "def", "AddChromeOSActions", "(", "actions", ")", ":", "# Actions sent by the Chrome OS window manager.", "actions", ".", "add", "(", "'Accel_NextWindow_Tab'", ")", "actions", ".", "add", "(", "'Accel_PrevWindow_Tab'", ")", "actions", ".", "add", "(", "'Accel_NextWindow_F5'", ")", "actions", ".", "add", "(", "'Accel_PrevWindow_F5'", ")", "# Actions sent by the Chrome OS power manager.", "actions", ".", "add", "(", "'Accel_BrightnessDown_F6'", ")", "actions", ".", "add", "(", "'Accel_BrightnessUp_F7'", ")", "# Actions sent by Chrome OS update engine.", "actions", ".", "add", "(", "'Updater.ServerCertificateChanged'", ")", "actions", ".", "add", "(", "'Updater.ServerCertificateFailed'", ")", "# Actions sent by Chrome OS cryptohome.", "actions", ".", "add", "(", "'Cryptohome.PKCS11InitFail'", ")" ]

[ "BraceHighlightIndicator", "(", "self", "bool", "useBraceHighlightIndicator", "int", "indicator", ")" ]

[ "def", "BraceHighlightIndicator", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_BraceHighlightIndicator", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Register", "features", "need", "by", "this", "module", "." ]

[ "def", "__register_features", "(", ")", ":", "# The feature is optional so that it is never implicitly added.", "# It's used only for internal purposes, and in all cases we", "# want to explicitly use it.", "feature", ".", "feature", "(", "'target-type'", ",", "[", "]", ",", "[", "'composite'", ",", "'optional'", "]", ")", "feature", ".", "feature", "(", "'main-target-type'", ",", "[", "]", ",", "[", "'optional'", ",", "'incidental'", "]", ")", "feature", ".", "feature", "(", "'base-target-type'", ",", "[", "]", ",", "[", "'composite'", ",", "'optional'", ",", "'free'", "]", ")" ]

[ "Get", "the", "results", "for", "a", "specified", "benchmark", ".", "If", "filename", "specifies", "an", "executable", "benchmark", "then", "the", "results", "are", "generated", "by", "running", "the", "benchmark", ".", "Otherwise", "filename", "must", "name", "a", "valid", "JSON", "output", "file", "which", "is", "loaded", "and", "the", "result", "returned", "." ]

[ "def", "run_or_load_benchmark", "(", "filename", ",", "benchmark_flags", ")", ":", "ftype", "=", "check_input_file", "(", "filename", ")", "if", "ftype", "==", "IT_JSON", ":", "return", "load_benchmark_results", "(", "filename", ")", "elif", "ftype", "==", "IT_Executable", ":", "return", "run_benchmark", "(", "filename", ",", "benchmark_flags", ")", "else", ":", "assert", "False" ]

[ "Try", "to", "fill", "the", "rectangle", "with", "a", "given", "number", "of", "squares", "." ]

[ "def", "cover_rectangle", "(", "num_squares", ")", ":", "size_x", "=", "72", "size_y", "=", "37", "model", "=", "cp_model", ".", "CpModel", "(", ")", "areas", "=", "[", "]", "sizes", "=", "[", "]", "x_intervals", "=", "[", "]", "y_intervals", "=", "[", "]", "x_starts", "=", "[", "]", "y_starts", "=", "[", "]", "# Creates intervals for the NoOverlap2D and size variables.", "for", "i", "in", "range", "(", "num_squares", ")", ":", "size", "=", "model", ".", "NewIntVar", "(", "1", ",", "size_y", ",", "'size_%i'", "%", "i", ")", "start_x", "=", "model", ".", "NewIntVar", "(", "0", ",", "size_x", ",", "'sx_%i'", "%", "i", ")", "end_x", "=", "model", ".", "NewIntVar", "(", "0", ",", "size_x", ",", "'ex_%i'", "%", "i", ")", "start_y", "=", "model", ".", "NewIntVar", "(", "0", ",", "size_y", ",", "'sy_%i'", "%", "i", ")", "end_y", "=", "model", ".", "NewIntVar", "(", "0", ",", "size_y", ",", "'ey_%i'", "%", "i", ")", "interval_x", "=", "model", ".", "NewIntervalVar", "(", "start_x", ",", "size", ",", "end_x", ",", "'ix_%i'", "%", "i", ")", "interval_y", "=", "model", ".", "NewIntervalVar", "(", "start_y", ",", "size", ",", "end_y", ",", "'iy_%i'", "%", "i", ")", "area", "=", "model", ".", "NewIntVar", "(", "1", ",", "size_y", "*", "size_y", ",", "'area_%i'", "%", "i", ")", "model", ".", "AddProdEquality", "(", "area", ",", "[", "size", ",", "size", "]", ")", "areas", ".", "append", "(", "area", ")", "x_intervals", ".", "append", "(", "interval_x", ")", "y_intervals", ".", "append", "(", "interval_y", ")", "sizes", ".", "append", "(", "size", ")", "x_starts", ".", "append", "(", "start_x", ")", "y_starts", ".", "append", "(", "start_y", ")", "# Main constraint.", "model", ".", "AddNoOverlap2D", "(", "x_intervals", ",", "y_intervals", ")", "# Redundant constraints.", "model", ".", "AddCumulative", "(", "x_intervals", ",", "sizes", ",", "size_y", ")", "model", ".", "AddCumulative", "(", "y_intervals", ",", "sizes", ",", "size_x", ")", "# Forces the rectangle to be exactly covered.", "model", ".", "Add", "(", "sum", "(", "areas", ")", "==", "size_x", "*", "size_y", ")", "# Symmetry breaking 1: sizes are ordered.", "for", "i", "in", "range", "(", "num_squares", "-", "1", ")", ":", "model", ".", "Add", "(", "sizes", "[", "i", "]", "<=", "sizes", "[", "i", "+", "1", "]", ")", "# Define same to be true iff sizes[i] == sizes[i + 1]", "same", "=", "model", ".", "NewBoolVar", "(", "''", ")", "model", ".", "Add", "(", "sizes", "[", "i", "]", "==", "sizes", "[", "i", "+", "1", "]", ")", ".", "OnlyEnforceIf", "(", "same", ")", "model", ".", "Add", "(", "sizes", "[", "i", "]", "<", "sizes", "[", "i", "+", "1", "]", ")", ".", "OnlyEnforceIf", "(", "same", ".", "Not", "(", ")", ")", "# Tie break with starts.", "model", ".", "Add", "(", "x_starts", "[", "i", "]", "<=", "x_starts", "[", "i", "+", "1", "]", ")", ".", "OnlyEnforceIf", "(", "same", ")", "# Symmetry breaking 2: first square in one quadrant.", "model", ".", "Add", "(", "x_starts", "[", "0", "]", "<", "36", ")", "model", ".", "Add", "(", "y_starts", "[", "0", "]", "<", "19", ")", "# Creates a solver and solves.", "solver", "=", "cp_model", ".", "CpSolver", "(", ")", "status", "=", "solver", ".", "Solve", "(", "model", ")", "print", "(", "'%s found in %0.2fs'", "%", "(", "solver", ".", "StatusName", "(", "status", ")", ",", "solver", ".", "WallTime", "(", ")", ")", ")", "# Prints solution.", "if", "status", "==", "cp_model", ".", "OPTIMAL", ":", "display", "=", "[", "[", "' '", "for", "_", "in", "range", "(", "size_x", ")", "]", "for", "_", "in", "range", "(", "size_y", ")", "]", "for", "i", "in", "range", "(", "num_squares", ")", ":", "sol_x", "=", "solver", ".", "Value", "(", "x_starts", "[", "i", "]", ")", "sol_y", "=", "solver", ".", "Value", "(", "y_starts", "[", "i", "]", ")", "sol_s", "=", "solver", ".", "Value", "(", "sizes", "[", "i", "]", ")", "char", "=", "format", "(", "i", ",", "'01x'", ")", "for", "j", "in", "range", "(", "sol_s", ")", ":", "for", "k", "in", "range", "(", "sol_s", ")", ":", "if", "display", "[", "sol_y", "+", "j", "]", "[", "sol_x", "+", "k", "]", "!=", "' '", ":", "print", "(", "'ERROR between %s and %s'", "%", "(", "display", "[", "sol_y", "+", "j", "]", "[", "sol_x", "+", "k", "]", ",", "char", ")", ")", "display", "[", "sol_y", "+", "j", "]", "[", "sol_x", "+", "k", "]", "=", "char", "for", "line", "in", "range", "(", "size_y", ")", ":", "print", "(", "' '", ".", "join", "(", "display", "[", "line", "]", ")", ")", "return", "status", "==", "cp_model", ".", "FEASIBLE" ]

[ "Does", "self", "appear", "in", "other?" ]

[ "def", "in_", "(", "self", ",", "other", ")", ":", "return", "self", "in", "FoldedCase", "(", "other", ")" ]

[ "Assigns", "non", "-", "overlapping", "lanes", "for", "the", "activities", "on", "each", "device", "." ]

[ "def", "_assign_lanes", "(", "self", ")", ":", "for", "device_stats", "in", "self", ".", "_step_stats", ".", "dev_stats", ":", "# TODO(pbar): Genuine thread IDs in NodeExecStats might be helpful.", "lanes", "=", "[", "0", "]", "for", "ns", "in", "device_stats", ".", "node_stats", ":", "l", "=", "-", "1", "for", "(", "i", ",", "lts", ")", "in", "enumerate", "(", "lanes", ")", ":", "if", "ns", ".", "all_start_micros", ">", "lts", ":", "l", "=", "i", "lanes", "[", "l", "]", "=", "ns", ".", "all_start_micros", "+", "ns", ".", "all_end_rel_micros", "break", "if", "l", "<", "0", ":", "l", "=", "len", "(", "lanes", ")", "lanes", ".", "append", "(", "ns", ".", "all_start_micros", "+", "ns", ".", "all_end_rel_micros", ")", "ns", ".", "thread_id", "=", "l" ]

[ "Get", "the", "number", "of", "elements", "in", "this", "stream", "." ]

[ "def", "len", "(", "self", ")", "->", "int", ":", "raise", "NotImplementedError" ]

[ "Calculate", "x", "-", "y", "." ]

[ "def", "__sub__", "(", "self", ",", "other", ")", ":", "if", "not", "isinstance", "(", "other", ",", "Tensor", ")", ":", "if", "not", "isinstance", "(", "other", ",", "np", ".", "ndarray", ")", ":", "if", "not", "isinstance", "(", "other", ",", "list", ")", ":", "other", "=", "[", "other", "]", "other", "=", "np", ".", "array", "(", "other", ",", "dtype", "=", "np", ".", "float32", ")", "tensor", "=", "Tensor", "(", "GetTensorName", "(", ")", ")", "ws", ".", "FeedTensor", "(", "tensor", ",", "other", ")", "other", "=", "tensor", "output", "=", "self", ".", "CreateOperator", "(", "inputs", "=", "[", "self", ",", "other", "]", ",", "nout", "=", "1", ",", "op_type", "=", "'Sub'", ")", "if", "self", ".", "shape", "is", "not", "None", ":", "output", ".", "shape", "=", "self", ".", "shape", "[", ":", "]", "return", "output" ]

[ "Get", "MachAr", "instance", "or", "MachAr", "-", "like", "instance" ]

[ "def", "_get_machar", "(", "ftype", ")", ":", "params", "=", "_MACHAR_PARAMS", ".", "get", "(", "ftype", ")", "if", "params", "is", "None", ":", "raise", "ValueError", "(", "repr", "(", "ftype", ")", ")", "# Detect known / suspected types", "key", "=", "ftype", "(", "'-0.1'", ")", ".", "newbyteorder", "(", "'<'", ")", ".", "tobytes", "(", ")", "ma_like", "=", "None", "if", "ftype", "==", "ntypes", ".", "longdouble", ":", "# Could be 80 bit == 10 byte extended precision, where last bytes can", "# be random garbage.", "# Comparing first 10 bytes to pattern first to avoid branching on the", "# random garbage.", "ma_like", "=", "_KNOWN_TYPES", ".", "get", "(", "key", "[", ":", "10", "]", ")", "if", "ma_like", "is", "None", ":", "ma_like", "=", "_KNOWN_TYPES", ".", "get", "(", "key", ")", "if", "ma_like", "is", "not", "None", ":", "return", "ma_like", "# Fall back to parameter discovery", "warnings", ".", "warn", "(", "'Signature {} for {} does not match any known type: '", "'falling back to type probe function'", ".", "format", "(", "key", ",", "ftype", ")", ",", "UserWarning", ",", "stacklevel", "=", "2", ")", "return", "_discovered_machar", "(", "ftype", ")" ]

[ "Return", "the", "console", "object", "used", "by", "readline", "so", "that", "it", "can", "be", "used", "for", "printing", "in", "color", "." ]

[ "def", "GetOutputFile", "(", ")", ":", "return", "rl", ".", "console" ]

[ "Accumulates", "the", "given", "confusion", "matrix", "condition", "statistics", "." ]

[ "def", "update_state", "(", "self", ",", "y_true", ",", "y_pred", ",", "sample_weight", "=", "None", ")", ":", "return", "metrics_utils", ".", "update_confusion_matrix_variables", "(", "{", "self", ".", "_confusion_matrix_cond", ":", "self", ".", "accumulator", "}", ",", "y_true", ",", "y_pred", ",", "thresholds", "=", "self", ".", "thresholds", ",", "sample_weight", "=", "sample_weight", ")" ]

[ "Performs", "NRZI", "encode", "and", "checks", "the", "result" ]

[ "def", "test_encode", "(", "self", ")", ":", "encoder", "=", "digital", ".", "diff_encoder_bb", "(", "2", ",", "digital", ".", "DIFF_NRZI", ")", "self", ".", "tb", ".", "connect", "(", "self", ".", "source", ",", "encoder", ",", "self", ".", "sink", ")", "self", ".", "tb", ".", "start", "(", ")", "self", ".", "tb", ".", "wait", "(", ")", "expected", "=", "np", ".", "cumsum", "(", "(", "1", "^", "self", ".", "data", ")", "&", "1", ")", "&", "1", "np", ".", "testing", ".", "assert_equal", "(", "self", ".", "sink", ".", "data", "(", ")", ",", "expected", ",", "'NRZI encode output does not match expected result'", ")" ]

[ "Try", "to", "compile", "link", "to", "an", "executable", "and", "run", "a", "program", "built", "from", "body", "and", "headers", ".", "Return", "true", "on", "success", "false", "otherwise", "." ]

[ "def", "try_run", "(", "self", ",", "body", ",", "headers", "=", "None", ",", "include_dirs", "=", "None", ",", "libraries", "=", "None", ",", "library_dirs", "=", "None", ",", "lang", "=", "\"c\"", ")", ":", "from", "distutils", ".", "ccompiler", "import", "CompileError", ",", "LinkError", "self", ".", "_check_compiler", "(", ")", "try", ":", "src", ",", "obj", ",", "exe", "=", "self", ".", "_link", "(", "body", ",", "headers", ",", "include_dirs", ",", "libraries", ",", "library_dirs", ",", "lang", ")", "self", ".", "spawn", "(", "[", "exe", "]", ")", "ok", "=", "1", "except", "(", "CompileError", ",", "LinkError", ",", "DistutilsExecError", ")", ":", "ok", "=", "0", "log", ".", "info", "(", "ok", "and", "\"success!\"", "or", "\"failure.\"", ")", "self", ".", "_clean", "(", ")", "return", "ok" ]

[ "Constructor", "of", "ExpressionEvaluator", "." ]

[ "def", "__init__", "(", "self", ",", "dump", ")", ":", "self", ".", "_dump", "=", "dump", "self", ".", "_cached_tensor_values", "=", "dict", "(", ")" ]

[ "listen", "(", "[", "backlog", "]", ")" ]

[ "def", "listen", "(", "self", ",", "backlog", "=", "None", ")", ":", "if", "backlog", "is", "not", "None", "and", "backlog", "<", "0", ":", "backlog", "=", "0", "if", "backlog", "is", "None", ":", "backlog", "=", "-", "1", "# Lower-level code picks default", "err", "=", "libzt", ".", "zts_bsd_listen", "(", "self", ".", "_fd", ",", "backlog", ")", "if", "err", "<", "0", ":", "handle_error", "(", "err", ")" ]

[ "Add", "an", "expand", "dims", "layer", "to", "the", "model", "that", "increases", "the", "rank", "of", "the", "input", "tensor", "by", "adding", "unit", "dimensions", ".", "Refer", "to", "the", "**", "ExpandDimsLayerParams", "**", "message", "in", "specification", "(", "NeuralNetwork", ".", "proto", ")", "for", "more", "details", "." ]

[ "def", "add_expand_dims", "(", "self", ",", "name", ",", "input_name", ",", "output_name", ",", "axes", ")", ":", "spec_layer", "=", "self", ".", "_add_generic_layer", "(", "name", ",", "[", "input_name", "]", ",", "[", "output_name", "]", ")", "spec_layer_params", "=", "spec_layer", ".", "expandDims", "spec_layer_params", ".", "axes", ".", "extend", "(", "axes", ")", "self", ".", "rank_dict", "[", "output_name", "]", "=", "self", ".", "_get_rank", "(", "input_name", ")", "+", "len", "(", "axes", ")", "return", "spec_layer" ]

[ "Set", "the", "order", "of", "dimensions", "e", ".", "g", ".", "to", "convert", "OpenCV", "s", "HxWxC", "images", "into", "CxHxW", "." ]

[ "def", "set_transpose", "(", "self", ",", "in_", ",", "order", ")", ":", "self", ".", "__check_input", "(", "in_", ")", "if", "len", "(", "order", ")", "!=", "len", "(", "self", ".", "inputs", "[", "in_", "]", ")", "-", "1", ":", "raise", "Exception", "(", "'Transpose order needs to have the same number of '", "'dimensions as the input.'", ")", "self", ".", "transpose", "[", "in_", "]", "=", "order" ]

[ "Clears", "a", "range", "of", "lines", "for", "multi", "-", "line", "comments", "." ]

[ "def", "RemoveMultiLineCommentsFromRange", "(", "lines", ",", "begin", ",", "end", ")", ":", "# Having // dummy comments makes the lines non-empty, so we will not get", "# unnecessary blank line warnings later in the code.", "for", "i", "in", "range", "(", "begin", ",", "end", ")", ":", "lines", "[", "i", "]", "=", "'// dummy'" ]

[ "Suggest", "a", "normalized", "version", "close", "to", "the", "given", "version", "string", "." ]

[ "def", "_suggest_normalized_version", "(", "s", ")", ":", "try", ":", "_normalized_key", "(", "s", ")", "return", "s", "# already rational", "except", "UnsupportedVersionError", ":", "pass", "rs", "=", "s", ".", "lower", "(", ")", "# part of this could use maketrans", "for", "orig", ",", "repl", "in", "(", "(", "'-alpha'", ",", "'a'", ")", ",", "(", "'-beta'", ",", "'b'", ")", ",", "(", "'alpha'", ",", "'a'", ")", ",", "(", "'beta'", ",", "'b'", ")", ",", "(", "'rc'", ",", "'c'", ")", ",", "(", "'-final'", ",", "''", ")", ",", "(", "'-pre'", ",", "'c'", ")", ",", "(", "'-release'", ",", "''", ")", ",", "(", "'.release'", ",", "''", ")", ",", "(", "'-stable'", ",", "''", ")", ",", "(", "'+'", ",", "'.'", ")", ",", "(", "'_'", ",", "'.'", ")", ",", "(", "' '", ",", "''", ")", ",", "(", "'.final'", ",", "''", ")", ",", "(", "'final'", ",", "''", ")", ")", ":", "rs", "=", "rs", ".", "replace", "(", "orig", ",", "repl", ")", "# if something ends with dev or pre, we add a 0", "rs", "=", "re", ".", "sub", "(", "r\"pre$\"", ",", "r\"pre0\"", ",", "rs", ")", "rs", "=", "re", ".", "sub", "(", "r\"dev$\"", ",", "r\"dev0\"", ",", "rs", ")", "# if we have something like \"b-2\" or \"a.2\" at the end of the", "# version, that is probably beta, alpha, etc", "# let's remove the dash or dot", "rs", "=", "re", ".", "sub", "(", "r\"([abc]|rc)[\\-\\.](\\d+)$\"", ",", "r\"\\1\\2\"", ",", "rs", ")", "# 1.0-dev-r371 -> 1.0.dev371", "# 0.1-dev-r79 -> 0.1.dev79", "rs", "=", "re", ".", "sub", "(", "r\"[\\-\\.](dev)[\\-\\.]?r?(\\d+)$\"", ",", "r\".\\1\\2\"", ",", "rs", ")", "# Clean: 2.0.a.3, 2.0.b1, 0.9.0~c1", "rs", "=", "re", ".", "sub", "(", "r\"[.~]?([abc])\\.?\"", ",", "r\"\\1\"", ",", "rs", ")", "# Clean: v0.3, v1.0", "if", "rs", ".", "startswith", "(", "'v'", ")", ":", "rs", "=", "rs", "[", "1", ":", "]", "# Clean leading '0's on numbers.", "#TODO: unintended side-effect on, e.g., \"2003.05.09\"", "# PyPI stats: 77 (~2%) better", "rs", "=", "re", ".", "sub", "(", "r\"\\b0+(\\d+)(?!\\d)\"", ",", "r\"\\1\"", ",", "rs", ")", "# Clean a/b/c with no version. E.g. \"1.0a\" -> \"1.0a0\". Setuptools infers", "# zero.", "# PyPI stats: 245 (7.56%) better", "rs", "=", "re", ".", "sub", "(", "r\"(\\d+[abc])$\"", ",", "r\"\\g<1>0\"", ",", "rs", ")", "# the 'dev-rNNN' tag is a dev tag", "rs", "=", "re", ".", "sub", "(", "r\"\\.?(dev-r|dev\\.r)\\.?(\\d+)$\"", ",", "r\".dev\\2\"", ",", "rs", ")", "# clean the - when used as a pre delimiter", "rs", "=", "re", ".", "sub", "(", "r\"-(a|b|c)(\\d+)$\"", ",", "r\"\\1\\2\"", ",", "rs", ")", "# a terminal \"dev\" or \"devel\" can be changed into \".dev0\"", "rs", "=", "re", ".", "sub", "(", "r\"[\\.\\-](dev|devel)$\"", ",", "r\".dev0\"", ",", "rs", ")", "# a terminal \"dev\" can be changed into \".dev0\"", "rs", "=", "re", ".", "sub", "(", "r\"(?![\\.\\-])dev$\"", ",", "r\".dev0\"", ",", "rs", ")", "# a terminal \"final\" or \"stable\" can be removed", "rs", "=", "re", ".", "sub", "(", "r\"(final|stable)$\"", ",", "\"\"", ",", "rs", ")", "# The 'r' and the '-' tags are post release tags", "# 0.4a1.r10 -> 0.4a1.post10", "# 0.9.33-17222 -> 0.9.33.post17222", "# 0.9.33-r17222 -> 0.9.33.post17222", "rs", "=", "re", ".", "sub", "(", "r\"\\.?(r|-|-r)\\.?(\\d+)$\"", ",", "r\".post\\2\"", ",", "rs", ")", "# Clean 'r' instead of 'dev' usage:", "# 0.9.33+r17222 -> 0.9.33.dev17222", "# 1.0dev123 -> 1.0.dev123", "# 1.0.git123 -> 1.0.dev123", "# 1.0.bzr123 -> 1.0.dev123", "# 0.1a0dev.123 -> 0.1a0.dev123", "# PyPI stats: ~150 (~4%) better", "rs", "=", "re", ".", "sub", "(", "r\"\\.?(dev|git|bzr)\\.?(\\d+)$\"", ",", "r\".dev\\2\"", ",", "rs", ")", "# Clean '.pre' (normalized from '-pre' above) instead of 'c' usage:", "# 0.2.pre1 -> 0.2c1", "# 0.2-c1 -> 0.2c1", "# 1.0preview123 -> 1.0c123", "# PyPI stats: ~21 (0.62%) better", "rs", "=", "re", ".", "sub", "(", "r\"\\.?(pre|preview|-c)(\\d+)$\"", ",", "r\"c\\g<2>\"", ",", "rs", ")", "# Tcl/Tk uses \"px\" for their post release markers", "rs", "=", "re", ".", "sub", "(", "r\"p(\\d+)$\"", ",", "r\".post\\1\"", ",", "rs", ")", "try", ":", "_normalized_key", "(", "rs", ")", "except", "UnsupportedVersionError", ":", "rs", "=", "None", "return", "rs" ]

[ "Generic", "method", "that", "evaluates", "performance", "of", "a", "list", "of", "batches", ".", "May", "be", "used", "to", "evaluate", "all", "actions", "or", "a", "single", "action", "." ]

[ "def", "evaluate_batches", "(", "sess", ",", "model", ",", "data_mean_3d", ",", "data_std_3d", ",", "dim_to_use_3d", ",", "dim_to_ignore_3d", ",", "data_mean_2d", ",", "data_std_2d", ",", "dim_to_use_2d", ",", "dim_to_ignore_2d", ",", "current_step", ",", "encoder_inputs", ",", "decoder_outputs", ",", "current_epoch", "=", "0", ")", ":", "n_joints", "=", "17", "if", "not", "(", "FLAGS", ".", "predict_14", ")", "else", "14", "nbatches", "=", "len", "(", "encoder_inputs", ")", "# Loop through test examples", "all_dists", ",", "start_time", ",", "loss", "=", "[", "]", ",", "time", ".", "time", "(", ")", ",", "0.", "log_every_n_batches", "=", "100", "for", "i", "in", "range", "(", "nbatches", ")", ":", "if", "current_epoch", ">", "0", "and", "(", "i", "+", "1", ")", "%", "log_every_n_batches", "==", "0", ":", "print", "(", "\"Working on test epoch {0}, batch {1} / {2}\"", ".", "format", "(", "current_epoch", ",", "i", "+", "1", ",", "nbatches", ")", ")", "enc_in", ",", "dec_out", "=", "encoder_inputs", "[", "i", "]", ",", "decoder_outputs", "[", "i", "]", "dp", "=", "1.0", "# dropout keep probability is always 1 at test time", "step_loss", ",", "loss_summary", ",", "poses3d", "=", "model", ".", "step", "(", "sess", ",", "enc_in", ",", "dec_out", ",", "dp", ",", "isTraining", "=", "False", ")", "loss", "+=", "step_loss", "# denormalize", "enc_in", "=", "data_utils", ".", "unNormalizeData", "(", "enc_in", ",", "data_mean_2d", ",", "data_std_2d", ",", "dim_to_ignore_2d", ")", "dec_out", "=", "data_utils", ".", "unNormalizeData", "(", "dec_out", ",", "data_mean_3d", ",", "data_std_3d", ",", "dim_to_ignore_3d", ")", "poses3d", "=", "data_utils", ".", "unNormalizeData", "(", "poses3d", ",", "data_mean_3d", ",", "data_std_3d", ",", "dim_to_ignore_3d", ")", "# Keep only the relevant dimensions", "dtu3d", "=", "np", ".", "hstack", "(", "(", "np", ".", "arange", "(", "3", ")", ",", "dim_to_use_3d", ")", ")", "if", "not", "(", "FLAGS", ".", "predict_14", ")", "else", "dim_to_use_3d", "dec_out", "=", "dec_out", "[", ":", ",", "dtu3d", "]", "poses3d", "=", "poses3d", "[", ":", ",", "dtu3d", "]", "assert", "dec_out", ".", "shape", "[", "0", "]", "==", "FLAGS", ".", "batch_size", "assert", "poses3d", ".", "shape", "[", "0", "]", "==", "FLAGS", ".", "batch_size", "if", "FLAGS", ".", "procrustes", ":", "# Apply per-frame procrustes alignment if asked to do so", "for", "j", "in", "range", "(", "FLAGS", ".", "batch_size", ")", ":", "gt", "=", "np", ".", "reshape", "(", "dec_out", "[", "j", ",", ":", "]", ",", "[", "-", "1", ",", "3", "]", ")", "out", "=", "np", ".", "reshape", "(", "poses3d", "[", "j", ",", ":", "]", ",", "[", "-", "1", ",", "3", "]", ")", "_", ",", "Z", ",", "T", ",", "b", ",", "c", "=", "procrustes", ".", "compute_similarity_transform", "(", "gt", ",", "out", ",", "compute_optimal_scale", "=", "True", ")", "out", "=", "(", "b", "*", "out", ".", "dot", "(", "T", ")", ")", "+", "c", "poses3d", "[", "j", ",", ":", "]", "=", "np", ".", "reshape", "(", "out", ",", "[", "-", "1", ",", "17", "*", "3", "]", ")", "if", "not", "(", "FLAGS", ".", "predict_14", ")", "else", "np", ".", "reshape", "(", "out", ",", "[", "-", "1", ",", "14", "*", "3", "]", ")", "# Compute Euclidean distance error per joint", "sqerr", "=", "(", "poses3d", "-", "dec_out", ")", "**", "2", "# Squared error between prediction and expected output", "dists", "=", "np", ".", "zeros", "(", "(", "sqerr", ".", "shape", "[", "0", "]", ",", "n_joints", ")", ")", "# Array with L2 error per joint in mm", "dist_idx", "=", "0", "for", "k", "in", "np", ".", "arange", "(", "0", ",", "n_joints", "*", "3", ",", "3", ")", ":", "# Sum across X,Y, and Z dimenstions to obtain L2 distance", "dists", "[", ":", ",", "dist_idx", "]", "=", "np", ".", "sqrt", "(", "np", ".", "sum", "(", "sqerr", "[", ":", ",", "k", ":", "k", "+", "3", "]", ",", "axis", "=", "1", ")", ")", "dist_idx", "=", "dist_idx", "+", "1", "all_dists", ".", "append", "(", "dists", ")", "assert", "sqerr", ".", "shape", "[", "0", "]", "==", "FLAGS", ".", "batch_size", "step_time", "=", "(", "time", ".", "time", "(", ")", "-", "start_time", ")", "/", "nbatches", "loss", "=", "loss", "/", "nbatches", "all_dists", "=", "np", ".", "vstack", "(", "all_dists", ")", "# Error per joint and total for all passed batches", "joint_err", "=", "np", ".", "mean", "(", "all_dists", ",", "axis", "=", "0", ")", "total_err", "=", "np", ".", "mean", "(", "all_dists", ")", "return", "total_err", ",", "joint_err", ",", "step_time", ",", "loss" ]

[ "Log", "-", "odds", "." ]

[ "def", "logits", "(", "self", ")", ":", "return", "self", ".", "_logits" ]

[ "Handle", "a", "single", "XML", "-", "RPC", "request", "passed", "through", "a", "CGI", "post", "method", "." ]

[ "def", "handle_request", "(", "self", ",", "request_text", "=", "None", ")", ":", "if", "request_text", "is", "None", "and", "os", ".", "environ", ".", "get", "(", "'REQUEST_METHOD'", ",", "None", ")", "==", "'GET'", ":", "self", ".", "handle_get", "(", ")", "else", ":", "# POST data is normally available through stdin", "try", ":", "length", "=", "int", "(", "os", ".", "environ", ".", "get", "(", "'CONTENT_LENGTH'", ",", "None", ")", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "length", "=", "-", "1", "if", "request_text", "is", "None", ":", "request_text", "=", "sys", ".", "stdin", ".", "read", "(", "length", ")", "self", ".", "handle_xmlrpc", "(", "request_text", ")" ]

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

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

[ "Sets", "the", ":", "class", ":", "AuiToolBarItem", "identifier", "." ]

[ "def", "SetToolId", "(", "self", ",", "id", ")", ":", "self", ".", "tool_id", "=", "id" ]

[ "Swaps", "self", "/", "other", "and", "returns", "__pow__", "." ]

[ "def", "__rpow__", "(", "self", ",", "other", ",", "context", "=", "None", ")", ":", "other", "=", "_convert_other", "(", "other", ")", "if", "other", "is", "NotImplemented", ":", "return", "other", "return", "other", ".", "__pow__", "(", "self", ",", "context", "=", "context", ")" ]

[ "Initialise", "an", "instance", "of", "the", "class", "." ]

[ "def", "__init__", "(", "self", ",", "sub_cfg", "=", "None", ")", ":", "# Find the build macros in the closest imported module from where this", "# was originally defined.", "self", ".", "_macros", "=", "None", "for", "cls", "in", "self", ".", "__class__", ".", "__mro__", ":", "if", "cls", "is", "object", ":", "continue", "mod", "=", "sys", ".", "modules", "[", "cls", ".", "__module__", "]", "if", "hasattr", "(", "mod", ",", "\"_default_macros\"", ")", ":", "self", ".", "_macros", "=", "mod", ".", "_default_macros", "break", "if", "sub_cfg", ":", "cfg", "=", "sub_cfg", "else", ":", "cfg", "=", "[", "]", "cfg", ".", "append", "(", "_pkg_config", ")", "global", "_config_stack", "_config_stack", "=", "cfg" ]

[ "Forward", "-", "deployment", "(", "i", ".", "e", ".", "DARINGVETERAN", "/", "DARINGNEOPHYTE", ")", "DLL", "Configuration", "INPUT", "-----", "Path", "to", "plugin", "s", "standard", "FB", "file", ".", "OUTPUT", "------", "Dictionary", "mapping", "archOs", "tag", "(", "e", ".", "g", ".", "x86", "-", "Windows", ")", "to", "a", "tuple", "containing", "plugin", "proxy", "and", "core", "DLLs", ".", "Note", "that", "either", "element", "may", "be", "None!" ]

[ "def", "parse_forward", "(", "xmlFile", ")", ":", "xmldoc", "=", "ElementTree", ".", "parse", "(", "xmlFile", ")", "arches", "=", "{", "}", "for", "arch", "in", "xmldoc", ".", "findall", "(", "\"package/arch\"", ")", ":", "proxy", "=", "getattr", "(", "arch", ".", "find", "(", "'base'", ")", ",", "'text'", ",", "None", ")", "core", "=", "getattr", "(", "arch", ".", "find", "(", "'core'", ")", ",", "'text'", ",", "None", ")", "arches", "[", "arch", ".", "get", "(", "'name'", ")", "]", "=", "(", "proxy", ",", "core", ")", "return", "arches" ]

[ "Evaluate", "a", "marker", "." ]

[ "def", "evaluate", "(", "self", ",", "environment", "=", "None", ")", ":", "current_environment", "=", "default_environment", "(", ")", "if", "environment", "is", "not", "None", ":", "current_environment", ".", "update", "(", "environment", ")", "return", "_evaluate_markers", "(", "self", ".", "_markers", ",", "current_environment", ")" ]

[ "Converts", "the", "given", "object", "to", "a", "Tensor", "or", "an", "IndexedSlices", "." ]

[ "def", "convert_to_tensor_or_indexed_slices", "(", "value", ",", "dtype", "=", "None", ",", "name", "=", "None", ")", ":", "return", "internal_convert_to_tensor_or_indexed_slices", "(", "value", "=", "value", ",", "dtype", "=", "dtype", ",", "name", "=", "name", ",", "as_ref", "=", "False", ")" ]

[ "Normalize", "X", "according", "to", "Kluger", "s", "log", "-", "interactions", "scheme", "." ]

[ "def", "_log_normalize", "(", "X", ")", ":", "X", "=", "make_nonnegative", "(", "X", ",", "min_value", "=", "1", ")", "if", "issparse", "(", "X", ")", ":", "raise", "ValueError", "(", "\"Cannot compute log of a sparse matrix,\"", "\" because log(x) diverges to -infinity as x\"", "\" goes to 0.\"", ")", "L", "=", "np", ".", "log", "(", "X", ")", "row_avg", "=", "L", ".", "mean", "(", "axis", "=", "1", ")", "[", ":", ",", "np", ".", "newaxis", "]", "col_avg", "=", "L", ".", "mean", "(", "axis", "=", "0", ")", "avg", "=", "L", ".", "mean", "(", ")", "return", "L", "-", "row_avg", "-", "col_avg", "+", "avg" ]

[ "Helper", "for", "_AddMessageMethods", "()", "." ]

[ "def", "_AddEqualsMethod", "(", "message_descriptor", ",", "cls", ")", ":", "def", "__eq__", "(", "self", ",", "other", ")", ":", "if", "(", "not", "isinstance", "(", "other", ",", "message_mod", ".", "Message", ")", "or", "other", ".", "DESCRIPTOR", "!=", "self", ".", "DESCRIPTOR", ")", ":", "return", "False", "if", "self", "is", "other", ":", "return", "True", "if", "self", ".", "DESCRIPTOR", ".", "full_name", "==", "_AnyFullTypeName", ":", "any_a", "=", "_InternalUnpackAny", "(", "self", ")", "any_b", "=", "_InternalUnpackAny", "(", "other", ")", "if", "any_a", "and", "any_b", ":", "return", "any_a", "==", "any_b", "if", "not", "self", ".", "ListFields", "(", ")", "==", "other", ".", "ListFields", "(", ")", ":", "return", "False", "# TODO(jieluo): Fix UnknownFieldSet to consider MessageSet extensions,", "# then use it for the comparison.", "unknown_fields", "=", "list", "(", "self", ".", "_unknown_fields", ")", "unknown_fields", ".", "sort", "(", ")", "other_unknown_fields", "=", "list", "(", "other", ".", "_unknown_fields", ")", "other_unknown_fields", ".", "sort", "(", ")", "return", "unknown_fields", "==", "other_unknown_fields", "cls", ".", "__eq__", "=", "__eq__" ]

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

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

[ "GetIdxFromWindow", "(", "self", "Window", "page", ")", "-", ">", "int" ]

[ "def", "GetIdxFromWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiTabContainer_GetIdxFromWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "list_auxiliary_states", "interface", ".", "Can", "override", "when", "creating", "new", "operators", "." ]

[ "def", "list_auxiliary_states", "(", "self", ")", ":", "return", "[", "]" ]

[ "parse", "an", "XML", "from", "a", "file", "descriptor", "and", "build", "a", "tree", "." ]

[ "def", "htmlReadFd", "(", "fd", ",", "URL", ",", "encoding", ",", "options", ")", ":", "ret", "=", "libxml2mod", ".", "htmlReadFd", "(", "fd", ",", "URL", ",", "encoding", ",", "options", ")", "if", "ret", "is", "None", ":", "raise", "treeError", "(", "'htmlReadFd() failed'", ")", "return", "xmlDoc", "(", "_obj", "=", "ret", ")" ]

[ "Formatted", "details", "of", "methods", "functions", "or", "code", "." ]

[ "def", "code_info", "(", "x", ")", ":", "return", "_format_code_info", "(", "_get_code_object", "(", "x", ")", ")" ]

[ "Subclasses", "need", "to", "override", "this", "only", "if", "the", "process", "of", "casting", "data", "from", "some", "accepted", "dtype", "to", "the", "internal", "dtype", "(", "s", ")", "bears", "the", "risk", "of", "truncation", "(", "e", ".", "g", ".", "float", "to", "int", ")", "." ]

[ "def", "_assert_safe_casting", "(", "cls", ",", "data", ",", "subarr", ")", ":", "pass" ]

[ "Return", "a", "string", "representing", "the", "user", "agent", "." ]

[ "def", "user_agent", "(", ")", ":", "data", "=", "{", "\"installer\"", ":", "{", "\"name\"", ":", "\"pip\"", ",", "\"version\"", ":", "__version__", "}", ",", "\"python\"", ":", "platform", ".", "python_version", "(", ")", ",", "\"implementation\"", ":", "{", "\"name\"", ":", "platform", ".", "python_implementation", "(", ")", ",", "}", ",", "}", "if", "data", "[", "\"implementation\"", "]", "[", "\"name\"", "]", "==", "'CPython'", ":", "data", "[", "\"implementation\"", "]", "[", "\"version\"", "]", "=", "platform", ".", "python_version", "(", ")", "elif", "data", "[", "\"implementation\"", "]", "[", "\"name\"", "]", "==", "'PyPy'", ":", "if", "sys", ".", "pypy_version_info", ".", "releaselevel", "==", "'final'", ":", "pypy_version_info", "=", "sys", ".", "pypy_version_info", "[", ":", "3", "]", "else", ":", "pypy_version_info", "=", "sys", ".", "pypy_version_info", "data", "[", "\"implementation\"", "]", "[", "\"version\"", "]", "=", "\".\"", ".", "join", "(", "[", "str", "(", "x", ")", "for", "x", "in", "pypy_version_info", "]", ")", "elif", "data", "[", "\"implementation\"", "]", "[", "\"name\"", "]", "==", "'Jython'", ":", "# Complete Guess", "data", "[", "\"implementation\"", "]", "[", "\"version\"", "]", "=", "platform", ".", "python_version", "(", ")", "elif", "data", "[", "\"implementation\"", "]", "[", "\"name\"", "]", "==", "'IronPython'", ":", "# Complete Guess", "data", "[", "\"implementation\"", "]", "[", "\"version\"", "]", "=", "platform", ".", "python_version", "(", ")", "if", "sys", ".", "platform", ".", "startswith", "(", "\"linux\"", ")", ":", "from", "pip", ".", "_vendor", "import", "distro", "distro_infos", "=", "dict", "(", "filter", "(", "lambda", "x", ":", "x", "[", "1", "]", ",", "zip", "(", "[", "\"name\"", ",", "\"version\"", ",", "\"id\"", "]", ",", "distro", ".", "linux_distribution", "(", ")", ")", ",", ")", ")", "libc", "=", "dict", "(", "filter", "(", "lambda", "x", ":", "x", "[", "1", "]", ",", "zip", "(", "[", "\"lib\"", ",", "\"version\"", "]", ",", "libc_ver", "(", ")", ")", ",", ")", ")", "if", "libc", ":", "distro_infos", "[", "\"libc\"", "]", "=", "libc", "if", "distro_infos", ":", "data", "[", "\"distro\"", "]", "=", "distro_infos", "if", "sys", ".", "platform", ".", "startswith", "(", "\"darwin\"", ")", "and", "platform", ".", "mac_ver", "(", ")", "[", "0", "]", ":", "data", "[", "\"distro\"", "]", "=", "{", "\"name\"", ":", "\"macOS\"", ",", "\"version\"", ":", "platform", ".", "mac_ver", "(", ")", "[", "0", "]", "}", "if", "platform", ".", "system", "(", ")", ":", "data", ".", "setdefault", "(", "\"system\"", ",", "{", "}", ")", "[", "\"name\"", "]", "=", "platform", ".", "system", "(", ")", "if", "platform", ".", "release", "(", ")", ":", "data", ".", "setdefault", "(", "\"system\"", ",", "{", "}", ")", "[", "\"release\"", "]", "=", "platform", ".", "release", "(", ")", "if", "platform", ".", "machine", "(", ")", ":", "data", "[", "\"cpu\"", "]", "=", "platform", ".", "machine", "(", ")", "if", "has_tls", "(", ")", ":", "import", "_ssl", "as", "ssl", "data", "[", "\"openssl_version\"", "]", "=", "ssl", ".", "OPENSSL_VERSION", "setuptools_version", "=", "get_installed_version", "(", "\"setuptools\"", ")", "if", "setuptools_version", "is", "not", "None", ":", "data", "[", "\"setuptools_version\"", "]", "=", "setuptools_version", "# Use None rather than False so as not to give the impression that", "# pip knows it is not being run under CI. Rather, it is a null or", "# inconclusive result. Also, we include some value rather than no", "# value to make it easier to know that the check has been run.", "data", "[", "\"ci\"", "]", "=", "True", "if", "looks_like_ci", "(", ")", "else", "None", "user_data", "=", "os", ".", "environ", ".", "get", "(", "\"PIP_USER_AGENT_USER_DATA\"", ")", "if", "user_data", "is", "not", "None", ":", "data", "[", "\"user_data\"", "]", "=", "user_data", "return", "\"{data[installer][name]}/{data[installer][version]} {json}\"", ".", "format", "(", "data", "=", "data", ",", "json", "=", "json", ".", "dumps", "(", "data", ",", "separators", "=", "(", "\",\"", ",", "\":\"", ")", ",", "sort_keys", "=", "True", ")", ",", ")" ]

[ "Check", "that", "a", "device", "spec", "is", "valid", "." ]

[ "def", "check_valid", "(", "spec", ")", ":", "# Construct a DeviceSpec. It will assert a failure if spec is invalid.", "DeviceSpec", ".", "from_string", "(", "spec", ")" ]

[ "Display", "a", "one", "-", "line", "informational", "message", "on", "screen", "." ]

[ "def", "_info_toast", "(", "self", ",", "message", ")", ":", "self", ".", "_toast", "(", "self", ".", "INFO_MESSAGE_PREFIX", "+", "message", ",", "color", "=", "self", ".", "_INFO_TOAST_COLOR_PAIR", ")" ]

[ "Returns", "a", "list", "of", "dicts", "containing", "the", "following", "values", ":", "name", ":", "name", "of", "the", "entry", "(", "string", ")", "type", ":", "string", "containing", "the", "type", "of", "the", "value", "(", "or", "module", ")", "value", ":", "value", "of", "the", "entry", "if", "it", "is", "a", "string", "int", "double", "or", "bool", "modified", ":", "true", "if", "the", "value", "is", "a", "local", "change", "that", "has", "not", "been", "committed", "default", ":", "true", "if", "the", "value", "has", "not", "been", "changed", "(", "i", ".", "e", ".", "the", "value", "is", "the", "default", "from", "the", "specification", ")", "TODO", ":", "use", "the", "consts", "for", "those", "last", "ones", "Throws", "DataNotFoundError", "if", "the", "identifier", "is", "bad" ]

[ "def", "get_value_maps", "(", "self", ",", "identifier", "=", "None", ",", "all", "=", "False", ")", ":", "result", "=", "[", "]", "if", "not", "identifier", "or", "identifier", "==", "\"/\"", ":", "# No identifier, so we need the list of current modules", "for", "module", "in", "self", ".", "_specifications", ".", "keys", "(", ")", ":", "if", "all", ":", "spec", "=", "self", ".", "get_module_spec", "(", "module", ")", "if", "spec", ":", "spec_part", "=", "spec", ".", "get_config_spec", "(", ")", "self", ".", "_append_value_item", "(", "result", ",", "spec_part", ",", "module", ",", "all", ",", "True", ")", "else", ":", "entry", "=", "_create_value_map_entry", "(", "module", ",", "'module'", ",", "None", ")", "result", ".", "append", "(", "entry", ")", "else", ":", "# Strip off start and end slashes, if they are there", "if", "len", "(", "identifier", ")", ">", "0", "and", "identifier", "[", "0", "]", "==", "'/'", ":", "identifier", "=", "identifier", "[", "1", ":", "]", "if", "len", "(", "identifier", ")", ">", "0", "and", "identifier", "[", "-", "1", "]", "==", "'/'", ":", "identifier", "=", "identifier", "[", ":", "-", "1", "]", "module", ",", "sep", ",", "id", "=", "identifier", ".", "partition", "(", "'/'", ")", "spec", "=", "self", ".", "get_module_spec", "(", "module", ")", "if", "spec", ":", "spec_part", "=", "find_spec_part", "(", "spec", ".", "get_config_spec", "(", ")", ",", "id", ")", "self", ".", "_append_value_item", "(", "result", ",", "spec_part", ",", "identifier", ",", "all", ",", "True", ")", "return", "result" ]

[ "write", "USB", "config", "defines" ]

[ "def", "write_USB_config", "(", "f", ")", ":", "if", "not", "have_type_prefix", "(", "'OTG'", ")", ":", "return", "f", ".", "write", "(", "'// USB configuration\\n'", ")", "(", "USB_VID", ",", "USB_PID", ")", "=", "get_USB_IDs", "(", ")", "f", ".", "write", "(", "'#define HAL_USB_VENDOR_ID 0x%04x\\n'", "%", "int", "(", "USB_VID", ")", ")", "f", ".", "write", "(", "'#define HAL_USB_PRODUCT_ID 0x%04x\\n'", "%", "int", "(", "USB_PID", ")", ")", "f", ".", "write", "(", "'#define HAL_USB_STRING_MANUFACTURER %s\\n'", "%", "get_config", "(", "\"USB_STRING_MANUFACTURER\"", ",", "default", "=", "\"\\\"ArduPilot\\\"\"", ")", ")", "default_product", "=", "\"%BOARD%\"", "if", "args", ".", "bootloader", ":", "default_product", "+=", "\"-BL\"", "f", ".", "write", "(", "'#define HAL_USB_STRING_PRODUCT %s\\n'", "%", "get_config", "(", "\"USB_STRING_PRODUCT\"", ",", "default", "=", "\"\\\"%s\\\"\"", "%", "default_product", ")", ")", "f", ".", "write", "(", "'#define HAL_USB_STRING_SERIAL %s\\n'", "%", "get_config", "(", "\"USB_STRING_SERIAL\"", ",", "default", "=", "\"\\\"%SERIAL%\\\"\"", ")", ")", "f", ".", "write", "(", "'\\n\\n'", ")" ]

[ "Convert", "a", "bit", "array", "to", "a", "prettily", "formated", "hex", "string", ".", "If", "the", "array", "length", "is", "not", "a", "multiple", "of", "8", "it", "is", "padded", "with", "0", "-", "bits", "from", "the", "left", ".", "For", "example", "[", "1", "0", "0", "1", "1", "0", "1", "0", "0", "1", "0", "]", "becomes", "04", ":", "d2", ".", "Args", ":", "bit_array", ":", "the", "bit", "array", "to", "convert", "Returns", ":", "the", "formatted", "hex", "string", "." ]

[ "def", "bits_to_hex", "(", "bit_array", ",", "delimiter", "=", "\":\"", ")", ":", "# Pad the first partial byte.", "partial_bits", "=", "len", "(", "bit_array", ")", "%", "8", "pad_length", "=", "8", "-", "partial_bits", "if", "partial_bits", "else", "0", "bitstring", "=", "\"0\"", "*", "pad_length", "+", "\"\"", ".", "join", "(", "map", "(", "str", ",", "bit_array", ")", ")", "byte_array", "=", "[", "int", "(", "bitstring", "[", "i", ":", "i", "+", "8", "]", ",", "2", ")", "for", "i", "in", "range", "(", "0", ",", "len", "(", "bitstring", ")", ",", "8", ")", "]", "return", "delimiter", ".", "join", "(", "map", "(", "lambda", "x", ":", "\"%02x\"", "%", "x", ",", "byte_array", ")", ")", "return", "bytes_to_hex", "(", "byte_array", ",", "delimiter", "=", "delimiter", ")" ]

[ "Handle", "bare", "Attributes", "i", ".", "e", ".", "[", "tf", ".", "foo", "tf", ".", "bar", "]", "." ]

[ "def", "visit_Attribute", "(", "self", ",", "node", ")", ":", "# pylint: disable=invalid-name", "full_name", "=", "self", ".", "_get_attribute_full_path", "(", "node", ")", "if", "full_name", ":", "self", ".", "_rename_functions", "(", "node", ",", "full_name", ")", "if", "full_name", "in", "self", ".", "_api_change_spec", ".", "change_to_function", ":", "if", "not", "hasattr", "(", "node", ",", "\"is_function_for_call\"", ")", ":", "new_text", "=", "full_name", "+", "\"()\"", "self", ".", "_file_edit", ".", "add", "(", "\"Changed %r to %r\"", "%", "(", "full_name", ",", "new_text", ")", ",", "node", ".", "lineno", ",", "node", ".", "col_offset", ",", "full_name", ",", "new_text", ")", "ast", ".", "NodeVisitor", ".", "generic_visit", "(", "self", ",", "node", ")" ]

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

[ "def", "ScrollLayout", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "VarHVScrollHelper_ScrollLayout", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Normalize", "case", "of", "pathname", "." ]

[ "def", "normcase", "(", "s", ")", ":", "return", "s", ".", "replace", "(", "\"/\"", ",", "\"\\\\\"", ")", ".", "lower", "(", ")" ]

[ "Menu", "command", "to", "turn", "Dial", "rollover", "on", "/", "off", "(", "i", ".", "e", ".", "does", "value", "accumulate", "every", "time", "you", "complete", "a", "revolution", "of", "the", "dial?", ")" ]

[ "def", "_setRollover", "(", "self", ")", ":", "self", ".", "_valuator", "[", "'fRollover'", "]", "=", "self", ".", "_fRollover", ".", "get", "(", ")" ]

[ "Get", "blobs", "and", "copy", "them", "into", "this", "layer", "s", "top", "blob", "vector", "." ]

[ "def", "forward", "(", "self", ")", ":", "blobs", "=", "self", ".", "_get_next_minibatch", "(", ")", "return", "blobs" ]

[ "AnnotationSetStyles", "(", "self", "int", "line", "String", "styles", ")" ]

[ "def", "AnnotationSetStyles", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_AnnotationSetStyles", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Clear", "the", "regular", "expression", "cache" ]

[ "def", "purge", "(", ")", ":", "_cache", ".", "clear", "(", ")", "_cache_repl", ".", "clear", "(", ")" ]

[ "Return", "the", "turtle", "s", "y", "coordinate", "---", "No", "arguments", "." ]

[ "def", "ycor", "(", "self", ")", ":", "return", "self", ".", "_position", "[", "1", "]" ]

[ "Returns", "a", "pair", "of", "trajectories", "obtained", "from", "splitting", "this", "one", "at", "the", "given", "time" ]

[ "def", "split", "(", "self", ",", "time", ")", ":", "if", "time", "<=", "self", ".", "times", "[", "0", "]", ":", "#split before start of trajectory", "return", "self", ".", "constructor", "(", ")", "(", "[", "time", "]", ",", "[", "self", ".", "milestones", "[", "0", "]", "]", ")", ",", "self", ".", "constructor", "(", ")", "(", "[", "time", "]", "+", "self", ".", "times", ",", "[", "self", ".", "milestones", "[", "0", "]", "]", "+", "self", ".", "milestones", ")", "elif", "time", ">=", "self", ".", "times", "[", "-", "1", "]", ":", "#split after end of trajectory", "return", "self", ".", "constructor", "(", ")", "(", "self", ".", "times", "+", "[", "time", "]", ",", "self", ".", "milestones", "+", "[", "self", ".", "milestones", "[", "-", "1", "]", "]", ")", ",", "self", ".", "constructor", "(", ")", "(", "[", "time", "]", ",", "[", "self", ".", "milestones", "[", "-", "1", "]", "]", ")", "i", ",", "u", "=", "self", ".", "getSegment", "(", "time", ")", "assert", "i", ">=", "0", ",", "\"getSegment returned -1? something must be wrong with the times\"", "#split in middle of trajectory", "splitpt", "=", "self", ".", "interpolate_state", "(", "self", ".", "milestones", "[", "i", "]", ",", "self", ".", "milestones", "[", "i", "+", "1", "]", ",", "u", ",", "self", ".", "times", "[", "i", "+", "1", "]", "-", "self", ".", "times", "[", "i", "]", ")", "front", "=", "self", ".", "constructor", "(", ")", "(", "self", ".", "times", "[", ":", "i", "+", "1", "]", ",", "self", ".", "milestones", "[", ":", "i", "+", "1", "]", ")", "back", "=", "self", ".", "constructor", "(", ")", "(", "self", ".", "times", "[", "i", "+", "1", ":", "]", ",", "self", ".", "milestones", "[", "i", "+", "1", ":", "]", ")", "if", "u", ">", "0", ":", "front", ".", "times", ".", "append", "(", "time", ")", "front", ".", "milestones", ".", "append", "(", "splitpt", ")", "if", "u", "<", "1", ":", "back", ".", "times", "=", "[", "time", "]", "+", "back", ".", "times", "back", ".", "milestones", "=", "[", "splitpt", "]", "+", "back", ".", "milestones", "return", "(", "front", ",", "back", ")" ]

[ "This", "process", "validates", "a", "method", "evaluates", "it", "and", "if", "it", "succed", "generates", "a", "ZIP", "file", "with", "a", "JSON", "entry", "for", "each", "sample", ".", "Params", ":", "p", ":", "Dictionary", "of", "parmeters", "with", "the", "GT", "/", "submission", "locations", ".", "If", "None", "is", "passed", "the", "parameters", "send", "by", "the", "system", "are", "used", ".", "default_evaluation_params_fn", ":", "points", "to", "a", "function", "that", "returns", "a", "dictionary", "with", "the", "default", "parameters", "used", "for", "the", "evaluation", "validate_data_fn", ":", "points", "to", "a", "method", "that", "validates", "the", "corrct", "format", "of", "the", "submission", "evaluate_method_fn", ":", "points", "to", "a", "function", "that", "evaluated", "the", "submission", "and", "return", "a", "Dictionary", "with", "the", "results" ]

[ "def", "main_evaluation", "(", "p", ",", "default_evaluation_params_fn", ",", "validate_data_fn", ",", "evaluate_method_fn", ",", "show_result", "=", "True", ",", "per_sample", "=", "True", ")", ":", "if", "(", "p", "==", "None", ")", ":", "p", "=", "dict", "(", "[", "s", "[", "1", ":", "]", ".", "split", "(", "'='", ")", "for", "s", "in", "sys", ".", "argv", "[", "1", ":", "]", "]", ")", "if", "(", "len", "(", "sys", ".", "argv", ")", "<", "3", ")", ":", "print_help", "(", ")", "evalParams", "=", "default_evaluation_params_fn", "(", ")", "if", "'p'", "in", "p", ".", "keys", "(", ")", ":", "evalParams", ".", "update", "(", "p", "[", "'p'", "]", "if", "isinstance", "(", "p", "[", "'p'", "]", ",", "dict", ")", "else", "json", ".", "loads", "(", "p", "[", "'p'", "]", "[", "1", ":", "-", "1", "]", ")", ")", "resDict", "=", "{", "'calculated'", ":", "True", ",", "'Message'", ":", "''", ",", "'method'", ":", "'{}'", ",", "'per_sample'", ":", "'{}'", "}", "try", ":", "validate_data_fn", "(", "p", "[", "'g'", "]", ",", "p", "[", "'s'", "]", ",", "evalParams", ")", "evalData", "=", "evaluate_method_fn", "(", "p", "[", "'g'", "]", ",", "p", "[", "'s'", "]", ",", "evalParams", ")", "resDict", ".", "update", "(", "evalData", ")", "except", "Exception", ",", "e", ":", "resDict", "[", "'Message'", "]", "=", "str", "(", "e", ")", "resDict", "[", "'calculated'", "]", "=", "False", "if", "'o'", "in", "p", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "p", "[", "'o'", "]", ")", ":", "os", ".", "makedirs", "(", "p", "[", "'o'", "]", ")", "resultsOutputname", "=", "p", "[", "'o'", "]", "+", "'/results.zip'", "outZip", "=", "zipfile", ".", "ZipFile", "(", "resultsOutputname", ",", "mode", "=", "'w'", ",", "allowZip64", "=", "True", ")", "del", "resDict", "[", "'per_sample'", "]", "if", "'output_items'", "in", "resDict", ".", "keys", "(", ")", ":", "del", "resDict", "[", "'output_items'", "]", "outZip", ".", "writestr", "(", "'method.json'", ",", "json", ".", "dumps", "(", "resDict", ")", ")", "if", "not", "resDict", "[", "'calculated'", "]", ":", "if", "show_result", ":", "sys", ".", "stderr", ".", "write", "(", "'Error!\\n'", "+", "resDict", "[", "'Message'", "]", "+", "'\\n\\n'", ")", "if", "'o'", "in", "p", ":", "outZip", ".", "close", "(", ")", "return", "resDict", "if", "'o'", "in", "p", ":", "if", "per_sample", "==", "True", ":", "for", "k", ",", "v", "in", "evalData", "[", "'per_sample'", "]", ".", "iteritems", "(", ")", ":", "outZip", ".", "writestr", "(", "k", "+", "'.json'", ",", "json", ".", "dumps", "(", "v", ")", ")", "if", "'output_items'", "in", "evalData", ".", "keys", "(", ")", ":", "for", "k", ",", "v", "in", "evalData", "[", "'output_items'", "]", ".", "iteritems", "(", ")", ":", "outZip", ".", "writestr", "(", "k", ",", "v", ")", "outZip", ".", "close", "(", ")", "if", "show_result", ":", "sys", ".", "stdout", ".", "write", "(", "\"Calculated!\"", ")", "sys", ".", "stdout", ".", "write", "(", "json", ".", "dumps", "(", "resDict", "[", "'method'", "]", ")", ")", "return", "resDict" ]

[ "Return", "content", "signatures", "and", "names", "of", "all", "our", "children", "separated", "by", "new", "-", "lines", ".", "Ensure", "that", "the", "nodes", "are", "sorted", "." ]

[ "def", "get_contents", "(", "self", ")", ":", "return", "SCons", ".", "Node", ".", "_get_contents_map", "[", "self", ".", "_func_get_contents", "]", "(", "self", ")" ]

[ "Return", "a", "count", "of", "messages", "in", "the", "mailbox", "." ]

[ "def", "__len__", "(", "self", ")", ":", "self", ".", "_refresh", "(", ")", "return", "len", "(", "self", ".", "_toc", ")" ]

[ "Returns", "the", "accuracy", "of", "model", "on", "the", "given", "data" ]

[ "def", "accuracy", "(", "model", ",", "X", ",", "y", ")", ":", "correct", "=", "sum", "(", "1", "for", "label", ",", "probs", "in", "zip", "(", "y", ",", "model", ".", "classify", "(", "X", ")", ")", "if", "label", "==", "np", ".", "argmax", "(", "probs", ")", ")", "return", "float", "(", "correct", ")", "/", "len", "(", "y", ")" ]

[ "Appends", "a", "cell", "into", "the", "stack", "." ]

[ "def", "add", "(", "self", ",", "cell", ")", ":", "self", ".", "register_child", "(", "cell", ")" ]

[ "return", "parameter", "object", "instance", "for", "lcmaes", ".", "pcmaes", "." ]

[ "def", "to_params", "(", "x0", ",", "sigma0", ",", "str_algo", "=", "b'acmaes'", ",", "fplot", "=", "None", ",", "lbounds", "=", "None", ",", "ubounds", "=", "None", ",", "scaling", "=", "False", ",", "vscaling", "=", "None", ",", "vshift", "=", "None", ",", "*", "*", "kwargs", ")", ":", "has_bounds", "=", "not", "lbounds", "==", "None", "and", "not", "ubounds", "==", "None", "p", "=", "None", "if", "has_bounds", ":", "if", "scaling", "==", "False", ":", "gp", "=", "lcmaes", ".", "make_genopheno_pwqb", "(", "lbounds", ",", "ubounds", ",", "len", "(", "ubounds", ")", ")", "p", "=", "lcmaes", ".", "make_parameters_pwqb", "(", "x0", ",", "sigma0", ",", "gp", ")", "else", ":", "gp", "=", "lcmaes", ".", "make_genopheno_pwqb_ls", "(", "lbounds", ",", "ubounds", ",", "len", "(", "ubounds", ")", ")", "p", "=", "lcmaes", ".", "make_parameters_pwqb_ls", "(", "x0", ",", "sigma0", ",", "gp", ",", "-", "1", ",", "0", ")", "else", ":", "if", "vscaling", "is", "None", ":", "p", "=", "lcmaes", ".", "make_simple_parameters", "(", "x0", ",", "sigma0", ")", "else", ":", "gp", "=", "lcmaes", ".", "make_genopheno_ls", "(", "vscaling", ",", "vshift", ")", "p", "=", "lcmaes", ".", "make_parameters_ls", "(", "x0", ",", "sigma0", ",", "gp", ")", "p", ".", "set_str_algo", "(", "str_algo", ")", "if", "fplot", "and", "fplot", "!=", "True", ":", "# then fplot must be filename", "global", "fplot_current", "fplot_current", "=", "fplot", "if", "fplot", "or", "fplot", "is", "None", ":", "# 0 or False or '' or \"\" prevents writing", "p", ".", "set_fplot", "(", "fplot_current", ")", "for", "key", ",", "val", "in", "kwargs", ".", "items", "(", ")", ":", "setter", "=", "\"set_\"", "+", "key", "if", "not", "hasattr", "(", "p", ",", "setter", ")", ":", "raise", "ValueError", "(", "setter", "+", "\" is not known as method of CMAParameters\"", ")", "getattr", "(", "p", ",", "setter", ")", "(", "val", ")", "# call setter with value", "return", "p" ]

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

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

[ "Extract", "the", "raw", "traceback", "from", "the", "current", "stack", "frame", "." ]

[ "def", "extract_stack", "(", "f", "=", "None", ",", "limit", "=", "None", ")", ":", "if", "f", "is", "None", ":", "try", ":", "raise", "ZeroDivisionError", "except", "ZeroDivisionError", ":", "f", "=", "sys", ".", "exc_info", "(", ")", "[", "2", "]", ".", "tb_frame", ".", "f_back", "if", "limit", "is", "None", ":", "if", "hasattr", "(", "sys", ",", "'tracebacklimit'", ")", ":", "limit", "=", "sys", ".", "tracebacklimit", "list", "=", "[", "]", "n", "=", "0", "while", "f", "is", "not", "None", "and", "(", "limit", "is", "None", "or", "n", "<", "limit", ")", ":", "lineno", "=", "f", ".", "f_lineno", "co", "=", "f", ".", "f_code", "filename", "=", "co", ".", "co_filename", "name", "=", "co", ".", "co_name", "linecache", ".", "checkcache", "(", "filename", ")", "line", "=", "linecache", ".", "getline", "(", "filename", ",", "lineno", ",", "f", ".", "f_globals", ")", "if", "line", ":", "line", "=", "line", ".", "strip", "(", ")", "else", ":", "line", "=", "None", "list", ".", "append", "(", "(", "filename", ",", "lineno", ",", "name", ",", "line", ")", ")", "f", "=", "f", ".", "f_back", "n", "=", "n", "+", "1", "list", ".", "reverse", "(", ")", "return", "list" ]

[ ":", "param", "str", "name", ":", "the", "identifier", "of", "score", "will", "be", "auto", "-", "generated", "if", "not", "specified", ":", "param", "config", ":", "the", "low", "-", "level", "config", "of", "this", "score", ":", "type", "config", ":", "protobuf", "object" ]

[ "def", "__init__", "(", "self", ",", "name", "=", "None", ",", "config", "=", "None", ")", ":", "BaseScore", ".", "__init__", "(", "self", ",", "name", "=", "name", ",", "class_id", "=", "None", ",", "topic_names", "=", "None", ",", "model_name", "=", "None", ",", "config", "=", "config", ")" ]

[ "Write", "the", "header", "for", "the", "output", "CSV", "file", "." ]

[ "def", "write_header", "(", "self", ")", ":", "# Write the first line of the header.", "self", ".", "writer", ".", "writeheader", "(", ")", "# Write the second line of the header.", "self", ".", "writer", ".", "writerow", "(", "self", ".", "variable_units", ")" ]

[ "Wrapper", "for", "removeNodes", "()", "Thrift", "method" ]

[ "async", "def", "remove_nodes", "(", "client", ":", "AdminAPI", ",", "req", ":", "RemoveNodesRequest", ")", "->", "RemoveNodesResponse", ":", "return", "await", "client", ".", "removeNodes", "(", "req", ")" ]

[ "Fetches", "weights", "from", "features", "." ]

[ "def", "_weights", "(", "features", ",", "weight_column", ")", ":", "with", "ops", ".", "name_scope", "(", "None", ",", "'weights'", ",", "values", "=", "features", ".", "values", "(", ")", ")", ":", "if", "weight_column", "is", "None", ":", "return", "1.", "if", "isinstance", "(", "weight_column", ",", "six", ".", "string_types", ")", ":", "weight_column", "=", "feature_column_lib", ".", "numeric_column", "(", "key", "=", "weight_column", ")", "if", "not", "isinstance", "(", "weight_column", ",", "feature_column_lib", ".", "_NumericColumn", ")", ":", "# pylint: disable=protected-access", "raise", "TypeError", "(", "'Weight column must be either a string or _NumericColumn.'", "' Given type: {}.'", ".", "format", "(", "type", "(", "weight_column", ")", ")", ")", "weights", "=", "weight_column", ".", "_get_dense_tensor", "(", "# pylint: disable=protected-access", "feature_column_lib", ".", "_LazyBuilder", "(", "features", ")", ")", "# pylint: disable=protected-access", "if", "not", "(", "weights", ".", "dtype", ".", "is_floating", "or", "weights", ".", "dtype", ".", "is_integer", ")", ":", "raise", "ValueError", "(", "'Weight column should be castable to float. '", "'Given dtype: {}'", ".", "format", "(", "weights", ".", "dtype", ")", ")", "weights", "=", "_maybe_expand_dim", "(", "math_ops", ".", "to_float", "(", "weights", ",", "name", "=", "'weights'", ")", ")", "return", "weights" ]

[ "Takes", "a", "dict", "|env|", "whose", "values", "are", "strings", "that", "can", "refer", "to", "other", "keys", "for", "example", "env", "[", "foo", "]", "=", "$", "(", "bar", ")", "and", "$", "(", "baz", ")", ".", "Returns", "a", "list", "L", "of", "all", "keys", "of", "env", "such", "that", "key2", "is", "after", "key1", "in", "L", "if", "env", "[", "key2", "]", "refers", "to", "env", "[", "key1", "]", "." ]

[ "def", "_TopologicallySortedEnvVarKeys", "(", "env", ")", ":", "# Since environment variables can refer to other variables, the evaluation", "# order is important. Below is the logic to compute the dependency graph", "# and sort it.", "regex", "=", "re", ".", "compile", "(", "r'\\$\\{([a-zA-Z0-9\\-_]+)\\}'", ")", "def", "GetEdges", "(", "node", ")", ":", "# Use a definition of edges such that user_of_variable -> used_varible.", "# This happens to be easier in this case, since a variable's", "# definition contains all variables it references in a single string.", "# We can then reverse the result of the topological sort at the end.", "# Since: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))", "matches", "=", "set", "(", "[", "v", "for", "v", "in", "regex", ".", "findall", "(", "env", "[", "node", "]", ")", "if", "v", "in", "env", "]", ")", "for", "dependee", "in", "matches", ":", "assert", "'${'", "not", "in", "dependee", ",", "'Nested variables not supported: '", "+", "dependee", "return", "matches", "try", ":", "# Topologically sort, and then reverse, because we used an edge definition", "# that's inverted from the expected result of this function (see comment", "# above).", "order", "=", "gyp", ".", "common", ".", "TopologicallySorted", "(", "env", ".", "keys", "(", ")", ",", "GetEdges", ")", "order", ".", "reverse", "(", ")", "return", "order", "except", "gyp", ".", "common", ".", "CycleError", "as", "e", ":", "raise", "GypError", "(", "'Xcode environment variables are cyclically dependent: '", "+", "str", "(", "e", ".", "nodes", ")", ")" ]

[ "convert", "words", "of", "a", "paragraph", "into", "tagged", "HTML", "text", "handle", "xrefs" ]

[ "def", "make_html_para", "(", "self", ",", "words", ")", ":", "line", "=", "\"\"", "if", "words", ":", "line", "=", "self", ".", "make_html_word", "(", "words", "[", "0", "]", ")", "for", "word", "in", "words", "[", "1", ":", "]", ":", "line", "=", "line", "+", "\" \"", "+", "self", ".", "make_html_word", "(", "word", ")", "# handle hyperlinks", "line", "=", "re_url", ".", "sub", "(", "r'<a href=\"\\1\">\\1</a>'", ",", "line", ")", "# convert `...' quotations into real left and right single quotes", "line", "=", "re", ".", "sub", "(", "r\"(^|\\W)`(.*?)'(\\W|$)\"", ",", "r'\\1&lsquo;\\2&rsquo;\\3'", ",", "line", ")", "# convert tilde into non-breakable space", "line", "=", "string", ".", "replace", "(", "line", ",", "\"~\"", ",", "\"&nbsp;\"", ")", "return", "para_header", "+", "line", "+", "para_footer" ]

[ "Return", "a", "copy", "of", "this", "RequestsCookieJar", "." ]

[ "def", "copy", "(", "self", ")", ":", "new_cj", "=", "RequestsCookieJar", "(", ")", "new_cj", ".", "update", "(", "self", ")", "return", "new_cj" ]

[ "SetEncoding", "(", "self", "String", "encoding", ")" ]

[ "def", "SetEncoding", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextFileHandler_SetEncoding", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Long", "short", "-", "term", "memory", "cell", "with", "attention", "(", "LSTMA", ")", "." ]

[ "def", "__call__", "(", "self", ",", "inputs", ",", "state", ",", "scope", "=", "None", ")", ":", "with", "vs", ".", "variable_scope", "(", "scope", "or", "type", "(", "self", ")", ".", "__name__", ")", ":", "if", "self", ".", "_state_is_tuple", ":", "state", ",", "attns", ",", "attn_states", "=", "state", "else", ":", "states", "=", "state", "state", "=", "array_ops", ".", "slice", "(", "states", ",", "[", "0", ",", "0", "]", ",", "[", "-", "1", ",", "self", ".", "_cell", ".", "state_size", "]", ")", "attns", "=", "array_ops", ".", "slice", "(", "states", ",", "[", "0", ",", "self", ".", "_cell", ".", "state_size", "]", ",", "[", "-", "1", ",", "self", ".", "_attn_size", "]", ")", "attn_states", "=", "array_ops", ".", "slice", "(", "states", ",", "[", "0", ",", "self", ".", "_cell", ".", "state_size", "+", "self", ".", "_attn_size", "]", ",", "[", "-", "1", ",", "self", ".", "_attn_size", "*", "self", ".", "_attn_length", "]", ")", "attn_states", "=", "array_ops", ".", "reshape", "(", "attn_states", ",", "[", "-", "1", ",", "self", ".", "_attn_length", ",", "self", ".", "_attn_size", "]", ")", "input_size", "=", "self", ".", "_input_size", "if", "input_size", "is", "None", ":", "input_size", "=", "inputs", ".", "get_shape", "(", ")", ".", "as_list", "(", ")", "[", "1", "]", "inputs", "=", "_linear", "(", "[", "inputs", ",", "attns", "]", ",", "input_size", ",", "True", ")", "lstm_output", ",", "new_state", "=", "self", ".", "_cell", "(", "inputs", ",", "state", ")", "if", "self", ".", "_state_is_tuple", ":", "new_state_cat", "=", "array_ops", ".", "concat", "(", "1", ",", "nest", ".", "flatten", "(", "new_state", ")", ")", "else", ":", "new_state_cat", "=", "new_state", "new_attns", ",", "new_attn_states", "=", "self", ".", "_attention", "(", "new_state_cat", ",", "attn_states", ")", "with", "vs", ".", "variable_scope", "(", "\"AttnOutputProjection\"", ")", ":", "output", "=", "_linear", "(", "[", "lstm_output", ",", "new_attns", "]", ",", "self", ".", "_attn_size", ",", "True", ")", "new_attn_states", "=", "array_ops", ".", "concat", "(", "1", ",", "[", "new_attn_states", ",", "array_ops", ".", "expand_dims", "(", "output", ",", "1", ")", "]", ")", "new_attn_states", "=", "array_ops", ".", "reshape", "(", "new_attn_states", ",", "[", "-", "1", ",", "self", ".", "_attn_length", "*", "self", ".", "_attn_size", "]", ")", "new_state", "=", "(", "new_state", ",", "new_attns", ",", "new_attn_states", ")", "if", "not", "self", ".", "_state_is_tuple", ":", "new_state", "=", "array_ops", ".", "concat", "(", "1", ",", "list", "(", "new_state", ")", ")", "return", "output", ",", "new_state" ]

[ "GetTreeCtrl", "(", "self", ")", "-", ">", "TreeCtrl" ]

[ "def", "GetTreeCtrl", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "Treebook_GetTreeCtrl", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "print", "the", "given", "line", "(", "provided", "without", "newline", "at", "end", ")", "and", "wrap", "it", "at", "wrap_pos", "splitting", "the", "line", "at", "commas", ".", "Also", "handles", "commented", "out", "lines", "." ]

[ "def", "print_wrapped", "(", "parser", ",", "fileobj", ",", "line", ",", "wrap_pos", "=", "99", ")", ":", "orig_line", "=", "line", "prefix", "=", "\"\"", "next_prefix", "=", "\"// \"", "if", "line", ".", "startswith", "(", "\"//\"", ")", "else", "\" \"", "while", "parser", ".", "indent", "*", "4", "+", "len", "(", "prefix", ")", "+", "len", "(", "line", ")", ">=", "wrap_pos", ":", "splitpos", "=", "line", ".", "rfind", "(", "','", ",", "0", ",", "wrap_pos", "-", "parser", ".", "indent", "*", "4", "-", "len", "(", "prefix", ")", ")", "if", "splitpos", "==", "-", "1", ":", "raise", "Exception", "(", "\"Unable to split line: %s\"", "%", "orig_line", ")", "parser", ".", "write", "(", "fileobj", ",", "prefix", "+", "line", "[", ":", "splitpos", "+", "1", "]", "+", "\"\\n\"", ")", "line", "=", "line", "[", "splitpos", "+", "1", ":", "]", ".", "lstrip", "(", ")", "prefix", "=", "next_prefix", "parser", ".", "write", "(", "fileobj", ",", "prefix", "+", "line", "+", "\"\\n\"", ")" ]

[ "Class", "constructor", "." ]

[ "def", "__init__", "(", "self", ",", "name", "=", "\"\"", ",", "default", "=", "None", ",", "description", "=", "\"\"", ")", ":", "self", ".", "name", "=", "name", "self", ".", "default", "=", "default", "self", ".", "description", "=", "description" ]

[ "Gaussian", "distribution", "." ]

[ "def", "gauss", "(", "self", ",", "mu", ",", "sigma", ")", ":", "# When x and y are two variables from [0, 1), uniformly", "# distributed, then", "#", "# cos(2*pi*x)*sqrt(-2*log(1-y))", "# sin(2*pi*x)*sqrt(-2*log(1-y))", "#", "# are two *independent* variables with normal distribution", "# (mu = 0, sigma = 1).", "# (Lambert Meertens)", "# (corrected version; bug discovered by Mike Miller, fixed by LM)", "# Multithreading note: When two threads call this function", "# simultaneously, it is possible that they will receive the", "# same return value. The window is very small though. To", "# avoid this, you have to use a lock around all calls. (I", "# didn't want to slow this down in the serial case by using a", "# lock here.)", "random", "=", "self", ".", "random", "z", "=", "self", ".", "gauss_next", "self", ".", "gauss_next", "=", "None", "if", "z", "is", "None", ":", "x2pi", "=", "random", "(", ")", "*", "TWOPI", "g2rad", "=", "_sqrt", "(", "-", "2.0", "*", "_log", "(", "1.0", "-", "random", "(", ")", ")", ")", "z", "=", "_cos", "(", "x2pi", ")", "*", "g2rad", "self", ".", "gauss_next", "=", "_sin", "(", "x2pi", ")", "*", "g2rad", "return", "mu", "+", "z", "*", "sigma" ]

[ "Handles", "result", "processing", "." ]

[ "def", "__ProcessResult", "(", "self", ",", "result", ")", ":", "if", "result", "[", "'status'", "]", ":", "self", ".", "__success_count", "+=", "1", "for", "k", ",", "v", "in", "result", "[", "'edits'", "]", ".", "iteritems", "(", ")", ":", "self", ".", "__edits", "[", "k", "]", ".", "extend", "(", "v", ")", "self", ".", "__edit_count", "+=", "len", "(", "v", ")", "else", ":", "self", ".", "__failed_count", "+=", "1", "sys", ".", "stdout", ".", "write", "(", "'\\nFailed to process %s\\n'", "%", "result", "[", "'filename'", "]", ")", "sys", ".", "stdout", ".", "write", "(", "result", "[", "'stderr'", "]", ")", "sys", ".", "stdout", ".", "write", "(", "'\\n'", ")", "percentage", "=", "(", "float", "(", "self", ".", "__success_count", "+", "self", ".", "__failed_count", ")", "/", "len", "(", "self", ".", "__filenames", ")", ")", "*", "100", "sys", ".", "stdout", ".", "write", "(", "'Succeeded: %d, Failed: %d, Edits: %d [%.2f%%]\\r'", "%", "(", "self", ".", "__success_count", ",", "self", ".", "__failed_count", ",", "self", ".", "__edit_count", ",", "percentage", ")", ")", "sys", ".", "stdout", ".", "flush", "(", ")" ]

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

[ "def", "GetMarginOptions", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_GetMarginOptions", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Generates", "a", "podspec", "file", "from", "all", "BUILD", "files", "under", "absl", "directory", "." ]

[ "def", "generate", "(", "args", ")", ":", "rules", "=", "filter", "(", "relevant_rule", ",", "collect_rules", "(", "\"absl\"", ")", ")", "with", "open", "(", "args", ".", "output", ",", "\"wt\"", ")", "as", "f", ":", "write_podspec", "(", "f", ",", "rules", ",", "vars", "(", "args", ")", ")" ]

[ "Checks", "for", "invalid", "increment", "*", "count", "++", "." ]

[ "def", "CheckInvalidIncrement", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "_RE_PATTERN_INVALID_INCREMENT", ".", "match", "(", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/invalid_increment'", ",", "5", ",", "'Changing pointer instead of value (or unused value of operator*).'", ")" ]

[ "Overwritten", "by", "subclass", "to", "execute", "the", "algorithm", "." ]

[ "def", "RequestData", "(", "self", ",", "vtkself", ",", "request", ",", "inInfo", ",", "outInfo", ")", ":", "raise", "NotImplementedError", "(", "'RequestData must be implemented'", ")" ]

[ "force", "warnings", "to", "treated", "as", "errors" ]

[ "def", "_parse_policy_werror", "(", "self", ",", "has_baseline", ",", "final_targets", ",", "extra_flags", ")", ":", "flags", "=", "self", ".", "cc_flags", "[", "\"werror\"", "]", "if", "not", "flags", ":", "self", ".", "dist_log", "(", "\"current compiler doesn't support werror flags, \"", "\"warnings will 'not' treated as errors\"", ",", "stderr", "=", "True", ")", "else", ":", "self", ".", "dist_log", "(", "\"compiler warnings are treated as errors\"", ")", "extra_flags", "+=", "flags", "return", "has_baseline", ",", "final_targets", ",", "extra_flags" ]

[ "Constructs", "a", "De", "Jong", "problem", "(", "Box", "-", "Constrained", "Continuous", "Single", "-", "Objective", ")" ]

[ "def", "_dejong_ctor", "(", "self", ",", "dim", "=", "10", ")", ":", "# We construct the arg list for the original constructor exposed by", "# boost_python", "arg_list", "=", "[", "]", "arg_list", ".", "append", "(", "dim", ")", "self", ".", "_orig_init", "(", "*", "arg_list", ")" ]

[ "Loads", "a", "PKCS#1", "DER", "-", "encoded", "public", "key", "file", "from", "OpenSSL", "." ]

[ "def", "load_pkcs1_openssl_der", "(", "cls", ",", "keyfile", ")", ":", "from", "rsa", ".", "asn1", "import", "OpenSSLPubKey", "from", "pyasn1", ".", "codec", ".", "der", "import", "decoder", "from", "pyasn1", ".", "type", "import", "univ", "(", "keyinfo", ",", "_", ")", "=", "decoder", ".", "decode", "(", "keyfile", ",", "asn1Spec", "=", "OpenSSLPubKey", "(", ")", ")", "if", "keyinfo", "[", "'header'", "]", "[", "'oid'", "]", "!=", "univ", ".", "ObjectIdentifier", "(", "'1.2.840.113549.1.1.1'", ")", ":", "raise", "TypeError", "(", "\"This is not a DER-encoded OpenSSL-compatible public key\"", ")", "return", "cls", ".", "_load_pkcs1_der", "(", "keyinfo", "[", "'key'", "]", "[", "1", ":", "]", ")" ]