Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Remove", "connections", "created", "by", ":", "py", ":", "meth", ":", "addParameterEditWidgetConnections", "." ]

[ "def", "removeParameterEditWidgetConnections", "(", "parameterEditWidgets", ",", "updateParameterNodeFromGUI", ")", ":", "for", "(", "widget", ",", "parameterName", ")", "in", "parameterEditWidgets", ":", "widgetClassName", "=", "widget", ".", "className", "(", ")", "if", "widgetClassName", "==", "\"QSpinBox\"", ":", "widget", ".", "disconnect", "(", "\"valueChanged(int)\"", ",", "updateParameterNodeFromGUI", ")", "elif", "widgetClassName", "==", "\"QPushButton\"", ":", "widget", ".", "disconnect", "(", "\"toggled(bool)\"", ",", "updateParameterNodeFromGUI", ")", "elif", "widgetClassName", "==", "\"qMRMLNodeComboBox\"", ":", "widget", ".", "disconnect", "(", "\"currentNodeIDChanged(QString)\"", ",", "updateParameterNodeFromGUI", ")", "elif", "widgetClassName", "==", "\"QComboBox\"", ":", "widget", ".", "disconnect", "(", "\"currentIndexChanged(int)\"", ",", "updateParameterNodeFromGUI", ")", "elif", "widgetClassName", "==", "\"ctkSliderWidget\"", ":", "widget", ".", "disconnect", "(", "\"valueChanged(double)\"", ",", "updateParameterNodeFromGUI", ")" ]

[ ">", ":", "Greater", "than", "Required", "argument", ":", "an", "AE", "object", "reference", "Keyword", "argument", "_attributes", ":", "AppleEvent", "attribute", "dictionary", "Returns", ":", "anything" ]

[ "def", "_3e_", "(", "self", ",", "_object", ",", "_attributes", "=", "{", "}", ",", "*", "*", "_arguments", ")", ":", "_code", "=", "'ascr'", "_subcode", "=", "'> '", "if", "_arguments", ":", "raise", "TypeError", ",", "'No optional args expected'", "_arguments", "[", "'----'", "]", "=", "_object", "_reply", ",", "_arguments", ",", "_attributes", "=", "self", ".", "send", "(", "_code", ",", "_subcode", ",", "_arguments", ",", "_attributes", ")", "if", "_arguments", ".", "get", "(", "'errn'", ",", "0", ")", ":", "raise", "aetools", ".", "Error", ",", "aetools", ".", "decodeerror", "(", "_arguments", ")", "# XXXX Optionally decode result", "if", "_arguments", ".", "has_key", "(", "'----'", ")", ":", "return", "_arguments", "[", "'----'", "]" ]

[ "Returns", "a", "fresh", "path", "object" ]

[ "def", "beginPath", "(", "self", ")", ":", "return", "PDFPathObject", "(", ")" ]

[ "Returns", "the", "state", "of", "the", "scheduler", "as", "a", ":", "class", ":", "dict", "." ]

[ "def", "state_dict", "(", "self", ")", ":", "return", "{", "key", ":", "value", "for", "key", ",", "value", "in", "self", ".", "__dict__", ".", "items", "(", ")", "if", "key", "!=", "'optimizer'", "}" ]

[ "DoSetClientSize", "(", "self", "int", "width", "int", "height", ")" ]

