Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Set", "a", "new", "config", "set", "for", "conf", ".", "env", ".", "If", "a", "config", "set", "of", "that", "name", "already", "exists", "recall", "it", "without", "modification", "." ]

[ "def", "setenv", "(", "self", ",", "name", ",", "env", "=", "None", ")", ":", "if", "name", "not", "in", "self", ".", "all_envs", "or", "env", ":", "if", "not", "env", ":", "env", "=", "ConfigSet", ".", "ConfigSet", "(", ")", "self", ".", "prepare_env", "(", "env", ")", "else", ":", "env", "=", "env", ".", "derive", "(", ")", "self", ".", "all_envs", "[", "name", "]", "=", "env", "self", ".", "variant", "=", "name" ]

[ "Install", "or", "upgrade", "setuptools", "and", "EasyInstall" ]

[ "def", "main", "(", "argv", ",", "version", "=", "DEFAULT_VERSION", ")", ":", "try", ":", "import", "setuptools", "except", "ImportError", ":", "egg", "=", "None", "try", ":", "egg", "=", "download_setuptools", "(", "version", ",", "delay", "=", "0", ")", "sys", ".", "path", ".", "insert", "(", "0", ",", "egg", ")", "from", "setuptools", ".", "command", ".", "easy_install", "import", "main", "return", "main", "(", "list", "(", "argv", ")", "+", "[", "egg", "]", ")", "# we're done here", "finally", ":", "if", "egg", "and", "os", ".", "path", ".", "exists", "(", "egg", ")", ":", "os", ".", "unlink", "(", "egg", ")", "else", ":", "if", "setuptools", ".", "__version__", "==", "'0.0.1'", ":", "print", ">>", "sys", ".", "stderr", ",", "(", "\"You have an obsolete version of setuptools installed. Please\\n\"", "\"remove it from your system entirely before rerunning this script.\"", ")", "sys", ".", "exit", "(", "2", ")", "req", "=", "\"setuptools>=\"", "+", "version", "import", "pkg_resources", "try", ":", "pkg_resources", ".", "require", "(", "req", ")", "except", "pkg_resources", ".", "VersionConflict", ":", "try", ":", "from", "setuptools", ".", "command", ".", "easy_install", "import", "main", "except", "ImportError", ":", "from", "easy_install", "import", "main", "main", "(", "list", "(", "argv", ")", "+", "[", "download_setuptools", "(", "delay", "=", "0", ")", "]", ")", "sys", ".", "exit", "(", "0", ")", "# try to force an exit", "else", ":", "if", "argv", ":", "from", "setuptools", ".", "command", ".", "easy_install", "import", "main", "main", "(", "argv", ")", "else", ":", "print", "\"Setuptools version\"", ",", "version", ",", "\"or greater has been installed.\"", "print", "'(Run \"ez_setup.py -U setuptools\" to reinstall or upgrade.)'" ]

[ "i", "f", "z", "o", "-", ">", "i", "f", "o", "z", "where", "weights_split", "[", "0", "]", "==", "i", "etc", ".", "Used", "to", "transform", "lstm", "weights", "from", "pytorch", "to", "CoreML", "format" ]

[ "def", "_ifzo_to_ifoz", "(", "weights", ",", "name", ")", ":", "split_size", "=", "weights", ".", "shape", "[", "0", "]", "//", "4", "weights_split", "=", "mb", ".", "split", "(", "x", "=", "weights", ",", "split_sizes", "=", "_np", ".", "array", "(", "[", "split_size", "]", "*", "4", ")", ",", "axis", "=", "0", ")", "weights_concat", "=", "mb", ".", "concat", "(", "values", "=", "[", "weights_split", "[", "0", "]", ",", "weights_split", "[", "1", "]", ",", "weights_split", "[", "3", "]", ",", "weights_split", "[", "2", "]", "]", ",", "axis", "=", "0", ",", ")", "# make transpose a noOP for 0/1d tensors", "return", "mb", ".", "transpose", "(", "x", "=", "weights_concat", ",", "perm", "=", "(", "[", "1", ",", "0", "]", "if", "len", "(", "weights", ".", "shape", ")", ">", "1", "else", "[", "0", "]", ")", ",", "name", "=", "name", ")" ]

[ "Solve", "6D", "equations", "using", "fact", "that", "3", "axes", "are", "intersecting", ".", "The", "3", "intersecting", "axes", "are", "all", "part", "of", "T0links", "and", "will", "be", "used", "to", "compute", "the", "rotation", "of", "the", "robot", ".", "The", "other", "3", "axes", "are", "part", "of", "T1links", "and", "will", "be", "used", "to", "first", "compute", "the", "position", "." ]

[ "def", "solve6DIntersectingAxes", "(", "self", ",", "T0links", ",", "T1links", ",", "transvars", ",", "rotvars", ",", "solveRotationFirst", ",", "endbranchtree", ")", ":", "assert", "(", "len", "(", "transvars", ")", "==", "3", "and", "len", "(", "rotvars", ")", "==", "3", ")", "T0", "=", "self", ".", "multiplyMatrix", "(", "T0links", ")", "T0posoffset", "=", "eye", "(", "4", ")", "T0posoffset", "[", "0", ":", "3", ",", "3", "]", "=", "-", "T0", "[", "0", ":", "3", ",", "3", "]", "T0links", "=", "[", "T0posoffset", "]", "+", "T0links", "T1links", "=", "[", "T0posoffset", "]", "+", "T1links", "T1", "=", "self", ".", "multiplyMatrix", "(", "T1links", ")", "othersolvedvars", "=", "rotvars", "+", "self", ".", "freejointvars", "if", "solveRotationFirst", "else", "self", ".", "freejointvars", "[", ":", "]", "T1linksinv", "=", "[", "self", ".", "affineInverse", "(", "T", ")", "for", "T", "in", "T1links", "]", "AllEquations", "=", "self", ".", "buildEquationsFromPositions", "(", "T1links", ",", "T1linksinv", ",", "transvars", ",", "othersolvedvars", ",", "uselength", "=", "True", ")", "self", ".", "checkSolvability", "(", "AllEquations", ",", "transvars", ",", "self", ".", "freejointvars", ")", "rottree", "=", "[", "]", "if", "solveRotationFirst", ":", "newendbranchtree", "=", "endbranchtree", "else", ":", "newendbranchtree", "=", "[", "AST", ".", "SolverSequence", "(", "[", "rottree", "]", ")", "]", "curvars", "=", "transvars", "[", ":", "]", "solsubs", "=", "self", ".", "freevarsubs", "[", ":", "]", "transtree", "=", "self", ".", "solveAllEquations", "(", "AllEquations", ",", "curvars", "=", "curvars", ",", "othersolvedvars", "=", "othersolvedvars", "[", ":", "]", ",", "solsubs", "=", "solsubs", ",", "endbranchtree", "=", "newendbranchtree", ")", "transtree", "=", "self", ".", "verifyAllEquations", "(", "AllEquations", ",", "rotvars", "if", "solveRotationFirst", "else", "transvars", "+", "rotvars", ",", "self", ".", "freevarsubs", "[", ":", "]", ",", "transtree", ")", "solvertree", "=", "[", "]", "solvedvarsubs", "=", "self", ".", "freevarsubs", "[", ":", "]", "if", "solveRotationFirst", ":", "storesolutiontree", "=", "transtree", "else", ":", "solvertree", "+=", "transtree", "storesolutiontree", "=", "endbranchtree", "for", "tvar", "in", "transvars", ":", "solvedvarsubs", "+=", "self", ".", "Variable", "(", "tvar", ")", ".", "subs", "oldglobalsymbols", "=", "self", ".", "globalsymbols", "[", ":", "]", "try", ":", "T1sub", "=", "T1", ".", "subs", "(", "solvedvarsubs", ")", "Ree", "=", "zeros", "(", "(", "3", ",", "3", ")", ")", "for", "i", "in", "range", "(", "3", ")", ":", "for", "j", "in", "range", "(", "3", ")", ":", "Ree", "[", "i", ",", "j", "]", "=", "Symbol", "(", "'new_r%d%d'", "%", "(", "i", ",", "j", ")", ")", "self", ".", "globalsymbols", ".", "append", "(", "(", "Ree", "[", "i", ",", "j", "]", ",", "T1sub", "[", "i", ",", "j", "]", ")", ")", "othersolvedvars", "=", "self", ".", "freejointvars", "if", "solveRotationFirst", "else", "transvars", "+", "self", ".", "freejointvars", "AllEquations", "=", "self", ".", "buildEquationsFromRotation", "(", "T0links", ",", "Ree", ",", "rotvars", ",", "othersolvedvars", ")", "self", ".", "checkSolvability", "(", "AllEquations", ",", "rotvars", ",", "othersolvedvars", ")", "currotvars", "=", "rotvars", "[", ":", "]", "rottree", "+=", "self", ".", "solveAllEquations", "(", "AllEquations", ",", "curvars", "=", "currotvars", ",", "othersolvedvars", "=", "othersolvedvars", ",", "solsubs", "=", "self", ".", "freevarsubs", "[", ":", "]", ",", "endbranchtree", "=", "storesolutiontree", ")", "if", "len", "(", "rottree", ")", "==", "0", ":", "raise", "self", ".", "CannotSolveError", "(", "'could not solve for all rotation variables: %s:%s'", "%", "(", "str", "(", "freevar", ")", ",", "str", "(", "freevalue", ")", ")", ")", "if", "solveRotationFirst", ":", "solvertree", ".", "append", "(", "AST", ".", "SolverRotation", "(", "T1sub", ",", "rottree", ")", ")", "else", ":", "rottree", "[", ":", "]", "=", "[", "AST", ".", "SolverRotation", "(", "T1sub", ",", "rottree", "[", ":", "]", ")", "]", "return", "solvertree", "finally", ":", "self", ".", "globalsymbols", "=", "oldglobalsymbols" ]

[ "Reset", "the", "barrier", "to", "the", "initial", "state", "." ]

[ "def", "reset", "(", "self", ")", ":", "with", "self", ".", "_cond", ":", "if", "self", ".", "_count", ">", "0", ":", "if", "self", ".", "_state", "==", "0", ":", "#reset the barrier, waking up threads", "self", ".", "_state", "=", "-", "1", "elif", "self", ".", "_state", "==", "-", "2", ":", "#was broken, set it to reset state", "#which clears when the last thread exits", "self", ".", "_state", "=", "-", "1", "else", ":", "self", ".", "_state", "=", "0", "self", ".", "_cond", ".", "notify_all", "(", ")" ]

[ "If", "input", "points", "to", ")", "or", "}", "or", "]", "or", ">", "finds", "the", "position", "that", "opens", "it", "." ]

[ "def", "ReverseCloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "endchar", "=", "line", "[", "pos", "]", "if", "endchar", "not", "in", "')}]>'", ":", "return", "(", "line", ",", "0", ",", "-", "1", ")", "if", "endchar", "==", "')'", ":", "startchar", "=", "'('", "if", "endchar", "==", "']'", ":", "startchar", "=", "'['", "if", "endchar", "==", "'}'", ":", "startchar", "=", "'{'", "if", "endchar", "==", "'>'", ":", "startchar", "=", "'<'", "# Check last line", "(", "start_pos", ",", "num_open", ")", "=", "FindStartOfExpressionInLine", "(", "line", ",", "pos", ",", "0", ",", "startchar", ",", "endchar", ")", "if", "start_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "start_pos", ")", "# Continue scanning backward", "while", "linenum", ">", "0", ":", "linenum", "-=", "1", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "(", "start_pos", ",", "num_open", ")", "=", "FindStartOfExpressionInLine", "(", "line", ",", "len", "(", "line", ")", "-", "1", ",", "num_open", ",", "startchar", ",", "endchar", ")", "if", "start_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "start_pos", ")", "# Did not find startchar before beginning of file, give up", "return", "(", "line", ",", "0", ",", "-", "1", ")" ]

[ "QSort", "(", "TIntV", "self", "int", "const", "&", "MnLValN", "int", "const", "&", "MxRValN", "bool", "const", "&", "Asc", ")" ]

[ "def", "QSort", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TIntV_QSort", "(", "self", ",", "*", "args", ")" ]

[ "__init__", "(", "self", "Window", "parent", "int", "id", "=", "-", "1", "Point", "pos", "=", "DefaultPosition", "Size", "size", "=", "DefaultSize", "int", "style", "=", "HW_DEFAULT_STYLE", "String", "name", "=", "HtmlWindowNameStr", ")", "-", ">", "HtmlWindow" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_html", ".", "HtmlWindow_swiginit", "(", "self", ",", "_html", ".", "new_HtmlWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")", "self", ".", "_setOORInfo", "(", "self", ")", "HtmlWindow", ".", "_setCallbackInfo", "(", "self", ",", "self", ",", "HtmlWindow", ")" ]

[ "Show", "documentation", "from", "XML", "and", "try", "to", "display", "best", "matching", "docstring" ]

[ "def", "_update_docs_page", "(", "self", ")", ":", "buf", "=", "self", ".", "_docs_text_display", ".", "get_buffer", "(", ")", "buf", ".", "delete", "(", "buf", ".", "get_start_iter", "(", ")", ",", "buf", ".", "get_end_iter", "(", ")", ")", "pos", "=", "buf", ".", "get_end_iter", "(", ")", "# Add link to wiki page for this block, at the top, as long as it's not an OOT block", "if", "self", ".", "_block", ".", "category", "and", "self", ".", "_block", ".", "category", "[", "0", "]", "==", "\"Core\"", ":", "note", "=", "\"Wiki Page for this Block: \"", "prefix", "=", "self", ".", "_config", ".", "wiki_block_docs_url_prefix", "suffix", "=", "self", ".", "_block", ".", "label", ".", "replace", "(", "\" \"", ",", "\"_\"", ")", "href", "=", "f'<a href=\"{prefix+suffix}\">Visit Wiki Page</a>'", "self", ".", "_docs_link", ".", "set_markup", "(", "href", ")", "else", ":", "self", ".", "_docs_link", ".", "set_markup", "(", "'Out of Tree Block'", ")", "docstrings", "=", "self", ".", "_block", ".", "documentation", ".", "copy", "(", ")", "if", "not", "docstrings", ":", "return", "# show documentation string from block yaml", "from_yaml", "=", "docstrings", ".", "pop", "(", "''", ",", "''", ")", "for", "line", "in", "from_yaml", ".", "splitlines", "(", ")", ":", "if", "line", ".", "lstrip", "(", ")", "==", "line", "and", "line", ".", "endswith", "(", "':'", ")", ":", "buf", ".", "insert_with_tags_by_name", "(", "pos", ",", "line", "+", "'\\n'", ",", "'b'", ")", "else", ":", "buf", ".", "insert", "(", "pos", ",", "line", "+", "'\\n'", ")", "if", "from_yaml", ":", "buf", ".", "insert", "(", "pos", ",", "'\\n'", ")", "# if given the current parameters an exact match can be made", "block_constructor", "=", "self", ".", "_block", ".", "templates", ".", "render", "(", "'make'", ")", ".", "rsplit", "(", "'.'", ",", "2", ")", "[", "-", "1", "]", "block_class", "=", "block_constructor", ".", "partition", "(", "'('", ")", "[", "0", "]", ".", "strip", "(", ")", "if", "block_class", "in", "docstrings", ":", "docstrings", "=", "{", "block_class", ":", "docstrings", "[", "block_class", "]", "}", "# show docstring(s) extracted from python sources", "for", "cls_name", ",", "docstring", "in", "docstrings", ".", "items", "(", ")", ":", "buf", ".", "insert_with_tags_by_name", "(", "pos", ",", "cls_name", "+", "'\\n'", ",", "'b'", ")", "buf", ".", "insert", "(", "pos", ",", "docstring", "+", "'\\n\\n'", ")", "pos", ".", "backward_chars", "(", "2", ")", "buf", ".", "delete", "(", "pos", ",", "buf", ".", "get_end_iter", "(", ")", ")" ]

[ "plots", "the", "Innovation", "data", ".", ":", "return", ":" ]

[ "def", "plot", "(", "self", ")", ":", "if", "self", ".", "fig", "is", "None", ":", "return", "for", "i", "in", "range", "(", "len", "(", "self", ".", "_variable_names", ")", ")", ":", "# create a subplot for every variable", "plt", ".", "subplot", "(", "len", "(", "self", ".", "_variable_names", ")", ",", "1", ",", "i", "+", "1", ")", "if", "self", ".", "_sub_titles", "is", "not", "None", ":", "plt", ".", "title", "(", "self", ".", "_sub_titles", "[", "i", "]", ")", "# plot the value and the standard deviation", "plt", ".", "plot", "(", "1e-6", "*", "self", ".", "plot_data", "[", "'timestamp'", "]", ",", "self", ".", "plot_data", "[", "self", ".", "_variable_names", "[", "i", "]", "[", "0", "]", "]", ",", "'b'", ")", "plt", ".", "plot", "(", "1e-6", "*", "self", ".", "plot_data", "[", "'timestamp'", "]", ",", "np", ".", "sqrt", "(", "self", ".", "plot_data", "[", "self", ".", "_variable_names", "[", "i", "]", "[", "1", "]", "]", ")", ",", "'r'", ")", "plt", ".", "plot", "(", "1e-6", "*", "self", ".", "plot_data", "[", "'timestamp'", "]", ",", "-", "np", ".", "sqrt", "(", "self", ".", "plot_data", "[", "self", ".", "_variable_names", "[", "i", "]", "[", "1", "]", "]", ")", ",", "'r'", ")", "plt", ".", "xlabel", "(", "self", ".", "_x_labels", "[", "i", "]", ")", "plt", ".", "ylabel", "(", "self", ".", "_y_labels", "[", "i", "]", ")", "plt", ".", "grid", "(", ")", "# add the maximum and minimum value as an annotation", "_", ",", "max_value", ",", "max_time", "=", "get_max_arg_time_value", "(", "self", ".", "plot_data", "[", "self", ".", "_variable_names", "[", "i", "]", "[", "0", "]", "]", ",", "1e-6", "*", "self", ".", "plot_data", "[", "'timestamp'", "]", ")", "_", ",", "min_value", ",", "min_time", "=", "get_min_arg_time_value", "(", "self", ".", "plot_data", "[", "self", ".", "_variable_names", "[", "i", "]", "[", "0", "]", "]", ",", "1e-6", "*", "self", ".", "plot_data", "[", "'timestamp'", "]", ")", "plt", ".", "text", "(", "max_time", ",", "max_value", ",", "'max={:.2f}'", ".", "format", "(", "max_value", ")", ",", "fontsize", "=", "12", ",", "horizontalalignment", "=", "'left'", ",", "verticalalignment", "=", "'bottom'", ")", "plt", ".", "text", "(", "min_time", ",", "min_value", ",", "'min={:.2f}'", ".", "format", "(", "min_value", ")", ",", "fontsize", "=", "12", ",", "horizontalalignment", "=", "'left'", ",", "verticalalignment", "=", "'top'", ")", "self", ".", "fig", ".", "tight_layout", "(", "rect", "=", "[", "0", ",", "0.03", ",", "1", ",", "0.95", "]", ")" ]

[ "The", "constructor", "of", "the", "PythonSolver", "-", "Object", "." ]

[ "def", "__init__", "(", "self", ",", "model", ",", "settings", ")", ":", "if", "not", "isinstance", "(", "model", ",", "KratosMultiphysics", ".", "Model", ")", ":", "raise", "Exception", "(", "\"Input is expected to be provided as a Kratos Model object\"", ")", "if", "not", "isinstance", "(", "settings", ",", "KratosMultiphysics", ".", "Parameters", ")", ":", "raise", "Exception", "(", "\"Input is expected to be provided as a Kratos Parameters object\"", ")", "self", ".", "model", "=", "model", "self", ".", "settings", "=", "settings", "self", ".", "ValidateSettings", "(", ")", "self", ".", "echo_level", "=", "self", ".", "settings", "[", "\"echo_level\"", "]", ".", "GetInt", "(", ")" ]

[ "Reads", "a", "response", "file", "and", "returns", "the", "list", "of", "cmdline", "params", "found", "in", "the", "file", "." ]

[ "def", "read_response_file", "(", "response_filename", ")", ":", "if", "response_filename", ".", "startswith", "(", "'@'", ")", ":", "response_filename", "=", "response_filename", "[", "1", ":", "]", "if", "not", "os", ".", "path", ".", "exists", "(", "response_filename", ")", ":", "raise", "IOError", "(", "\"response file not found: %s\"", "%", "response_filename", ")", "# Guess encoding based on the file suffix", "components", "=", "os", ".", "path", ".", "basename", "(", "response_filename", ")", ".", "split", "(", "'.'", ")", "encoding_suffix", "=", "components", "[", "-", "1", "]", ".", "lower", "(", ")", "if", "len", "(", "components", ")", ">", "1", "and", "(", "encoding_suffix", ".", "startswith", "(", "'utf'", ")", "or", "encoding_suffix", ".", "startswith", "(", "'cp'", ")", "or", "encoding_suffix", ".", "startswith", "(", "'iso'", ")", "or", "encoding_suffix", "in", "[", "'ascii'", ",", "'latin-1'", "]", ")", ":", "guessed_encoding", "=", "encoding_suffix", "else", ":", "guessed_encoding", "=", "'utf-8'", "try", ":", "# First try with the guessed encoding", "with", "open", "(", "response_filename", ",", "encoding", "=", "guessed_encoding", ")", "as", "f", ":", "args", "=", "f", ".", "read", "(", ")", "except", "(", "ValueError", ",", "LookupError", ")", ":", "# UnicodeDecodeError is a subclass of ValueError, and Python raises either a ValueError or a UnicodeDecodeError on decode errors. LookupError is raised if guessed encoding is not an encoding.", "if", "DEBUG", ":", "logging", ".", "warning", "(", "f'Failed to parse response file {response_filename} with guessed encoding \"{guessed_encoding}\". Trying default system encoding...'", ")", "# If that fails, try with the Python default locale.getpreferredencoding()", "with", "open", "(", "response_filename", ")", "as", "f", ":", "args", "=", "f", ".", "read", "(", ")", "args", "=", "shlex", ".", "split", "(", "args", ")", "if", "DEBUG", ":", "logging", ".", "warning", "(", "'Read response file '", "+", "response_filename", "+", "': '", "+", "str", "(", "args", ")", ")", "return", "args" ]

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

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

[ "ShowWithoutActivating", "(", "self", ")" ]

[ "def", "ShowWithoutActivating", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "TopLevelWindow_ShowWithoutActivating", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Checks", "that", "the", "file", "contains", "a", "header", "guard", "." ]

[ "def", "CheckForHeaderGuard", "(", "filename", ",", "clean_lines", ",", "error", ")", ":", "# Don't check for header guards if there are error suppression", "# comments somewhere in this file.", "#", "# Because this is silencing a warning for a nonexistent line, we", "# only support the very specific NOLINT(build/header_guard) syntax,", "# and not the general NOLINT or NOLINT(*) syntax.", "raw_lines", "=", "clean_lines", ".", "lines_without_raw_strings", "for", "i", "in", "raw_lines", ":", "if", "Search", "(", "r'//\\s*NOLINT\\(build/header_guard\\)'", ",", "i", ")", ":", "return", "cppvar", "=", "GetHeaderGuardCPPVariable", "(", "filename", ")", "ifndef", "=", "''", "ifndef_linenum", "=", "0", "define", "=", "''", "endif", "=", "''", "endif_linenum", "=", "0", "for", "linenum", ",", "line", "in", "enumerate", "(", "raw_lines", ")", ":", "linesplit", "=", "line", ".", "split", "(", ")", "if", "len", "(", "linesplit", ")", ">=", "2", ":", "# find the first occurrence of #ifndef and #define, save arg", "if", "not", "ifndef", "and", "linesplit", "[", "0", "]", "==", "'#ifndef'", ":", "# set ifndef to the header guard presented on the #ifndef line.", "ifndef", "=", "linesplit", "[", "1", "]", "ifndef_linenum", "=", "linenum", "if", "not", "define", "and", "linesplit", "[", "0", "]", "==", "'#define'", ":", "define", "=", "linesplit", "[", "1", "]", "# find the last occurrence of #endif, save entire line", "if", "line", ".", "startswith", "(", "'#endif'", ")", ":", "endif", "=", "line", "endif_linenum", "=", "linenum", "if", "not", "ifndef", "or", "not", "define", "or", "ifndef", "!=", "define", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'No #ifndef header guard found, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "# The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__", "# for backward compatibility.", "if", "ifndef", "!=", "cppvar", ":", "error_level", "=", "0", "if", "ifndef", "!=", "cppvar", "+", "'_'", ":", "error_level", "=", "5", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "ifndef_linenum", "]", ",", "ifndef_linenum", ",", "error", ")", "error", "(", "filename", ",", "ifndef_linenum", ",", "'build/header_guard'", ",", "error_level", ",", "'#ifndef header guard has wrong style, please use: %s'", "%", "cppvar", ")", "# Check for \"//\" comments on endif line.", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "endif_linenum", "]", ",", "endif_linenum", ",", "error", ")", "match", "=", "Match", "(", "r'#endif\\s*//\\s*'", "+", "cppvar", "+", "r'(_)?\\b'", ",", "endif", ")", "if", "match", ":", "if", "match", ".", "group", "(", "1", ")", "==", "'_'", ":", "# Issue low severity warning for deprecated double trailing underscore", "error", "(", "filename", ",", "endif_linenum", ",", "'build/header_guard'", ",", "0", ",", "'#endif line should be \"#endif // %s\"'", "%", "cppvar", ")", "return", "# Didn't find the corresponding \"//\" comment. If this file does not", "# contain any \"//\" comments at all, it could be that the compiler", "# only wants \"/**/\" comments, look for those instead.", "no_single_line_comments", "=", "True", "for", "i", "in", "xrange", "(", "1", ",", "len", "(", "raw_lines", ")", "-", "1", ")", ":", "line", "=", "raw_lines", "[", "i", "]", "if", "Match", "(", "r'^(?:(?:\\'(?:\\.|[^\\'])*\\')|(?:\"(?:\\.|[^\"])*\")|[^\\'\"])*//'", ",", "line", ")", ":", "no_single_line_comments", "=", "False", "break", "if", "no_single_line_comments", ":", "match", "=", "Match", "(", "r'#endif\\s*/\\*\\s*'", "+", "cppvar", "+", "r'(_)?\\s*\\*/'", ",", "endif", ")", "if", "match", ":", "if", "match", ".", "group", "(", "1", ")", "==", "'_'", ":", "# Low severity warning for double trailing underscore", "error", "(", "filename", ",", "endif_linenum", ",", "'build/header_guard'", ",", "0", ",", "'#endif line should be \"#endif /* %s */\"'", "%", "cppvar", ")", "return", "# Didn't find anything", "error", "(", "filename", ",", "endif_linenum", ",", "'build/header_guard'", ",", "5", ",", "'#endif line should be \"#endif // %s\"'", "%", "cppvar", ")" ]

[ "Convenience", "function", "used", "by", "the", "inst", "property", "to", "make", "calls", "shorter" ]

[ "def", "get_instrument", "(", "self", ")", ":", "return", "self", ".", "instrument" ]

[ "Return", "a", "string", "suitable", "for", "HTTP", "." ]

[ "def", "output", "(", "self", ",", "attrs", "=", "None", ",", "header", "=", "\"Set-Cookie:\"", ",", "sep", "=", "\"\\015\\012\"", ")", ":", "result", "=", "[", "]", "items", "=", "self", ".", "items", "(", ")", "items", ".", "sort", "(", ")", "for", "K", ",", "V", "in", "items", ":", "result", ".", "append", "(", "V", ".", "output", "(", "attrs", ",", "header", ")", ")", "return", "sep", ".", "join", "(", "result", ")" ]

[ "Rotates", "the", "sequence", "so", "it", "begins", "at", "start_pos", ".", "If", "flip", "is", "True", "it", "also", "switches", "the", "forward", "and", "reverse", "strands", ".", "This", "function", "assumes", "that", "the", "segment", "is", "a", "circular", "completed", "replicon", "with", "no", "overlap", "." ]

[ "def", "rotate_sequence", "(", "self", ",", "start_pos", ",", "flip", ")", ":", "unrotated_seq", "=", "self", ".", "forward_sequence", "rotated_seq", "=", "unrotated_seq", "[", "start_pos", ":", "]", "+", "unrotated_seq", "[", ":", "start_pos", "]", "rev_comp_rotated_seq", "=", "reverse_complement", "(", "rotated_seq", ")", "if", "flip", ":", "self", ".", "forward_sequence", "=", "rev_comp_rotated_seq", "self", ".", "reverse_sequence", "=", "rotated_seq", "else", ":", "self", ".", "forward_sequence", "=", "rotated_seq", "self", ".", "reverse_sequence", "=", "rev_comp_rotated_seq" ]

[ "Convert", "the", "input", "into", "a", "C", "contiguous", "float", "array", "." ]

[ "def", "_as_float_array", "(", "x", ",", "check_finite", "=", "False", ")", ":", "x", "=", "np", ".", "ascontiguousarray", "(", "x", ")", "dtyp", "=", "_get_dtype", "(", "x", ".", "dtype", ")", "x", "=", "x", ".", "astype", "(", "dtyp", ",", "copy", "=", "False", ")", "if", "check_finite", "and", "not", "np", ".", "isfinite", "(", "x", ")", ".", "all", "(", ")", ":", "raise", "ValueError", "(", "\"Array must not contain infs or nans.\"", ")", "return", "x" ]

[ "Return", "the", "thickness", "of", "a", "disk", "given", "the", "volume", "and", "area", "." ]

[ "def", "_get_thickness_from_volume_and_area", "(", "self", ",", "volume", ",", "area", ")", ":", "# max phi (for a sphere) is 6^(-1/3) * pi^(-1/6)", "phi", "=", "math", ".", "pow", "(", "volume", ",", "1", "/", "3.0", ")", "/", "math", ".", "pow", "(", "area", ",", "1", "/", "2.0", ")", "# find a solution, if possible", "max_alpha", "=", "math", ".", "pi", "**", "(", "-", "1.0", "/", "6", ")", "*", "6.0", "**", "(", "-", "1.0", "/", "3", ")", "low", "=", "0.0", "high", "=", "max_alpha", "a", "=", "1.0", "b", "=", "1.5", "-", "1", "/", "(", "16", "*", "math", ".", "pi", "*", "phi", "**", "6", ")", "c", "=", "0.75", "d", "=", "0.125", "high_value", "=", "a", "*", "high", "**", "3", "+", "b", "*", "high", "**", "2", "+", "c", "*", "high", "+", "d", "for", "_", "in", "range", "(", "53", ")", ":", "mid", "=", "(", "low", "+", "high", ")", "/", "2", "mid_value", "=", "a", "*", "high", "**", "3", "+", "b", "*", "high", "**", "2", "+", "c", "*", "high", "+", "d", "if", "(", "high_value", ">", "0", ")", "==", "(", "mid_value", ">", "0", ")", ":", "high_value", "=", "mid_value", "high", "=", "mid", "else", ":", "low", "=", "mid", "# in the case this fails, return NaN", "if", "low", "==", "0", "or", "high", "==", "max_alpha", ":", "return", "float", "(", "'nan'", ")", "alpha", "=", "(", "low", "+", "high", ")", "/", "2.0", "height", "=", "(", "volume", "*", "4", "*", "alpha", "**", "2", "/", "math", ".", "pi", ")", "**", "(", "1.0", "/", "3", ")", "return", "height" ]

[ "Include", "the", "given", "datetime", "instance", "in", "the", "recurrence", "set", "exclusion", "list", ".", "Dates", "included", "that", "way", "will", "not", "be", "generated", "even", "if", "some", "inclusive", "rrule", "or", "rdate", "matches", "them", "." ]

[ "def", "exdate", "(", "self", ",", "exdate", ")", ":", "self", ".", "_exdate", ".", "append", "(", "exdate", ")" ]

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

[ "def", "IsEditCancelled", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewEvent_IsEditCancelled", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "The", "dynamic", "address", "of", "our", "receiver", "." ]

[ "def", "reply_to", "(", "self", ")", "->", "str", ":", "return", "self", ".", "receiver", ".", "remote_source", ".", "address" ]

[ "Returns", "ctype", "arrays", "for", "the", "key", "-", "value", "args", "and", "the", "whether", "string", "keys", "are", "used", ".", "For", "internal", "use", "only", "." ]

[ "def", "_ctype_key_value", "(", "keys", ",", "vals", ")", ":", "if", "isinstance", "(", "keys", ",", "(", "tuple", ",", "list", ")", ")", ":", "assert", "(", "len", "(", "keys", ")", "==", "len", "(", "vals", ")", ")", "c_keys", "=", "[", "]", "c_vals", "=", "[", "]", "use_str_keys", "=", "None", "for", "key", ",", "val", "in", "zip", "(", "keys", ",", "vals", ")", ":", "c_key_i", ",", "c_val_i", ",", "str_keys_i", "=", "_ctype_key_value", "(", "key", ",", "val", ")", "c_keys", "+=", "c_key_i", "c_vals", "+=", "c_val_i", "use_str_keys", "=", "str_keys_i", "if", "use_str_keys", "is", "None", "else", "use_str_keys", "assert", "(", "use_str_keys", "==", "str_keys_i", ")", ",", "\"inconsistent types of keys detected.\"", "c_keys_arr", "=", "c_array", "(", "ctypes", ".", "c_char_p", ",", "c_keys", ")", "if", "use_str_keys", "else", "c_array", "(", "ctypes", ".", "c_int", ",", "c_keys", ")", "c_vals_arr", "=", "c_array", "(", "ctypes", ".", "c_void_p", ",", "c_vals", ")", "return", "(", "c_keys_arr", ",", "c_vals_arr", ",", "use_str_keys", ")", "assert", "(", "isinstance", "(", "keys", ",", "(", "int", ",", ")", "+", "string_types", ")", ")", ",", "\"unexpected type for keys: \"", "+", "str", "(", "type", "(", "keys", ")", ")", "use_str_keys", "=", "isinstance", "(", "keys", ",", "string_types", ")", "if", "isinstance", "(", "vals", ",", "NDArray", ")", ":", "c_keys", "=", "c_str_array", "(", "[", "keys", "]", ")", "if", "use_str_keys", "else", "c_array_buf", "(", "ctypes", ".", "c_int", ",", "array", "(", "'i'", ",", "[", "keys", "]", ")", ")", "return", "(", "c_keys", ",", "c_handle_array", "(", "[", "vals", "]", ")", ",", "use_str_keys", ")", "else", ":", "for", "value", "in", "vals", ":", "assert", "(", "isinstance", "(", "value", ",", "NDArray", ")", ")", "c_keys", "=", "c_str_array", "(", "[", "keys", "]", "*", "len", "(", "vals", ")", ")", "if", "use_str_keys", "else", "c_array_buf", "(", "ctypes", ".", "c_int", ",", "array", "(", "'i'", ",", "[", "keys", "]", "*", "len", "(", "vals", ")", ")", ")", "return", "(", "c_keys", ",", "c_handle_array", "(", "vals", ")", ",", "use_str_keys", ")" ]

[ "Make", "sure", "that", "we", "actually", "have", "the", "commit", "locally" ]

[ "def", "_ensure_commit", "(", "git_sha1", ":", "str", ")", "->", "None", ":", "cmd", "=", "[", "\"git\"", ",", "\"cat-file\"", ",", "\"-e\"", ",", "git_sha1", "+", "\"^{commit}\"", "]", "p", "=", "subprocess", ".", "run", "(", "cmd", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ",", "check", "=", "False", ")", "if", "p", ".", "returncode", "==", "0", ":", "# we have the commit locally", "return", "# we don't have the commit, must fetch", "cmd", "=", "[", "\"git\"", ",", "\"fetch\"", ",", "\"https://github.com/pytorch/pytorch.git\"", ",", "git_sha1", "]", "p", "=", "subprocess", ".", "run", "(", "cmd", ",", "check", "=", "True", ")" ]

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

[ "def", "ProcessFile", "(", "filename", ",", "vlevel", ",", "extra_check_functions", "=", "None", ")", ":", "_SetVerboseLevel", "(", "vlevel", ")", "_BackupFilters", "(", ")", "old_errors", "=", "_cpplint_state", ".", "error_count", "if", "not", "ProcessConfigOverrides", "(", "filename", ")", ":", "_RestoreFilters", "(", ")", "return", "lf_lines", "=", "[", "]", "crlf_lines", "=", "[", "]", "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", "filename", "==", "'-'", ":", "lines", "=", "codecs", ".", "StreamReaderWriter", "(", "sys", ".", "stdin", ",", "codecs", ".", "getreader", "(", "'utf8'", ")", ",", "codecs", ".", "getwriter", "(", "'utf8'", ")", ",", "'replace'", ")", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "else", ":", "with", "codecs", ".", "open", "(", "filename", ",", "'r'", ",", "'utf8'", ",", "'replace'", ")", "as", "target_file", ":", "lines", "=", "target_file", ".", "read", "(", ")", ".", "split", "(", "'\\n'", ")", "# Remove trailing '\\r'.", "# The -1 accounts for the extra trailing blank line we get from split()", "for", "linenum", "in", "range", "(", "len", "(", "lines", ")", "-", "1", ")", ":", "if", "lines", "[", "linenum", "]", ".", "endswith", "(", "'\\r'", ")", ":", "lines", "[", "linenum", "]", "=", "lines", "[", "linenum", "]", ".", "rstrip", "(", "'\\r'", ")", "crlf_lines", ".", "append", "(", "linenum", "+", "1", ")", "else", ":", "lf_lines", ".", "append", "(", "linenum", "+", "1", ")", "except", "IOError", ":", "_cpplint_state", ".", "PrintError", "(", "\"Skipping input '%s': Can't open for reading\\n\"", "%", "filename", ")", "_RestoreFilters", "(", ")", "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", "GetAllExtensions", "(", ")", ":", "_cpplint_state", ".", "PrintError", "(", "'Ignoring %s; not a valid file name '", "'(%s)\\n'", "%", "(", "filename", ",", "', '", ".", "join", "(", "GetAllExtensions", "(", ")", ")", ")", ")", "else", ":", "ProcessFileData", "(", "filename", ",", "file_extension", ",", "lines", ",", "Error", ",", "extra_check_functions", ")", "# If end-of-line sequences are a mix of LF and CR-LF, issue", "# warnings on the lines with CR.", "#", "# Don't issue any warnings if all lines are uniformly LF or CR-LF,", "# since critique can handle these just fine, and the style guide", "# doesn't dictate a particular end of line sequence.", "#", "# We can't depend on os.linesep to determine what the desired", "# end-of-line sequence should be, since that will return the", "# server-side end-of-line sequence.", "if", "lf_lines", "and", "crlf_lines", ":", "# Warn on every line with CR. An alternative approach might be to", "# check whether the file is mostly CRLF or just LF, and warn on the", "# minority, we bias toward LF here since most tools prefer LF.", "for", "linenum", "in", "crlf_lines", ":", "Error", "(", "filename", ",", "linenum", ",", "'whitespace/newline'", ",", "1", ",", "'Unexpected \\\\r (^M) found; better to use only \\\\n'", ")", "# Suppress printing anything if --quiet was passed unless the error", "# count has increased after processing this file.", "if", "not", "_cpplint_state", ".", "quiet", "or", "old_errors", "!=", "_cpplint_state", ".", "error_count", ":", "_cpplint_state", ".", "PrintInfo", "(", "'Done processing %s\\n'", "%", "filename", ")", "_RestoreFilters", "(", ")" ]

[ "Register", "an", "extension", "code", "." ]

[ "def", "add_extension", "(", "module", ",", "name", ",", "code", ")", ":", "code", "=", "int", "(", "code", ")", "if", "not", "1", "<=", "code", "<=", "0x7fffffff", ":", "raise", "ValueError", ",", "\"code out of range\"", "key", "=", "(", "module", ",", "name", ")", "if", "(", "_extension_registry", ".", "get", "(", "key", ")", "==", "code", "and", "_inverted_registry", ".", "get", "(", "code", ")", "==", "key", ")", ":", "return", "# Redundant registrations are benign", "if", "key", "in", "_extension_registry", ":", "raise", "ValueError", "(", "\"key %s is already registered with code %s\"", "%", "(", "key", ",", "_extension_registry", "[", "key", "]", ")", ")", "if", "code", "in", "_inverted_registry", ":", "raise", "ValueError", "(", "\"code %s is already in use for key %s\"", "%", "(", "code", ",", "_inverted_registry", "[", "code", "]", ")", ")", "_extension_registry", "[", "key", "]", "=", "code", "_inverted_registry", "[", "code", "]", "=", "key" ]

[ "We", "must", "escape", "the", "defines", "that", "we", "give", "to", "XCode", "so", "that", "it", "knows", "not", "to", "split", "on", "spaces", "and", "to", "respect", "backslash", "and", "quote", "literals", ".", "However", "we", "must", "not", "quote", "the", "define", "or", "Xcode", "will", "incorrectly", "intepret", "variables", "especially", "$", "(", "inherited", ")", "." ]

[ "def", "EscapeXcodeDefine", "(", "s", ")", ":", "return", "re", ".", "sub", "(", "_xcode_define_re", ",", "r'\\\\\\1'", ",", "s", ")" ]

[ "Get", "class", "info", "on", "the", "top", "of", "the", "stack", "." ]

[ "def", "InnermostClass", "(", "self", ")", ":", "for", "i", "in", "range", "(", "len", "(", "self", ".", "stack", ")", ",", "0", ",", "-", "1", ")", ":", "classinfo", "=", "self", ".", "stack", "[", "i", "-", "1", "]", "if", "isinstance", "(", "classinfo", ",", "_ClassInfo", ")", ":", "return", "classinfo", "return", "None" ]

[ "Writes", "the", "XML", "content", "to", "disk", "touching", "the", "file", "only", "if", "it", "has", "changed", "." ]

[ "def", "XmlToString", "(", "content", ",", "encoding", "=", "'utf-8'", ",", "pretty", "=", "False", ")", ":", "# We create a huge list of all the elements of the file.", "xml_parts", "=", "[", "'<?xml version=\"1.0\" encoding=\"%s\"?>'", "%", "encoding", "]", "if", "pretty", ":", "xml_parts", ".", "append", "(", "'\\n'", ")", "_ConstructContentList", "(", "xml_parts", ",", "content", ",", "pretty", ")", "# Convert it to a string", "return", "''", ".", "join", "(", "xml_parts", ")" ]

[ "Simple", "moving", "average", "." ]

[ "def", "sma", "(", "self", ",", "n", ",", "array", "=", "False", ")", ":", "result", "=", "talib", ".", "SMA", "(", "self", ".", "close", ",", "n", ")", "if", "array", ":", "return", "result", "return", "result", "[", "-", "1", "]" ]

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

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

[ "Reports", "for", "missing", "stl", "includes", "." ]

[ "def", "CheckForIncludeWhatYouUse", "(", "filename", ",", "clean_lines", ",", "include_state", ",", "error", ",", "io", "=", "codecs", ")", ":", "required", "=", "{", "}", "# A map of header name to linenumber and the template entity.", "# Example of required: { '<functional>': (1219, 'less<>') }", "for", "linenum", "in", "xrange", "(", "clean_lines", ".", "NumLines", "(", ")", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "not", "line", "or", "line", "[", "0", "]", "==", "'#'", ":", "continue", "# String is special -- it is a non-templatized type in STL.", "matched", "=", "_RE_PATTERN_STRING", ".", "search", "(", "line", ")", "if", "matched", ":", "# Don't warn about strings in non-STL namespaces:", "# (We check only the first match per line; good enough.)", "prefix", "=", "line", "[", ":", "matched", ".", "start", "(", ")", "]", "if", "prefix", ".", "endswith", "(", "'std::'", ")", "or", "not", "prefix", ".", "endswith", "(", "'::'", ")", ":", "required", "[", "'<string>'", "]", "=", "(", "linenum", ",", "'string'", ")", "for", "pattern", ",", "template", ",", "header", "in", "_re_pattern_algorithm_header", ":", "if", "pattern", ".", "search", "(", "line", ")", ":", "required", "[", "header", "]", "=", "(", "linenum", ",", "template", ")", "# The following function is just a speed up, no semantics are changed.", "if", "not", "'<'", "in", "line", ":", "# Reduces the cpu time usage by skipping lines.", "continue", "for", "pattern", ",", "template", ",", "header", "in", "_re_pattern_templates", ":", "if", "pattern", ".", "search", "(", "line", ")", ":", "required", "[", "header", "]", "=", "(", "linenum", ",", "template", ")", "# The policy is that if you #include something in foo.h you don't need to", "# include it again in foo.cc. Here, we will look at possible includes.", "# Let's copy the include_state so it is only messed up within this function.", "include_state", "=", "include_state", ".", "copy", "(", ")", "# Did we find the header for this file (if any) and successfully load it?", "header_found", "=", "False", "# Use the absolute path so that matching works properly.", "abs_filename", "=", "FileInfo", "(", "filename", ")", ".", "FullName", "(", ")", "# For Emacs's flymake.", "# If cpplint is invoked from Emacs's flymake, a temporary file is generated", "# by flymake and that file name might end with '_flymake.cc'. In that case,", "# restore original file name here so that the corresponding header file can be", "# found.", "# e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h'", "# instead of 'foo_flymake.h'", "abs_filename", "=", "re", ".", "sub", "(", "r'_flymake\\.cc$'", ",", "'.cc'", ",", "abs_filename", ")", "# include_state is modified during iteration, so we iterate over a copy of", "# the keys.", "header_keys", "=", "include_state", ".", "keys", "(", ")", "for", "header", "in", "header_keys", ":", "(", "same_module", ",", "common_path", ")", "=", "FilesBelongToSameModule", "(", "abs_filename", ",", "header", ")", "fullpath", "=", "common_path", "+", "header", "if", "same_module", "and", "UpdateIncludeState", "(", "fullpath", ",", "include_state", ",", "io", ")", ":", "header_found", "=", "True", "# If we can't find the header file for a .cc, assume it's because we don't", "# know where to look. In that case we'll give up as we're not sure they", "# didn't include it in the .h file.", "# TODO(unknown): Do a better job of finding .h files so we are confident that", "# not having the .h file means there isn't one.", "if", "filename", ".", "endswith", "(", "'.cc'", ")", "and", "not", "header_found", ":", "return", "# All the lines have been processed, report the errors found.", "for", "required_header_unstripped", "in", "required", ":", "template", "=", "required", "[", "required_header_unstripped", "]", "[", "1", "]", "if", "required_header_unstripped", ".", "strip", "(", "'<>\"'", ")", "not", "in", "include_state", ":", "error", "(", "filename", ",", "required", "[", "required_header_unstripped", "]", "[", "0", "]", ",", "'build/include_what_you_use'", ",", "4", ",", "'Add #include '", "+", "required_header_unstripped", "+", "' for '", "+", "template", ")" ]

[ "Enter", "literal", "mode", "(", "CDATA", ")", "till", "EOF", "." ]

[ "def", "setnomoretags", "(", "self", ")", ":", "self", ".", "nomoretags", "=", "self", ".", "literal", "=", "1" ]

[ "Returns", "True", "if", "the", "axis", "is", "a", "sequence", "axis", "and", "False", "otherwise" ]

[ "def", "is_sequence_axis", "(", "self", ")", ":", "return", "super", "(", "Axis", ",", "self", ")", ".", "is_sequence_axis", "(", ")" ]

[ "Check", "rules", "that", "are", "applicable", "to", "#include", "lines", "." ]

[ "def", "CheckIncludeLine", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "include_state", ",", "error", ")", ":", "fileinfo", "=", "FileInfo", "(", "filename", ")", "line", "=", "clean_lines", ".", "lines", "[", "linenum", "]", "# \"include\" should use the new style \"foo/bar.h\" instead of just \"bar.h\"", "if", "_RE_PATTERN_INCLUDE_NEW_STYLE", ".", "search", "(", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/include'", ",", "4", ",", "'Include the directory when naming .h files'", ")", "# we shouldn't include a file more than once. actually, there are a", "# handful of instances where doing so is okay, but in general it's", "# not.", "match", "=", "_RE_PATTERN_INCLUDE", ".", "search", "(", "line", ")", "if", "match", ":", "include", "=", "match", ".", "group", "(", "2", ")", "is_system", "=", "(", "match", ".", "group", "(", "1", ")", "==", "'<'", ")", "if", "include", "in", "include_state", ":", "error", "(", "filename", ",", "linenum", ",", "'build/include'", ",", "4", ",", "'\"%s\" already included at %s:%s'", "%", "(", "include", ",", "filename", ",", "include_state", "[", "include", "]", ")", ")", "else", ":", "include_state", "[", "include", "]", "=", "linenum", "# We want to ensure that headers appear in the right order:", "# 1) for foo.cc, foo.h (preferred location)", "# 2) c system files", "# 3) cpp system files", "# 4) for foo.cc, foo.h (deprecated location)", "# 5) other google headers", "#", "# We classify each include statement as one of those 5 types", "# using a number of techniques. The include_state object keeps", "# track of the highest type seen, and complains if we see a", "# lower type after that.", "error_message", "=", "include_state", ".", "CheckNextIncludeOrder", "(", "_ClassifyInclude", "(", "fileinfo", ",", "include", ",", "is_system", ")", ")", "if", "error_message", ":", "error", "(", "filename", ",", "linenum", ",", "'build/include_order'", ",", "4", ",", "'%s. Should be: %s.h, c system, c++ system, other.'", "%", "(", "error_message", ",", "fileinfo", ".", "BaseName", "(", ")", ")", ")", "canonical_include", "=", "include_state", ".", "CanonicalizeAlphabeticalOrder", "(", "include", ")", "if", "not", "include_state", ".", "IsInAlphabeticalOrder", "(", "clean_lines", ",", "linenum", ",", "canonical_include", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/include_alpha'", ",", "4", ",", "'Include \"%s\" not in alphabetical order'", "%", "include", ")", "include_state", ".", "SetLastHeader", "(", "canonical_include", ")", "# Look for any of the stream classes that are part of standard C++.", "match", "=", "_RE_PATTERN_INCLUDE", ".", "match", "(", "line", ")", "if", "match", ":", "include", "=", "match", ".", "group", "(", "2", ")", "if", "Match", "(", "r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$'", ",", "include", ")", ":", "# Many unit tests use cout, so we exempt them.", "if", "not", "_IsTestFilename", "(", "filename", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/streams'", ",", "3", ",", "'Streams are highly discouraged.'", ")" ]

[ "SetFileCounter", "(", "int", "counter", ")" ]

[ "def", "SetFileCounter", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextHTMLHandler_SetFileCounter", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Export", "this", "DSA", "key", "." ]

[ "def", "export_key", "(", "self", ",", "format", "=", "'PEM'", ",", "pkcs8", "=", "None", ",", "passphrase", "=", "None", ",", "protection", "=", "None", ",", "randfunc", "=", "None", ")", ":", "if", "passphrase", "is", "not", "None", ":", "passphrase", "=", "tobytes", "(", "passphrase", ")", "if", "randfunc", "is", "None", ":", "randfunc", "=", "Random", ".", "get_random_bytes", "if", "format", "==", "'OpenSSH'", ":", "tup1", "=", "[", "self", ".", "_key", "[", "x", "]", ".", "to_bytes", "(", ")", "for", "x", "in", "(", "'p'", ",", "'q'", ",", "'g'", ",", "'y'", ")", "]", "def", "func", "(", "x", ")", ":", "if", "(", "bord", "(", "x", "[", "0", "]", ")", "&", "0x80", ")", ":", "return", "bchr", "(", "0", ")", "+", "x", "else", ":", "return", "x", "tup2", "=", "[", "func", "(", "x", ")", "for", "x", "in", "tup1", "]", "keyparts", "=", "[", "b'ssh-dss'", "]", "+", "tup2", "keystring", "=", "b''", ".", "join", "(", "[", "struct", ".", "pack", "(", "\">I\"", ",", "len", "(", "kp", ")", ")", "+", "kp", "for", "kp", "in", "keyparts", "]", ")", "return", "b'ssh-dss '", "+", "binascii", ".", "b2a_base64", "(", "keystring", ")", "[", ":", "-", "1", "]", "# DER format is always used, even in case of PEM, which simply", "# encodes it into BASE64.", "params", "=", "DerSequence", "(", "[", "self", ".", "p", ",", "self", ".", "q", ",", "self", ".", "g", "]", ")", "if", "self", ".", "has_private", "(", ")", ":", "if", "pkcs8", "is", "None", ":", "pkcs8", "=", "True", "if", "pkcs8", ":", "if", "not", "protection", ":", "protection", "=", "'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC'", "private_key", "=", "DerInteger", "(", "self", ".", "x", ")", ".", "encode", "(", ")", "binary_key", "=", "PKCS8", ".", "wrap", "(", "private_key", ",", "oid", ",", "passphrase", ",", "protection", ",", "key_params", "=", "params", ",", "randfunc", "=", "randfunc", ")", "if", "passphrase", ":", "key_type", "=", "'ENCRYPTED PRIVATE'", "else", ":", "key_type", "=", "'PRIVATE'", "passphrase", "=", "None", "else", ":", "if", "format", "!=", "'PEM'", "and", "passphrase", ":", "raise", "ValueError", "(", "\"DSA private key cannot be encrypted\"", ")", "ints", "=", "[", "0", ",", "self", ".", "p", ",", "self", ".", "q", ",", "self", ".", "g", ",", "self", ".", "y", ",", "self", ".", "x", "]", "binary_key", "=", "DerSequence", "(", "ints", ")", ".", "encode", "(", ")", "key_type", "=", "\"DSA PRIVATE\"", "else", ":", "if", "pkcs8", ":", "raise", "ValueError", "(", "\"PKCS#8 is only meaningful for private keys\"", ")", "binary_key", "=", "_create_subject_public_key_info", "(", "oid", ",", "DerInteger", "(", "self", ".", "y", ")", ",", "params", ")", "key_type", "=", "\"PUBLIC\"", "if", "format", "==", "'DER'", ":", "return", "binary_key", "if", "format", "==", "'PEM'", ":", "pem_str", "=", "PEM", ".", "encode", "(", "binary_key", ",", "key_type", "+", "\" KEY\"", ",", "passphrase", ",", "randfunc", ")", "return", "tobytes", "(", "pem_str", ")", "raise", "ValueError", "(", "\"Unknown key format '%s'. Cannot export the DSA key.\"", "%", "format", ")" ]

[ "Returns", "flags", "that", "need", "to", "be", "added", "to", ".", "c", "and", ".", "m", "compilations", "." ]

[ "def", "GetCflagsC", "(", "self", ",", "configname", ")", ":", "self", ".", "configname", "=", "configname", "cflags_c", "=", "[", "]", "self", ".", "_Appendf", "(", "cflags_c", ",", "'GCC_C_LANGUAGE_STANDARD'", ",", "'-std=%s'", ")", "cflags_c", "+=", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'OTHER_CFLAGS'", ",", "[", "]", ")", "self", ".", "configname", "=", "None", "return", "cflags_c" ]

[ "Return", "a", "dict", "with", "the", "Python", "implementation", "and", "version", "." ]

[ "def", "_implementation", "(", ")", ":", "implementation", "=", "platform", ".", "python_implementation", "(", ")", "if", "implementation", "==", "'CPython'", ":", "implementation_version", "=", "platform", ".", "python_version", "(", ")", "elif", "implementation", "==", "'PyPy'", ":", "implementation_version", "=", "'%s.%s.%s'", "%", "(", "sys", ".", "pypy_version_info", ".", "major", ",", "sys", ".", "pypy_version_info", ".", "minor", ",", "sys", ".", "pypy_version_info", ".", "micro", ")", "if", "sys", ".", "pypy_version_info", ".", "releaselevel", "!=", "'final'", ":", "implementation_version", "=", "''", ".", "join", "(", "[", "implementation_version", ",", "sys", ".", "pypy_version_info", ".", "releaselevel", "]", ")", "elif", "implementation", "==", "'Jython'", ":", "implementation_version", "=", "platform", ".", "python_version", "(", ")", "# Complete Guess", "elif", "implementation", "==", "'IronPython'", ":", "implementation_version", "=", "platform", ".", "python_version", "(", ")", "# Complete Guess", "else", ":", "implementation_version", "=", "'Unknown'", "return", "{", "'name'", ":", "implementation", ",", "'version'", ":", "implementation_version", "}" ]

[ "Get", "the", "size", "of", "the", "terminal", "window", "." ]

[ "def", "get_terminal_size", "(", "fallback", "=", "(", "80", ",", "24", ")", ")", ":", "# Try the environment first", "try", ":", "columns", "=", "int", "(", "os", ".", "environ", "[", "\"COLUMNS\"", "]", ")", "except", "(", "KeyError", ",", "ValueError", ")", ":", "columns", "=", "0", "try", ":", "lines", "=", "int", "(", "os", ".", "environ", "[", "\"LINES\"", "]", ")", "except", "(", "KeyError", ",", "ValueError", ")", ":", "lines", "=", "0", "# Only query if necessary", "if", "columns", "<=", "0", "or", "lines", "<=", "0", ":", "try", ":", "size", "=", "_get_terminal_size", "(", "sys", ".", "__stdout__", ".", "fileno", "(", ")", ")", "except", "(", "NameError", ",", "OSError", ")", ":", "size", "=", "terminal_size", "(", "*", "fallback", ")", "if", "columns", "<=", "0", ":", "columns", "=", "size", ".", "columns", "if", "lines", "<=", "0", ":", "lines", "=", "size", ".", "lines", "return", "terminal_size", "(", "columns", ",", "lines", ")" ]

[ "Create", "ops", "to", "restore", "saveable", "." ]

[ "def", "restore_op", "(", "self", ",", "filename_tensor", ",", "saveable", ",", "preferred_shard", ")", ":", "# pylint: disable=protected-access", "tensors", "=", "[", "]", "for", "spec", "in", "saveable", ".", "specs", ":", "tensors", ".", "append", "(", "io_ops", ".", "restore_v2", "(", "filename_tensor", ",", "[", "spec", ".", "name", "]", ",", "[", "spec", ".", "slice_spec", "]", ",", "[", "spec", ".", "tensor", ".", "dtype", "]", ")", "[", "0", "]", ")", "return", "tensors" ]

[]

[ "def", "_GenericHandler", "(", "self", ",", "callback", ",", "uid", ",", "response", ")", ":", "obj", "=", "None", "unpack_exception", "=", "None", "if", "response", ".", "WasAcked", "(", ")", ":", "request_type", "=", "self", ".", "COMMAND_CLASS_DICT", "[", "response", ".", "command_class", "]", "pid_descriptor", "=", "self", ".", "_pid_store", ".", "GetPid", "(", "response", ".", "pid", ",", "uid", ".", "manufacturer_id", ")", "if", "pid_descriptor", ":", "try", ":", "obj", "=", "pid_descriptor", ".", "Unpack", "(", "response", ".", "data", ",", "request_type", ")", "except", "PidStore", ".", "UnpackException", "as", "e", ":", "obj", "=", "None", "unpack_exception", "=", "e", "else", ":", "obj", "=", "response", ".", "data", "callback", "(", "response", ",", "obj", ",", "unpack_exception", ")" ]

[ "Establish", "a", "TLS", "connection", "to", "the", "proxy", "using", "the", "provided", "SSL", "context", "." ]

[ "def", "_connect_tls_proxy", "(", "self", ",", "hostname", ",", "conn", ")", ":", "proxy_config", "=", "self", ".", "proxy_config", "ssl_context", "=", "proxy_config", ".", "ssl_context", "if", "ssl_context", ":", "# If the user provided a proxy context, we assume CA and client", "# certificates have already been set", "return", "ssl_wrap_socket", "(", "sock", "=", "conn", ",", "server_hostname", "=", "hostname", ",", "ssl_context", "=", "ssl_context", ",", ")", "ssl_context", "=", "create_proxy_ssl_context", "(", "self", ".", "ssl_version", ",", "self", ".", "cert_reqs", ",", "self", ".", "ca_certs", ",", "self", ".", "ca_cert_dir", ",", "self", ".", "ca_cert_data", ",", ")", "# If no cert was provided, use only the default options for server", "# certificate validation", "return", "ssl_wrap_socket", "(", "sock", "=", "conn", ",", "ca_certs", "=", "self", ".", "ca_certs", ",", "ca_cert_dir", "=", "self", ".", "ca_cert_dir", ",", "ca_cert_data", "=", "self", ".", "ca_cert_data", ",", "server_hostname", "=", "hostname", ",", "ssl_context", "=", "ssl_context", ",", ")" ]

[ "Gets", "the", "last", "L", "{", "Class", "}", "that", "was", "added", "to", "the", "document", "@return", ":", "L", "{", "Class", "}" ]

[ "def", "GetLastClass", "(", "self", ")", ":", "return", "self", ".", "lastclass" ]

[ "Called", "when", "a", "FileCheck", "message", "is", "received", ".", "Check", "the", "current", "file", "." ]

[ "def", "OnFileCheck", "(", "self", ",", "id", ",", "code", ")", ":", "import", "scriptutils", "scriptutils", ".", "CheckFile", "(", ")" ]

[ "This", "heuristicly", "adds", "types", "from", "a", "curated", "list", "used", "in", "the", "template", "to", "the", "import", "list", "." ]

[ "def", "render", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "s", "=", "Template", ".", "render", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "type_list", "=", "[", "]", "for", "x", "in", "TYPING_TYPES", ":", "if", "re", ".", "search", "(", "r'\\b{}\\b'", ".", "format", "(", "x", ")", ",", "s", ")", ":", "type_list", ".", "append", "(", "x", ")", "return", "s", ".", "replace", "(", "\"{TYPES}\"", ",", "\", \"", ".", "join", "(", "type_list", ")", ")" ]

[ "Load", "vertex", "and", "edges", "from", "raw", "C", "++", "wire", "data", "structure", "." ]

[ "def", "load_from_raw", "(", "self", ",", "raw_wires", ")", ":", "self", ".", "raw_wires", "=", "raw_wires", "self", ".", "__initialize_wires", "(", ")" ]

[ "Initialise", "an", "instance", "of", "a", "module", "Makefile", "." ]

[ "def", "__init__", "(", "self", ",", "configuration", ",", "build_file", ",", "install_dir", "=", "None", ",", "static", "=", "0", ",", "console", "=", "0", ",", "qt", "=", "0", ",", "opengl", "=", "0", ",", "threaded", "=", "0", ",", "warnings", "=", "1", ",", "debug", "=", "0", ",", "dir", "=", "None", ",", "makefile", "=", "\"Makefile\"", ",", "installs", "=", "None", ",", "strip", "=", "1", ",", "export_all", "=", "0", ",", "universal", "=", "None", ",", "arch", "=", "None", ")", ":", "Makefile", ".", "__init__", "(", "self", ",", "configuration", ",", "console", ",", "qt", ",", "opengl", ",", "1", ",", "threaded", ",", "warnings", ",", "debug", ",", "dir", ",", "makefile", ",", "installs", ",", "universal", ",", "arch", ")", "self", ".", "_build", "=", "self", ".", "parse_build_file", "(", "build_file", ")", "self", ".", "_install_dir", "=", "install_dir", "self", ".", "static", "=", "static", "self", ".", "_manifest", "=", "(", "\"embed_manifest_dll\"", "in", "self", ".", "optional_list", "(", "\"CONFIG\"", ")", ")", "# Don't strip or restrict the exports if this is a debug or static", "# build.", "if", "debug", "or", "static", ":", "self", ".", "_strip", "=", "0", "self", ".", "_limit_exports", "=", "0", "else", ":", "self", ".", "_strip", "=", "strip", "self", ".", "_limit_exports", "=", "not", "export_all", "# Save the target name for later.", "self", ".", "_target", "=", "self", ".", "_build", "[", "\"target\"", "]", "# The name of the module entry point is Python version specific.", "if", "self", ".", "config", ".", "py_version", ">=", "0x030000", ":", "self", ".", "_entry_point", "=", "\"PyInit_%s\"", "%", "self", ".", "_target", "else", ":", "self", ".", "_entry_point", "=", "\"init%s\"", "%", "self", ".", "_target", "if", "sys", ".", "platform", "!=", "\"win32\"", "and", "static", ":", "self", ".", "_target", "=", "\"lib\"", "+", "self", ".", "_target", "if", "sys", ".", "platform", "==", "\"win32\"", "and", "debug", ":", "self", ".", "_target", "=", "self", ".", "_target", "+", "\"_d\"" ]

[ "ToUc", "(", "TChA", "self", ")", "-", ">", "TChA" ]

[ "def", "ToUc", "(", "self", ")", ":", "return", "_snap", ".", "TChA_ToUc", "(", "self", ")" ]

[ "Builds", "a", "proto2", "message", "class", "based", "on", "the", "passed", "in", "descriptor", "." ]

[ "def", "GetPrototype", "(", "self", ",", "descriptor", ")", ":", "return", "self", ".", "GetSymbol", "(", "descriptor", ".", "full_name", ")" ]

[ "Maintains", "a", "map", "of", "functions", "that", "are", "called", "from", "other", "functions" ]

[ "def", "updateFunctionCallMap", "(", "self", ",", "caller", ",", "callee", ")", ":", "if", "not", "caller", "in", "self", ".", "calledFunctionTable", ":", "self", ".", "calledFunctionTable", "[", "caller", "]", "=", "[", "]", "if", "not", "callee", "in", "self", ".", "calledFunctionTable", "[", "caller", "]", ":", "self", ".", "calledFunctionTable", "[", "caller", "]", ".", "append", "(", "callee", ")", "if", "not", "caller", "in", "self", ".", "comprehensiveCalledFunctionTable", ":", "self", ".", "comprehensiveCalledFunctionTable", "[", "caller", "]", "=", "[", "]", "self", ".", "comprehensiveCalledFunctionTable", "[", "caller", "]", ".", "append", "(", "callee", ")" ]

[ "If", "input", "points", "to", "(", "or", "{", "or", "[", "or", "<", "finds", "the", "position", "that", "closes", "it", "." ]

[ "def", "CloseExpression", "(", "clean_lines", ",", "linenum", ",", "pos", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "startchar", "=", "line", "[", "pos", "]", "if", "startchar", "not", "in", "'({[<'", ":", "return", "(", "line", ",", "clean_lines", ".", "NumLines", "(", ")", ",", "-", "1", ")", "if", "startchar", "==", "'('", ":", "endchar", "=", "')'", "if", "startchar", "==", "'['", ":", "endchar", "=", "']'", "if", "startchar", "==", "'{'", ":", "endchar", "=", "'}'", "if", "startchar", "==", "'<'", ":", "endchar", "=", "'>'", "# Check first line", "(", "end_pos", ",", "num_open", ")", "=", "FindEndOfExpressionInLine", "(", "line", ",", "pos", ",", "0", ",", "startchar", ",", "endchar", ")", "if", "end_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "end_pos", ")", "# Continue scanning forward", "while", "linenum", "<", "clean_lines", ".", "NumLines", "(", ")", "-", "1", ":", "linenum", "+=", "1", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "(", "end_pos", ",", "num_open", ")", "=", "FindEndOfExpressionInLine", "(", "line", ",", "0", ",", "num_open", ",", "startchar", ",", "endchar", ")", "if", "end_pos", ">", "-", "1", ":", "return", "(", "line", ",", "linenum", ",", "end_pos", ")", "# Did not find endchar before end of file, give up", "return", "(", "line", ",", "clean_lines", ".", "NumLines", "(", ")", ",", "-", "1", ")" ]

[ "Fork", "a", "new", "subprocess", "to", "process", "the", "request", "." ]

[ "def", "process_request", "(", "self", ",", "request", ",", "client_address", ")", ":", "self", ".", "collect_children", "(", ")", "pid", "=", "os", ".", "fork", "(", ")", "if", "pid", ":", "# Parent process", "if", "self", ".", "active_children", "is", "None", ":", "self", ".", "active_children", "=", "[", "]", "self", ".", "active_children", ".", "append", "(", "pid", ")", "self", ".", "close_request", "(", "request", ")", "#close handle in parent process", "return", "else", ":", "# Child process.", "# This must never return, hence os._exit()!", "try", ":", "self", ".", "finish_request", "(", "request", ",", "client_address", ")", "self", ".", "shutdown_request", "(", "request", ")", "os", ".", "_exit", "(", "0", ")", "except", ":", "try", ":", "self", ".", "handle_error", "(", "request", ",", "client_address", ")", "self", ".", "shutdown_request", "(", "request", ")", "finally", ":", "os", ".", "_exit", "(", "1", ")" ]

[ "Stop", "analyzing", "function", "body", "." ]

[ "def", "End", "(", "self", ")", ":", "self", ".", "in_a_function", "=", "False" ]

[ "Returns", "a", "list", "of", "entries", "contained", "within", "a", "directory", "." ]

[ "def", "list_directory", "(", "dirname", ")", ":", "if", "not", "is_directory", "(", "dirname", ")", ":", "raise", "errors", ".", "NotFoundError", "(", "None", ",", "None", ",", "\"Could not find directory\"", ")", "file_list", "=", "get_matching_files", "(", "os", ".", "path", ".", "join", "(", "compat", ".", "as_str_any", "(", "dirname", ")", ",", "\"*\"", ")", ")", "return", "[", "compat", ".", "as_str_any", "(", "pywrap_tensorflow", ".", "Basename", "(", "compat", ".", "as_bytes", "(", "filename", ")", ")", ")", "for", "filename", "in", "file_list", "]" ]

[ "atom", "::", "=", "(", "expr", ")", "|", "[", "expr", "]", "|", "options", "|", "long", "|", "shorts", "|", "argument", "|", "command", ";" ]

[ "def", "parse_atom", "(", "tokens", ",", "options", ")", ":", "token", "=", "tokens", ".", "current", "(", ")", "result", "=", "[", "]", "if", "token", "in", "'(['", ":", "tokens", ".", "move", "(", ")", "matching", ",", "pattern", "=", "{", "'('", ":", "[", "')'", ",", "Required", "]", ",", "'['", ":", "[", "']'", ",", "Optional", "]", "}", "[", "token", "]", "result", "=", "pattern", "(", "*", "parse_expr", "(", "tokens", ",", "options", ")", ")", "if", "tokens", ".", "move", "(", ")", "!=", "matching", ":", "raise", "tokens", ".", "error", "(", "\"unmatched '%s'\"", "%", "token", ")", "return", "[", "result", "]", "elif", "token", "==", "'options'", ":", "tokens", ".", "move", "(", ")", "return", "[", "OptionsShortcut", "(", ")", "]", "elif", "token", ".", "startswith", "(", "'--'", ")", "and", "token", "!=", "'--'", ":", "return", "parse_long", "(", "tokens", ",", "options", ")", "elif", "token", ".", "startswith", "(", "'-'", ")", "and", "token", "not", "in", "(", "'-'", ",", "'--'", ")", ":", "return", "parse_shorts", "(", "tokens", ",", "options", ")", "elif", "token", ".", "startswith", "(", "'<'", ")", "and", "token", ".", "endswith", "(", "'>'", ")", "or", "token", ".", "isupper", "(", ")", ":", "return", "[", "Argument", "(", "tokens", ".", "move", "(", ")", ")", "]", "else", ":", "return", "[", "Command", "(", "tokens", ".", "move", "(", ")", ")", "]" ]

[ "Checks", "that", "the", "file", "contains", "a", "header", "guard", "." ]

[ "def", "CheckForHeaderGuard", "(", "filename", ",", "lines", ",", "error", ")", ":", "cppvar", "=", "GetHeaderGuardCPPVariable", "(", "filename", ")", "ifndef", "=", "None", "ifndef_linenum", "=", "0", "define", "=", "None", "endif", "=", "None", "endif_linenum", "=", "0", "for", "linenum", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "linesplit", "=", "line", ".", "split", "(", ")", "if", "len", "(", "linesplit", ")", ">=", "2", ":", "# find the first occurrence of #ifndef and #define, save arg", "if", "not", "ifndef", "and", "linesplit", "[", "0", "]", "==", "'#ifndef'", ":", "# set ifndef to the header guard presented on the #ifndef line.", "ifndef", "=", "linesplit", "[", "1", "]", "ifndef_linenum", "=", "linenum", "if", "not", "define", "and", "linesplit", "[", "0", "]", "==", "'#define'", ":", "define", "=", "linesplit", "[", "1", "]", "# find the last occurrence of #endif, save entire line", "if", "line", ".", "startswith", "(", "'#endif'", ")", ":", "endif", "=", "line", "endif_linenum", "=", "linenum", "if", "not", "ifndef", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'No #ifndef header guard found, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "if", "not", "define", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'No #define header guard found, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "# The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__", "# for backward compatibility.", "if", "ifndef", "!=", "cppvar", ":", "error_level", "=", "0", "if", "ifndef", "!=", "cppvar", "+", "'_'", ":", "error_level", "=", "5", "ParseNolintSuppressions", "(", "filename", ",", "lines", "[", "ifndef_linenum", "]", ",", "ifndef_linenum", ",", "error", ")", "error", "(", "filename", ",", "ifndef_linenum", ",", "'build/header_guard'", ",", "error_level", ",", "'#ifndef header guard has wrong style, please use: %s'", "%", "cppvar", ")", "if", "define", "!=", "ifndef", ":", "error", "(", "filename", ",", "0", ",", "'build/header_guard'", ",", "5", ",", "'#ifndef and #define don\\'t match, suggested CPP variable is: %s'", "%", "cppvar", ")", "return", "if", "endif", "!=", "(", "'#endif // %s'", "%", "cppvar", ")", ":", "error_level", "=", "0", "if", "endif", "!=", "(", "'#endif // %s'", "%", "(", "cppvar", "+", "'_'", ")", ")", ":", "error_level", "=", "5", "ParseNolintSuppressions", "(", "filename", ",", "lines", "[", "endif_linenum", "]", ",", "endif_linenum", ",", "error", ")", "error", "(", "filename", ",", "endif_linenum", ",", "'build/header_guard'", ",", "error_level", ",", "'#endif line should be \"#endif // %s\"'", "%", "cppvar", ")" ]

[ "Add", "libname", "to", "the", "list", "of", "libraries", "that", "will", "be", "included", "in", "all", "links", "driven", "by", "this", "compiler", "object", ".", "Note", "that", "libname", "should", "*", "not", "*", "be", "the", "name", "of", "a", "file", "containing", "a", "library", "but", "the", "name", "of", "the", "library", "itself", ":", "the", "actual", "filename", "will", "be", "inferred", "by", "the", "linker", "the", "compiler", "or", "the", "compiler", "class", "(", "depending", "on", "the", "platform", ")", "." ]

[ "def", "add_library", "(", "self", ",", "libname", ")", ":", "self", ".", "libraries", ".", "append", "(", "libname", ")" ]

[ "Write", "out", "a", "link", "step", ".", "Fills", "out", "target", ".", "binary", "." ]

[ "def", "_WriteLinkForArch", "(", "self", ",", "ninja_file", ",", "spec", ",", "config_name", ",", "config", ",", "link_deps", ",", "compile_deps", ",", "arch", "=", "None", ")", ":", "command", "=", "{", "'executable'", ":", "'link'", ",", "'loadable_module'", ":", "'solink_module'", ",", "'shared_library'", ":", "'solink'", ",", "}", "[", "spec", "[", "'type'", "]", "]", "command_suffix", "=", "''", "implicit_deps", "=", "set", "(", ")", "solibs", "=", "set", "(", ")", "order_deps", "=", "set", "(", ")", "if", "compile_deps", ":", "# Normally, the compiles of the target already depend on compile_deps,", "# but a shared_library target might have no sources and only link together", "# a few static_library deps, so the link step also needs to depend", "# on compile_deps to make sure actions in the shared_library target", "# get run before the link.", "order_deps", ".", "add", "(", "compile_deps", ")", "if", "'dependencies'", "in", "spec", ":", "# Two kinds of dependencies:", "# - Linkable dependencies (like a .a or a .so): add them to the link line.", "# - Non-linkable dependencies (like a rule that generates a file", "# and writes a stamp file): add them to implicit_deps", "extra_link_deps", "=", "set", "(", ")", "for", "dep", "in", "spec", "[", "'dependencies'", "]", ":", "target", "=", "self", ".", "target_outputs", ".", "get", "(", "dep", ")", "if", "not", "target", ":", "continue", "linkable", "=", "target", ".", "Linkable", "(", ")", "if", "linkable", ":", "new_deps", "=", "[", "]", "if", "self", ".", "flavor", "==", "'win'", "and", "target", ".", "component_objs", "and", "self", ".", "msvs_settings", ".", "IsUseLibraryDependencyInputs", "(", "config_name", ")", ":", "new_deps", "=", "target", ".", "component_objs", "if", "target", ".", "compile_deps", ":", "order_deps", ".", "add", "(", "target", ".", "compile_deps", ")", "elif", "self", ".", "flavor", "==", "'win'", "and", "target", ".", "import_lib", ":", "new_deps", "=", "[", "target", ".", "import_lib", "]", "elif", "target", ".", "UsesToc", "(", "self", ".", "flavor", ")", ":", "solibs", ".", "add", "(", "target", ".", "binary", ")", "implicit_deps", ".", "add", "(", "target", ".", "binary", "+", "'.TOC'", ")", "else", ":", "new_deps", "=", "[", "target", ".", "binary", "]", "for", "new_dep", "in", "new_deps", ":", "if", "new_dep", "not", "in", "extra_link_deps", ":", "extra_link_deps", ".", "add", "(", "new_dep", ")", "link_deps", ".", "append", "(", "new_dep", ")", "final_output", "=", "target", ".", "FinalOutput", "(", ")", "if", "not", "linkable", "or", "final_output", "!=", "target", ".", "binary", ":", "implicit_deps", ".", "add", "(", "final_output", ")", "extra_bindings", "=", "[", "]", "if", "self", ".", "target", ".", "uses_cpp", "and", "self", ".", "flavor", "!=", "'win'", ":", "extra_bindings", ".", "append", "(", "(", "'ld'", ",", "'$ldxx'", ")", ")", "output", "=", "self", ".", "_ComputeOutput", "(", "spec", ",", "arch", ")", "if", "arch", "is", "None", "and", "not", "self", ".", "is_mac_bundle", ":", "self", ".", "_AppendPostbuildVariable", "(", "extra_bindings", ",", "spec", ",", "output", ",", "output", ")", "is_executable", "=", "spec", "[", "'type'", "]", "==", "'executable'", "# The ldflags config key is not used on mac or win. On those platforms", "# linker flags are set via xcode_settings and msvs_settings, respectively.", "if", "self", ".", "toolset", "==", "'target'", ":", "env_ldflags", "=", "os", ".", "environ", ".", "get", "(", "'LDFLAGS'", ",", "''", ")", ".", "split", "(", ")", "else", ":", "# self.toolset == 'host'", "env_ldflags", "=", "os", ".", "environ", ".", "get", "(", "'LDFLAGS_host'", ",", "''", ")", ".", "split", "(", ")", "if", "self", ".", "flavor", "==", "'mac'", ":", "ldflags", "=", "self", ".", "xcode_settings", ".", "GetLdflags", "(", "config_name", ",", "self", ".", "_ExpandSpecial", "(", "generator_default_variables", "[", "'PRODUCT_DIR'", "]", ")", ",", "self", ".", "_GypPathToNinja", ",", "arch", ")", "ldflags", "=", "env_ldflags", "+", "ldflags", "elif", "self", ".", "flavor", "==", "'win'", ":", "manifest_base_name", "=", "self", ".", "_GypPathToUniqueOutput", "(", "self", ".", "ComputeOutputFileName", "(", "spec", ")", ")", "ldflags", ",", "intermediate_manifest", ",", "manifest_files", "=", "self", ".", "msvs_settings", ".", "GetLdflags", "(", "config_name", ",", "self", ".", "_GypPathToNinja", ",", "self", ".", "_ExpandSpecial", ",", "manifest_base_name", ",", "output", ",", "is_executable", ",", "self", ".", "toplevel_build", ")", "ldflags", "=", "env_ldflags", "+", "ldflags", "self", ".", "_WriteVariableList", "(", "ninja_file", ",", "'manifests'", ",", "manifest_files", ")", "implicit_deps", "=", "implicit_deps", ".", "union", "(", "manifest_files", ")", "if", "intermediate_manifest", ":", "self", ".", "_WriteVariableList", "(", "ninja_file", ",", "'intermediatemanifest'", ",", "[", "intermediate_manifest", "]", ")", "command_suffix", "=", "GetWinLinkRuleNameSuffix", "(", "self", ".", "msvs_settings", ".", "IsEmbedManifest", "(", "config_name", ")", ")", "def_file", "=", "self", ".", "msvs_settings", ".", "GetDefFile", "(", "self", ".", "_GypPathToNinja", ")", "if", "def_file", ":", "implicit_deps", ".", "add", "(", "def_file", ")", "else", ":", "# Respect environment variables related to build, but target-specific", "# flags can still override them.", "ldflags", "=", "env_ldflags", "+", "config", ".", "get", "(", "'ldflags'", ",", "[", "]", ")", "if", "is_executable", "and", "len", "(", "solibs", ")", ":", "rpath", "=", "'lib/'", "if", "self", ".", "toolset", "!=", "'target'", ":", "rpath", "+=", "self", ".", "toolset", "ldflags", ".", "append", "(", "r'-Wl,-rpath=\\$$ORIGIN/%s'", "%", "rpath", ")", "else", ":", "ldflags", ".", "append", "(", "'-Wl,-rpath=%s'", "%", "self", ".", "target_rpath", ")", "ldflags", ".", "append", "(", "'-Wl,-rpath-link=%s'", "%", "rpath", ")", "self", ".", "_WriteVariableList", "(", "ninja_file", ",", "'ldflags'", ",", "map", "(", "self", ".", "_ExpandSpecial", ",", "ldflags", ")", ")", "library_dirs", "=", "config", ".", "get", "(", "'library_dirs'", ",", "[", "]", ")", "if", "self", ".", "flavor", "==", "'win'", ":", "library_dirs", "=", "[", "self", ".", "msvs_settings", ".", "ConvertVSMacros", "(", "l", ",", "config_name", ")", "for", "l", "in", "library_dirs", "]", "library_dirs", "=", "[", "'/LIBPATH:'", "+", "self", ".", "_QuoteShellArgument", "(", "self", ".", "_GypPathToNinja", "(", "l", ")", ",", "self", ".", "flavor", ")", "for", "l", "in", "library_dirs", "]", "else", ":", "library_dirs", "=", "[", "self", ".", "_QuoteShellArgument", "(", "'-L'", "+", "self", ".", "_GypPathToNinja", "(", "l", ")", ",", "self", ".", "flavor", ")", "for", "l", "in", "library_dirs", "]", "libraries", "=", "gyp", ".", "common", ".", "uniquer", "(", "map", "(", "self", ".", "_ExpandSpecial", ",", "spec", ".", "get", "(", "'libraries'", ",", "[", "]", ")", ")", ")", "if", "self", ".", "flavor", "==", "'mac'", ":", "libraries", "=", "self", ".", "xcode_settings", ".", "AdjustLibraries", "(", "libraries", ",", "config_name", ")", "elif", "self", ".", "flavor", "==", "'win'", ":", "libraries", "=", "self", ".", "msvs_settings", ".", "AdjustLibraries", "(", "libraries", ")", "self", ".", "_WriteVariableList", "(", "ninja_file", ",", "'libs'", ",", "library_dirs", "+", "libraries", ")", "linked_binary", "=", "output", "if", "command", "in", "(", "'solink'", ",", "'solink_module'", ")", ":", "extra_bindings", ".", "append", "(", "(", "'soname'", ",", "os", ".", "path", ".", "split", "(", "output", ")", "[", "1", "]", ")", ")", "extra_bindings", ".", "append", "(", "(", "'lib'", ",", "gyp", ".", "common", ".", "EncodePOSIXShellArgument", "(", "output", ")", ")", ")", "if", "self", ".", "flavor", "!=", "'win'", ":", "link_file_list", "=", "output", "if", "self", ".", "is_mac_bundle", ":", "# 'Dependency Framework.framework/Versions/A/Dependency Framework' ->", "# 'Dependency Framework.framework.rsp'", "link_file_list", "=", "self", ".", "xcode_settings", ".", "GetWrapperName", "(", ")", "if", "arch", ":", "link_file_list", "+=", "'.'", "+", "arch", "link_file_list", "+=", "'.rsp'", "# If an rspfile contains spaces, ninja surrounds the filename with", "# quotes around it and then passes it to open(), creating a file with", "# quotes in its name (and when looking for the rsp file, the name", "# makes it through bash which strips the quotes) :-/", "link_file_list", "=", "link_file_list", ".", "replace", "(", "' '", ",", "'_'", ")", "extra_bindings", ".", "append", "(", "(", "'link_file_list'", ",", "gyp", ".", "common", ".", "EncodePOSIXShellArgument", "(", "link_file_list", ")", ")", ")", "if", "self", ".", "flavor", "==", "'win'", ":", "extra_bindings", ".", "append", "(", "(", "'binary'", ",", "output", ")", ")", "if", "'/NOENTRY'", "not", "in", "ldflags", "and", "not", "self", ".", "msvs_settings", ".", "GetNoImportLibrary", "(", "config_name", ")", ":", "self", ".", "target", ".", "import_lib", "=", "output", "+", "'.lib'", "extra_bindings", ".", "append", "(", "(", "'implibflag'", ",", "'/IMPLIB:%s'", "%", "self", ".", "target", ".", "import_lib", ")", ")", "pdbname", "=", "self", ".", "msvs_settings", ".", "GetPDBName", "(", "config_name", ",", "self", ".", "_ExpandSpecial", ",", "output", "+", "'.pdb'", ")", "output", "=", "[", "output", ",", "self", ".", "target", ".", "import_lib", "]", "if", "pdbname", ":", "output", ".", "append", "(", "pdbname", ")", "elif", "not", "self", ".", "is_mac_bundle", ":", "output", "=", "[", "output", ",", "output", "+", "'.TOC'", "]", "else", ":", "command", "=", "command", "+", "'_notoc'", "elif", "self", ".", "flavor", "==", "'win'", ":", "extra_bindings", ".", "append", "(", "(", "'binary'", ",", "output", ")", ")", "pdbname", "=", "self", ".", "msvs_settings", ".", "GetPDBName", "(", "config_name", ",", "self", ".", "_ExpandSpecial", ",", "output", "+", "'.pdb'", ")", "if", "pdbname", ":", "output", "=", "[", "output", ",", "pdbname", "]", "if", "len", "(", "solibs", ")", ":", "extra_bindings", ".", "append", "(", "(", "'solibs'", ",", "gyp", ".", "common", ".", "EncodePOSIXShellList", "(", "sorted", "(", "solibs", ")", ")", ")", ")", "ninja_file", ".", "build", "(", "output", ",", "command", "+", "command_suffix", ",", "link_deps", ",", "implicit", "=", "sorted", "(", "implicit_deps", ")", ",", "order_only", "=", "list", "(", "order_deps", ")", ",", "variables", "=", "extra_bindings", ")", "return", "linked_binary" ]

[ "Prepend", "an", "int16", "to", "the", "Builder", "buffer", "." ]

[ "def", "PrependInt16", "(", "self", ",", "x", ")", ":", "self", ".", "Prepend", "(", "N", ".", "Int16Flags", ",", "x", ")" ]

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

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

[ "更新周线、月线、15分钟线等扩展数据索引" ]

[ "def", "update_extern_data", "(", "connect", ",", "market", ",", "code", ",", "data_type", ")", ":", "def", "getWeekDate", "(", "olddate", ")", ":", "y", "=", "olddate", "//", "100000000", "m", "=", "olddate", "//", "1000000", "-", "y", "*", "100", "d", "=", "olddate", "//", "10000", "-", "(", "y", "*", "10000", "+", "m", "*", "100", ")", "tempdate", "=", "datetime", ".", "date", "(", "y", ",", "m", ",", "d", ")", "# python中周一是第0天，周五的第4天", "startdate", "=", "tempdate", "+", "datetime", ".", "timedelta", "(", "0", "-", "tempdate", ".", "weekday", "(", ")", ")", "enddate", "=", "tempdate", "+", "datetime", ".", "timedelta", "(", "4", "-", "tempdate", ".", "weekday", "(", ")", ")", "return", "(", "startdate", ".", "year", "*", "100000000", "+", "startdate", ".", "month", "*", "1000000", "+", "startdate", ".", "day", "*", "10000", ",", "enddate", ".", "year", "*", "100000000", "+", "enddate", ".", "month", "*", "1000000", "+", "enddate", ".", "day", "*", "10000", ")", "def", "getMonthDate", "(", "olddate", ")", ":", "y", "=", "olddate", "//", "100000000", "m", "=", "olddate", "//", "1000000", "-", "y", "*", "100", "import", "calendar", "_", ",", "d", "=", "calendar", ".", "monthrange", "(", "y", ",", "m", ")", "return", "(", "y", "*", "100000000", "+", "m", "*", "1000000", "+", "10000", ",", "y", "*", "100000000", "+", "m", "*", "1000000", "+", "d", "*", "10000", ")", "def", "getQuarterDate", "(", "olddate", ")", ":", "startDict", "=", "{", "1", ":", "1", ",", "2", ":", "1", ",", "3", ":", "1", ",", "4", ":", "4", ",", "5", ":", "4", ",", "6", ":", "4", ",", "7", ":", "7", ",", "8", ":", "7", ",", "9", ":", "7", ",", "10", ":", "10", ",", "11", ":", "10", ",", "12", ":", "10", "}", "endDict", "=", "{", "1", ":", "3", ",", "2", ":", "3", ",", "3", ":", "3", ",", "4", ":", "6", ",", "5", ":", "6", ",", "6", ":", "6", ",", "7", ":", "9", ",", "8", ":", "9", ",", "9", ":", "9", ",", "10", ":", "12", ",", "11", ":", "12", ",", "12", ":", "12", "}", "d_dict", "=", "{", "3", ":", "310000", ",", "6", ":", "300000", ",", "9", ":", "300000", ",", "12", ":", "310000", "}", "y", "=", "olddate", "//", "100000000", "m", "=", "olddate", "//", "1000000", "-", "y", "*", "100", "start_m", "=", "startDict", "[", "m", "]", "end_m", "=", "endDict", "[", "m", "]", "return", "(", "y", "*", "100000000", "+", "start_m", "*", "1000000", "+", "10000", ",", "y", "*", "100000000", "+", "end_m", "*", "1000000", "+", "d_dict", "[", "end_m", "]", ")", "def", "getHalfyearDate", "(", "olddate", ")", ":", "y", "=", "olddate", "//", "100000000", "m", "=", "olddate", "//", "1000000", "-", "y", "*", "100", "return", "(", "y", "*", "100000000", "+", "(", "1010000", "if", "m", "<", "7", "else", "7010000", ")", ",", "y", "*", "100000000", "+", "(", "6300000", "if", "m", "<", "7", "else", "12310000", ")", ")", "def", "getYearDate", "(", "olddate", ")", ":", "y", "=", "olddate", "//", "100000000", "return", "(", "y", "*", "100000000", "+", "1010000", ",", "y", "*", "100000000", "+", "12310000", ")", "def", "getMin60Date", "(", "olddate", ")", ":", "mint", "=", "olddate", "-", "olddate", "//", "10000", "*", "10000", "newdate", "=", "olddate", "//", "10000", "*", "10000", "if", "mint", "<=", "1030", ":", "startdate", "=", "newdate", "+", "931", "enddate", "=", "newdate", "+", "1030", "elif", "mint", "<=", "1130", ":", "startdate", "=", "newdate", "+", "1031", "enddate", "=", "newdate", "+", "1130", "elif", "mint", "<=", "1400", ":", "startdate", "=", "newdate", "+", "1301", "enddate", "=", "newdate", "+", "1400", "else", ":", "startdate", "=", "newdate", "+", "1401", "enddate", "=", "newdate", "+", "1500", "return", "(", "startdate", ",", "enddate", ")", "def", "getMin15Date", "(", "olddate", ")", ":", "mint", "=", "olddate", "-", "olddate", "//", "10000", "*", "10000", "newdate", "=", "olddate", "//", "10000", "*", "10000", "if", "mint", "<=", "945", ":", "startdate", "=", "newdate", "+", "931", "enddate", "=", "newdate", "+", "945", "elif", "mint", "<=", "1000", ":", "startdate", "=", "newdate", "+", "946", "enddate", "=", "newdate", "+", "1000", "elif", "mint", "<=", "1015", ":", "startdate", "=", "newdate", "+", "1001", "enddate", "=", "newdate", "+", "1015", "elif", "mint", "<=", "1030", ":", "startdate", "=", "newdate", "+", "1016", "enddate", "=", "newdate", "+", "1030", "elif", "mint", "<=", "1045", ":", "startdate", "=", "newdate", "+", "1031", "enddate", "=", "newdate", "+", "1045", "elif", "mint", "<=", "1100", ":", "startdate", "=", "newdate", "+", "1046", "enddate", "=", "newdate", "+", "1100", "elif", "mint", "<=", "1115", ":", "startdate", "=", "newdate", "+", "1101", "enddate", "=", "newdate", "+", "1115", "elif", "mint", "<=", "1130", ":", "startdate", "=", "newdate", "+", "1116", "enddate", "=", "newdate", "+", "1130", "elif", "mint", "<=", "1315", ":", "startdate", "=", "newdate", "+", "1301", "enddate", "=", "newdate", "+", "1315", "elif", "mint", "<=", "1330", ":", "startdate", "=", "newdate", "+", "1316", "enddate", "=", "newdate", "+", "1330", "elif", "mint", "<=", "1345", ":", "startdate", "=", "newdate", "+", "1331", "enddate", "=", "newdate", "+", "1345", "elif", "mint", "<=", "1400", ":", "startdate", "=", "newdate", "+", "1346", "enddate", "=", "newdate", "+", "1400", "elif", "mint", "<=", "1415", ":", "startdate", "=", "newdate", "+", "1401", "enddate", "=", "newdate", "+", "1415", "elif", "mint", "<=", "1430", ":", "startdate", "=", "newdate", "+", "1416", "enddate", "=", "newdate", "+", "1430", "elif", "mint", "<=", "1445", ":", "startdate", "=", "newdate", "+", "1431", "enddate", "=", "newdate", "+", "1445", "else", ":", "startdate", "=", "newdate", "+", "1446", "enddate", "=", "newdate", "+", "1500", "return", "(", "startdate", ",", "enddate", ")", "def", "getMin30Date", "(", "olddate", ")", ":", "mint", "=", "olddate", "-", "olddate", "//", "10000", "*", "10000", "newdate", "=", "olddate", "//", "10000", "*", "10000", "if", "mint", "<=", "1000", ":", "startdate", "=", "newdate", "+", "931", "enddate", "=", "newdate", "+", "1000", "elif", "mint", "<=", "1030", ":", "startdate", "=", "newdate", "+", "1001", "enddate", "=", "newdate", "+", "1030", "elif", "mint", "<=", "1100", ":", "startdate", "=", "newdate", "+", "1031", "enddate", "=", "newdate", "+", "1100", "elif", "mint", "<=", "1130", ":", "startdate", "=", "newdate", "+", "1101", "enddate", "=", "newdate", "+", "1130", "elif", "mint", "<=", "1330", ":", "startdate", "=", "newdate", "+", "1301", "enddate", "=", "newdate", "+", "1330", "elif", "mint", "<=", "1400", ":", "startdate", "=", "newdate", "+", "1331", "enddate", "=", "newdate", "+", "1400", "elif", "mint", "<=", "1430", ":", "startdate", "=", "newdate", "+", "1401", "enddate", "=", "newdate", "+", "1430", "else", ":", "startdate", "=", "newdate", "+", "1431", "enddate", "=", "newdate", "+", "1500", "return", "(", "startdate", ",", "enddate", ")", "def", "getNewDate", "(", "index_type", ",", "olddate", ")", ":", "if", "index_type", "==", "'week'", ":", "return", "getWeekDate", "(", "olddate", ")", "elif", "index_type", "==", "'month'", ":", "return", "getMonthDate", "(", "olddate", ")", "elif", "index_type", "==", "'quarter'", ":", "return", "getQuarterDate", "(", "olddate", ")", "elif", "index_type", "==", "'halfyear'", ":", "return", "getHalfyearDate", "(", "olddate", ")", "elif", "index_type", "==", "'year'", ":", "return", "getYearDate", "(", "olddate", ")", "elif", "index_type", "==", "'min15'", ":", "return", "getMin15Date", "(", "olddate", ")", "elif", "index_type", "==", "'min30'", ":", "return", "getMin30Date", "(", "olddate", ")", "elif", "index_type", "==", "'min60'", ":", "return", "getMin60Date", "(", "olddate", ")", "else", ":", "return", "None", "if", "data_type", ".", "lower", "(", ")", "==", "'day'", ":", "index_list", "=", "(", "'week'", ",", "'month'", ",", "'year'", ")", "#index_list = ('week', 'month', 'quarter', 'halfyear', 'year')", "base_table", "=", "get_table", "(", "connect", ",", "market", ",", "code", ",", "'day'", ")", "else", ":", "index_list", "=", "(", "'min15'", ",", "'min30'", ",", "'min60'", ")", "#index_list = ('min15', )", "base_table", "=", "get_table", "(", "connect", ",", "market", ",", "code", ",", "'min5'", ")", "base_lastdate", "=", "get_lastdatetime", "(", "connect", ",", "base_table", ")", "if", "base_lastdate", "is", "None", ":", "return", "for", "index_type", "in", "index_list", ":", "hku_debug", "(", "\"{}{} update {} index\"", ".", "format", "(", "market", ",", "code", ",", "index_type", ")", ")", "index_table", "=", "get_table", "(", "connect", ",", "market", ",", "code", ",", "index_type", ")", "index_last_date", "=", "get_lastdatetime", "(", "connect", ",", "index_table", ")", "# 获取当前日期大于等于索引表最大日期的基础表日期列表", "cur", "=", "connect", ".", "cursor", "(", ")", "if", "index_last_date", "is", "None", ":", "cur", ".", "execute", "(", "'select date, open, high, low, close, amount, count from {} order by date asc '", ".", "format", "(", "base_table", ")", ")", "else", ":", "start_date", ",", "_", "=", "getNewDate", "(", "index_type", ",", "index_last_date", ")", "cur", ".", "execute", "(", "'select date, open, high, low, close, amount, count from {} where date>={}'", ".", "format", "(", "base_table", ",", "start_date", ")", ")", "base_list", "=", "[", "x", "for", "x", "in", "cur", "]", "cur", ".", "close", "(", ")", "last_start_date", "=", "199012010000", "last_end_date", "=", "199012010000", "update_buffer", "=", "[", "]", "insert_buffer", "=", "[", "]", "#for current_base in base_list:", "length_base_all", "=", "len", "(", "base_list", ")", "for", "x", "in", "range", "(", "length_base_all", ")", ":", "current_date", "=", "base_list", "[", "x", "]", "[", "0", "]", "if", "current_date", "<=", "last_end_date", ":", "continue", "last_start_date", ",", "last_end_date", "=", "getNewDate", "(", "index_type", ",", "current_date", ")", "#cur = connect.cursor()", "#cur.execute(", "# 'select date, open, high, low, close, amount, count from {} \\", "# where date>={} and date<={} order by date asc'.format(", "# base_table, last_start_date, last_end_date", "# )", "#)", "#base_record_list = [r for r in cur]", "#cur.close()", "base_record_list", "=", "[", "]", "start_ix", "=", "x", "ix_date", "=", "current_date", "while", "start_ix", "<", "length_base_all", "and", "ix_date", ">=", "last_start_date", "and", "ix_date", "<=", "last_end_date", ":", "base_record_list", ".", "append", "(", "base_list", "[", "start_ix", "]", ")", "ix_date", "=", "base_list", "[", "start_ix", "]", "[", "0", "]", "start_ix", "+=", "1", "if", "not", "base_record_list", ":", "continue", "length", "=", "len", "(", "base_record_list", ")", "open_price", "=", "base_record_list", "[", "0", "]", "[", "1", "]", "high_price", "=", "base_record_list", "[", "0", "]", "[", "2", "]", "low_price", "=", "base_record_list", "[", "0", "]", "[", "3", "]", "close_price", "=", "base_record_list", "[", "length", "-", "1", "]", "[", "4", "]", "amount", "=", "base_record_list", "[", "0", "]", "[", "5", "]", "count", "=", "base_record_list", "[", "0", "]", "[", "6", "]", "for", "i", "in", "range", "(", "1", ",", "length", ")", ":", "if", "base_record_list", "[", "i", "]", "[", "2", "]", ">", "high_price", ":", "high_price", "=", "base_record_list", "[", "i", "]", "[", "2", "]", "if", "base_record_list", "[", "i", "]", "[", "3", "]", "<", "low_price", ":", "low_price", "=", "base_record_list", "[", "i", "]", "[", "3", "]", "amount", "+=", "base_record_list", "[", "i", "]", "[", "5", "]", "count", "+=", "base_record_list", "[", "i", "]", "[", "6", "]", "if", "last_end_date", "==", "index_last_date", ":", "update_buffer", ".", "append", "(", "(", "open_price", ",", "high_price", ",", "low_price", ",", "close_price", ",", "amount", ",", "count", ",", "last_end_date", ")", ")", "else", ":", "insert_buffer", ".", "append", "(", "(", "last_end_date", ",", "open_price", ",", "high_price", ",", "low_price", ",", "close_price", ",", "amount", ",", "count", ")", ")", "if", "update_buffer", ":", "cur", "=", "connect", ".", "cursor", "(", ")", "cur", ".", "executemany", "(", "\"update {} set open=%s, high=%s, low=%s, close=%s, amount=%s, count=%s \\\n where date=%s\"", ".", "format", "(", "index_table", ")", ",", "update_buffer", ")", "connect", ".", "commit", "(", ")", "cur", ".", "close", "(", ")", "if", "insert_buffer", ":", "cur", "=", "connect", ".", "cursor", "(", ")", "cur", ".", "executemany", "(", "\"insert into {} (date, open, high, low, close, amount, count) \\\n values (%s, %s, %s, %s, %s, %s, %s)\"", ".", "format", "(", "index_table", ")", ",", "insert_buffer", ")", "connect", ".", "commit", "(", ")", "cur", ".", "close", "(", ")" ]

[ "Check", "if", "the", "value", "can", "be", "inserted", "into", "our", "array", "without", "casting", "and", "convert", "it", "to", "an", "appropriate", "native", "type", "if", "necessary", "." ]

[ "def", "_validate_fill_value", "(", "self", ",", "value", ")", ":", "if", "not", "can_hold_element", "(", "self", ".", "_values", ",", "value", ")", ":", "raise", "TypeError", "return", "value" ]

[ "Pass", "*", "args", "and", "**", "kwargs", "to", "the", "handler", "s", "function", "if", "it", "exists", "." ]

[ "def", "__call__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "if", "hasattr", "(", "self", ",", "'func'", ")", ":", "return", "self", ".", "func", "(", "*", "args", ",", "*", "*", "kwargs", ")", "else", ":", "return", "self", ".", "_init_call", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "r", "DecToDMS", "(", "double", "arg1", "char", "const", "*", "arg2", "int", "arg3", "=", "2", ")", "-", ">", "char", "const", "*" ]

[ "def", "DecToDMS", "(", "*", "args", ")", ":", "return", "_gdal", ".", "DecToDMS", "(", "*", "args", ")" ]

[ "Return", "the", "converted", "indexing", "tuple", "and", "the", "integer", "axes", "." ]

[ "def", "_basic_indexing_key_int_to_slice", "(", "idcs", ")", ":", "int_axes", "=", "[", "]", "conv_idcs", "=", "[", "]", "for", "ax", ",", "idx", "in", "enumerate", "(", "idcs", ")", ":", "if", "isinstance", "(", "idx", ",", "integer_types", ")", ":", "conv_idcs", ".", "append", "(", "_int_to_slice", "(", "idx", ")", ")", "int_axes", ".", "append", "(", "ax", ")", "else", ":", "conv_idcs", ".", "append", "(", "idx", ")", "return", "tuple", "(", "conv_idcs", ")", ",", "tuple", "(", "int_axes", ")" ]

[ "Drop", "the", "channel", "axis", "when", "it", "is", "a", "singleton", ".", "This", "function", "is", "for", "easy", "transformation", "of", "an", "array", "shaped", "(", "width", "height", "1", ")", "into", "(", "width", "height", ")", ".", "A", "RuntimeError", "is", "raised", "when", "there", "is", "more", "than", "one", "channel", "unless", "ignoreMultiChannel", "=", "True", "in", "which", "case", "self", "is", "returned", "." ]

[ "def", "dropChannelAxis", "(", "self", ",", "ignoreMultiChannel", "=", "False", ")", ":", "ci", "=", "self", ".", "channelIndex", "if", "ci", "==", "self", ".", "ndim", ":", "return", "self", "if", "self", ".", "shape", "[", "ci", "]", "!=", "1", ":", "if", "ignoreMultiChannel", ":", "return", "self", "raise", "RuntimeError", "(", "\"dropChannelAxis(): only allowed when there is a single channel.\"", ")", "return", "self", ".", "bindAxis", "(", "ci", ",", "0", ")" ]

[ "Update", "cursor", "after", "moved", "by", "left", "/", "right", "." ]

[ "def", "_update_after_move", "(", "self", ")", "->", "None", ":", "bar", "=", "self", ".", "_manager", ".", "get_bar", "(", "self", ".", "_x", ")", "self", ".", "_y", "=", "bar", ".", "close_price", "self", ".", "_update_line", "(", ")", "self", ".", "_update_label", "(", ")" ]

[ "Creates", "a", "client", "for", "the", "Google", "Apps", "Provisioning", "service", "." ]

[ "def", "__init__", "(", "self", ",", "email", "=", "None", ",", "password", "=", "None", ",", "domain", "=", "None", ",", "source", "=", "None", ",", "server", "=", "'apps-apis.google.com'", ",", "additional_headers", "=", "None", ",", "*", "*", "kwargs", ")", ":", "gdata", ".", "service", ".", "GDataService", ".", "__init__", "(", "self", ",", "email", "=", "email", ",", "password", "=", "password", ",", "service", "=", "'apps'", ",", "source", "=", "source", ",", "server", "=", "server", ",", "additional_headers", "=", "additional_headers", ",", "*", "*", "kwargs", ")", "self", ".", "ssl", "=", "True", "self", ".", "port", "=", "443", "self", ".", "domain", "=", "domain" ]

[ "Returns", "the", "keyword", "units", "and", "argument", "list", "separately", "." ]

[ "def", "getall", "(", "pstring", ")", ":", "unit", "=", "\"\"", "arglist", "=", "(", ")", "kwarglist", "=", "{", "}", "unstart", "=", "len", "(", "pstring", ")", "argstart", "=", "unstart", "if", "'}'", "in", "pstring", ":", "# the property has a user-defined unit", "unstart", "=", "pstring", ".", "find", "(", "'{'", ")", "unstop", "=", "pstring", ".", "find", "(", "'}'", ",", "unstart", ")", "if", "unstop", "==", "-", "1", ":", "raise", "ValueError", "(", "\"Incorrect format in units specification \"", "+", "pstring", ")", "unit", "=", "pstring", "[", "unstart", "+", "1", ":", "unstop", "]", "if", "'('", "in", "pstring", ":", "# If the property has additional arguments", "argstart", "=", "pstring", ".", "find", "(", "'('", ")", "argstop", "=", "pstring", ".", "find", "(", "')'", ",", "argstart", ")", "if", "argstop", "==", "-", "1", ":", "raise", "ValueError", "(", "\"Incorrect format in argument list \"", "+", "pstring", ")", "argstr", "=", "pstring", "[", "argstart", ":", "argstop", "+", "1", "]", "arglist", "=", "io_xml", ".", "read_tuple", "(", "argstr", ",", "delims", "=", "\"()\"", ",", "split", "=", "\";\"", ",", "arg_type", "=", "str", ")", "for", "arg", "in", "arglist", ":", "# If a keyword argument is used", "equals", "=", "arg", ".", "find", "(", "'='", ")", "if", "equals", ">=", "0", ":", "kwarglist", "[", "arg", "[", "0", ":", "equals", "]", ".", "strip", "(", ")", "]", "=", "arg", "[", "equals", "+", "1", ":", "]", ".", "strip", "(", ")", "arglist", "=", "tuple", "(", "a", "for", "a", "in", "arglist", "if", "not", "a", "==", "arg", ")", "pstring", "=", "pstring", "[", "0", ":", "min", "(", "unstart", ",", "argstart", ")", "]", ".", "strip", "(", ")", "# strips the arguments from pstring name", "return", "(", "pstring", ",", "unit", ",", "arglist", ",", "kwarglist", ")" ]

[ "Compute", "open", "high", "low", "and", "close", "values", "of", "a", "group", "excluding", "missing", "values", "." ]

[ "def", "ohlc", "(", "self", ")", "->", "DataFrame", ":", "if", "self", ".", "obj", ".", "ndim", "==", "1", ":", "# self._iterate_slices() yields only self._selected_obj", "obj", "=", "self", ".", "_selected_obj", "is_numeric", "=", "is_numeric_dtype", "(", "obj", ".", "dtype", ")", "if", "not", "is_numeric", ":", "raise", "DataError", "(", "\"No numeric types to aggregate\"", ")", "res_values", "=", "self", ".", "grouper", ".", "_cython_operation", "(", "\"aggregate\"", ",", "obj", ".", "_values", ",", "\"ohlc\"", ",", "axis", "=", "0", ",", "min_count", "=", "-", "1", ")", "agg_names", "=", "[", "\"open\"", ",", "\"high\"", ",", "\"low\"", ",", "\"close\"", "]", "result", "=", "self", ".", "obj", ".", "_constructor_expanddim", "(", "res_values", ",", "index", "=", "self", ".", "grouper", ".", "result_index", ",", "columns", "=", "agg_names", ")", "return", "self", ".", "_reindex_output", "(", "result", ")", "return", "self", ".", "_apply_to_column_groupbys", "(", "lambda", "x", ":", "x", ".", "ohlc", "(", ")", ",", "self", ".", "_obj_with_exclusions", ")" ]

[ "gets", "colors", "from", "opend", "document", ".", "if", "there", "is", "no", "document", "display", "dialog", "to", "chose", "a", "file", ".", "returns", "a", "list", "[", "name", "c", "m", "y", "k", "]" ]

[ "def", "getColorsFromDocument", "(", ")", ":", "def", "getColors", "(", ")", ":", "\"\"\"gets the colors and returns a list[name,c,m,y,k]\"\"\"", "colorNames", "=", "scribus", ".", "getColorNames", "(", ")", "list", "=", "[", "]", "scribus", ".", "statusMessage", "(", "\"Reading Colors...\"", ")", "stepsTotal", "=", "len", "(", "colorNames", ")", "scribus", ".", "progressTotal", "(", "stepsTotal", ")", "steps", "=", "0", "for", "name", "in", "colorNames", ":", "color", "=", "scribus", ".", "getColor", "(", "name", ")", "listitem", "=", "[", "name", ",", "color", "[", "0", "]", ",", "color", "[", "1", "]", ",", "color", "[", "2", "]", ",", "color", "[", "3", "]", "]", "list", ".", "append", "(", "listitem", ")", "#update progress bar", "steps", "=", "steps", "+", "1", "scribus", ".", "progressSet", "(", "steps", ")", "return", "list", "#check if we have a document - otherwise display open file dialog", "if", "scribus", ".", "haveDoc", "(", ")", ">", "0", ":", "pass", "list", "=", "getColors", "(", ")", "return", "list", "else", ":", "pass", "#display file open dialog", "file", "=", "scribus", ".", "fileDialog", "(", "\"ColorChart by Sebastian Stetter\"", ",", "'Scribus files(*.sla *.SLA *.sla.gz *.SLA.GZ)'", ")", "#open file", "try", ":", "scribus", ".", "openDoc", "(", "file", ")", "except", ":", "scribus", ".", "messageBox", "(", "\"ColorChart by Sebastian Stetter\"", ",", "\"could not open file\"", ")", "sys", ".", "exit", "(", ")", "list", "=", "getColors", "(", ")", "return", "list" ]

[ "The", "default", "implementation", "calls", "DeleteContents", "(", "an", "empty", "implementation", ")", "sets", "the", "modified", "flag", "to", "false", ".", "Override", "this", "to", "supply", "additional", "behaviour", "when", "the", "document", "is", "closed", "with", "Close", "." ]

[ "def", "OnCloseDocument", "(", "self", ")", ":", "self", ".", "NotifyClosing", "(", ")", "self", ".", "DeleteContents", "(", ")", "self", ".", "Modify", "(", "False", ")", "return", "True" ]

[ "Suggest", "selection", "parameter", "." ]

[ "def", "suggest_sel", "(", "all_type", ":", "List", "[", "np", ".", "ndarray", "]", ",", "all_box", ":", "List", "[", "np", ".", "ndarray", "]", ",", "rcut", ":", "float", ",", "ratio", ":", "float", "=", "1.5", ",", ")", "->", "List", "[", "int", "]", ":", "max_den", "=", "get_max_density", "(", "all_type", ",", "all_box", ")", "return", "[", "int", "(", "ii", ")", "for", "ii", "in", "max_den", "*", "4.0", "/", "3.0", "*", "np", ".", "pi", "*", "rcut", "**", "3", "*", "ratio", "]" ]

[ "SetPickerCtrlGrowable", "(", "self", "bool", "grow", "=", "True", ")" ]

[ "def", "SetPickerCtrlGrowable", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "PickerBase_SetPickerCtrlGrowable", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "True", "if", "modified", "editor", "value", "should", "be", "committed", "to", "the", "property", ".", "To", "just", "mark", "the", "property", "value", "modified", "call", "propgrid", ".", "EditorsValueWasModified", "()", "." ]

[ "def", "OnEvent", "(", "self", ",", "propgrid", ",", "property", ",", "ctrl", ",", "event", ")", ":", "if", "not", "ctrl", ":", "return", "False", "evtType", "=", "event", ".", "GetEventType", "(", ")", "if", "evtType", "==", "wx", ".", "wxEVT_COMMAND_TEXT_ENTER", ":", "if", "propgrid", ".", "IsEditorsValueModified", "(", ")", ":", "return", "True", "elif", "evtType", "==", "wx", ".", "wxEVT_COMMAND_TEXT_UPDATED", ":", "#", "# Pass this event outside wxPropertyGrid so that,", "# if necessary, program can tell when user is editing", "# a textctrl.", "event", ".", "Skip", "(", ")", "event", ".", "SetId", "(", "propgrid", ".", "GetId", "(", ")", ")", "propgrid", ".", "EditorsValueWasModified", "(", ")", "return", "False", "return", "False" ]

[ "r", "Computes", "the", "multi", "-", "class", "cross", "entropy", "loss", "(", "using", "logits", "by", "default", ")", "." ]

[ "def", "cross_entropy", "(", "pred", ":", "Tensor", ",", "label", ":", "Tensor", ",", "axis", ":", "int", "=", "1", ",", "with_logits", ":", "bool", "=", "True", ",", "label_smooth", ":", "float", "=", "0", ",", "reduction", ":", "str", "=", "\"mean\"", ",", ")", "->", "Tensor", ":", "n0", "=", "pred", ".", "ndim", "n1", "=", "label", ".", "ndim", "assert", "n0", "==", "n1", "+", "1", ",", "(", "\"target ndim must be one less than input ndim; input_ndim={} \"", "\"target_ndim={}\"", ".", "format", "(", "n0", ",", "n1", ")", ")", "ls", "=", "label_smooth", "if", "with_logits", ":", "logZ", "=", "logsumexp", "(", "pred", ",", "axis", ")", "primary_term", "=", "indexing_one_hot", "(", "pred", ",", "label", ",", "axis", ")", "else", ":", "logZ", "=", "0", "primary_term", "=", "log", "(", "indexing_one_hot", "(", "pred", ",", "label", ",", "axis", ")", ")", "if", "ls", "is", "None", "or", "type", "(", "ls", ")", "in", "(", "int", ",", "float", ")", "and", "ls", "==", "0", ":", "return", "logZ", "-", "primary_term", "if", "not", "with_logits", ":", "pred", "=", "log", "(", "pred", ")", "return", "logZ", "-", "ls", "*", "pred", ".", "mean", "(", "axis", ")", "-", "(", "1", "-", "ls", ")", "*", "primary_term" ]

[ "Draws", "a", "toolbar", "background", "with", "a", "gradient", "shading", "." ]

[ "def", "DrawBackground", "(", "self", ",", "dc", ",", "wnd", ",", "_rect", ",", "horizontal", "=", "True", ")", ":", "rect", "=", "wx", ".", "Rect", "(", "*", "_rect", ")", "start_colour", "=", "StepColour", "(", "self", ".", "_base_colour", ",", "180", ")", "end_colour", "=", "StepColour", "(", "self", ".", "_base_colour", ",", "85", ")", "reflex_colour", "=", "StepColour", "(", "self", ".", "_base_colour", ",", "95", ")", "dc", ".", "GradientFillLinear", "(", "rect", ",", "start_colour", ",", "end_colour", ",", "(", "horizontal", "and", "[", "wx", ".", "SOUTH", "]", "or", "[", "wx", ".", "EAST", "]", ")", "[", "0", "]", ")", "left", "=", "rect", ".", "GetLeft", "(", ")", "right", "=", "rect", ".", "GetRight", "(", ")", "top", "=", "rect", ".", "GetTop", "(", ")", "bottom", "=", "rect", ".", "GetBottom", "(", ")", "dc", ".", "SetPen", "(", "wx", ".", "Pen", "(", "reflex_colour", ")", ")", "if", "horizontal", ":", "dc", ".", "DrawLine", "(", "left", ",", "bottom", ",", "right", "+", "1", ",", "bottom", ")", "else", ":", "dc", ".", "DrawLine", "(", "right", ",", "top", ",", "right", ",", "bottom", "+", "1", ")" ]

[ "LoadURL", "(", "self", "String", "url", ")" ]

[ "def", "LoadURL", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html2", ".", "WebView_LoadURL", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Called", "when", "the", "data", "is", "changed", "this", "updates", "the", "visible", "data", "." ]

[ "def", "initialize", "(", "self", ",", "data", ")", ":", "self", ".", "_data", "=", "data" ]

[ "Read", "config", "-", "files", "change", "configuration", "-", "dict", "accordingly", "." ]

[ "def", "readconfig", "(", "cfgdict", ")", ":", "default_cfg", "=", "\"turtle.cfg\"", "cfgdict1", "=", "{", "}", "cfgdict2", "=", "{", "}", "if", "isfile", "(", "default_cfg", ")", ":", "cfgdict1", "=", "config_dict", "(", "default_cfg", ")", "#print \"1. Loading config-file %s from: %s\" % (default_cfg, os.getcwd())", "if", "\"importconfig\"", "in", "cfgdict1", ":", "default_cfg", "=", "\"turtle_%s.cfg\"", "%", "cfgdict1", "[", "\"importconfig\"", "]", "try", ":", "head", ",", "tail", "=", "split", "(", "__file__", ")", "cfg_file2", "=", "join", "(", "head", ",", "default_cfg", ")", "except", ":", "cfg_file2", "=", "\"\"", "if", "isfile", "(", "cfg_file2", ")", ":", "#print \"2. Loading config-file %s:\" % cfg_file2", "cfgdict2", "=", "config_dict", "(", "cfg_file2", ")", "## show(_CFG)", "## show(cfgdict2)", "_CFG", ".", "update", "(", "cfgdict2", ")", "## show(_CFG)", "## show(cfgdict1)", "_CFG", ".", "update", "(", "cfgdict1", ")" ]

[ "Get", "the", "bracket", "piece", "as", "an", "array", "cell", "." ]

[ "def", "getcell", "(", "self", ",", "index", ")", ":", "piece", "=", "self", ".", "getpiece", "(", "index", ")", "span", "=", "'span class=\"bracket align-'", "+", "self", ".", "alignment", "+", "'\"'", "return", "TaggedBit", "(", ")", ".", "constant", "(", "piece", ",", "span", ")" ]

[ "Return", "the", "roots", "of", "the", "series", "polynomial", "." ]

[ "def", "roots", "(", "self", ")", ":", "roots", "=", "self", ".", "_roots", "(", "self", ".", "coef", ")", "return", "pu", ".", "mapdomain", "(", "roots", ",", "self", ".", "window", ",", "self", ".", "domain", ")" ]

[ "Returns", "a", "command", "(", "with", "arguments", ")", "to", "be", "used", "to", "set", "up", "the", "environment", "." ]

[ "def", "SetupScript", "(", "self", ",", "target_arch", ")", ":", "# Check if we are running in the SDK command line environment and use", "# the setup script from the SDK if so. |target_arch| should be either", "# 'x86' or 'x64'.", "assert", "target_arch", "in", "(", "'x86'", ",", "'x64'", ")", "sdk_dir", "=", "os", ".", "environ", ".", "get", "(", "'WindowsSDKDir'", ")", "if", "self", ".", "sdk_based", "and", "sdk_dir", ":", "return", "[", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "sdk_dir", ",", "'Bin/SetEnv.Cmd'", ")", ")", ",", "'/'", "+", "target_arch", "]", "else", ":", "# We don't use VC/vcvarsall.bat for x86 because vcvarsall calls", "# vcvars32, which it can only find if VS??COMNTOOLS is set, which it", "# isn't always.", "if", "target_arch", "==", "'x86'", ":", "if", "self", ".", "short_name", "==", "'2013'", "and", "(", "os", ".", "environ", ".", "get", "(", "'PROCESSOR_ARCHITECTURE'", ")", "==", "'AMD64'", "or", "os", ".", "environ", ".", "get", "(", "'PROCESSOR_ARCHITEW6432'", ")", "==", "'AMD64'", ")", ":", "# VS2013 non-Express has a x64-x86 cross that we want to prefer.", "return", "[", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "'VC/vcvarsall.bat'", ")", ")", ",", "'amd64_x86'", "]", "# Otherwise, the standard x86 compiler.", "return", "[", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "'Common7/Tools/vsvars32.bat'", ")", ")", "]", "else", ":", "assert", "target_arch", "==", "'x64'", "arg", "=", "'x86_amd64'", "# Use the 64-on-64 compiler if we're not using an express", "# edition and we're running on a 64bit OS.", "if", "self", ".", "short_name", "[", "-", "1", "]", "!=", "'e'", "and", "(", "os", ".", "environ", ".", "get", "(", "'PROCESSOR_ARCHITECTURE'", ")", "==", "'AMD64'", "or", "os", ".", "environ", ".", "get", "(", "'PROCESSOR_ARCHITEW6432'", ")", "==", "'AMD64'", ")", ":", "arg", "=", "'amd64'", "return", "[", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "self", ".", "path", ",", "'VC/vcvarsall.bat'", ")", ")", ",", "arg", "]" ]

[ "Randomly", "split", "the", "rows", "of", "an", "SArray", "into", "two", "SArrays", ".", "The", "first", "SArray", "contains", "*", "M", "*", "rows", "sampled", "uniformly", "(", "without", "replacement", ")", "from", "the", "original", "SArray", ".", "*", "M", "*", "is", "approximately", "the", "fraction", "times", "the", "original", "number", "of", "rows", ".", "The", "second", "SArray", "contains", "the", "remaining", "rows", "of", "the", "original", "SArray", "." ]

[ "def", "random_split", "(", "self", ",", "fraction", ",", "seed", "=", "None", ")", ":", "from", ".", "sframe", "import", "SFrame", "temporary_sf", "=", "SFrame", "(", ")", "temporary_sf", "[", "'X1'", "]", "=", "self", "(", "train", ",", "test", ")", "=", "temporary_sf", ".", "random_split", "(", "fraction", ",", "seed", ")", "return", "(", "train", "[", "'X1'", "]", ",", "test", "[", "'X1'", "]", ")" ]

[ "Handle", "the", "3D", "scene", "events", "." ]

[ "def", "action", "(", "self", ",", "arg", ")", ":", "if", "arg", "[", "\"Type\"", "]", "==", "\"SoKeyboardEvent\"", ":", "if", "arg", "[", "\"Key\"", "]", "==", "\"ESCAPE\"", ":", "self", ".", "finish", "(", ")", "elif", "arg", "[", "\"Type\"", "]", "==", "\"SoLocation2Event\"", ":", "# mouse movement detection", "if", "self", ".", "active", ":", "(", "self", ".", "point", ",", "ctrlPoint", ",", "info", ")", "=", "gui_tool_utils", ".", "getPoint", "(", "self", ",", "arg", ")", "gui_tool_utils", ".", "redraw3DView", "(", ")", "elif", "arg", "[", "\"Type\"", "]", "==", "\"SoMouseButtonEvent\"", ":", "if", "arg", "[", "\"State\"", "]", "==", "\"DOWN\"", "and", "arg", "[", "\"Button\"", "]", "==", "\"BUTTON1\"", ":", "if", "self", ".", "point", ":", "self", ".", "active", "=", "False", "Gui", ".", "Snapper", ".", "off", "(", ")", "self", ".", "node", ".", "append", "(", "self", ".", "point", ")", "self", ".", "ui", ".", "textUi", "(", ")", "self", ".", "ui", ".", "textValue", ".", "setFocus", "(", ")" ]

[ "Insert", "(", "ArtProvider", "provider", ")" ]

[ "def", "Insert", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "ArtProvider_Insert", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Monkey", "-", "patch", "distutils", "with", "our", "own", "build_ext", "class", "knowing", "about", "pycc", "-", "compiled", "extensions", "modules", "." ]

[ "def", "monkey_patch_distutils", "(", "cls", ")", ":", "if", "cls", ".", "_distutils_monkey_patched", ":", "return", "_orig_build_ext", "=", "build_ext", ".", "build_ext", "class", "_CC_build_ext", "(", "_orig_build_ext", ")", ":", "def", "build_extension", "(", "self", ",", "ext", ")", ":", "if", "isinstance", "(", "ext", ",", "_CCExtension", ")", ":", "ext", ".", "_prepare_object_files", "(", "self", ")", "_orig_build_ext", ".", "build_extension", "(", "self", ",", "ext", ")", "build_ext", ".", "build_ext", "=", "_CC_build_ext", "cls", ".", "_distutils_monkey_patched", "=", "True" ]

[ "Sorting", "comparator", "key", "used", "for", "comparing", "two", "#include", "lines", ".", "Returns", "the", "filename", "without", "the", "#include", "/", "#import", "prefix", "." ]

[ "def", "IncludeCompareKey", "(", "line", ")", ":", "for", "prefix", "in", "(", "'#include '", ",", "'#import '", ")", ":", "if", "line", ".", "startswith", "(", "prefix", ")", ":", "line", "=", "line", "[", "len", "(", "prefix", ")", ":", "]", "break", "# The win32 api has all sorts of implicit include order dependencies :-/", "# Give a few headers special sort keys that make sure they appear before all", "# other headers.", "if", "line", ".", "startswith", "(", "'<windows.h>'", ")", ":", "# Must be before e.g. shellapi.h", "return", "'0'", "if", "line", ".", "startswith", "(", "'<unknwn.h>'", ")", ":", "# Must be before e.g. intshcut.h", "return", "'1'", "# C++ system headers should come after C system headers.", "if", "line", ".", "startswith", "(", "'<'", ")", ":", "if", "line", ".", "find", "(", "'.h>'", ")", "!=", "-", "1", ":", "return", "'2'", "+", "line", "else", ":", "return", "'3'", "+", "line", "return", "'4'", "+", "line" ]

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

[ "def", "CheckComment", "(", "line", ",", "filename", ",", "linenum", ",", "next_line_start", ",", "error", ")", ":", "commentpos", "=", "line", ".", "find", "(", "'//'", ")", "if", "commentpos", "!=", "-", "1", ":", "# Check if the // may be in quotes. If so, ignore it", "if", "re", ".", "sub", "(", "r'\\\\.'", ",", "''", ",", "line", "[", "0", ":", "commentpos", "]", ")", ".", "count", "(", "'\"'", ")", "%", "2", "==", "0", ":", "# Allow one space for new scopes, two spaces otherwise:", "if", "(", "not", "(", "Match", "(", "r'^.*{ *//'", ",", "line", ")", "and", "next_line_start", "==", "commentpos", ")", "and", "(", "(", "commentpos", ">=", "1", "and", "line", "[", "commentpos", "-", "1", "]", "not", "in", "string", ".", "whitespace", ")", "or", "(", "commentpos", ">=", "2", "and", "line", "[", "commentpos", "-", "2", "]", "not", "in", "string", ".", "whitespace", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/comments'", ",", "2", ",", "'At least two spaces is best between code and comments'", ")", "# Checks for common mistakes in TODO comments.", "comment", "=", "line", "[", "commentpos", ":", "]", "match", "=", "_RE_PATTERN_TODO", ".", "match", "(", "comment", ")", "if", "match", ":", "# One whitespace is correct; zero whitespace is handled elsewhere.", "leading_whitespace", "=", "match", ".", "group", "(", "1", ")", "if", "len", "(", "leading_whitespace", ")", ">", "1", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/todo'", ",", "2", ",", "'Too many spaces before TODO'", ")", "username", "=", "match", ".", "group", "(", "2", ")", "if", "not", "username", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/todo'", ",", "2", ",", "'Missing username in TODO; it should look like '", "'\"// TODO(my_username): Stuff.\"'", ")", "middle_whitespace", "=", "match", ".", "group", "(", "3", ")", "# Comparisons made explicit for correctness -- pylint: disable=g-explicit-bool-comparison", "if", "middle_whitespace", "!=", "' '", "and", "middle_whitespace", "!=", "''", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/todo'", ",", "2", ",", "'TODO(my_username) should be followed by a space'", ")", "# If the comment contains an alphanumeric character, there", "# should be a space somewhere between it and the // unless", "# it's a /// or //! Doxygen comment.", "if", "(", "Match", "(", "r'//[^ ]*\\w'", ",", "comment", ")", "and", "not", "Match", "(", "r'(///|//\\!)(\\s+|$)'", ",", "comment", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'whitespace/comments'", ",", "4", ",", "'Should have a space between // and comment'", ")" ]

[ "register", "a", "function", "to", "be", "executed", "upon", "normal", "program", "termination" ]

[ "def", "register", "(", "func", ",", "*", "targs", ",", "*", "*", "kargs", ")", ":", "_exithandlers", ".", "append", "(", "(", "func", ",", "targs", ",", "kargs", ")", ")" ]

[ "Return", "list", "of", "fds", "inherited", "from", "parent", "process", "." ]

[ "def", "get_inherited_fds", "(", "self", ")", ":", "return", "self", ".", "_inherited_fds" ]

[ "Strip", "HTML", "comments", "from", "a", "unicode", "string", "." ]

[ "def", "strip_html_comments", "(", "text", ")", ":", "lines", "=", "text", ".", "splitlines", "(", "True", ")", "# preserve line endings.", "# Remove HTML comments (which we only allow to take a special form).", "new_lines", "=", "filter", "(", "lambda", "line", ":", "not", "line", ".", "startswith", "(", "\"<!--\"", ")", ",", "lines", ")", "return", "\"\"", ".", "join", "(", "new_lines", ")" ]

[ "parse", "data" ]

[ "def", "parse", "(", "self", ",", "msp", ",", "dataSize", ")", ":", "ofs", "=", "msp", ".", "p", "for", "i", "in", "range", "(", "len", "(", "self", ".", "format", ")", ")", ":", "fmt", "=", "self", ".", "format", "[", "i", "]", "fields", "=", "self", ".", "fields", "[", "i", "]", ".", "split", "(", "','", ")", "if", "fmt", "[", "0", "]", "==", "'{'", ":", "# we have a repeat count from an earlier variable", "right", "=", "fmt", ".", "find", "(", "'}'", ")", "vname", "=", "fmt", "[", "1", ":", "right", "]", "count", "=", "self", ".", "values", "[", "vname", "]", "fmt", "=", "\"%u%s\"", "%", "(", "count", ",", "fmt", "[", "right", "+", "1", ":", "]", ")", "if", "fmt", "[", "0", "]", ".", "isdigit", "(", ")", ":", "repeat", "=", "int", "(", "re", ".", "search", "(", "r'\\d+'", ",", "fmt", ")", ".", "group", "(", ")", ")", "else", ":", "repeat", "=", "None", "fmt", "=", "\"<\"", "+", "fmt", "fmt_size", "=", "struct", ".", "calcsize", "(", "fmt", ")", "if", "dataSize", "<", "fmt_size", ":", "raise", "Exception", "(", "\"Format %s needs %u bytes got %u for %s\"", "%", "(", "self", ".", "name", ",", "fmt_size", ",", "dataSize", ",", "fmt", ")", ")", "values", "=", "list", "(", "struct", ".", "unpack", "(", "fmt", ",", "msp", ".", "inBuf", "[", "ofs", ":", "ofs", "+", "fmt_size", "]", ")", ")", "if", "repeat", "is", "not", "None", ":", "for", "i", "in", "range", "(", "len", "(", "fields", ")", ")", ":", "self", ".", "values", "[", "fields", "[", "i", "]", "]", "=", "[", "]", "for", "j", "in", "range", "(", "repeat", ")", ":", "self", ".", "values", "[", "fields", "[", "i", "]", "]", ".", "append", "(", "values", "[", "j", "*", "len", "(", "fields", ")", "]", ")", "else", ":", "for", "i", "in", "range", "(", "len", "(", "fields", ")", ")", ":", "self", ".", "values", "[", "fields", "[", "i", "]", "]", "=", "values", "[", "i", "]", "dataSize", "-=", "fmt_size", "ofs", "+=", "fmt_size", "msp", ".", "by_name", "[", "self", ".", "name", "]", "=", "self" ]

[ "places", ":", "places", "COMMA", "SYMBOL" ]

[ "def", "p_places_places_comma_symbol", "(", "p", ")", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]", "p", "[", "0", "]", ".", "append", "(", "Atom", "(", "p", "[", "3", "]", ")", ")", "p", "[", "0", "]", "[", "-", "1", "]", ".", "lineno", "=", "get_lineno", "(", "p", ",", "3", ")" ]

[ "Returns", "all", "targets", "(", "direct", "and", "dependencies", ")", "for", "the", "specified", "build_file", "." ]

[ "def", "AllTargets", "(", "target_list", ",", "target_dicts", ",", "build_file", ")", ":", "bftargets", "=", "BuildFileTargets", "(", "target_list", ",", "build_file", ")", "deptargets", "=", "DeepDependencyTargets", "(", "target_dicts", ",", "bftargets", ")", "return", "bftargets", "+", "deptargets" ]

[ "Shift", "the", "bits", "of", "an", "integer", "to", "the", "left", "." ]

[ "def", "left_shift", "(", "a", ",", "n", ")", ":", "m", "=", "getmask", "(", "a", ")", "if", "m", "is", "nomask", ":", "d", "=", "umath", ".", "left_shift", "(", "filled", "(", "a", ")", ",", "n", ")", "return", "masked_array", "(", "d", ")", "else", ":", "d", "=", "umath", ".", "left_shift", "(", "filled", "(", "a", ",", "0", ")", ",", "n", ")", "return", "masked_array", "(", "d", ",", "mask", "=", "m", ")" ]

[ "GetClassDefaultAttributes", "(", "int", "variant", "=", "WINDOW_VARIANT_NORMAL", ")", "-", ">", "VisualAttributes" ]

[ "def", "GetClassDefaultAttributes", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ListBox_GetClassDefaultAttributes", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Computes", "average", "precision@k", "of", "predictions", "with", "respect", "to", "sparse", "labels", "." ]

[ "def", "_streaming_sparse_average_precision_at_top_k", "(", "labels", ",", "predictions_idx", ",", "weights", "=", "None", ",", "metrics_collections", "=", "None", ",", "updates_collections", "=", "None", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "'average_precision_at_top_k'", ",", "(", "predictions_idx", ",", "labels", ",", "weights", ")", ")", "as", "scope", ":", "# Calculate per-example average precision, and apply weights.", "average_precision", "=", "_sparse_average_precision_at_top_k", "(", "predictions_idx", "=", "predictions_idx", ",", "labels", "=", "labels", ")", "if", "weights", "is", "not", "None", ":", "weights", "=", "weights_broadcast_ops", ".", "broadcast_weights", "(", "math_ops", ".", "cast", "(", "weights", ",", "dtypes", ".", "float64", ")", ",", "average_precision", ")", "average_precision", "=", "math_ops", ".", "multiply", "(", "average_precision", ",", "weights", ")", "# Create accumulation variables and update ops for max average precision and", "# total average precision.", "with", "ops", ".", "name_scope", "(", "None", ",", "'max'", ",", "(", "average_precision", ",", ")", ")", "as", "max_scope", ":", "# `max` is the max possible precision. Since max for any row is 1.0:", "# - For the unweighted case, this is just the number of rows.", "# - For the weighted case, it's the sum of the weights broadcast across", "# `average_precision` rows.", "max_var", "=", "metric_variable", "(", "[", "]", ",", "dtypes", ".", "float64", ",", "name", "=", "max_scope", ")", "if", "weights", "is", "None", ":", "batch_max", "=", "math_ops", ".", "cast", "(", "array_ops", ".", "size", "(", "average_precision", ",", "name", "=", "'batch_max'", ")", ",", "dtypes", ".", "float64", ")", "else", ":", "batch_max", "=", "math_ops", ".", "reduce_sum", "(", "weights", ",", "name", "=", "'batch_max'", ")", "max_update", "=", "state_ops", ".", "assign_add", "(", "max_var", ",", "batch_max", ",", "name", "=", "'update'", ")", "with", "ops", ".", "name_scope", "(", "None", ",", "'total'", ",", "(", "average_precision", ",", ")", ")", "as", "total_scope", ":", "total_var", "=", "metric_variable", "(", "[", "]", ",", "dtypes", ".", "float64", ",", "name", "=", "total_scope", ")", "batch_total", "=", "math_ops", ".", "reduce_sum", "(", "average_precision", ",", "name", "=", "'batch_total'", ")", "total_update", "=", "state_ops", ".", "assign_add", "(", "total_var", ",", "batch_total", ",", "name", "=", "'update'", ")", "# Divide total by max to get mean, for both vars and the update ops.", "def", "precision_across_replicas", "(", "_", ",", "total_var", ",", "max_var", ")", ":", "return", "_safe_scalar_div", "(", "total_var", ",", "max_var", ",", "name", "=", "'mean'", ")", "mean_average_precision", "=", "_aggregate_across_replicas", "(", "metrics_collections", ",", "precision_across_replicas", ",", "total_var", ",", "max_var", ")", "update", "=", "_safe_scalar_div", "(", "total_update", ",", "max_update", ",", "name", "=", "scope", ")", "if", "updates_collections", ":", "ops", ".", "add_to_collections", "(", "updates_collections", ",", "update", ")", "return", "mean_average_precision", ",", "update" ]