[ "def", "DoSetClientSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_wizard", ".", "PyWizardPage_DoSetClientSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "The", "contents", "of", "an", "alias", "is", "the", "concatenation", "of", "the", "content", "signatures", "of", "all", "its", "sources", "." ]

[ "def", "get_contents", "(", "self", ")", ":", "childsigs", "=", "[", "n", ".", "get_csig", "(", ")", "for", "n", "in", "self", ".", "children", "(", ")", "]", "return", "''", ".", "join", "(", "childsigs", ")" ]

[ "Return", "a", "list", "of", "the", "values", "." ]

[ "def", "tolist", "(", "self", ")", ":", "if", "not", "isinstance", "(", "self", ".", "_values", ",", "np", ".", "ndarray", ")", ":", "# check for ndarray instead of dtype to catch DTA/TDA", "return", "list", "(", "self", ".", "_values", ")", "return", "self", ".", "_values", ".", "tolist", "(", ")" ]

[ "Args", ":", "functions", ":", "List", "of", "2", "-", "tuples", "(", "prefix", "function", ")", "e", ".", "g", ".", "[", "(", "pluralize", "_Pluralize", ")", "(", "cycle", "_Cycle", ")", "]" ]

[ "def", "__init__", "(", "self", ",", "functions", ")", ":", "self", ".", "functions", "=", "functions" ]

[ "extended_message", ":", "Message", "instance", "for", "which", "we", "are", "the", "Extensions", "dict", "." ]

[ "def", "__init__", "(", "self", ",", "extended_message", ")", ":", "self", ".", "_extended_message", "=", "extended_message" ]

[ "Guess", "the", "extensions", "for", "a", "file", "based", "on", "its", "MIME", "type", "." ]

[ "def", "guess_all_extensions", "(", "type", ",", "strict", "=", "True", ")", ":", "if", "_db", "is", "None", ":", "init", "(", ")", "return", "_db", ".", "guess_all_extensions", "(", "type", ",", "strict", ")" ]

[ "Update", "the", "panel", "for", "the", "current", "filetype", "handler" ]

[ "def", "UpdateForHandler", "(", "self", ")", ":", "handler", "=", "self", ".", "GetCurrentHandler", "(", ")", "elist", "=", "self", ".", "FindWindowById", "(", "ID_EXECUTABLES", ")", "elist", ".", "DeleteAllItems", "(", ")", "def_ch", "=", "self", ".", "FindWindowById", "(", "wx", ".", "ID_DEFAULT", ")", "def_ch", ".", "SetItems", "(", "handler", ".", "GetAliases", "(", ")", ")", "def_ch", ".", "SetStringSelection", "(", "handler", ".", "GetDefault", "(", ")", ")", "self", ".", "SetListItems", "(", "handler", ".", "GetCommands", "(", ")", ")", "# Enable control states", "transient", "=", "handler", ".", "meta", ".", "transient", "def_ch", ".", "Enable", "(", "not", "transient", ")", "elist", ".", "Enable", "(", "not", "transient", ")", "self", ".", "addbtn", ".", "Enable", "(", "not", "transient", ")", "self", ".", "delbtn", ".", "Enable", "(", "not", "transient", ")", "if", "self", ".", "infotxt", ".", "Show", "(", "transient", ")", ":", "self", ".", "Layout", "(", ")" ]

[ "r", "SetEquirectangular2", "(", "SpatialReference", "self", "double", "clat", "double", "clong", "double", "pseudostdparallellat", "double", "fe", "double", "fn", ")", "-", ">", "OGRErr" ]

[ "def", "SetEquirectangular2", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_osr", ".", "SpatialReference_SetEquirectangular2", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Notification", "that", "a", "TimerHandle", "has", "been", "cancelled", "." ]

[ "def", "_timer_handle_cancelled", "(", "self", ",", "handle", ")", ":", "raise", "NotImplementedError" ]

[ "Return", "the", "main", "path", "to", "the", "top", "-", "level", "dir", "of", "the", "Intel", "compiler", "using", "the", "given", "version", ".", "The", "compiler", "will", "be", "in", "<top", ">", "/", "bin", "/", "icl", ".", "exe", "(", "icc", "on", "linux", ")", "the", "include", "dir", "is", "<top", ">", "/", "include", "etc", "." ]

[ "def", "get_intel_compiler_top", "(", "version", ",", "abi", ")", ":", "if", "is_windows", ":", "if", "not", "SCons", ".", "Util", ".", "can_read_reg", ":", "raise", "NoRegistryModuleError", "(", "\"No Windows registry module was found\"", ")", "top", "=", "get_intel_registry_value", "(", "'ProductDir'", ",", "version", ",", "abi", ")", "archdir", "=", "{", "'x86_64'", ":", "'intel64'", ",", "'amd64'", ":", "'intel64'", ",", "'em64t'", ":", "'intel64'", ",", "'x86'", ":", "'ia32'", ",", "'i386'", ":", "'ia32'", ",", "'ia32'", ":", "'ia32'", "}", "[", "abi", "]", "# for v11 and greater", "# pre-11, icl was in Bin. 11 and later, it's in Bin/<abi> apparently.", "if", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "top", ",", "\"Bin\"", ",", "\"icl.exe\"", ")", ")", "and", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "top", ",", "\"Bin\"", ",", "abi", ",", "\"icl.exe\"", ")", ")", "and", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "top", ",", "\"Bin\"", ",", "archdir", ",", "\"icl.exe\"", ")", ")", ":", "raise", "MissingDirError", "(", "\"Can't find Intel compiler in %s\"", "%", "(", "top", ")", ")", "elif", "is_mac", "or", "is_linux", ":", "def", "find_in_2008style_dir", "(", "version", ")", ":", "# first dir is new (>=9.0) style, second is old (8.0) style.", "dirs", "=", "(", "'/opt/intel/cc/%s'", ",", "'/opt/intel_cc_%s'", ")", "if", "abi", "==", "'x86_64'", ":", "dirs", "=", "(", "'/opt/intel/cce/%s'", ",", ")", "# 'e' stands for 'em64t', aka x86_64 aka amd64", "top", "=", "None", "for", "d", "in", "dirs", ":", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", "%", "version", ",", "\"bin\"", ",", "\"icc\"", ")", ")", ":", "top", "=", "d", "%", "version", "break", "return", "top", "def", "find_in_2010style_dir", "(", "version", ")", ":", "dirs", "=", "(", "'/opt/intel/Compiler/%s/*'", "%", "version", ")", "# typically /opt/intel/Compiler/11.1/064 (then bin/intel64/icc)", "dirs", "=", "glob", ".", "glob", "(", "dirs", ")", "# find highest sub-version number by reverse sorting and picking first existing one.", "dirs", ".", "sort", "(", ")", "dirs", ".", "reverse", "(", ")", "top", "=", "None", "for", "d", "in", "dirs", ":", "if", "(", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"ia32\"", ",", "\"icc\"", ")", ")", "or", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"intel64\"", ",", "\"icc\"", ")", ")", ")", ":", "top", "=", "d", "break", "return", "top", "def", "find_in_2011style_dir", "(", "version", ")", ":", "# The 2011 (compiler v12) dirs are inconsistent, so just redo the search from", "# get_all_compiler_versions and look for a match (search the newest form first)", "top", "=", "None", "for", "d", "in", "glob", ".", "glob", "(", "'/opt/intel/composer_xe_*'", ")", ":", "# Typical dir here is /opt/intel/composer_xe_2011_sp1.11.344", "# The _sp1 is useless, the installers are named 2011.9.x, 2011.10.x, 2011.11.x", "m", "=", "re", ".", "search", "(", "r'([0-9]{0,4})(?:_sp\\d*)?\\.([0-9][0-9.]*)$'", ",", "d", ")", "if", "m", ":", "cur_ver", "=", "\"%s.%s\"", "%", "(", "m", ".", "group", "(", "1", ")", ",", "m", ".", "group", "(", "2", ")", ")", "if", "cur_ver", "==", "version", "and", "(", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"ia32\"", ",", "\"icc\"", ")", ")", "or", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"intel64\"", ",", "\"icc\"", ")", ")", ")", ":", "top", "=", "d", "break", "if", "not", "top", ":", "for", "d", "in", "glob", ".", "glob", "(", "'/opt/intel/composerxe-*'", ")", ":", "# Typical dir here is /opt/intel/composerxe-2011.4.184", "m", "=", "re", ".", "search", "(", "r'([0-9][0-9.]*)$'", ",", "d", ")", "if", "m", "and", "m", ".", "group", "(", "1", ")", "==", "version", "and", "(", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"ia32\"", ",", "\"icc\"", ")", ")", "or", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"intel64\"", ",", "\"icc\"", ")", ")", ")", ":", "top", "=", "d", "break", "return", "top", "def", "find_in_2016style_dir", "(", "version", ")", ":", "# The 2016 (compiler v16) dirs are inconsistent from previous.", "top", "=", "None", "for", "d", "in", "glob", ".", "glob", "(", "'/opt/intel/compilers_and_libraries_%s/linux'", "%", "version", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"ia32\"", ",", "\"icc\"", ")", ")", "or", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "d", ",", "\"bin\"", ",", "\"intel64\"", ",", "\"icc\"", ")", ")", ":", "top", "=", "d", "break", "return", "top", "top", "=", "find_in_2016style_dir", "(", "version", ")", "or", "find_in_2011style_dir", "(", "version", ")", "or", "find_in_2010style_dir", "(", "version", ")", "or", "find_in_2008style_dir", "(", "version", ")", "# print \"INTELC: top=\",top", "if", "not", "top", ":", "raise", "MissingDirError", "(", "\"Can't find version %s Intel compiler in %s (abi='%s')\"", "%", "(", "version", ",", "top", ",", "abi", ")", ")", "return", "top" ]

[ "LineUpRectExtend", "(", "self", ")" ]

[ "def", "LineUpRectExtend", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_LineUpRectExtend", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Perform", "a", "bunch", "of", "sanity", "tests", "to", "make", "sure", "the", "Add", "-", "on", "SDK", "environment", "is", "sane", "and", "then", "display", "a", "welcome", "message", "." ]

[ "def", "welcome", "(", ")", ":", "try", ":", "if", "sys", ".", "version_info", "[", "0", "]", ">", "2", ":", "print", "(", "\"Error: You appear to be using Python %d, but \"", "\"the Add-on SDK only supports the Python 2.x line.\"", "%", "(", "sys", ".", "version_info", "[", "0", "]", ")", ")", "return", "import", "mozrunner", "if", "'CUDDLEFISH_ROOT'", "not", "in", "os", ".", "environ", ":", "print", "(", "\"Error: CUDDLEFISH_ROOT environment variable does \"", "\"not exist! It should point to the root of the \"", "\"Add-on SDK repository.\"", ")", "return", "env_root", "=", "os", ".", "environ", "[", "'CUDDLEFISH_ROOT'", "]", "bin_dir", "=", "os", ".", "path", ".", "join", "(", "env_root", ",", "'bin'", ")", "python_lib_dir", "=", "os", ".", "path", ".", "join", "(", "env_root", ",", "'python-lib'", ")", "path", "=", "os", ".", "environ", "[", "'PATH'", "]", ".", "split", "(", "os", ".", "path", ".", "pathsep", ")", "if", "bin_dir", "not", "in", "path", ":", "print", "(", "\"Warning: the Add-on SDK binary directory %s \"", "\"does not appear to be in your PATH. You may \"", "\"not be able to run 'cfx' or other SDK tools.\"", "%", "bin_dir", ")", "if", "python_lib_dir", "not", "in", "sys", ".", "path", ":", "print", "(", "\"Warning: the Add-on SDK python-lib directory %s \"", "\"does not appear to be in your sys.path, which \"", "\"is odd because I'm running from it.\"", "%", "python_lib_dir", ")", "if", "not", "mozrunner", ".", "__path__", "[", "0", "]", ".", "startswith", "(", "env_root", ")", ":", "print", "(", "\"Warning: your mozrunner package is installed at %s, \"", "\"which does not seem to be located inside the Jetpack \"", "\"SDK. This may cause problems, and you may want to \"", "\"uninstall the other version. See bug 556562 for \"", "\"more information.\"", "%", "mozrunner", ".", "__path__", "[", "0", "]", ")", "except", "Exception", ":", "# Apparently we can't get the actual exception object in the", "# 'except' clause in a way that's syntax-compatible for both", "# Python 2.x and 3.x, so we'll have to use the traceback module.", "import", "traceback", "_", ",", "e", ",", "_", "=", "sys", ".", "exc_info", "(", ")", "print", "(", "\"Verification of Add-on SDK environment failed (%s).\"", "%", "e", ")", "print", "(", "\"Your SDK may not work properly.\"", ")", "return", "print", "(", "\"Welcome to the Add-on SDK. For the docs, visit https://developer.mozilla.org/en-US/Add-ons/SDK\"", ")" ]

[ "Try", "to", "find", "common", "names", "to", "attach", "to", "the", "result", "of", "an", "operation", "between", "a", "and", "b", ".", "Return", "a", "consensus", "list", "of", "names", "if", "they", "match", "at", "least", "partly", "or", "list", "of", "None", "if", "they", "have", "completely", "different", "names", "." ]

[ "def", "_maybe_match_names", "(", "self", ",", "other", ")", ":", "if", "len", "(", "self", ".", "names", ")", "!=", "len", "(", "other", ".", "names", ")", ":", "return", "[", "None", "]", "*", "len", "(", "self", ".", "names", ")", "names", "=", "[", "]", "for", "a_name", ",", "b_name", "in", "zip", "(", "self", ".", "names", ",", "other", ".", "names", ")", ":", "if", "a_name", "==", "b_name", ":", "names", ".", "append", "(", "a_name", ")", "else", ":", "# TODO: what if they both have np.nan for their names?", "names", ".", "append", "(", "None", ")", "return", "names" ]

[ "Send", "a", "WHOIS", "command", "." ]

[ "def", "whois", "(", "self", ",", "targets", ")", ":", "self", ".", "send_raw", "(", "\"WHOIS \"", "+", "\",\"", ".", "join", "(", "targets", ")", ")" ]

[ "The", "loss", "to", "minimize", "while", "training", "." ]

[ "def", "loss", "(", "self", ",", "data", ",", "labels", ")", ":", "if", "self", ".", "is_regression", ":", "diff", "=", "self", ".", "training_inference_graph", "(", "data", ")", "-", "math_ops", ".", "to_float", "(", "labels", ")", "mean_squared_error", "=", "math_ops", ".", "reduce_mean", "(", "diff", "*", "diff", ")", "root_mean_squared_error", "=", "math_ops", ".", "sqrt", "(", "mean_squared_error", ",", "name", "=", "\"loss\"", ")", "loss", "=", "root_mean_squared_error", "else", ":", "loss", "=", "math_ops", ".", "reduce_mean", "(", "nn_ops", ".", "sparse_softmax_cross_entropy_with_logits", "(", "self", ".", "training_inference_graph", "(", "data", ")", ",", "array_ops", ".", "squeeze", "(", "math_ops", ".", "to_int32", "(", "labels", ")", ")", ")", ",", "name", "=", "\"loss\"", ")", "if", "self", ".", "regularizer", ":", "loss", "+=", "layers", ".", "apply_regularization", "(", "self", ".", "regularizer", ",", "variables", ".", "trainable_variables", "(", ")", ")", "return", "loss" ]

[ "Export", "trained", "threshold", "to", "TorchQuantizer", "s", "quant", "info", "[", "bitwidth", "fp", "]", "." ]

[ "def", "export_quant_info", "(", "self", ")", ":", "bitwidth", "=", "self", ".", "bitwidth", ".", "item", "(", ")", "ceil_log2t", "=", "torch", ".", "ceil", "(", "self", ".", "log_threshold", ")", ".", "item", "(", ")", "return", "[", "bitwidth", ",", "int", "(", "bitwidth", "-", "1", "-", "ceil_log2t", ")", "]" ]

[ "Convert", "the", "X", "units", "of", "ws", "to", "wavelength", "." ]

[ "def", "_convertToWavelength", "(", "self", ",", "ws", ")", ":", "wavelengthWSName", "=", "self", ".", "_names", ".", "withSuffix", "(", "'in_wavelength'", ")", "wavelengthWS", "=", "ConvertUnits", "(", "InputWorkspace", "=", "ws", ",", "OutputWorkspace", "=", "wavelengthWSName", ",", "Target", "=", "'Wavelength'", ",", "EMode", "=", "'Elastic'", ",", "EnableLogging", "=", "self", ".", "_subalgLogging", ")", "self", ".", "_cleanup", ".", "cleanup", "(", "ws", ")", "return", "wavelengthWS" ]

[ "Opens", "getting", "started", "wizard", "." ]

[ "def", "OpenGettingStartedWizard", "(", "self", ")", ":", "self", ".", "OpenDialog", "(", "'GETTINGSTARTED'", ")" ]

[ "Same", "as", "isinstance", "(", "x", "array", ")", "except", "on", "Python", "2", ".", "2", "where", "it", "always", "returns", "False", ".", "This", "helps", "PyPNG", "work", "on", "Python", "2", ".", "2", "." ]

[ "def", "isarray", "(", "x", ")", ":", "try", ":", "return", "isinstance", "(", "x", ",", "array", ")", "except", ":", "return", "False" ]

[ "Validate", "ESLint", "is", "the", "expected", "version" ]

[ "def", "_validate_version", "(", "self", ",", "warn", "=", "False", ")", ":", "esl_version", "=", "callo", "(", "[", "self", ".", "path", ",", "\"--version\"", "]", ")", ".", "rstrip", "(", ")", "# Ignore the leading v in the version string.", "if", "ESLINT_VERSION", "==", "esl_version", "[", "1", ":", "]", ":", "return", "True", "if", "warn", ":", "print", "(", "\"WARNING: eslint found in path, but incorrect version found at \"", "+", "self", ".", "path", "+", "\" with version: \"", "+", "esl_version", ")", "return", "False" ]

[ "Gets", "TensorInfos", "for", "all", "outputs", "of", "the", "SignatureDef", "." ]

[ "def", "_get_outputs_tensor_info_from_meta_graph_def", "(", "meta_graph_def", ",", "signature_def_key", ")", ":", "return", "signature_def_utils", ".", "get_signature_def_by_key", "(", "meta_graph_def", ",", "signature_def_key", ")", ".", "outputs" ]

[ "GetPartialTextExtents", "(", "self", "text", ")", "-", ">", "[", "widths", "]" ]

[ "def", "GetPartialTextExtents", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "GraphicsContext_GetPartialTextExtents", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "a", "string", "representing", "time", "in", "seconds", "since", "epoch", "t", "." ]

[ "def", "time2netscape", "(", "t", "=", "None", ")", ":", "if", "t", "is", "None", ":", "dt", "=", "datetime", ".", "datetime", ".", "utcnow", "(", ")", "else", ":", "dt", "=", "datetime", ".", "datetime", ".", "utcfromtimestamp", "(", "t", ")", "return", "\"%s, %02d-%s-%04d %02d:%02d:%02d GMT\"", "%", "(", "DAYS", "[", "dt", ".", "weekday", "(", ")", "]", ",", "dt", ".", "day", ",", "MONTHS", "[", "dt", ".", "month", "-", "1", "]", ",", "dt", ".", "year", ",", "dt", ".", "hour", ",", "dt", ".", "minute", ",", "dt", ".", "second", ")" ]

[ "Get", "the", "mode", "." ]

[ "def", "mode", "(", "self", ")", ":", "return", "self", ".", "_mode" ]

[ "Return", "the", "union", "of", "two", "sets", "as", "a", "new", "set", "." ]

[ "def", "union", "(", "self", ",", "other", ")", ":", "result", "=", "self", ".", "__class__", "(", "self", ")", "result", ".", "_update", "(", "other", ")", "return", "result" ]

[ "Transform", "a", "Ruby", "signature", "into", "RST", "nodes", ".", "Returns", "(", "fully", "qualified", "name", "of", "the", "thing", "classname", "if", "any", ")", "." ]

[ "def", "handle_signature", "(", "self", ",", "sig", ",", "signode", ")", ":", "m", "=", "rb_sig_re", ".", "match", "(", "sig", ")", "if", "m", "is", "None", ":", "raise", "ValueError", "name_prefix", ",", "name", ",", "arglist", ",", "retann", "=", "m", ".", "groups", "(", ")", "if", "not", "name_prefix", ":", "name_prefix", "=", "\"\"", "# determine module and class name (if applicable), as well as full name", "modname", "=", "self", ".", "options", ".", "get", "(", "'module'", ",", "self", ".", "env", ".", "temp_data", ".", "get", "(", "'rb:module'", ")", ")", "classname", "=", "self", ".", "env", ".", "temp_data", ".", "get", "(", "'rb:class'", ")", "if", "self", ".", "objtype", "==", "'global'", ":", "add_module", "=", "False", "modname", "=", "None", "classname", "=", "None", "fullname", "=", "name", "elif", "classname", ":", "add_module", "=", "False", "if", "name_prefix", "and", "name_prefix", ".", "startswith", "(", "classname", ")", ":", "fullname", "=", "name_prefix", "+", "name", "# class name is given again in the signature", "name_prefix", "=", "name_prefix", "[", "len", "(", "classname", ")", ":", "]", ".", "lstrip", "(", "'.'", ")", "else", ":", "separator", "=", "separators", "[", "self", ".", "objtype", "]", "fullname", "=", "classname", "+", "separator", "+", "name_prefix", "+", "name", "else", ":", "add_module", "=", "True", "if", "name_prefix", ":", "classname", "=", "name_prefix", ".", "rstrip", "(", "'.'", ")", "fullname", "=", "name_prefix", "+", "name", "else", ":", "classname", "=", "''", "fullname", "=", "name", "signode", "[", "'module'", "]", "=", "modname", "signode", "[", "'class'", "]", "=", "self", ".", "class_name", "=", "classname", "signode", "[", "'fullname'", "]", "=", "fullname", "sig_prefix", "=", "self", ".", "get_signature_prefix", "(", "sig", ")", "if", "sig_prefix", ":", "signode", "+=", "addnodes", ".", "desc_annotation", "(", "sig_prefix", ",", "sig_prefix", ")", "if", "name_prefix", ":", "signode", "+=", "addnodes", ".", "desc_addname", "(", "name_prefix", ",", "name_prefix", ")", "# exceptions are a special case, since they are documented in the", "# 'exceptions' module.", "elif", "add_module", "and", "self", ".", "env", ".", "config", ".", "add_module_names", ":", "if", "self", ".", "objtype", "==", "'global'", ":", "nodetext", "=", "''", "signode", "+=", "addnodes", ".", "desc_addname", "(", "nodetext", ",", "nodetext", ")", "else", ":", "modname", "=", "self", ".", "options", ".", "get", "(", "'module'", ",", "self", ".", "env", ".", "temp_data", ".", "get", "(", "'rb:module'", ")", ")", "if", "modname", "and", "modname", "!=", "'exceptions'", ":", "nodetext", "=", "modname", "+", "separators", "[", "self", ".", "objtype", "]", "signode", "+=", "addnodes", ".", "desc_addname", "(", "nodetext", ",", "nodetext", ")", "signode", "+=", "addnodes", ".", "desc_name", "(", "name", ",", "name", ")", "if", "not", "arglist", ":", "if", "self", ".", "needs_arglist", "(", ")", ":", "# for callables, add an empty parameter list", "signode", "+=", "addnodes", ".", "desc_parameterlist", "(", ")", "if", "retann", ":", "signode", "+=", "addnodes", ".", "desc_returns", "(", "retann", ",", "retann", ")", "return", "fullname", ",", "name_prefix", "signode", "+=", "addnodes", ".", "desc_parameterlist", "(", ")", "stack", "=", "[", "signode", "[", "-", "1", "]", "]", "for", "token", "in", "rb_paramlist_re", ".", "split", "(", "arglist", ")", ":", "if", "token", "==", "'['", ":", "opt", "=", "addnodes", ".", "desc_optional", "(", ")", "stack", "[", "-", "1", "]", "+=", "opt", "stack", ".", "append", "(", "opt", ")", "elif", "token", "==", "']'", ":", "try", ":", "stack", ".", "pop", "(", ")", "except", "IndexError", ":", "raise", "ValueError", "elif", "not", "token", "or", "token", "==", "','", "or", "token", ".", "isspace", "(", ")", ":", "pass", "else", ":", "token", "=", "token", ".", "strip", "(", ")", "stack", "[", "-", "1", "]", "+=", "addnodes", ".", "desc_parameter", "(", "token", ",", "token", ")", "if", "len", "(", "stack", ")", "!=", "1", ":", "raise", "ValueError", "if", "retann", ":", "signode", "+=", "addnodes", ".", "desc_returns", "(", "retann", ",", "retann", ")", "return", "fullname", ",", "name_prefix" ]

[ "SetPos", "(", "self", "int", "x", "int", "y", ")" ]

[ "def", "SetPos", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html", ".", "HtmlCell_SetPos", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Validate", "tolerance", "values", "." ]

[ "def", "validate_tol", "(", "rtol", ",", "atol", ",", "n", ")", ":", "if", "rtol", "<", "100", "*", "EPS", ":", "warn", "(", "\"`rtol` is too low, setting to {}\"", ".", "format", "(", "100", "*", "EPS", ")", ")", "rtol", "=", "100", "*", "EPS", "atol", "=", "np", ".", "asarray", "(", "atol", ")", "if", "atol", ".", "ndim", ">", "0", "and", "atol", ".", "shape", "!=", "(", "n", ",", ")", ":", "raise", "ValueError", "(", "\"`atol` has wrong shape.\"", ")", "if", "np", ".", "any", "(", "atol", "<", "0", ")", ":", "raise", "ValueError", "(", "\"`atol` must be positive.\"", ")", "return", "rtol", ",", "atol" ]

[ "ApplyAdam", "TBE", "register" ]

[ "def", "_apply_adam_tbe", "(", ")", ":", "return" ]

[ "Determine", "if", "int_", "falls", "into", "one", "of", "the", "ranges", "in", "ranges", "." ]

[ "def", "intranges_contain", "(", "int_", ",", "ranges", ")", ":", "tuple_", "=", "_encode_range", "(", "int_", ",", "0", ")", "pos", "=", "bisect", ".", "bisect_left", "(", "ranges", ",", "tuple_", ")", "# we could be immediately ahead of a tuple (start, end)", "# with start < int_ <= end", "if", "pos", ">", "0", ":", "left", ",", "right", "=", "_decode_range", "(", "ranges", "[", "pos", "-", "1", "]", ")", "if", "left", "<=", "int_", "<", "right", ":", "return", "True", "# or we could be immediately behind a tuple (int_, end)", "if", "pos", "<", "len", "(", "ranges", ")", ":", "left", ",", "_", "=", "_decode_range", "(", "ranges", "[", "pos", "]", ")", "if", "left", "==", "int_", ":", "return", "True", "return", "False" ]

[ "Return", "the", "mask", "of", "the", "records", ".", "A", "record", "is", "masked", "when", "all", "the", "fields", "are", "masked", "." ]

[ "def", "_get_recordmask", "(", "self", ")", ":", "_mask", "=", "ndarray", ".", "__getattribute__", "(", "self", ",", "'_mask'", ")", ".", "view", "(", "ndarray", ")", "if", "_mask", ".", "dtype", ".", "names", "is", "None", ":", "return", "_mask", "return", "np", ".", "all", "(", "flatten_structured_array", "(", "_mask", ")", ",", "axis", "=", "-", "1", ")" ]

[ "NewStringProperty", "(", "String", "label", "=", "(", "*", "wxPGProperty", "::", "sm_wxPG_LABEL", ")", "String", "name", "=", "(", "*", "wxPGProperty", "::", "sm_wxPG_LABEL", ")", "String", "value", "=", "wxEmptyString", ")", "-", ">", "PGProperty" ]

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

[ "Show", "array", "indices", "for", "the", "lines", "at", "the", "top", "and", "bottom", "of", "the", "output", "." ]

[ "def", "_show_array_indices", "(", "self", ")", ":", "indices_top", "=", "self", ".", "_show_array_index_at_line", "(", "0", ")", "output_top", "=", "self", ".", "_output_top_row", "if", "self", ".", "_main_menu_pad", ":", "output_top", "+=", "1", "bottom_line_index", "=", "(", "self", ".", "_output_pad_screen_location", ".", "bottom", "-", "output_top", "-", "1", ")", "indices_bottom", "=", "self", ".", "_show_array_index_at_line", "(", "bottom_line_index", ")", "if", "indices_top", "or", "indices_bottom", ":", "return", "{", "0", ":", "indices_top", ",", "-", "1", ":", "indices_bottom", "}", "else", ":", "return", "None" ]

[ "Convenience", "function", "to", "format", "and", "return", "a", "key", "=", "value", "pair", "." ]

[ "def", "_formatparam", "(", "param", ",", "value", "=", "None", ",", "quote", "=", "1", ")", ":", "if", "value", "is", "not", "None", "and", "len", "(", "value", ")", ">", "0", ":", "if", "quote", "or", "tspecials", ".", "search", "(", "value", ")", ":", "value", "=", "value", ".", "replace", "(", "'\\\\'", ",", "'\\\\\\\\'", ")", ".", "replace", "(", "'\"'", ",", "r'\\\"'", ")", "return", "'%s=\"%s\"'", "%", "(", "param", ",", "value", ")", "else", ":", "return", "'%s=%s'", "%", "(", "param", ",", "value", ")", "else", ":", "return", "param" ]

[ "Write", "text", "word", "-", "wrapped", "at", "self", ".", "width", "characters", "." ]

[ "def", "_line", "(", "self", ",", "text", ",", "indent", "=", "0", ")", ":", "leading_space", "=", "' '", "*", "indent", "while", "len", "(", "leading_space", ")", "+", "len", "(", "text", ")", ">", "self", ".", "width", ":", "# The text is too wide; wrap if possible.", "# Find the rightmost space that would obey our width constraint and", "# that's not an escaped space.", "available_space", "=", "self", ".", "width", "-", "len", "(", "leading_space", ")", "-", "len", "(", "' $'", ")", "space", "=", "available_space", "while", "True", ":", "space", "=", "text", ".", "rfind", "(", "' '", ",", "0", ",", "space", ")", "if", "(", "space", "<", "0", "or", "self", ".", "_count_dollars_before_index", "(", "text", ",", "space", ")", "%", "2", "==", "0", ")", ":", "break", "if", "space", "<", "0", ":", "# No such space; just use the first unescaped space we can find.", "space", "=", "available_space", "-", "1", "while", "True", ":", "space", "=", "text", ".", "find", "(", "' '", ",", "space", "+", "1", ")", "if", "(", "space", "<", "0", "or", "self", ".", "_count_dollars_before_index", "(", "text", ",", "space", ")", "%", "2", "==", "0", ")", ":", "break", "if", "space", "<", "0", ":", "# Give up on breaking.", "break", "self", ".", "output", ".", "write", "(", "leading_space", "+", "text", "[", "0", ":", "space", "]", "+", "' $\\n'", ")", "text", "=", "text", "[", "space", "+", "1", ":", "]", "# Subsequent lines are continuations, so indent them.", "leading_space", "=", "' '", "*", "(", "indent", "+", "2", ")", "self", ".", "output", ".", "write", "(", "leading_space", "+", "text", "+", "'\\n'", ")" ]

[ "Add", "a", "timedelta", "-", "like", "Tick", "or", "TimedeltaIndex", "-", "like", "object", "to", "self", "yielding", "an", "int64", "numpy", "array" ]

[ "def", "_add_delta", "(", "self", ",", "other", ")", ":", "if", "isinstance", "(", "other", ",", "(", "Tick", ",", "timedelta", ",", "np", ".", "timedelta64", ")", ")", ":", "new_values", "=", "self", ".", "_add_timedeltalike_scalar", "(", "other", ")", "elif", "is_timedelta64_dtype", "(", "other", ")", ":", "# ndarray[timedelta64] or TimedeltaArray/index", "new_values", "=", "self", ".", "_add_delta_tdi", "(", "other", ")", "return", "new_values" ]

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

[ "Add", "a", "dbus", "file", "to", "the", "list", "of", "dbus", "files", "to", "process", ".", "Store", "them", "in", "the", "attribute", "*", "dbus_lst", "*", "." ]

[ "def", "add_dbus_file", "(", "self", ",", "filename", ",", "prefix", ",", "mode", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'dbus_lst'", ")", ":", "self", ".", "dbus_lst", "=", "[", "]", "if", "not", "'process_dbus'", "in", "self", ".", "meths", ":", "self", ".", "meths", ".", "append", "(", "'process_dbus'", ")", "self", ".", "dbus_lst", ".", "append", "(", "[", "filename", ",", "prefix", ",", "mode", "]", ")" ]

[ "This", "returns", "True", "if", "the", "EOF", "exception", "was", "ever", "raised", "." ]

[ "def", "eof", "(", "self", ")", ":", "return", "self", ".", "flag_eof" ]

[ "Support", "the", "pickle", "protocol", "." ]

[ "def", "__setstate__", "(", "self", ",", "state", ")", ":", "self", ".", "__init__", "(", ")", "self", ".", "ParseFromString", "(", "state", "[", "'serialized'", "]", ")" ]

[ "Called", "after", "renderer", "has", "written", "content", "." ]

[ "def", "postWrite", "(", "self", ",", "page", ")", ":", "pass" ]

[ "Iterate", "over", "atomic", "positions", ".", "Returns", "Quantity", "(", "Vec3", "()", "unit", ")", "objects", "unlike", "iter_locations", "which", "returns", "Atom", ".", "Location", "objects", "." ]

[ "def", "iter_positions", "(", "self", ")", ":", "for", "loc", "in", "self", ".", "iter_locations", "(", ")", ":", "yield", "loc", ".", "position" ]

[ "Construct", "a", "FieldTypeArray", "." ]

[ "def", "__init__", "(", "self", ",", "element_type", ")", ":", "# type: (FieldTypeSingle) -> None", "self", ".", "element_type", "=", "element_type", "# type: FieldTypeSingle", "super", "(", "FieldTypeArray", ",", "self", ")", ".", "__init__", "(", "element_type", ".", "file_name", ",", "element_type", ".", "line", ",", "element_type", ".", "column", ")" ]

[ "GetPlaybackRate", "(", "self", ")", "-", ">", "double" ]

[ "def", "GetPlaybackRate", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_media", ".", "MediaCtrl_GetPlaybackRate", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Convert", "a", "blob", "proto", "to", "an", "array", ".", "In", "default", "we", "will", "just", "return", "the", "data", "unless", "return_diff", "is", "True", "in", "which", "case", "we", "will", "return", "the", "diff", "." ]

[ "def", "blobproto_to_array", "(", "blob", ",", "return_diff", "=", "False", ")", ":", "if", "return_diff", ":", "return", "np", ".", "array", "(", "blob", ".", "diff", ")", ".", "reshape", "(", "blob", ".", "num", ",", "blob", ".", "channels", ",", "blob", ".", "height", ",", "blob", ".", "width", ")", "else", ":", "return", "np", ".", "array", "(", "blob", ".", "data", ")", ".", "reshape", "(", "blob", ".", "num", ",", "blob", ".", "channels", ",", "blob", ".", "height", ",", "blob", ".", "width", ")" ]

[ "indicator", "is", "a", "NodePath" ]

[ "def", "setAvatarPhysicsIndicator", "(", "self", ",", "indicator", ")", ":", "assert", "self", ".", "notify", ".", "debugStateCall", "(", "self", ")", "self", ".", "cWallSphereNodePath", ".", "show", "(", ")" ]

[ "Sets", "the", "error", "-", "message", "filters", "." ]

[ "def", "SetFilters", "(", "self", ",", "filters", ")", ":", "# Default filters always have less priority than the flag ones.", "self", ".", "filters", "=", "_DEFAULT_FILTERS", "[", ":", "]", "for", "filt", "in", "filters", ".", "split", "(", "','", ")", ":", "clean_filt", "=", "filt", ".", "strip", "(", ")", "if", "clean_filt", ":", "self", ".", "filters", ".", "append", "(", "clean_filt", ")", "for", "filt", "in", "self", ".", "filters", ":", "if", "not", "(", "filt", ".", "startswith", "(", "'+'", ")", "or", "filt", ".", "startswith", "(", "'-'", ")", ")", ":", "raise", "ValueError", "(", "'Every filter in --filters must start with + or -'", "' (%s does not)'", "%", "filt", ")" ]

[ "Returns", "pointLabel", "Drawing", "Function" ]

[ "def", "GetPointLabelFunc", "(", "self", ")", ":", "return", "self", ".", "_pointLabelFunc" ]

[ "Return", "the", "file", "descriptor", "of", "the", "profiler", "s", "log", "file", "." ]

[ "def", "fileno", "(", "self", ")", ":", "return", "self", ".", "_prof", ".", "fileno", "(", ")" ]

[ "Handles", "the", "wx", ".", "EVT_MOTION", "event", "for", ":", "class", ":", "FlatMenu", "." ]

[ "def", "OnMouseMove", "(", "self", ",", "event", ")", ":", "if", "\"__WXMSW__\"", "in", "wx", ".", "Platform", ":", "# Ignore dummy mouse move events", "pt", "=", "wx", ".", "GetMousePosition", "(", ")", "if", "self", ".", "_mousePtAtStartup", "==", "pt", ":", "return", "pos", "=", "event", ".", "GetPosition", "(", ")", "# we need to ignore extra mouse events: example when this happens is when", "# the mouse is on the menu and we open a submenu from keyboard - Windows", "# then sends us a dummy mouse move event, we (correctly) determine that it", "# happens in the parent menu and so immediately close the just opened", "# submenunot", "if", "\"__WXMSW__\"", "in", "wx", ".", "Platform", ":", "ptCur", "=", "self", ".", "ClientToScreen", "(", "pos", ")", "if", "ptCur", "==", "self", ".", "_ptLast", ":", "return", "self", ".", "_ptLast", "=", "ptCur", "# first let the scrollbar handle it", "self", ".", "TryScrollButtons", "(", "event", ")", "self", ".", "ProcessMouseMove", "(", "pos", ")" ]

[ "Get", "the", "original", "object", "if", "wrapped", "in", "one", "or", "more", "@decorators" ]

[ "def", "_get_wrapped", "(", "obj", ")", ":", "orig_obj", "=", "obj", "i", "=", "0", "while", "safe_hasattr", "(", "obj", ",", "'__wrapped__'", ")", ":", "obj", "=", "obj", ".", "__wrapped__", "i", "+=", "1", "if", "i", ">", "100", ":", "# __wrapped__ is probably a lie, so return the thing we started with", "return", "orig_obj", "return", "obj" ]

[ "Insert", "item", "x", "in", "list", "a", "and", "keep", "it", "sorted", "assuming", "a", "is", "sorted", "." ]

[ "def", "insort_right", "(", "a", ",", "x", ",", "lo", "=", "0", ",", "hi", "=", "None", ")", ":", "if", "lo", "<", "0", ":", "raise", "ValueError", "(", "'lo must be non-negative'", ")", "if", "hi", "is", "None", ":", "hi", "=", "len", "(", "a", ")", "while", "lo", "<", "hi", ":", "mid", "=", "(", "lo", "+", "hi", ")", "//", "2", "if", "x", "<", "a", "[", "mid", "]", ":", "hi", "=", "mid", "else", ":", "lo", "=", "mid", "+", "1", "a", ".", "insert", "(", "lo", ",", "x", ")" ]

[ "For", "each", "direct", "dependency", "of", "the", "currently", "build", "manifest", "check", "if", "it", "is", "also", "cargo", "-", "builded", "and", "if", "yes", "then", "extract", "it", "s", "git", "configs", "and", "install", "dir" ]

[ "def", "_resolve_dep_to_git", "(", "self", ")", ":", "dependencies", "=", "self", ".", "manifest", ".", "get_dependencies", "(", "self", ".", "ctx", ")", "if", "not", "dependencies", ":", "return", "[", "]", "dep_to_git", "=", "{", "}", "for", "dep", "in", "dependencies", ":", "dep_manifest", "=", "self", ".", "loader", ".", "load_manifest", "(", "dep", ")", "dep_builder", "=", "dep_manifest", ".", "get", "(", "\"build\"", ",", "\"builder\"", ",", "ctx", "=", "self", ".", "ctx", ")", "if", "dep_builder", "not", "in", "[", "\"cargo\"", ",", "\"nop\"", "]", "or", "dep", "==", "\"rust\"", ":", "# This is a direct dependency, but it is not build with cargo", "# and it is not simply copying files with nop, so ignore it.", "# The \"rust\" dependency is an exception since it contains the", "# toolchain.", "continue", "git_conf", "=", "dep_manifest", ".", "get_section_as_dict", "(", "\"git\"", ",", "self", ".", "ctx", ")", "if", "\"repo_url\"", "not", "in", "git_conf", ":", "raise", "Exception", "(", "\"A cargo dependency requires git.repo_url to be defined.\"", ")", "source_dir", "=", "self", ".", "loader", ".", "get_project_install_dir", "(", "dep_manifest", ")", "if", "dep_builder", "==", "\"cargo\"", ":", "source_dir", "=", "os", ".", "path", ".", "join", "(", "source_dir", ",", "\"source\"", ")", "git_conf", "[", "\"source_dir\"", "]", "=", "source_dir", "dep_to_git", "[", "dep", "]", "=", "git_conf", "return", "dep_to_git" ]

[ "Update", "cef", "/", "patch", "/", "directory", "with", "CEF", "Python", "patches", ".", "Issue73", "is", "applied", "in", "getenv", "()", "by", "setting", "appropriate", "env", "var", "." ]

[ "def", "update_cef_patches", "(", ")", ":", "print", "(", "\"[automate.py] Updating CEF patches with CEF Python patches\"", ")", "cef_dir", "=", "os", ".", "path", ".", "join", "(", "Options", ".", "cef_build_dir", ",", "\"cef\"", ")", "cef_patch_dir", "=", "os", ".", "path", ".", "join", "(", "cef_dir", ",", "\"patch\"", ")", "cef_patches_dir", "=", "os", ".", "path", ".", "join", "(", "cef_patch_dir", ",", "\"patches\"", ")", "# Copy src/patches/*.patch to cef/patch/patches/", "cefpython_patches_dir", "=", "os", ".", "path", ".", "join", "(", "Options", ".", "cefpython_dir", ",", "\"patches\"", ")", "cefpython_patches", "=", "glob", ".", "glob", "(", "os", ".", "path", ".", "join", "(", "cefpython_patches_dir", ",", "\"*.patch\"", ")", ")", "for", "file_", "in", "cefpython_patches", ":", "print", "(", "\"[automate.py] Copying %s to %s\"", "%", "(", "os", ".", "path", ".", "basename", "(", "file_", ")", ",", "cef_patches_dir", ")", ")", "shutil", ".", "copy", "(", "file_", ",", "cef_patches_dir", ")", "# Append cefpython/patches/patch.py to cef/patch/patch.cfg", "cef_patch_cfg", "=", "os", ".", "path", ".", "join", "(", "cef_patch_dir", ",", "\"patch.cfg\"", ")", "print", "(", "\"[automate.py] Overwriting %s\"", "%", "cef_patch_cfg", ")", "with", "open", "(", "cef_patch_cfg", ",", "\"rb\"", ")", "as", "fp", ":", "cef_patch_cfg_contents", "=", "fp", ".", "read", "(", ")", ".", "decode", "(", "\"utf-8\"", ")", "cef_patch_cfg_contents", "+=", "\"\\n\"", "cefpython_patch_cfg", "=", "os", ".", "path", ".", "join", "(", "cefpython_patches_dir", ",", "\"patch.py\"", ")", "with", "open", "(", "cefpython_patch_cfg", ",", "\"rb\"", ")", "as", "fp", ":", "cefpython_patch_cfg_contents", "=", "fp", ".", "read", "(", ")", ".", "decode", "(", "\"utf-8\"", ")", "with", "open", "(", "cef_patch_cfg", ",", "\"wb\"", ")", "as", "fp", ":", "cef_patch_cfg_contents", "=", "cef_patch_cfg_contents", ".", "replace", "(", "\"\\r\\n\"", ",", "\"\\n\"", ")", "cefpython_patch_cfg_contents", "=", "cefpython_patch_cfg_contents", ".", "replace", "(", "\"\\r\\n\"", ",", "\"\\n\"", ")", "new_contents", "=", "cef_patch_cfg_contents", "+", "cefpython_patch_cfg_contents", "fp", ".", "write", "(", "new_contents", ".", "encode", "(", "\"utf-8\"", ")", ")" ]

[ "Validate", "that", "the", "given", "value", "match", "Names", "production" ]

[ "def", "validateNamesValue", "(", "value", ")", ":", "ret", "=", "libxml2mod", ".", "xmlValidateNamesValue", "(", "value", ")", "return", "ret" ]

[ "Note", "that", "we", "pass", "in", "a", "descriptor", "instead", "of", "the", "generated", "directly", "since", "at", "the", "time", "we", "construct", "a", "_RepeatedCompositeFieldContainer", "we", "haven", "t", "yet", "necessarily", "initialized", "the", "type", "that", "will", "be", "contained", "in", "the", "container", "." ]

[ "def", "__init__", "(", "self", ",", "message_listener", ",", "message_descriptor", ")", ":", "super", "(", "RepeatedCompositeFieldContainer", ",", "self", ")", ".", "__init__", "(", "message_listener", ")", "self", ".", "_message_descriptor", "=", "message_descriptor" ]

[ "Error", "to", "specify", "that", "the", "json", "file", "is", "corrupt", "and", "couldn", "t", "be", "parsed", "." ]

[ "def", "error_project_json_decode", "(", "args", ")", ":", "message", "=", "\"Unable to parse '{}'.\\n\"", ".", "format", "(", "args", ".", "project_file", ")", "if", "not", "args", ".", "silent", "and", "HAS_WIN_MODULES", ":", "MESSAGEBOX", "(", "None", ",", "message", ",", "command_title", "(", "args", ")", ",", "win32con", ".", "MB_OK", "|", "win32con", ".", "MB_ICONERROR", ")", "else", ":", "sys", ".", "stderr", ".", "write", "(", "message", ")", "sys", ".", "exit", "(", "601", ")" ]

[ "Returns", "a", "path", "canonicalized", "for", "alphabetical", "comparison", "." ]

[ "def", "CanonicalizeAlphabeticalOrder", "(", "self", ",", "header_path", ")", ":", "return", "header_path", ".", "replace", "(", "'-inl.h'", ",", "'.h'", ")", ".", "replace", "(", "'-'", ",", "'_'", ")", ".", "lower", "(", ")" ]

[ "Check", "a", "palette", "argument", "(", "to", "the", ":", "class", ":", "Writer", "class", ")", "for", "validity", ".", "Returns", "the", "palette", "as", "a", "list", "if", "okay", ";", "raises", "an", "exception", "otherwise", "." ]

[ "def", "check_palette", "(", "palette", ")", ":", "# None is the default and is allowed.", "if", "palette", "is", "None", ":", "return", "None", "p", "=", "list", "(", "palette", ")", "if", "not", "(", "0", "<", "len", "(", "p", ")", "<=", "256", ")", ":", "raise", "ValueError", "(", "\"a palette must have between 1 and 256 entries\"", ")", "seen_triple", "=", "False", "for", "i", ",", "t", "in", "enumerate", "(", "p", ")", ":", "if", "len", "(", "t", ")", "not", "in", "(", "3", ",", "4", ")", ":", "raise", "ValueError", "(", "\"palette entry %d: entries must be 3- or 4-tuples.\"", "%", "i", ")", "if", "len", "(", "t", ")", "==", "3", ":", "seen_triple", "=", "True", "if", "seen_triple", "and", "len", "(", "t", ")", "==", "4", ":", "raise", "ValueError", "(", "\"palette entry %d: all 4-tuples must precede all 3-tuples\"", "%", "i", ")", "for", "x", "in", "t", ":", "if", "int", "(", "x", ")", "!=", "x", "or", "not", "(", "0", "<=", "x", "<=", "255", ")", ":", "raise", "ValueError", "(", "\"palette entry %d: values must be integer: 0 <= x <= 255\"", "%", "i", ")", "return", "p" ]

[ "Calculate", "the", "entropy", "of", "a", "chunk", "of", "data", "." ]

[ "def", "entropy_H", "(", "self", ",", "data", ")", ":", "if", "len", "(", "data", ")", "==", "0", ":", "return", "0.0", "occurences", "=", "array", ".", "array", "(", "'L'", ",", "[", "0", "]", "*", "256", ")", "for", "x", "in", "data", ":", "occurences", "[", "ord", "(", "x", ")", "]", "+=", "1", "entropy", "=", "0", "for", "x", "in", "occurences", ":", "if", "x", ":", "p_x", "=", "float", "(", "x", ")", "/", "len", "(", "data", ")", "entropy", "-=", "p_x", "*", "math", ".", "log", "(", "p_x", ",", "2", ")", "return", "entropy" ]

[ "Extends", "the", "lock", "on", "a", "task", "previously", "locked", "by", "get_one", "for", "another", "self", ".", "timeout", "seconds", ".", "If", "the", "task", "has", "already", "timed", "out", "raises", "TaskTimedOutException", "." ]

[ "def", "extend", "(", "self", ",", "tr", ",", "taskDict", ")", ":", "pass" ]

[ "SetColumnImage", "(", "self", "int", "column", "int", "image", ")" ]

[ "def", "SetColumnImage", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "TreeListCtrl_SetColumnImage", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Reads", "|count|", "bytes", "from", "the", "file", "-", "like", "|file|", "object", "raising", "a", "MachOError", "if", "any", "other", "number", "of", "bytes", "is", "read", "." ]

[ "def", "CheckedRead", "(", "file", ",", "count", ")", ":", "bytes", "=", "file", ".", "read", "(", "count", ")", "if", "len", "(", "bytes", ")", "!=", "count", ":", "raise", "MachOError", ",", "'read: expected length %d, observed %d'", "%", "(", "count", ",", "len", "(", "bytes", ")", ")", "return", "bytes" ]

[ "r", "getJacobian", "(", "GeneralizedIKSolver", "self", ")" ]

[ "def", "getJacobian", "(", "self", ")", "->", "\"void\"", ":", "return", "_robotsim", ".", "GeneralizedIKSolver_getJacobian", "(", "self", ")" ]

[ "Get", "a", "specific", "header", "as", "from", "a", "dictionary", "." ]

[ "def", "__getitem__", "(", "self", ",", "name", ")", ":", "return", "self", ".", "dict", "[", "name", ".", "lower", "(", ")", "]" ]

[ "Convenience", "method", "for", "serializing", "objects", "using", "the", "given", "protocol", "factory", "and", "a", "TMemoryBuffer", "." ]

[ "def", "serialize", "(", "protocol_factory", ",", "thr", ")", ":", "# type: (Any, Any) -> AnyStr", "transport", "=", "TTransport", ".", "TMemoryBuffer", "(", ")", "protocol", "=", "protocol_factory", ".", "getProtocol", "(", "transport", ")", "thr", ".", "write", "(", "protocol", ")", "if", "isinstance", "(", "protocol", ",", "THeaderProtocol", ".", "THeaderProtocol", ")", ":", "protocol", ".", "trans", ".", "flush", "(", ")", "return", "transport", ".", "getvalue", "(", ")" ]

[ "Compute", "the", "gradient", "of", "loss", "with", "respect", "to", "coefs", "and", "intercept", "for", "specified", "layer", "." ]

[ "def", "_compute_loss_grad", "(", "self", ",", "layer", ",", "n_samples", ",", "activations", ",", "deltas", ",", "coef_grads", ",", "intercept_grads", ")", ":", "coef_grads", "[", "layer", "]", "=", "safe_sparse_dot", "(", "activations", "[", "layer", "]", ".", "T", ",", "deltas", "[", "layer", "]", ")", "coef_grads", "[", "layer", "]", "+=", "(", "self", ".", "alpha", "*", "self", ".", "coefs_", "[", "layer", "]", ")", "coef_grads", "[", "layer", "]", "/=", "n_samples", "intercept_grads", "[", "layer", "]", "=", "np", ".", "mean", "(", "deltas", "[", "layer", "]", ",", "0", ")", "return", "coef_grads", ",", "intercept_grads" ]

[ "Test", "if", "the", "address", "is", "reserved", "for", "link", "-", "local", "." ]

[ "def", "is_link_local", "(", "self", ")", ":", "return", "(", "self", ".", "network_address", ".", "is_link_local", "and", "self", ".", "broadcast_address", ".", "is_link_local", ")" ]

[ "Helper", "to", "define", "a", "parse", "action", "by", "mapping", "a", "function", "to", "all", "elements", "of", "a", "ParseResults", "list", ".", "If", "any", "additional", "args", "are", "passed", "they", "are", "forwarded", "to", "the", "given", "function", "as", "additional", "arguments", "after", "the", "token", "as", "in", "C", "{", "hex_integer", "=", "Word", "(", "hexnums", ")", ".", "setParseAction", "(", "tokenMap", "(", "int", "16", "))", "}", "which", "will", "convert", "the", "parsed", "data", "to", "an", "integer", "using", "base", "16", "." ]

[ "def", "tokenMap", "(", "func", ",", "*", "args", ")", ":", "def", "pa", "(", "s", ",", "l", ",", "t", ")", ":", "return", "[", "func", "(", "tokn", ",", "*", "args", ")", "for", "tokn", "in", "t", "]", "try", ":", "func_name", "=", "getattr", "(", "func", ",", "'__name__'", ",", "getattr", "(", "func", ",", "'__class__'", ")", ".", "__name__", ")", "except", "Exception", ":", "func_name", "=", "str", "(", "func", ")", "pa", ".", "__name__", "=", "func_name", "return", "pa" ]

[ "Set", "the", "logging", "flag", "to", "int", "(", "1", "=", "on", "0", "=", "off", ")" ]

[ "def", "setLogging", "(", "self", ",", "enable", ")", ":", "self", ".", "__logging", "=", "enable" ]

[ "Update", "metrics", "using", "the", "output", "of", "self", ".", "model", "." ]

[ "def", "call", "(", "self", ",", "eval_data", ")", ":", "raise", "NotImplementedError", "(", "\"Evaluators must define a call member function.\"", ")" ]

[ "Dict", "-", "like", "values", "()", "that", "returns", "a", "list", "of", "values", "of", "cookies", "from", "the" ]

[ "def", "values", "(", "self", ")", ":", "return", "list", "(", "self", ".", "itervalues", "(", ")", ")" ]

[ "Creates", "necessary", "tasks", "to", "produce", "initial", "cache", "archive", "." ]

[ "def", "_PopulateCommonPipelines", "(", "self", ")", ":", "self", ".", "_original_headers_path", "=", "self", ".", "RebaseOutputPath", "(", "'common/response-headers.json'", ")", "@", "self", ".", "RegisterTask", "(", "'common/webpages-patched.wpr'", ",", "dependencies", "=", "[", "self", ".", "_common_builder", ".", "original_wpr_task", "]", ")", "def", "BuildPatchedWpr", "(", ")", ":", "shutil", ".", "copyfile", "(", "self", ".", "_common_builder", ".", "original_wpr_task", ".", "path", ",", "BuildPatchedWpr", ".", "path", ")", "wpr_archive", "=", "wpr_backend", ".", "WprArchiveBackend", "(", "BuildPatchedWpr", ".", "path", ")", "# Save up original response headers.", "original_response_headers", "=", "{", "e", ".", "url", ":", "e", ".", "GetResponseHeadersDict", "(", ")", "for", "e", "in", "wpr_archive", ".", "ListUrlEntries", "(", ")", "}", "logging", ".", "info", "(", "'save up response headers for %d resources'", ",", "len", "(", "original_response_headers", ")", ")", "if", "not", "original_response_headers", ":", "# TODO(gabadie): How is it possible to not even have the main resource", "# in the WPR archive? Example URL can be found in:", "# http://crbug.com/623966#c5", "raise", "Exception", "(", "'Looks like no resources were recorded in WPR during: {}'", ".", "format", "(", "self", ".", "_common_builder", ".", "original_wpr_task", ".", "name", ")", ")", "with", "open", "(", "self", ".", "_original_headers_path", ",", "'w'", ")", "as", "file_output", ":", "json", ".", "dump", "(", "original_response_headers", ",", "file_output", ")", "# Patch WPR.", "wpr_url_entries", "=", "wpr_archive", ".", "ListUrlEntries", "(", ")", "for", "wpr_url_entry", "in", "wpr_url_entries", ":", "sandwich_utils", ".", "PatchWprEntryToBeCached", "(", "wpr_url_entry", ")", "logging", ".", "info", "(", "'number of patched entries: %d'", ",", "len", "(", "wpr_url_entries", ")", ")", "wpr_archive", ".", "Persist", "(", ")", "@", "self", ".", "RegisterTask", "(", "'common/original-cache.zip'", ",", "[", "BuildPatchedWpr", "]", ")", "def", "BuildOriginalCache", "(", ")", ":", "runner", "=", "self", ".", "_common_builder", ".", "CreateSandwichRunner", "(", ")", "runner", ".", "wpr_archive_path", "=", "BuildPatchedWpr", ".", "path", "runner", ".", "cache_archive_path", "=", "BuildOriginalCache", ".", "path", "runner", ".", "cache_operation", "=", "sandwich_runner", ".", "CacheOperation", ".", "SAVE", "runner", ".", "output_dir", "=", "BuildOriginalCache", ".", "run_path", "runner", ".", "Run", "(", ")", "BuildOriginalCache", ".", "run_path", "=", "BuildOriginalCache", ".", "path", "[", ":", "-", "4", "]", "+", "'-run'", "original_cache_trace_path", "=", "os", ".", "path", ".", "join", "(", "BuildOriginalCache", ".", "run_path", ",", "'0'", ",", "sandwich_runner", ".", "TRACE_FILENAME", ")", "@", "self", ".", "RegisterTask", "(", "'common/patched-cache.zip'", ",", "[", "BuildOriginalCache", "]", ")", "def", "BuildPatchedCache", "(", ")", ":", "_PatchCacheArchive", "(", "BuildOriginalCache", ".", "path", ",", "original_cache_trace_path", ",", "BuildPatchedCache", ".", "path", ")", "@", "self", ".", "RegisterTask", "(", "'common/patched-cache-validation.json'", ",", "[", "BuildPatchedCache", "]", ")", "def", "ValidatePatchedCache", "(", ")", ":", "cache_validation_result", "=", "_ValidateCacheArchiveContent", "(", "original_cache_trace_path", ",", "BuildPatchedCache", ".", "path", ")", "with", "open", "(", "ValidatePatchedCache", ".", "path", ",", "'w'", ")", "as", "output", ":", "json", ".", "dump", "(", "cache_validation_result", ",", "output", ")", "self", ".", "_wpr_archive_path", "=", "BuildPatchedWpr", ".", "path", "self", ".", "_trace_from_grabbing_reference_cache", "=", "original_cache_trace_path", "self", ".", "_cache_path", "=", "BuildPatchedCache", ".", "path", "self", ".", "_cache_validation_task", "=", "ValidatePatchedCache", "self", ".", "_common_builder", ".", "default_final_tasks", ".", "append", "(", "ValidatePatchedCache", ")" ]

[ "Return", "all", "items", "." ]

[ "def", "find_all", "(", "self", ")", ":", "return", "self", ".", "find", "(", "'all'", ")" ]

[ "Construct", "a", "new", "PeriodArray", "from", "a", "sequence", "of", "Period", "scalars", "." ]

[ "def", "period_array", "(", "data", ":", "Sequence", "[", "Optional", "[", "Period", "]", "]", ",", "freq", ":", "Optional", "[", "Union", "[", "str", ",", "Tick", "]", "]", "=", "None", ",", "copy", ":", "bool", "=", "False", ",", ")", "->", "PeriodArray", ":", "if", "is_datetime64_dtype", "(", "data", ")", ":", "return", "PeriodArray", ".", "_from_datetime64", "(", "data", ",", "freq", ")", "if", "isinstance", "(", "data", ",", "(", "ABCPeriodIndex", ",", "ABCSeries", ",", "PeriodArray", ")", ")", ":", "return", "PeriodArray", "(", "data", ",", "freq", ")", "# other iterable of some kind", "if", "not", "isinstance", "(", "data", ",", "(", "np", ".", "ndarray", ",", "list", ",", "tuple", ")", ")", ":", "data", "=", "list", "(", "data", ")", "data", "=", "np", ".", "asarray", "(", "data", ")", "dtype", ":", "Optional", "[", "PeriodDtype", "]", "if", "freq", ":", "dtype", "=", "PeriodDtype", "(", "freq", ")", "else", ":", "dtype", "=", "None", "if", "is_float_dtype", "(", "data", ")", "and", "len", "(", "data", ")", ">", "0", ":", "raise", "TypeError", "(", "\"PeriodIndex does not allow floating point in construction\"", ")", "data", "=", "ensure_object", "(", "data", ")", "return", "PeriodArray", ".", "_from_sequence", "(", "data", ",", "dtype", "=", "dtype", ")" ]

[ "ApplyTextEffectToSelection", "(", "self", "int", "flags", ")", "-", ">", "bool" ]

[ "def", "ApplyTextEffectToSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_ApplyTextEffectToSelection", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Saves", "optimizer", "weights", "of", "a", "optimizer", "to", "a", "HDF5", "group", "." ]

[ "def", "save_optimizer_weights_to_hdf5_group", "(", "hdf5_group", ",", "optimizer", ")", ":", "symbolic_weights", "=", "getattr", "(", "optimizer", ",", "'weights'", ")", "if", "symbolic_weights", ":", "weights_group", "=", "hdf5_group", ".", "create_group", "(", "'optimizer_weights'", ")", "weight_names", "=", "[", "str", "(", "w", ".", "name", ")", ".", "encode", "(", "'utf8'", ")", "for", "w", "in", "symbolic_weights", "]", "save_attributes_to_hdf5_group", "(", "weights_group", ",", "'weight_names'", ",", "weight_names", ")", "weight_values", "=", "K", ".", "batch_get_value", "(", "symbolic_weights", ")", "for", "name", ",", "val", "in", "zip", "(", "weight_names", ",", "weight_values", ")", ":", "param_dset", "=", "weights_group", ".", "create_dataset", "(", "name", ",", "val", ".", "shape", ",", "dtype", "=", "val", ".", "dtype", ")", "if", "not", "val", ".", "shape", ":", "# scalar", "param_dset", "[", "(", ")", "]", "=", "val", "else", ":", "param_dset", "[", ":", "]", "=", "val" ]

[ "The", "example", "indices", "represented", "as", "a", "dense", "tensor", "." ]

[ "def", "example_indices", "(", "self", ")", ":", "return", "self", ".", "_example_indices" ]

[ "Finds", "the", "next", "active", "tab", "(", "used", "mainly", "when", ":", "class", ":", "AuiNotebook", "has", "inactive", "/", "disabled", "tabs", "in", "it", ")", "." ]

[ "def", "FindNextActiveTab", "(", "self", ",", "ctrl_idx", ",", "ctrl", ")", ":", "if", "self", ".", "GetEnabled", "(", "ctrl_idx", ")", ":", "return", "ctrl_idx", "for", "indx", "in", "xrange", "(", "ctrl_idx", ",", "ctrl", ".", "GetPageCount", "(", ")", ")", ":", "if", "self", ".", "GetEnabled", "(", "indx", ")", ":", "return", "indx", "for", "indx", "in", "xrange", "(", "ctrl_idx", ",", "-", "1", ",", "-", "1", ")", ":", "if", "self", ".", "GetEnabled", "(", "indx", ")", ":", "return", "indx", "return", "0" ]

[ "Return", "two", "lists", "one", "with", "modules", "that", "are", "certainly", "missing", "and", "one", "with", "modules", "that", "*", "may", "*", "be", "missing", ".", "The", "latter", "names", "could", "either", "be", "submodules", "*", "or", "*", "just", "global", "names", "in", "the", "package", "." ]

[ "def", "any_missing_maybe", "(", "self", ")", ":", "missing", "=", "[", "]", "maybe", "=", "[", "]", "for", "name", "in", "self", ".", "badmodules", ":", "if", "name", "in", "self", ".", "excludes", ":", "continue", "i", "=", "name", ".", "rfind", "(", "\".\"", ")", "if", "i", "<", "0", ":", "missing", ".", "append", "(", "name", ")", "continue", "subname", "=", "name", "[", "i", "+", "1", ":", "]", "pkgname", "=", "name", "[", ":", "i", "]", "pkg", "=", "self", ".", "modules", ".", "get", "(", "pkgname", ")", "if", "pkg", "is", "not", "None", ":", "if", "pkgname", "in", "self", ".", "badmodules", "[", "name", "]", ":", "# The package tried to import this module itself and", "# failed. It's definitely missing.", "missing", ".", "append", "(", "name", ")", "elif", "subname", "in", "pkg", ".", "globalnames", ":", "# It's a global in the package: definitely not missing.", "pass", "elif", "pkg", ".", "starimports", ":", "# It could be missing, but the package did an \"import *\"", "# from a non-Python module, so we simply can't be sure.", "maybe", ".", "append", "(", "name", ")", "else", ":", "# It's not a global in the package, the package didn't", "# do funny star imports, it's very likely to be missing.", "# The symbol could be inserted into the package from the", "# outside, but since that's not good style we simply list", "# it missing.", "missing", ".", "append", "(", "name", ")", "else", ":", "missing", ".", "append", "(", "name", ")", "missing", ".", "sort", "(", ")", "maybe", ".", "sort", "(", ")", "return", "missing", ",", "maybe" ]

[ ":", "type", "nums", ":", "List", "[", "int", "]", ":", "rtype", ":", "TreeNode" ]

[ "def", "constructMaximumBinaryTree", "(", "self", ",", "nums", ")", ":", "# https://github.com/kamyu104/LintCode/blob/master/C++/max-tree.cpp", "nodeStack", "=", "[", "]", "for", "num", "in", "nums", ":", "node", "=", "TreeNode", "(", "num", ")", "while", "nodeStack", "and", "num", ">", "nodeStack", "[", "-", "1", "]", ".", "val", ":", "node", ".", "left", "=", "nodeStack", ".", "pop", "(", ")", "if", "nodeStack", ":", "nodeStack", "[", "-", "1", "]", ".", "right", "=", "node", "nodeStack", ".", "append", "(", "node", ")", "return", "nodeStack", "[", "0", "]" ]

[ "Get", "costmodel", "allreduce", "fusion", "tail", "percent", "." ]

[ "def", "get_costmodel_allreduce_fusion_tail_percent", "(", "self", ")", ":", "if", "self", ".", "_context_handle", "is", "None", ":", "raise", "ValueError", "(", "\"Context handle is none in context!!!\"", ")", "return", "self", ".", "_context_handle", ".", "get_costmodel_allreduce_fusion_tail_percent", "(", ")" ]

[ "Set", "the", "effects", "to", "use", "when", "showing", "and", "hiding", "the", "bar", "." ]

[ "def", "SetShowHideEffects", "(", "self", ",", "showEffect", ",", "hideEffect", ")", ":", "self", ".", "_showEffect", "=", "showEffect", "self", ".", "_hideEffect", "=", "hideEffect" ]

[ "Run", "the", "suite", "and", "tests", "specified", "." ]

[ "def", "run_tests", "(", "self", ")", ":", "self", ".", "_resmoke_logger", ".", "info", "(", "\"verbatim resmoke.py invocation: %s\"", ",", "\" \"", ".", "join", "(", "[", "shlex", ".", "quote", "(", "arg", ")", "for", "arg", "in", "sys", ".", "argv", "]", ")", ")", "if", "config", ".", "EVERGREEN_TASK_DOC", ":", "self", ".", "_resmoke_logger", ".", "info", "(", "\"Evergreen task documentation:\\n%s\"", ",", "config", ".", "EVERGREEN_TASK_DOC", ")", "elif", "config", ".", "EVERGREEN_TASK_NAME", ":", "self", ".", "_resmoke_logger", ".", "info", "(", "\"Evergreen task documentation is absent for this task.\"", ")", "task_name", "=", "utils", ".", "get_task_name_without_suffix", "(", "config", ".", "EVERGREEN_TASK_NAME", ",", "config", ".", "EVERGREEN_VARIANT_NAME", ")", "self", ".", "_resmoke_logger", ".", "info", "(", "\"If you are familiar with the functionality of %s task, \"", "\"please consider adding documentation for it in %s\"", ",", "task_name", ",", "os", ".", "path", ".", "join", "(", "config", ".", "CONFIG_DIR", ",", "\"evg_task_doc\"", ",", "\"evg_task_doc.yml\"", ")", ")", "self", ".", "_log_local_resmoke_invocation", "(", ")", "suites", "=", "None", "try", ":", "suites", "=", "self", ".", "_get_suites", "(", ")", "self", ".", "_setup_archival", "(", ")", "if", "config", ".", "SPAWN_USING", "==", "\"jasper\"", ":", "self", ".", "_setup_jasper", "(", ")", "self", ".", "_setup_signal_handler", "(", "suites", ")", "for", "suite", "in", "suites", ":", "self", ".", "_interrupted", "=", "self", ".", "_run_suite", "(", "suite", ")", "if", "self", ".", "_interrupted", "or", "(", "suite", ".", "options", ".", "fail_fast", "and", "suite", ".", "return_code", "!=", "0", ")", ":", "self", ".", "_log_resmoke_summary", "(", "suites", ")", "self", ".", "exit", "(", "suite", ".", "return_code", ")", "self", ".", "_log_resmoke_summary", "(", "suites", ")", "# Exit with a nonzero code if any of the suites failed.", "exit_code", "=", "max", "(", "suite", ".", "return_code", "for", "suite", "in", "suites", ")", "self", ".", "exit", "(", "exit_code", ")", "finally", ":", "self", ".", "_exit_archival", "(", ")", "if", "suites", ":", "reportfile", ".", "write", "(", "suites", ")" ]

[ "data_file", "is", "the", "base", "name", "of", "the", "data", "file", "to", "use", "defaulting", "to", ".", "coverage", ".", "data_suffix", "is", "appended", "(", "with", "a", "dot", ")", "to", "data_file", "to", "create", "the", "final", "file", "name", ".", "If", "data_suffix", "is", "simply", "True", "then", "a", "suffix", "is", "created", "with", "the", "machine", "and", "process", "identity", "included", "." ]

[ "def", "__init__", "(", "self", ",", "data_file", "=", "None", ",", "data_suffix", "=", "None", ",", "cover_pylib", "=", "None", ",", "auto_data", "=", "False", ",", "timid", "=", "None", ",", "branch", "=", "None", ",", "config_file", "=", "True", ",", "source", "=", "None", ",", "omit", "=", "None", ",", "include", "=", "None", ")", ":", "from", "coverage", "import", "__version__", "# A record of all the warnings that have been issued.", "self", ".", "_warnings", "=", "[", "]", "# Build our configuration from a number of sources:", "# 1: defaults:", "self", ".", "config", "=", "CoverageConfig", "(", ")", "# 2: from the coveragerc file:", "if", "config_file", ":", "if", "config_file", "is", "True", ":", "config_file", "=", "\".coveragerc\"", "try", ":", "self", ".", "config", ".", "from_file", "(", "config_file", ")", "except", "ValueError", ":", "_", ",", "err", ",", "_", "=", "sys", ".", "exc_info", "(", ")", "raise", "CoverageException", "(", "\"Couldn't read config file %s: %s\"", "%", "(", "config_file", ",", "err", ")", ")", "# 3: from environment variables:", "self", ".", "config", ".", "from_environment", "(", "'COVERAGE_OPTIONS'", ")", "env_data_file", "=", "os", ".", "environ", ".", "get", "(", "'COVERAGE_FILE'", ")", "if", "env_data_file", ":", "self", ".", "config", ".", "data_file", "=", "env_data_file", "# 4: from constructor arguments:", "if", "isinstance", "(", "omit", ",", "string_class", ")", ":", "omit", "=", "[", "omit", "]", "if", "isinstance", "(", "include", ",", "string_class", ")", ":", "include", "=", "[", "include", "]", "self", ".", "config", ".", "from_args", "(", "data_file", "=", "data_file", ",", "cover_pylib", "=", "cover_pylib", ",", "timid", "=", "timid", ",", "branch", "=", "branch", ",", "parallel", "=", "bool_or_none", "(", "data_suffix", ")", ",", "source", "=", "source", ",", "omit", "=", "omit", ",", "include", "=", "include", ")", "self", ".", "auto_data", "=", "auto_data", "self", ".", "atexit_registered", "=", "False", "# _exclude_re is a dict mapping exclusion list names to compiled", "# regexes.", "self", ".", "_exclude_re", "=", "{", "}", "self", ".", "_exclude_regex_stale", "(", ")", "self", ".", "file_locator", "=", "FileLocator", "(", ")", "# The source argument can be directories or package names.", "self", ".", "source", "=", "[", "]", "self", ".", "source_pkgs", "=", "[", "]", "for", "src", "in", "self", ".", "config", ".", "source", "or", "[", "]", ":", "if", "os", ".", "path", ".", "exists", "(", "src", ")", ":", "self", ".", "source", ".", "append", "(", "self", ".", "file_locator", ".", "canonical_filename", "(", "src", ")", ")", "else", ":", "self", ".", "source_pkgs", ".", "append", "(", "src", ")", "self", ".", "omit", "=", "self", ".", "_prep_patterns", "(", "self", ".", "config", ".", "omit", ")", "self", ".", "include", "=", "self", ".", "_prep_patterns", "(", "self", ".", "config", ".", "include", ")", "self", ".", "collector", "=", "Collector", "(", "self", ".", "_should_trace", ",", "timid", "=", "self", ".", "config", ".", "timid", ",", "branch", "=", "self", ".", "config", ".", "branch", ",", "warn", "=", "self", ".", "_warn", ")", "# Suffixes are a bit tricky. We want to use the data suffix only when", "# collecting data, not when combining data. So we save it as", "# `self.run_suffix` now, and promote it to `self.data_suffix` if we", "# find that we are collecting data later.", "if", "data_suffix", "or", "self", ".", "config", ".", "parallel", ":", "if", "not", "isinstance", "(", "data_suffix", ",", "string_class", ")", ":", "# if data_suffix=True, use .machinename.pid.random", "data_suffix", "=", "True", "else", ":", "data_suffix", "=", "None", "self", ".", "data_suffix", "=", "None", "self", ".", "run_suffix", "=", "data_suffix", "# Create the data file. We do this at construction time so that the", "# data file will be written into the directory where the process", "# started rather than wherever the process eventually chdir'd to.", "self", ".", "data", "=", "CoverageData", "(", "basename", "=", "self", ".", "config", ".", "data_file", ",", "collector", "=", "\"coverage v%s\"", "%", "__version__", ")", "# The dirs for files considered \"installed with the interpreter\".", "self", ".", "pylib_dirs", "=", "[", "]", "if", "not", "self", ".", "config", ".", "cover_pylib", ":", "# Look at where some standard modules are located. That's the", "# indication for \"installed with the interpreter\". In some", "# environments (virtualenv, for example), these modules may be", "# spread across a few locations. Look at all the candidate modules", "# we've imported, and take all the different ones.", "for", "m", "in", "(", "atexit", ",", "os", ",", "random", ",", "socket", ")", ":", "if", "hasattr", "(", "m", ",", "\"__file__\"", ")", ":", "m_dir", "=", "self", ".", "_canonical_dir", "(", "m", ".", "__file__", ")", "if", "m_dir", "not", "in", "self", ".", "pylib_dirs", ":", "self", ".", "pylib_dirs", ".", "append", "(", "m_dir", ")", "# To avoid tracing the coverage code itself, we skip anything located", "# where we are.", "self", ".", "cover_dir", "=", "self", ".", "_canonical_dir", "(", "__file__", ")", "# The matchers for _should_trace, created when tracing starts.", "self", ".", "source_match", "=", "None", "self", ".", "pylib_match", "=", "self", ".", "cover_match", "=", "None", "self", ".", "include_match", "=", "self", ".", "omit_match", "=", "None", "# Only _harvest_data once per measurement cycle.", "self", ".", "_harvested", "=", "False", "# Set the reporting precision.", "Numbers", ".", "set_precision", "(", "self", ".", "config", ".", "precision", ")", "# When tearing down the coverage object, modules can become None.", "# Saving the modules as object attributes avoids problems, but it is", "# quite ad-hoc which modules need to be saved and which references", "# need to use the object attributes.", "self", ".", "socket", "=", "socket", "self", ".", "os", "=", "os", "self", ".", "random", "=", "random" ]

[ "!", "Initializer" ]

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

[ "Returns", "true", "if", "the", "given", "line", "is", "blank", "." ]

[ "def", "IsBlankLine", "(", "line", ")", ":", "return", "not", "line", "or", "line", ".", "isspace", "(", ")" ]

[ "Returns", "the", "class", "of", "the", "request", "message", "for", "the", "specified", "method", "." ]

[ "def", "GetRequestClass", "(", "self", ",", "method_descriptor", ")", ":", "raise", "NotImplementedError" ]

[ "Goes", "to", "the", "next", "applicable", "step", "." ]

[ "def", "DCProfsDonePress", "(", ")", ":", "global", "NewMageSpells", ",", "NewPriestMask", "# check for mage spells and thief skills", "SpellTable", "=", "CommonTables", ".", "ClassSkills", ".", "GetValue", "(", "ClassName", ",", "\"MAGESPELL\"", ")", "ClericTable", "=", "CommonTables", ".", "ClassSkills", ".", "GetValue", "(", "ClassName", ",", "\"CLERICSPELL\"", ")", "DruidTable", "=", "CommonTables", ".", "ClassSkills", ".", "GetValue", "(", "ClassName", ",", "\"DRUIDSPELL\"", ")", "if", "SpellTable", "!=", "\"*\"", ":", "LUSpellSelection", ".", "OpenSpellsWindow", "(", "pc", ",", "SpellTable", ",", "1", ",", "1", ",", "0", ")", "SpellTable", "=", "GemRB", ".", "LoadTable", "(", "SpellTable", ")", "GemRB", ".", "SetMemorizableSpellsCount", "(", "pc", ",", "SpellTable", ".", "GetValue", "(", "0", ",", "0", ")", ",", "IE_SPELL_TYPE_WIZARD", ",", "0", ")", "NewMageSpells", "=", "1", "if", "ClericTable", "!=", "\"*\"", ":", "if", "not", "GemRB", ".", "HasResource", "(", "ClericTable", ",", "RES_2DA", ",", "1", ")", ":", "ClericTable", "=", "\"MXSPLPRS\"", "# iwd1 doesn't have a DRUIDSPELL column in the table", "# make sure we can cast spells at this level (paladins)", "ClericTable", "=", "GemRB", ".", "LoadTable", "(", "ClericTable", ")", "if", "ClericTable", ".", "GetRowName", "(", "0", ")", "==", "\"1\"", ":", "NewPriestMask", "=", "0x4000", "elif", "DruidTable", "!=", "\"*\"", ":", "# make sure we can cast spells at this level (rangers)", "if", "GameCheck", ".", "HasTOB", "(", ")", ":", "DruidTable", "=", "GemRB", ".", "LoadTable", "(", "DruidTable", ")", "if", "DruidTable", ".", "GetRowName", "(", "0", ")", "==", "\"1\"", ":", "NewPriestMask", "=", "0x8000", "else", ":", "NewPriestMask", "=", "0x8000", "# open the thieves selection window", "OpenSkillsWindow", "(", ")", "# we can be done now", "DCMainDoneButton", ".", "SetState", "(", "IE_GUI_BUTTON_ENABLED", ")", "# close out the profs window (don't assign yet!)", "if", "DCProfsWindow", ":", "DCProfsWindow", ".", "Unload", "(", ")", "return" ]

[ "returns", "true", "if", "any", "element", "is", "non", "-", "zero", "or", "masked" ]

[ "def", "__nonzero__", "(", "self", ")", ":", "# XXX: This changes bool conversion logic from MA.", "# XXX: In MA bool(a) == len(a) != 0, but in numpy", "# XXX: scalars do not have len", "m", "=", "self", ".", "_mask", "d", "=", "self", ".", "_data", "return", "bool", "(", "m", "is", "not", "nomask", "and", "m", ".", "any", "(", ")", "or", "d", "is", "not", "nomask", "and", "d", ".", "any", "(", ")", ")" ]

[ "Returns", "the", "range", "[", "min", "max", ")", "of", "elements", ".", "Raises", "an", "IndexError", "exception", "if", "an", "argument", "is", "out", "of", "bounds", "." ]

[ "def", "__getitem__", "(", "self", ",", "idx", ")", ":", "if", "isinstance", "(", "idx", ",", "slice", ")", ":", "indices", "=", "idx", ".", "indices", "(", "len", "(", "self", ")", ")", "retVal", "=", "[", "]", "for", "i", "in", "range", "(", "*", "indices", ")", ":", "port", "=", "None", "if", "self", ".", "SMProperty", ".", "GetProxy", "(", "i", ")", ":", "port", "=", "OutputPort", "(", "_getPyProxy", "(", "self", ".", "SMProperty", ".", "GetProxy", "(", "i", ")", ")", ",", "self", ".", "SMProperty", ".", "GetOutputPortForConnection", "(", "i", ")", ")", "retVal", ".", "append", "(", "port", ")", "return", "retVal", "elif", "idx", ">=", "len", "(", "self", ")", "or", "idx", "<", "0", ":", "raise", "IndexError", "return", "OutputPort", "(", "_getPyProxy", "(", "self", ".", "SMProperty", ".", "GetProxy", "(", "idx", ")", ")", ",", "self", ".", "SMProperty", ".", "GetOutputPortForConnection", "(", "idx", ")", ")" ]

[ "Coerce", "*", "s", "*", "to", "str", "." ]

[ "def", "ensure_str", "(", "s", ",", "encoding", "=", "'utf-8'", ",", "errors", "=", "'strict'", ")", ":", "if", "not", "isinstance", "(", "s", ",", "(", "text_type", ",", "binary_type", ")", ")", ":", "raise", "TypeError", "(", "\"not expecting type '%s'\"", "%", "type", "(", "s", ")", ")", "if", "PY2", "and", "isinstance", "(", "s", ",", "text_type", ")", ":", "s", "=", "s", ".", "encode", "(", "encoding", ",", "errors", ")", "elif", "PY3", "and", "isinstance", "(", "s", ",", "binary_type", ")", ":", "s", "=", "s", ".", "decode", "(", "encoding", ",", "errors", ")", "return", "s" ]

[ "See", "DenseColumn", "base", "class", "." ]

[ "def", "variable_shape", "(", "self", ")", ":", "return", "tensor_shape", ".", "TensorShape", "(", "self", ".", "shape", ")" ]

[ "Queries", "the", "device", "for", "memory", "information", "about", "the", "process", "with", "a", "pid", "of", "|pid|", ".", "It", "will", "query", "Native", "Dalvik", "and", "Pss", "memory", "of", "the", "process", ".", "It", "returns", "a", "list", "of", "values", ":", "[", "Native", "Pss", "Dalvik", "]", ".", "If", "the", "process", "is", "not", "found", "it", "will", "return", "[", "0", "0", "0", "]", "." ]

[ "def", "QueryMemory", "(", "adb", ",", "pid", ")", ":", "results", "=", "[", "0", ",", "0", ",", "0", "]", "mem_lines", "=", "adb", ".", "RunShellCommand", "(", "[", "'dumpsys'", ",", "'meminfo'", ",", "pid", "]", ")", "for", "line", "in", "mem_lines", ":", "match", "=", "re", ".", "split", "(", "'\\s+'", ",", "line", ".", "strip", "(", ")", ")", "# Skip data after the 'App Summary' line. This is to fix builds where", "# they have more entries that might match the other conditions.", "if", "len", "(", "match", ")", ">=", "2", "and", "match", "[", "0", "]", "==", "'App'", "and", "match", "[", "1", "]", "==", "'Summary'", ":", "break", "result_idx", "=", "None", "query_idx", "=", "None", "if", "match", "[", "0", "]", "==", "'Native'", "and", "match", "[", "1", "]", "==", "'Heap'", ":", "result_idx", "=", "0", "query_idx", "=", "-", "2", "elif", "match", "[", "0", "]", "==", "'Dalvik'", "and", "match", "[", "1", "]", "==", "'Heap'", ":", "result_idx", "=", "2", "query_idx", "=", "-", "2", "elif", "match", "[", "0", "]", "==", "'TOTAL'", ":", "result_idx", "=", "1", "query_idx", "=", "1", "# If we already have a result, skip it and don't overwrite the data.", "if", "result_idx", "is", "not", "None", "and", "results", "[", "result_idx", "]", "!=", "0", ":", "continue", "if", "result_idx", "is", "not", "None", "and", "query_idx", "is", "not", "None", ":", "results", "[", "result_idx", "]", "=", "round", "(", "float", "(", "match", "[", "query_idx", "]", ")", "/", "1000.0", ",", "2", ")", "return", "results" ]

[ "IsLeapYear", "(", "int", "year", "=", "Inv_Year", "int", "cal", "=", "Gregorian", ")", "-", ">", "bool" ]

[ "def", "IsLeapYear", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "DateTime_IsLeapYear", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "GetWatchAddress", "(", "SBWatchpoint", "self", ")", "-", ">", "lldb", "::", "addr_t" ]

[ "def", "GetWatchAddress", "(", "self", ")", ":", "return", "_lldb", ".", "SBWatchpoint_GetWatchAddress", "(", "self", ")" ]