Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Enable", "CW", "remeber", "to", "reset", "after", "to", "use", "LoRa", "again", "." ]

[ "def", "enableCW", "(", "self", ")", ":", "self", ".", "command", "(", "'radio cw on'", ")" ]

[ "AttributeNameKeyword", ":", "REQUIRED" ]

[ "def", "p_AttributeNameKeyword", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "p", "[", "1", "]" ]

[ "Snoop", "on", "fib", "streaming", "updates", "." ]

[ "def", "snoop", "(", "cli_opts", ":", "Bunch", ",", "# noqa: B902", "duration", ":", "int", ",", "initial_dump", ":", "bool", ",", "prefixes", ":", "List", "[", "str", "]", ",", ")", ":", "fib", ".", "FibSnoopCmd", "(", "cli_opts", ")", ".", "run", "(", "duration", ",", "initial_dump", ",", "prefixes", ")" ]

[ "Computes", "the", "length", "of", "each", "element", "in", "the", "Series", "/", "Index", "." ]

[ "def", "len", "(", "self", ")", ":", "return", "self", ".", "d_series", ".", "map_partitions", "(", "lambda", "s", ":", "s", ".", "list", ".", "len", "(", ")", ",", "meta", "=", "self", ".", "d_series", ".", "_meta", ")" ]

[ "operation" ]

[ "def", "ops", "(", "self", ",", "input_x", ")", ":", "input_shape", "=", "input_x", ".", "shape", "sequence_length", "=", "input_shape", "[", "1", "]", ".", "value", "# suppose input_x is not time major", "v", "=", "tf", ".", "tanh", "(", "tf", ".", "matmul", "(", "tf", ".", "reshape", "(", "input_x", ",", "[", "-", "1", ",", "self", ".", "hidden_size", "]", ")", ",", "self", ".", "W", ")", "+", "tf", ".", "reshape", "(", "self", ".", "b", ",", "[", "1", ",", "-", "1", "]", ")", ")", "vu", "=", "tf", ".", "matmul", "(", "v", ",", "tf", ".", "reshape", "(", "self", ".", "u", ",", "[", "-", "1", ",", "1", "]", ")", ")", "exps", "=", "tf", ".", "reshape", "(", "tf", ".", "exp", "(", "vu", ")", ",", "[", "-", "1", ",", "sequence_length", "]", ")", "alphas", "=", "exps", "/", "tf", ".", "reshape", "(", "tf", ".", "reduce_sum", "(", "exps", ",", "1", ")", ",", "[", "-", "1", ",", "1", "]", ")", "# Output of Bi-RNN is reduced with attention vector", "output", "=", "tf", ".", "reduce_sum", "(", "input_x", "*", "tf", ".", "reshape", "(", "alphas", ",", "[", "-", "1", ",", "sequence_length", ",", "1", "]", ")", ",", "1", ")", "return", "output" ]

[ "Device", "context", "of", "the", "array", "." ]

[ "def", "context", "(", "self", ")", ":", "dev_typeid", "=", "ctypes", ".", "c_int", "(", ")", "dev_id", "=", "ctypes", ".", "c_int", "(", ")", "check_call", "(", "_LIB", ".", "MXNDArrayGetContext", "(", "self", ".", "handle", ",", "ctypes", ".", "byref", "(", "dev_typeid", ")", ",", "ctypes", ".", "byref", "(", "dev_id", ")", ")", ")", "return", "Context", "(", "Context", ".", "devtype2str", "[", "dev_typeid", ".", "value", "]", ",", "dev_id", ".", "value", ")" ]

[ "Update", "the", "key", "ring", "by", "the", "configuration", "." ]

[ "def", "__update", "(", "self", ",", "value", "=", "None", ",", "module_cfg", "=", "None", ")", ":", "logger", ".", "debug", "(", "logger", ".", "DBGLVL_TRACE_BASIC", ",", "PYSERVER_COMMON_TSIG_KEYRING_UPDATE", ")", "(", "data", ",", "_", ")", "=", "self", ".", "__session", ".", "get_remote_config_value", "(", "'tsig_keys'", ",", "'keys'", ")", "if", "data", "is", "not", "None", ":", "# There's an update", "keyring", "=", "bundy", ".", "dns", ".", "TSIGKeyRing", "(", ")", "for", "key_data", "in", "data", ":", "key", "=", "bundy", ".", "dns", ".", "TSIGKey", "(", "key_data", ")", "if", "keyring", ".", "add", "(", "key", ")", "!=", "bundy", ".", "dns", ".", "TSIGKeyRing", ".", "SUCCESS", ":", "raise", "AddError", "(", "\"Can't add key \"", "+", "str", "(", "key", ")", ")", "self", ".", "__keyring", "=", "keyring" ]

[ "extrude", "(", "object", "vector", "[", "solid", "]", ")", "Create", "a", "Part", "::", "Extrusion", "object", "from", "a", "given", "object", "." ]

[ "def", "extrude", "(", "obj", ",", "vector", ",", "solid", "=", "False", ")", ":", "if", "not", "App", ".", "ActiveDocument", ":", "App", ".", "Console", ".", "PrintError", "(", "\"No active document. Aborting\\n\"", ")", "return", "newobj", "=", "App", ".", "ActiveDocument", ".", "addObject", "(", "\"Part::Extrusion\"", ",", "\"Extrusion\"", ")", "newobj", ".", "Base", "=", "obj", "newobj", ".", "Dir", "=", "vector", "newobj", ".", "Solid", "=", "solid", "if", "App", ".", "GuiUp", ":", "obj", ".", "ViewObject", ".", "Visibility", "=", "False", "gui_utils", ".", "format_object", "(", "newobj", ",", "obj", ")", "gui_utils", ".", "select", "(", "newobj", ")", "return", "newobj" ]

[ "Builds", "the", "QName" ]

[ "def", "buildQName", "(", "ncname", ",", "prefix", ",", "memory", ",", "len", ")", ":", "ret", "=", "libxml2mod", ".", "xmlBuildQName", "(", "ncname", ",", "prefix", ",", "memory", ",", "len", ")", "return", "ret" ]

[ "Register", "an", "event", "handler", "for", "a", "given", "event", "." ]

[ "def", "register", "(", "self", ",", "event_name", ",", "handler", ",", "unique_id", "=", "None", ",", "unique_id_uses_count", "=", "False", ")", ":", "self", ".", "_verify_and_register", "(", "event_name", ",", "handler", ",", "unique_id", ",", "register_method", "=", "self", ".", "_register", ",", "unique_id_uses_count", "=", "unique_id_uses_count", ")" ]

[ "Creates", "an", "array", "from", "any", "object", "exposing", "the", "array", "interface", "." ]

[ "def", "array", "(", "source_array", ",", "ctx", "=", "None", ",", "dtype", "=", "None", ")", ":", "if", "spsp", "is", "not", "None", "and", "isinstance", "(", "source_array", ",", "spsp", ".", "csr", ".", "csr_matrix", ")", ":", "return", "_sparse_array", "(", "source_array", ",", "ctx", "=", "ctx", ",", "dtype", "=", "dtype", ")", "elif", "isinstance", "(", "source_array", ",", "NDArray", ")", "and", "source_array", ".", "stype", "!=", "'default'", ":", "return", "_sparse_array", "(", "source_array", ",", "ctx", "=", "ctx", ",", "dtype", "=", "dtype", ")", "else", ":", "return", "_array", "(", "source_array", ",", "ctx", "=", "ctx", ",", "dtype", "=", "dtype", ")" ]

[ "Read", "an", "array", "of", "type", "typecode", "with", "the", "array", "descriptor", "given", "as", "array_desc", "." ]

[ "def", "_read_array", "(", "f", ",", "typecode", ",", "array_desc", ")", ":", "if", "typecode", "in", "[", "1", ",", "3", ",", "4", ",", "5", ",", "6", ",", "9", ",", "13", ",", "14", ",", "15", "]", ":", "if", "typecode", "==", "1", ":", "nbytes", "=", "_read_int32", "(", "f", ")", "if", "nbytes", "!=", "array_desc", "[", "'nbytes'", "]", ":", "warnings", ".", "warn", "(", "\"Not able to verify number of bytes from header\"", ")", "# Read bytes as numpy array", "array", "=", "np", ".", "fromstring", "(", "f", ".", "read", "(", "array_desc", "[", "'nbytes'", "]", ")", ",", "dtype", "=", "DTYPE_DICT", "[", "typecode", "]", ")", "elif", "typecode", "in", "[", "2", ",", "12", "]", ":", "# These are 2 byte types, need to skip every two as they are not packed", "array", "=", "np", ".", "fromstring", "(", "f", ".", "read", "(", "array_desc", "[", "'nbytes'", "]", "*", "2", ")", ",", "dtype", "=", "DTYPE_DICT", "[", "typecode", "]", ")", "[", "1", ":", ":", "2", "]", "else", ":", "# Read bytes into list", "array", "=", "[", "]", "for", "i", "in", "range", "(", "array_desc", "[", "'nelements'", "]", ")", ":", "dtype", "=", "typecode", "data", "=", "_read_data", "(", "f", ",", "dtype", ")", "array", ".", "append", "(", "data", ")", "array", "=", "np", ".", "array", "(", "array", ",", "dtype", "=", "np", ".", "object_", ")", "# Reshape array if needed", "if", "array_desc", "[", "'ndims'", "]", ">", "1", ":", "dims", "=", "array_desc", "[", "'dims'", "]", "[", ":", "int", "(", "array_desc", "[", "'ndims'", "]", ")", "]", "dims", ".", "reverse", "(", ")", "array", "=", "array", ".", "reshape", "(", "dims", ")", "# Go to next alignment position", "_align_32", "(", "f", ")", "return", "array" ]

[ "Initialization", "of", "screen", "colors", "." ]

[ "def", "_screen_color_init", "(", "self", ")", ":", "curses", ".", "start_color", "(", ")", "curses", ".", "use_default_colors", "(", ")", "self", ".", "_color_pairs", "=", "{", "}", "color_index", "=", "0", "# Prepare color pairs.", "for", "fg_color", "in", "self", ".", "_FOREGROUND_COLORS", ":", "for", "bg_color", "in", "self", ".", "_BACKGROUND_COLORS", ":", "color_index", "+=", "1", "curses", ".", "init_pair", "(", "color_index", ",", "self", ".", "_FOREGROUND_COLORS", "[", "fg_color", "]", ",", "self", ".", "_BACKGROUND_COLORS", "[", "bg_color", "]", ")", "color_name", "=", "fg_color", "if", "bg_color", "!=", "\"transparent\"", ":", "color_name", "+=", "\"_on_\"", "+", "bg_color", "self", ".", "_color_pairs", "[", "color_name", "]", "=", "curses", ".", "color_pair", "(", "color_index", ")", "# Try getting color(s) available only under 256-color support.", "try", ":", "color_index", "+=", "1", "curses", ".", "init_pair", "(", "color_index", ",", "245", ",", "-", "1", ")", "self", ".", "_color_pairs", "[", "cli_shared", ".", "COLOR_GRAY", "]", "=", "curses", ".", "color_pair", "(", "color_index", ")", "except", "curses", ".", "error", ":", "# Use fall-back color(s):", "self", ".", "_color_pairs", "[", "cli_shared", ".", "COLOR_GRAY", "]", "=", "(", "self", ".", "_color_pairs", "[", "cli_shared", ".", "COLOR_GREEN", "]", ")", "# A_BOLD or A_BLINK is not really a \"color\". But place it here for", "# convenience.", "self", ".", "_color_pairs", "[", "\"bold\"", "]", "=", "curses", ".", "A_BOLD", "self", ".", "_color_pairs", "[", "\"blink\"", "]", "=", "curses", ".", "A_BLINK", "self", ".", "_color_pairs", "[", "\"underline\"", "]", "=", "curses", ".", "A_UNDERLINE", "# Default color pair to use when a specified color pair does not exist.", "self", ".", "_default_color_pair", "=", "self", ".", "_color_pairs", "[", "cli_shared", ".", "COLOR_WHITE", "]" ]

[ "Convert", "a", "command", "line", "colour", "value", "to", "a", "RGB", "triple", "of", "integers", ".", "FIXME", ":", "Somewhere", "we", "need", "support", "for", "greyscale", "backgrounds", "etc", "." ]

[ "def", "color_triple", "(", "color", ")", ":", "if", "color", ".", "startswith", "(", "'#'", ")", "and", "len", "(", "color", ")", "==", "4", ":", "return", "(", "int", "(", "color", "[", "1", "]", ",", "16", ")", ",", "int", "(", "color", "[", "2", "]", ",", "16", ")", ",", "int", "(", "color", "[", "3", "]", ",", "16", ")", ")", "if", "color", ".", "startswith", "(", "'#'", ")", "and", "len", "(", "color", ")", "==", "7", ":", "return", "(", "int", "(", "color", "[", "1", ":", "3", "]", ",", "16", ")", ",", "int", "(", "color", "[", "3", ":", "5", "]", ",", "16", ")", ",", "int", "(", "color", "[", "5", ":", "7", "]", ",", "16", ")", ")", "elif", "color", ".", "startswith", "(", "'#'", ")", "and", "len", "(", "color", ")", "==", "13", ":", "return", "(", "int", "(", "color", "[", "1", ":", "5", "]", ",", "16", ")", ",", "int", "(", "color", "[", "5", ":", "9", "]", ",", "16", ")", ",", "int", "(", "color", "[", "9", ":", "13", "]", ",", "16", ")", ")" ]

[ "AddIcon", "(", "self", "Icon", "icon", ")", "-", ">", "int" ]

[ "def", "AddIcon", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "ImageList_AddIcon", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Creates", "an", "object", "to", "track", "tensor", "references", "." ]

[ "def", "__init__", "(", "self", ",", "name", ",", "object_id", ",", "timestamp", ",", "pid", ",", "allocator", ",", "num_bytes", ")", ":", "self", ".", "_name", "=", "name", "self", ".", "_pid", "=", "pid", "self", ".", "_object_id", "=", "object_id", "self", ".", "_create_time", "=", "timestamp", "self", ".", "_allocator", "=", "allocator", "self", ".", "_num_bytes", "=", "num_bytes", "self", ".", "_ref_times", "=", "[", "]", "self", ".", "_unref_times", "=", "[", "]" ]

[ "Returns", "whether", "a", "LinOp", "is", "constant", "." ]

[ "def", "is_const", "(", "operator", ")", "->", "bool", ":", "return", "operator", ".", "type", "in", "[", "lo", ".", "SCALAR_CONST", ",", "lo", ".", "SPARSE_CONST", ",", "lo", ".", "DENSE_CONST", ",", "lo", ".", "PARAM", "]" ]

[ "Re", "-", "map", "the", "characters", "in", "the", "string", "according", "to", "UTS46", "processing", "." ]

[ "def", "uts46_remap", "(", "domain", ",", "std3_rules", "=", "True", ",", "transitional", "=", "False", ")", ":", "from", ".", "uts46data", "import", "uts46data", "output", "=", "u\"\"", "try", ":", "for", "pos", ",", "char", "in", "enumerate", "(", "domain", ")", ":", "code_point", "=", "ord", "(", "char", ")", "uts46row", "=", "uts46data", "[", "code_point", "if", "code_point", "<", "256", "else", "bisect", ".", "bisect_left", "(", "uts46data", ",", "(", "code_point", ",", "\"Z\"", ")", ")", "-", "1", "]", "status", "=", "uts46row", "[", "1", "]", "replacement", "=", "uts46row", "[", "2", "]", "if", "len", "(", "uts46row", ")", "==", "3", "else", "None", "if", "(", "status", "==", "\"V\"", "or", "(", "status", "==", "\"D\"", "and", "not", "transitional", ")", "or", "(", "status", "==", "\"3\"", "and", "not", "std3_rules", "and", "replacement", "is", "None", ")", ")", ":", "output", "+=", "char", "elif", "replacement", "is", "not", "None", "and", "(", "status", "==", "\"M\"", "or", "(", "status", "==", "\"3\"", "and", "not", "std3_rules", ")", "or", "(", "status", "==", "\"D\"", "and", "transitional", ")", ")", ":", "output", "+=", "replacement", "elif", "status", "!=", "\"I\"", ":", "raise", "IndexError", "(", ")", "return", "unicodedata", ".", "normalize", "(", "\"NFC\"", ",", "output", ")", "except", "IndexError", ":", "raise", "InvalidCodepoint", "(", "\"Codepoint {0} not allowed at position {1} in {2}\"", ".", "format", "(", "_unot", "(", "code_point", ")", ",", "pos", "+", "1", ",", "repr", "(", "domain", ")", ")", ")" ]

[ "Returns", "the", "name", "of", "the", "data_", "or", "save_", "container" ]

[ "def", "__getContainerName", "(", "self", ",", "inWord", ")", ":", "return", "str", "(", "inWord", "[", "5", ":", "]", ")", ".", "strip", "(", ")" ]

[]

[ "def", "evaluate_link", "(", "self", ",", "link", ")", ":", "# type: (Link) -> Tuple[bool, Optional[str]]", "version", "=", "None", "if", "link", ".", "is_yanked", "and", "not", "self", ".", "_allow_yanked", ":", "reason", "=", "link", ".", "yanked_reason", "or", "'<none given>'", "return", "(", "False", ",", "f'yanked for reason: {reason}'", ")", "if", "link", ".", "egg_fragment", ":", "egg_info", "=", "link", ".", "egg_fragment", "ext", "=", "link", ".", "ext", "else", ":", "egg_info", ",", "ext", "=", "link", ".", "splitext", "(", ")", "if", "not", "ext", ":", "return", "(", "False", ",", "'not a file'", ")", "if", "ext", "not", "in", "SUPPORTED_EXTENSIONS", ":", "return", "(", "False", ",", "f'unsupported archive format: {ext}'", ")", "if", "\"binary\"", "not", "in", "self", ".", "_formats", "and", "ext", "==", "WHEEL_EXTENSION", ":", "reason", "=", "'No binaries permitted for {}'", ".", "format", "(", "self", ".", "project_name", ")", "return", "(", "False", ",", "reason", ")", "if", "\"macosx10\"", "in", "link", ".", "path", "and", "ext", "==", "'.zip'", ":", "return", "(", "False", ",", "'macosx10 one'", ")", "if", "ext", "==", "WHEEL_EXTENSION", ":", "try", ":", "wheel", "=", "Wheel", "(", "link", ".", "filename", ")", "except", "InvalidWheelFilename", ":", "return", "(", "False", ",", "'invalid wheel filename'", ")", "if", "canonicalize_name", "(", "wheel", ".", "name", ")", "!=", "self", ".", "_canonical_name", ":", "reason", "=", "'wrong project name (not {})'", ".", "format", "(", "self", ".", "project_name", ")", "return", "(", "False", ",", "reason", ")", "supported_tags", "=", "self", ".", "_target_python", ".", "get_tags", "(", ")", "if", "not", "wheel", ".", "supported", "(", "supported_tags", ")", ":", "# Include the wheel's tags in the reason string to", "# simplify troubleshooting compatibility issues.", "file_tags", "=", "wheel", ".", "get_formatted_file_tags", "(", ")", "reason", "=", "(", "\"none of the wheel's tags match: {}\"", ".", "format", "(", "', '", ".", "join", "(", "file_tags", ")", ")", ")", "return", "(", "False", ",", "reason", ")", "version", "=", "wheel", ".", "version", "# This should be up by the self.ok_binary check, but see issue 2700.", "if", "\"source\"", "not", "in", "self", ".", "_formats", "and", "ext", "!=", "WHEEL_EXTENSION", ":", "reason", "=", "f'No sources permitted for {self.project_name}'", "return", "(", "False", ",", "reason", ")", "if", "not", "version", ":", "version", "=", "_extract_version_from_fragment", "(", "egg_info", ",", "self", ".", "_canonical_name", ",", ")", "if", "not", "version", ":", "reason", "=", "f'Missing project version for {self.project_name}'", "return", "(", "False", ",", "reason", ")", "match", "=", "self", ".", "_py_version_re", ".", "search", "(", "version", ")", "if", "match", ":", "version", "=", "version", "[", ":", "match", ".", "start", "(", ")", "]", "py_version", "=", "match", ".", "group", "(", "1", ")", "if", "py_version", "!=", "self", ".", "_target_python", ".", "py_version", ":", "return", "(", "False", ",", "'Python version is incorrect'", ")", "supports_python", "=", "_check_link_requires_python", "(", "link", ",", "version_info", "=", "self", ".", "_target_python", ".", "py_version_info", ",", "ignore_requires_python", "=", "self", ".", "_ignore_requires_python", ",", ")", "if", "not", "supports_python", ":", "# Return None for the reason text to suppress calling", "# _log_skipped_link().", "return", "(", "False", ",", "None", ")", "logger", ".", "debug", "(", "'Found link %s, version: %s'", ",", "link", ",", "version", ")", "return", "(", "True", ",", "version", ")" ]

[ "Returns", "the", "next", "input", "from", "the", "iterator", "for", "all", "replicas", "." ]

[ "def", "get_next", "(", "self", ",", "name", "=", "None", ")", ":", "raise", "NotImplementedError", "(", "\"Iterating over an `AsyncDistributedIterator` \"", "\"is not supported right now.\"", ")" ]

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

[ "def", "_SetFilters", "(", "filters", ")", ":", "_cpplint_state", ".", "SetFilters", "(", "filters", ")" ]

[ "Check", "if", "line", "contains", "a", "redundant", "override", "or", "final", "virt", "-", "specifier", "." ]

[ "def", "CheckRedundantOverrideOrFinal", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "# Look for closing parenthesis nearby. We need one to confirm where", "# the declarator ends and where the virt-specifier starts to avoid", "# false positives.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "declarator_end", "=", "line", ".", "rfind", "(", "')'", ")", "if", "declarator_end", ">=", "0", ":", "fragment", "=", "line", "[", "declarator_end", ":", "]", "else", ":", "if", "linenum", ">", "1", "and", "clean_lines", ".", "elided", "[", "linenum", "-", "1", "]", ".", "rfind", "(", "')'", ")", ">=", "0", ":", "fragment", "=", "line", "else", ":", "return", "# Check that at most one of \"override\" or \"final\" is present, not both", "if", "Search", "(", "r'\\boverride\\b'", ",", "fragment", ")", "and", "Search", "(", "r'\\bfinal\\b'", ",", "fragment", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/inheritance'", ",", "4", ",", "(", "'\"override\" is redundant since function is '", "'already declared as \"final\"'", ")", ")" ]

[ "funcdef", ":", "DEF", "NAME", "parameters", "COLON", "suite" ]

[ "def", "p_funcdef", "(", "p", ")", ":", "p", "[", "0", "]", "=", "ast", ".", "Function", "(", "None", ",", "p", "[", "2", "]", ",", "tuple", "(", "p", "[", "3", "]", ")", ",", "(", ")", ",", "0", ",", "None", ",", "p", "[", "5", "]", ")" ]

[ "Constructor", ".", "Assigned", "self", ".", "SMProxyManager", "to", "vtkSMProxyManager", ".", "GetProxyManager", "()", "." ]

[ "def", "__init__", "(", "self", ",", "session", "=", "None", ")", ":", "global", "ActiveConnection", "if", "not", "session", ":", "session", "=", "ActiveConnection", ".", "Session", "self", ".", "SMProxyManager", "=", "session", ".", "GetSessionProxyManager", "(", ")" ]

[ "Check", "which", "modules", "introduced", "in", "Qt", "v5", ".", "4", "can", "be", "built", "and", "update", "the", "target", "configuration", "accordingly", ".", "target_config", "is", "the", "target", "configuration", ".", "disabled_modules", "is", "the", "list", "of", "modules", "that", "have", "been", "explicitly", "disabled", ".", "verbose", "is", "set", "if", "the", "output", "is", "to", "be", "displayed", "." ]

[ "def", "check_5_4_modules", "(", "target_config", ",", "disabled_modules", ",", "verbose", ")", ":", "check_module", "(", "target_config", ",", "disabled_modules", ",", "verbose", ",", "'QtWebChannel'", ",", "'qwebchannel.h'", ",", "'new QWebChannel()'", ")", "check_module", "(", "target_config", ",", "disabled_modules", ",", "verbose", ",", "'QtWebEngineWidgets'", ",", "'qwebengineview.h'", ",", "'new QWebEngineView()'", ")" ]

[ "Returns", "a", "GraphSet", "of", "cycles", "." ]

[ "def", "cycles", "(", "is_hamilton", "=", "False", ",", "graphset", "=", "None", ")", ":", "dc", "=", "{", "}", "for", "v", "in", "GraphSet", ".", "_vertices", ":", "dc", "[", "v", "]", "=", "2", "if", "is_hamilton", "else", "range", "(", "0", ",", "3", ",", "2", ")", "return", "GraphSet", ".", "graphs", "(", "vertex_groups", "=", "[", "[", "]", "]", ",", "degree_constraints", "=", "dc", ",", "graphset", "=", "graphset", ")" ]

[ "Calculates", "per", "-", "filter", "statistics", "for", "weights", "using", "a", "specific", "function", ":", "param", "weights", ":", "model", "layer", "weights", ":", "param", "fn", ":", "function", "to", "calculate", "per", "-", "filter", "statistics", ":", "param", "transpose", ":", "transpose", "weights", "data", "from", "IOHW", "to", "OIHW", "to", "collect", "stats", ":", "return", "statistics", "generated", "by", "fn" ]

[ "def", "calculate_per_filter_stats", "(", "weights", ",", "fn", ",", "transpose", "=", "False", ")", ":", "if", "transpose", ":", "weights_shape", "=", "[", "1", ",", "0", "]", "original_axes", "=", "np", ".", "array", "(", "range", "(", "len", "(", "weights", ".", "shape", ")", ")", ")", "weights_shape", ".", "extend", "(", "original_axes", "[", "2", ":", "]", ")", "weights", "=", "np", ".", "transpose", "(", "weights", ",", "weights_shape", ")", "if", "not", "weights", ".", "shape", ":", "return", "fn", "(", "weights", ")", "t", "=", "np", ".", "reshape", "(", "weights", ",", "(", "weights", ".", "shape", "[", "0", "]", ",", "-", "1", ")", ")", "return", "fn", "(", "t", ",", "axis", "=", "1", ")" ]

[ "Return", "a", "TileRegion", "representing", "the", "extent", "of", "this", "TileRegion", "projected", "onto", "a", "different", "level", "of", "the", "tile", "pyramid", "." ]

[ "def", "project_to_level", "(", "self", ",", "level", ")", ":", "level_delta", "=", "level", "-", "self", ".", "level", "if", "level_delta", "==", "0", ":", "return", "self", "scale_factor", "=", "2", "**", "level_delta", "proj_bbox", "=", "BBox", "(", "self", ".", "minx", "*", "scale_factor", ",", "self", ".", "miny", "*", "scale_factor", ",", "self", ".", "width", "*", "scale_factor", ",", "self", ".", "height", "*", "scale_factor", ")", "if", "level_delta", "<", "0", ":", "# Ensure that region bounds are still integers", "for", "prop", "in", "(", "proj_bbox", ".", "minx", ",", "proj_bbox", ".", "miny", ",", "proj_bbox", ".", "width", ",", "proj_bbox", ".", "height", ")", ":", "assert", "prop", "%", "1", "==", "0", "return", "TileRegion", "(", "level", ",", "proj_bbox", ")" ]

[ "Add", "the", "series", "or", "dataframe", "only", "operations", "to", "the", "cls", ";", "evaluate", "the", "doc", "strings", "again", "." ]

[ "def", "_add_series_or_dataframe_operations", "(", "cls", ")", ":", "from", "pandas", ".", "core", "import", "window", "as", "rwindow", "@", "Appender", "(", "rwindow", ".", "rolling", ".", "__doc__", ")", "def", "rolling", "(", "self", ",", "window", ",", "min_periods", "=", "None", ",", "center", "=", "False", ",", "win_type", "=", "None", ",", "on", "=", "None", ",", "axis", "=", "0", ",", "closed", "=", "None", ")", ":", "axis", "=", "self", ".", "_get_axis_number", "(", "axis", ")", "return", "rwindow", ".", "rolling", "(", "self", ",", "window", "=", "window", ",", "min_periods", "=", "min_periods", ",", "center", "=", "center", ",", "win_type", "=", "win_type", ",", "on", "=", "on", ",", "axis", "=", "axis", ",", "closed", "=", "closed", ")", "cls", ".", "rolling", "=", "rolling", "@", "Appender", "(", "rwindow", ".", "expanding", ".", "__doc__", ")", "def", "expanding", "(", "self", ",", "min_periods", "=", "1", ",", "center", "=", "False", ",", "axis", "=", "0", ")", ":", "axis", "=", "self", ".", "_get_axis_number", "(", "axis", ")", "return", "rwindow", ".", "expanding", "(", "self", ",", "min_periods", "=", "min_periods", ",", "center", "=", "center", ",", "axis", "=", "axis", ")", "cls", ".", "expanding", "=", "expanding", "@", "Appender", "(", "rwindow", ".", "ewm", ".", "__doc__", ")", "def", "ewm", "(", "self", ",", "com", "=", "None", ",", "span", "=", "None", ",", "halflife", "=", "None", ",", "alpha", "=", "None", ",", "min_periods", "=", "0", ",", "adjust", "=", "True", ",", "ignore_na", "=", "False", ",", "axis", "=", "0", ")", ":", "axis", "=", "self", ".", "_get_axis_number", "(", "axis", ")", "return", "rwindow", ".", "ewm", "(", "self", ",", "com", "=", "com", ",", "span", "=", "span", ",", "halflife", "=", "halflife", ",", "alpha", "=", "alpha", ",", "min_periods", "=", "min_periods", ",", "adjust", "=", "adjust", ",", "ignore_na", "=", "ignore_na", ",", "axis", "=", "axis", ")", "cls", ".", "ewm", "=", "ewm" ]

[ "Mark", "the", "object", "as", "expired", "to", "prevent", "future", "API", "accesses", "." ]

[ "def", "expire", "(", "self", ")", ":", "self", ".", "expired", "=", "True" ]

[ "Create", "a", "list", "of", "dependencies", "from", "input", "list", "of", "lines", "Each", "element", "contains", "the", "name", "of", "the", "object", "and", "a", "list", "of", "files", "that", "it", "depends", "on", ".", "Dependencies", "that", "contain", "/", "usr", "/", "are", "removed", "as", "they", "are", "system", "headers", "." ]

[ "def", "ExtractDependencies", "(", "input", ")", ":", "deps", "=", "[", "]", "for", "line", "in", "input", ":", "headersLine", "=", "line", ".", "startswith", "(", "\" \"", ")", "or", "line", ".", "startswith", "(", "\"\\t\"", ")", "line", "=", "line", ".", "strip", "(", ")", "isContinued", "=", "line", ".", "endswith", "(", "\"\\\\\"", ")", "line", "=", "line", ".", "rstrip", "(", "\"\\\\ \"", ")", "fileNames", "=", "line", ".", "strip", "(", ")", ".", "split", "(", "\" \"", ")", "if", "not", "headersLine", ":", "# its a source file line, there may be headers too", "sourceLine", "=", "fileNames", "[", "0", "]", ".", "rstrip", "(", "\":\"", ")", "fileNames", "=", "fileNames", "[", "1", ":", "]", "deps", ".", "append", "(", "[", "sourceLine", ",", "[", "]", "]", ")", "deps", "[", "-", "1", "]", "[", "1", "]", ".", "extend", "(", "header", "for", "header", "in", "fileNames", "if", "\"/usr/\"", "not", "in", "header", ")", "return", "deps" ]

[ "Convert", "a", "ctypes", "float", "pointer", "array", "to", "a", "numpy", "array", "." ]

[ "def", "cint32_array_to_numpy", "(", "cptr", ",", "length", ")", ":", "if", "isinstance", "(", "cptr", ",", "ctypes", ".", "POINTER", "(", "ctypes", ".", "c_int32", ")", ")", ":", "return", "np", ".", "fromiter", "(", "cptr", ",", "dtype", "=", "np", ".", "int32", ",", "count", "=", "length", ")", "else", ":", "raise", "RuntimeError", "(", "'Expected int pointer'", ")" ]

[ "Alias", "for", "fetch_lfw_pairs", "(", "download_if_missing", "=", "False", ")" ]

[ "def", "load_lfw_pairs", "(", "download_if_missing", "=", "False", ",", "*", "*", "kwargs", ")", ":", "return", "fetch_lfw_pairs", "(", "download_if_missing", "=", "download_if_missing", ",", "*", "*", "kwargs", ")" ]

[ "Check", "if", "a", "sparse", "matrix", "is", "symmetric" ]

[ "def", "is_sparse_symmetric", "(", "m", ",", "complex", ":", "bool", "=", "False", ")", "->", "bool", ":", "# https://mail.scipy.org/pipermail/scipy-dev/2014-October/020101.html", "if", "m", ".", "shape", "[", "0", "]", "!=", "m", ".", "shape", "[", "1", "]", ":", "raise", "ValueError", "(", "'m must be a square matrix'", ")", "if", "not", "isinstance", "(", "m", ",", "sp", ".", "coo_matrix", ")", ":", "m", "=", "sp", ".", "coo_matrix", "(", "m", ")", "r", ",", "c", ",", "v", "=", "m", ".", "row", ",", "m", ".", "col", ",", "m", ".", "data", "tril_no_diag", "=", "r", ">", "c", "triu_no_diag", "=", "c", ">", "r", "if", "triu_no_diag", ".", "sum", "(", ")", "!=", "tril_no_diag", ".", "sum", "(", ")", ":", "return", "False", "rl", "=", "r", "[", "tril_no_diag", "]", "cl", "=", "c", "[", "tril_no_diag", "]", "vl", "=", "v", "[", "tril_no_diag", "]", "ru", "=", "r", "[", "triu_no_diag", "]", "cu", "=", "c", "[", "triu_no_diag", "]", "vu", "=", "v", "[", "triu_no_diag", "]", "sortl", "=", "np", ".", "lexsort", "(", "(", "cl", ",", "rl", ")", ")", "sortu", "=", "np", ".", "lexsort", "(", "(", "ru", ",", "cu", ")", ")", "vl", "=", "vl", "[", "sortl", "]", "vu", "=", "vu", "[", "sortu", "]", "if", "complex", ":", "check", "=", "np", ".", "allclose", "(", "vl", ",", "np", ".", "conj", "(", "vu", ")", ")", "else", ":", "check", "=", "np", ".", "allclose", "(", "vl", ",", "vu", ")", "return", "check" ]

[ "source", ":", "<int", ">", "or", "<int", ">", "|<filename", ">", "|synth", "[", ":", "<param_name", ">", "=", "<value", ">", "[", ":", "...", "]]" ]

[ "def", "create_capture", "(", "source", "=", "0", ",", "fallback", "=", "presets", "[", "'chess'", "]", ")", ":", "source", "=", "str", "(", "source", ")", ".", "strip", "(", ")", "chunks", "=", "source", ".", "split", "(", "':'", ")", "# handle drive letter ('c:', ...)", "if", "len", "(", "chunks", ")", ">", "1", "and", "len", "(", "chunks", "[", "0", "]", ")", "==", "1", "and", "chunks", "[", "0", "]", ".", "isalpha", "(", ")", ":", "chunks", "[", "1", "]", "=", "chunks", "[", "0", "]", "+", "':'", "+", "chunks", "[", "1", "]", "del", "chunks", "[", "0", "]", "source", "=", "chunks", "[", "0", "]", "try", ":", "source", "=", "int", "(", "source", ")", "except", "ValueError", ":", "pass", "params", "=", "dict", "(", "s", ".", "split", "(", "'='", ")", "for", "s", "in", "chunks", "[", "1", ":", "]", ")", "cap", "=", "None", "if", "source", "==", "'synth'", ":", "Class", "=", "classes", ".", "get", "(", "params", ".", "get", "(", "'class'", ",", "None", ")", ",", "VideoSynthBase", ")", "try", ":", "cap", "=", "Class", "(", "*", "*", "params", ")", "except", ":", "pass", "else", ":", "cap", "=", "cv2", ".", "VideoCapture", "(", "source", ")", "if", "'size'", "in", "params", ":", "w", ",", "h", "=", "map", "(", "int", ",", "params", "[", "'size'", "]", ".", "split", "(", "'x'", ")", ")", "cap", ".", "set", "(", "cv2", ".", "CAP_PROP_FRAME_WIDTH", ",", "w", ")", "cap", ".", "set", "(", "cv2", ".", "CAP_PROP_FRAME_HEIGHT", ",", "h", ")", "if", "cap", "is", "None", "or", "not", "cap", ".", "isOpened", "(", ")", ":", "print", "'Warning: unable to open video source: '", ",", "source", "if", "fallback", "is", "not", "None", ":", "return", "create_capture", "(", "fallback", ",", "None", ")", "return", "cap" ]

[ "0x2003", "收到错误报文" ]

[ "def", "onFrontDisconnected", "(", "self", ",", "reasonCode", ")", ":", "pass" ]

[ "ClearTools", "(", "self", ")" ]

[ "def", "ClearTools", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBar_ClearTools", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

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

[ "def", "_get_predict_ops", "(", "self", ",", "features", ")", ":", "self", ".", "_validate_linear_feature_columns", "(", "features", ")", "return", "super", "(", "LinearRegressor", ",", "self", ")", ".", "_get_predict_ops", "(", "features", ")" ]

[ "The", "Convolutional", "weights", "in", "CoreML", "specification", "converted", "to", "the", "TensorFlow", "format", "for", "training", "in", "TensorFlow", "." ]

[ "def", "convert_conv1d_coreml_to_tf", "(", "conv_weights", ")", ":", "conv_weights", "=", "np", ".", "transpose", "(", "conv_weights", ",", "(", "3", ",", "1", ",", "0", ",", "2", ")", ")", "return", "np", ".", "squeeze", "(", "conv_weights", ",", "axis", "=", "3", ")" ]

[ "Compute", "the", "largest", "k", "singular", "values", "/", "vectors", "for", "a", "sparse", "matrix", "." ]

[ "def", "svds", "(", "A", ",", "k", "=", "6", ",", "ncv", "=", "None", ",", "tol", "=", "0", ",", "which", "=", "'LM'", ",", "v0", "=", "None", ",", "maxiter", "=", "None", ",", "return_singular_vectors", "=", "True", ")", ":", "if", "not", "(", "isinstance", "(", "A", ",", "LinearOperator", ")", "or", "isspmatrix", "(", "A", ")", ")", ":", "A", "=", "np", ".", "asarray", "(", "A", ")", "n", ",", "m", "=", "A", ".", "shape", "if", "k", "<=", "0", "or", "k", ">=", "min", "(", "n", ",", "m", ")", ":", "raise", "ValueError", "(", "\"k must be between 1 and min(A.shape), k=%d\"", "%", "k", ")", "if", "isinstance", "(", "A", ",", "LinearOperator", ")", ":", "if", "n", ">", "m", ":", "X_dot", "=", "A", ".", "matvec", "X_matmat", "=", "A", ".", "matmat", "XH_dot", "=", "A", ".", "rmatvec", "else", ":", "X_dot", "=", "A", ".", "rmatvec", "XH_dot", "=", "A", ".", "matvec", "dtype", "=", "getattr", "(", "A", ",", "'dtype'", ",", "None", ")", "if", "dtype", "is", "None", ":", "dtype", "=", "A", ".", "dot", "(", "np", ".", "zeros", "(", "[", "m", ",", "1", "]", ")", ")", ".", "dtype", "# A^H * V; works around lack of LinearOperator.adjoint.", "# XXX This can be slow!", "def", "X_matmat", "(", "V", ")", ":", "out", "=", "np", ".", "empty", "(", "(", "V", ".", "shape", "[", "1", "]", ",", "m", ")", ",", "dtype", "=", "dtype", ")", "for", "i", ",", "col", "in", "enumerate", "(", "V", ".", "T", ")", ":", "out", "[", "i", ",", ":", "]", "=", "A", ".", "rmatvec", "(", "col", ".", "reshape", "(", "-", "1", ",", "1", ")", ")", ".", "T", "return", "out", ".", "T", "else", ":", "if", "n", ">", "m", ":", "X_dot", "=", "X_matmat", "=", "A", ".", "dot", "XH_dot", "=", "_herm", "(", "A", ")", ".", "dot", "else", ":", "XH_dot", "=", "A", ".", "dot", "X_dot", "=", "X_matmat", "=", "_herm", "(", "A", ")", ".", "dot", "def", "matvec_XH_X", "(", "x", ")", ":", "return", "XH_dot", "(", "X_dot", "(", "x", ")", ")", "XH_X", "=", "LinearOperator", "(", "matvec", "=", "matvec_XH_X", ",", "dtype", "=", "A", ".", "dtype", ",", "shape", "=", "(", "min", "(", "A", ".", "shape", ")", ",", "min", "(", "A", ".", "shape", ")", ")", ")", "# Get a low rank approximation of the implicitly defined gramian matrix.", "# This is not a stable way to approach the problem.", "eigvals", ",", "eigvec", "=", "eigsh", "(", "XH_X", ",", "k", "=", "k", ",", "tol", "=", "tol", "**", "2", ",", "maxiter", "=", "maxiter", ",", "ncv", "=", "ncv", ",", "which", "=", "which", ",", "v0", "=", "v0", ")", "# In 'LM' mode try to be clever about small eigenvalues.", "# Otherwise in 'SM' mode do not try to be clever.", "if", "which", "==", "'LM'", ":", "# Gramian matrices have real non-negative eigenvalues.", "eigvals", "=", "np", ".", "maximum", "(", "eigvals", ".", "real", ",", "0", ")", "# Use the sophisticated detection of small eigenvalues from pinvh.", "t", "=", "eigvec", ".", "dtype", ".", "char", ".", "lower", "(", ")", "factor", "=", "{", "'f'", ":", "1E3", ",", "'d'", ":", "1E6", "}", "cond", "=", "factor", "[", "t", "]", "*", "np", ".", "finfo", "(", "t", ")", ".", "eps", "cutoff", "=", "cond", "*", "np", ".", "max", "(", "eigvals", ")", "# Get a mask indicating which eigenpairs are not degenerately tiny,", "# and create the re-ordered array of thresholded singular values.", "above_cutoff", "=", "(", "eigvals", ">", "cutoff", ")", "nlarge", "=", "above_cutoff", ".", "sum", "(", ")", "nsmall", "=", "k", "-", "nlarge", "slarge", "=", "np", ".", "sqrt", "(", "eigvals", "[", "above_cutoff", "]", ")", "s", "=", "np", ".", "zeros_like", "(", "eigvals", ")", "s", "[", ":", "nlarge", "]", "=", "slarge", "if", "not", "return_singular_vectors", ":", "return", "s", "if", "n", ">", "m", ":", "vlarge", "=", "eigvec", "[", ":", ",", "above_cutoff", "]", "ularge", "=", "X_matmat", "(", "vlarge", ")", "/", "slarge", "if", "return_singular_vectors", "!=", "'vh'", "else", "None", "vhlarge", "=", "_herm", "(", "vlarge", ")", "else", ":", "ularge", "=", "eigvec", "[", ":", ",", "above_cutoff", "]", "vhlarge", "=", "_herm", "(", "X_matmat", "(", "ularge", ")", "/", "slarge", ")", "if", "return_singular_vectors", "!=", "'u'", "else", "None", "u", "=", "_augmented_orthonormal_cols", "(", "ularge", ",", "nsmall", ")", "if", "ularge", "is", "not", "None", "else", "None", "vh", "=", "_augmented_orthonormal_rows", "(", "vhlarge", ",", "nsmall", ")", "if", "vhlarge", "is", "not", "None", "else", "None", "elif", "which", "==", "'SM'", ":", "s", "=", "np", ".", "sqrt", "(", "eigvals", ")", "if", "not", "return_singular_vectors", ":", "return", "s", "if", "n", ">", "m", ":", "v", "=", "eigvec", "u", "=", "X_matmat", "(", "v", ")", "/", "s", "if", "return_singular_vectors", "!=", "'vh'", "else", "None", "vh", "=", "_herm", "(", "v", ")", "else", ":", "u", "=", "eigvec", "vh", "=", "_herm", "(", "X_matmat", "(", "u", ")", "/", "s", ")", "if", "return_singular_vectors", "!=", "'u'", "else", "None", "else", ":", "raise", "ValueError", "(", "\"which must be either 'LM' or 'SM'.\"", ")", "return", "u", ",", "s", ",", "vh" ]

[ "r", "Compute", "bit", "-", "wise", "inversion", "or", "bit", "-", "wise", "NOT", "element", "-", "wise", ".", "Computes", "the", "bit", "-", "wise", "NOT", "of", "the", "underlying", "binary", "representation", "of", "the", "integers", "in", "the", "input", "arrays", ".", "This", "ufunc", "implements", "the", "C", "/", "Python", "operator", "~", ".", "Parameters", "----------", "x", ":", "array_like", "Only", "integer", "and", "boolean", "types", "are", "handled", ".", "out", ":", "ndarray", "None", "or", "tuple", "of", "ndarray", "and", "None", "optional", "A", "location", "into", "which", "the", "result", "is", "stored", ".", "If", "provided", "it", "must", "have", "a", "shape", "that", "the", "inputs", "broadcast", "to", ".", "If", "not", "provided", "or", "None", "a", "freshly", "-", "allocated", "array", "is", "returned", ".", "A", "tuple", "(", "possible", "only", "as", "a", "keyword", "argument", ")", "must", "have", "length", "equal", "to", "the", "number", "of", "outputs", ".", "Returns", "-------", "out", ":", "ndarray", "or", "scalar", "Result", ".", "This", "is", "a", "scalar", "if", "x", "is", "a", "scalar", ".", "See", "Also", "--------", "bitwise_and", "bitwise_or", "bitwise_xor", "logical_not", "binary_repr", ":", "Return", "the", "binary", "representation", "of", "the", "input", "number", "as", "a", "string", ".", "Examples", "--------", "We", "ve", "seen", "that", "13", "is", "represented", "by", "00001101", ".", "The", "invert", "or", "bit", "-", "wise", "NOT", "of", "13", "is", "then", ":", ">>>", "x", "=", "np", ".", "invert", "(", "np", ".", "array", "(", "13", "dtype", "=", "np", ".", "uint8", "))", ">>>", "x", "242", ">>>", "np", ".", "binary_repr", "(", "x", "width", "=", "8", ")", "11110010", "Notes", "-----", "bitwise_not", "is", "an", "alias", "for", "invert", ":", ">>>", "np", ".", "bitwise_not", "is", "np", ".", "invert", "True" ]

[ "def", "bitwise_not", "(", "x", ",", "out", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "_unary_func_helper", "(", "x", ",", "_npi", ".", "bitwise_not", ",", "_np", ".", "bitwise_not", ",", "out", "=", "out", ",", "*", "*", "kwargs", ")" ]

[ "Transform", "(", "self", "GraphicsMatrix", "matrix", ")" ]

[ "def", "Transform", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "GraphicsPath_Transform", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Try", "to", "do", "platform", "conversion", "with", "special", "casing", "for", "IntervalArray", ".", "Wrapper", "around", "maybe_convert_platform", "that", "alters", "the", "default", "return", "dtype", "in", "certain", "cases", "to", "be", "compatible", "with", "IntervalArray", ".", "For", "example", "empty", "lists", "return", "with", "integer", "dtype", "instead", "of", "object", "dtype", "which", "is", "prohibited", "for", "IntervalArray", "." ]

[ "def", "_maybe_convert_platform_interval", "(", "values", ")", "->", "ArrayLike", ":", "if", "isinstance", "(", "values", ",", "(", "list", ",", "tuple", ")", ")", "and", "len", "(", "values", ")", "==", "0", ":", "# GH 19016", "# empty lists/tuples get object dtype by default, but this is", "# prohibited for IntervalArray, so coerce to integer instead", "return", "np", ".", "array", "(", "[", "]", ",", "dtype", "=", "np", ".", "int64", ")", "elif", "not", "is_list_like", "(", "values", ")", "or", "isinstance", "(", "values", ",", "ABCDataFrame", ")", ":", "# This will raise later, but we avoid passing to maybe_convert_platform", "return", "values", "elif", "is_categorical_dtype", "(", "values", ")", ":", "values", "=", "np", ".", "asarray", "(", "values", ")", "elif", "not", "hasattr", "(", "values", ",", "\"dtype\"", ")", "and", "not", "isinstance", "(", "values", ",", "(", "list", ",", "tuple", ",", "range", ")", ")", ":", "# TODO: should we just cast these to list?", "return", "values", "else", ":", "values", "=", "extract_array", "(", "values", ",", "extract_numpy", "=", "True", ")", "if", "not", "hasattr", "(", "values", ",", "\"dtype\"", ")", ":", "return", "np", ".", "asarray", "(", "values", ")", "return", "values" ]

[ "Compute", "the", "*", "printable", "*", "MAC", "tag", "." ]

[ "def", "hexdigest", "(", "self", ")", ":", "return", "\"\"", ".", "join", "(", "[", "\"%02x\"", "%", "bord", "(", "x", ")", "for", "x", "in", "self", ".", "digest", "(", ")", "]", ")" ]

[ "Constructs", "a", "TF", "graph", "for", "evaluating", "a", "random", "tree", "." ]

[ "def", "inference_graph", "(", "self", ",", "input_data", ",", "data_spec", ",", "sparse_features", "=", "None", ")", ":", "sparse_indices", "=", "[", "]", "sparse_values", "=", "[", "]", "sparse_shape", "=", "[", "]", "if", "sparse_features", "is", "not", "None", ":", "sparse_indices", "=", "sparse_features", ".", "indices", "sparse_values", "=", "sparse_features", ".", "values", "sparse_shape", "=", "sparse_features", ".", "dense_shape", "if", "input_data", "is", "None", ":", "input_data", "=", "[", "]", "return", "model_ops", ".", "tree_predictions_v4", "(", "self", ".", "variables", ".", "tree", ",", "input_data", ",", "sparse_indices", ",", "sparse_values", ",", "sparse_shape", ",", "input_spec", "=", "data_spec", ".", "SerializeToString", "(", ")", ",", "params", "=", "self", ".", "params", ".", "serialized_params_proto", ")" ]

[ "Boxes", "a", "value", "if", "necessary", "." ]

[ "def", "box", "(", "self", ",", "value", ":", "ir", ".", "Value", ",", "to_typed", ":", "Optional", "[", "bool", "]", "=", "True", ")", "->", "ir", ".", "Value", ":", "with", "self", ".", "ip", ",", "self", ".", "loc", ":", "t", "=", "value", ".", "type", "if", "d", ".", "ObjectType", ".", "isinstance", "(", "t", ")", ":", "# Already boxed.", "return", "value", "boxed_type", "=", "d", ".", "ObjectType", ".", "get_typed", "(", "t", ")", "if", "to_typed", "else", "d", ".", "ObjectType", ".", "get", "(", ")", "return", "d", ".", "BoxOp", "(", "boxed_type", ",", "value", ")", ".", "result" ]

[ "Is", "the", "atom", "concave?" ]

[ "def", "is_atom_concave", "(", "self", ")", "->", "bool", ":", "return", "False" ]

[ "Constructs", "an", "FCC", "lattice", "of", "a", "given", "spatial", "extent", ".", "Periodic", "boundary", "conditions", "can", "also", "be", "imposed", "Sites", "are", "returned", "at", "the", "Bravais", "lattice", "points", "." ]

[ "def", "FCC", "(", "extent", ":", "Sequence", "[", "int", "]", ",", "*", ",", "pbc", ":", "Union", "[", "bool", ",", "Sequence", "[", "bool", "]", "]", "=", "True", ",", "*", "*", "kwargs", ")", "->", "Lattice", ":", "basis", "=", "[", "[", "0", ",", "0.5", ",", "0.5", "]", ",", "[", "0.5", ",", "0", ",", "0.5", "]", ",", "[", "0.5", ",", "0.5", ",", "0", "]", "]", "# determine if full point group is realised by the simulation box", "point_group", "=", "cubic", ".", "Oh", "(", ")", "if", "np", ".", "all", "(", "pbc", ")", "and", "len", "(", "set", "(", "extent", ")", ")", "==", "1", "else", "None", "return", "Lattice", "(", "basis_vectors", "=", "basis", ",", "extent", "=", "extent", ",", "pbc", "=", "pbc", ",", "point_group", "=", "point_group", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "true", "if", "other", "has", "the", "same", "known", "value", "as", "this", "Dimension", "." ]

[ "def", "__eq__", "(", "self", ",", "other", ")", ":", "try", ":", "other", "=", "as_dimension", "(", "other", ")", "except", "(", "TypeError", ",", "ValueError", ")", ":", "return", "NotImplemented", "if", "self", ".", "_value", "is", "None", "or", "other", ".", "value", "is", "None", ":", "return", "None", "return", "self", ".", "_value", "==", "other", ".", "value" ]

[ "Return", "all", "the", "non", "-", "masked", "data", "as", "a", "1", "-", "D", "array", "." ]

[ "def", "compressed", "(", "x", ")", ":", "return", "asanyarray", "(", "x", ")", ".", "compressed", "(", ")" ]

[ "Verifies", "that", "no", "two", "objects", "have", "the", "same", "ID", ".", "Checks", "all", "descendants", "." ]

[ "def", "EnsureNoIDCollisions", "(", "self", ")", ":", "ids", "=", "{", "}", "descendants", "=", "self", ".", "Descendants", "(", ")", "for", "descendant", "in", "descendants", ":", "if", "descendant", ".", "id", "in", "ids", ":", "other", "=", "ids", "[", "descendant", ".", "id", "]", "raise", "KeyError", "(", "'Duplicate ID %s, objects \"%s\" and \"%s\" in \"%s\"'", "%", "(", "descendant", ".", "id", ",", "str", "(", "descendant", ".", "_properties", ")", ",", "str", "(", "other", ".", "_properties", ")", ",", "self", ".", "_properties", "[", "'rootObject'", "]", ".", "Name", "(", ")", ")", ")", "ids", "[", "descendant", ".", "id", "]", "=", "descendant" ]

[ "Associate", "a", "unique", "name", "with", "an", "object", "." ]

[ "def", "associate_name_with_obj", "(", "self", ",", "name", ":", "str", ",", "obj", ":", "Any", ")", ":", "assert", "obj", "not", "in", "self", ".", "_obj_to_name", "assert", "name", "in", "self", ".", "_unassociated_names", "self", ".", "_obj_to_name", "[", "obj", "]", "=", "name", "self", ".", "_unassociated_names", ".", "remove", "(", "name", ")" ]

[ "Enable", "/", "Disable", "label", "editing", ".", "This", "functionality", "is", "enabled", "by", "default", ".", "@keyword", "enable", ":", "bool" ]

[ "def", "EnableLabelEditing", "(", "self", ",", "enable", "=", "True", ")", ":", "self", ".", "_editlabels", "=", "enable" ]

[ "status", "=", "exo", ".", "put_face_count_per_polyhedra", "(", "blkID", "entityCounts", ")" ]

[ "def", "put_face_count_per_polyhedra", "(", "self", ",", "blkID", ",", "entityCounts", ")", ":", "ebType", "=", "ex_entity_type", "(", "\"EX_ELEM_BLOCK\"", ")", "entity_counts", "=", "(", "c_int", "*", "len", "(", "entityCounts", ")", ")", "(", ")", "entity_counts", "[", ":", "]", "=", "entityCounts", "EXODUS_LIB", ".", "ex_put_entity_count_per_polyhedra", "(", "self", ".", "fileId", ",", "ebType", ",", "c_int", "(", "blkID", ")", ",", "entity_counts", ")", "return", "True" ]

[ "Scans", "for", "DLLs", "in", "the", "specified", "section", "of", "config", "that", "are", "in", "the", "subdirectory", "of", "output_dir", "named", "SERVERS_DIR", ".", "Returns", "a", "list", "of", "only", "the", "filename", "components", "of", "the", "paths", "to", "all", "matching", "DLLs", "." ]

[ "def", "ScanServerDlls", "(", "config", ",", "distribution", ",", "output_dir", ")", ":", "print", "\"Scanning for server DLLs in \"", "+", "output_dir", "registered_dll_list", "=", "[", "]", "ScanDllsInSection", "(", "config", ",", "'GENERAL'", ",", "output_dir", ",", "registered_dll_list", ")", "if", "distribution", ":", "if", "len", "(", "distribution", ")", ">", "1", "and", "distribution", "[", "0", "]", "==", "'_'", ":", "distribution", "=", "distribution", "[", "1", ":", "]", "ScanDllsInSection", "(", "config", ",", "distribution", ".", "upper", "(", ")", ",", "output_dir", ",", "registered_dll_list", ")", "return", "registered_dll_list" ]

[ "Add", "the", "getter", "for", "an", "accumulated", "value", "in", "the", "grad", "context", "." ]

[ "def", "AddBackPropAccumulatedValue", "(", "self", ",", "history_value", ",", "value", ",", "dead_branch", "=", "False", ")", ":", "history_ctxt", "=", "history_value", ".", "op", ".", "_get_control_flow_context", "(", ")", "# Find the cond context that controls history_value.", "cond_ctxt", "=", "None", "value_ctxt", "=", "value", ".", "op", ".", "_get_control_flow_context", "(", ")", "while", "value_ctxt", "and", "value_ctxt", "!=", "history_ctxt", ":", "if", "isinstance", "(", "value_ctxt", ",", "CondContext", ")", ":", "cond_ctxt", "=", "value_ctxt", "break", "value_ctxt", "=", "value_ctxt", ".", "outer_context", "with", "ops", ".", "control_dependencies", "(", "None", ")", ":", "self", ".", "grad_context", ".", "Enter", "(", ")", "if", "cond_ctxt", ":", "# Guard stack pop with a switch if it is controlled by a cond", "grad_state", "=", "self", "pred", "=", "None", "while", "pred", "is", "None", "and", "grad_state", ":", "pred", "=", "grad_state", ".", "history_map", ".", "get", "(", "cond_ctxt", ".", "pred", ".", "name", ")", "grad_state", "=", "grad_state", ".", "outer_grad_state", "branch", "=", "(", "1", "-", "cond_ctxt", ".", "branch", ")", "if", "dead_branch", "else", "cond_ctxt", ".", "branch", "history_value", "=", "_SwitchRefOrTensor", "(", "history_value", ",", "pred", ")", "[", "branch", "]", "pop", "=", "gen_data_flow_ops", ".", "_stack_pop", "(", "history_value", ",", "value", ".", "dtype", ".", "base_dtype", ")", "self", ".", "grad_context", ".", "Exit", "(", ")", "parallel_iterations", "=", "self", ".", "grad_context", ".", "parallel_iterations", "if", "parallel_iterations", "is", "not", "None", "and", "parallel_iterations", ">", "1", ":", "# All pops are ordered after pivot_for_body and before grad_sync.", "self", ".", "grad_sync", ".", "_add_control_input", "(", "pop", ".", "op", ")", "return", "pop" ]

[ "Calculate", "the", "gradient", "with", "@LOT", "." ]

[ "def", "calculate_gradient", "(", "self", ",", "LOT", ",", "bypass_scf", "=", "False", ",", "*", "*", "kwargs", ")", ":", "start", "=", "time", ".", "time", "(", ")", "self", ".", "grd", "=", "psi4", ".", "gradient", "(", "LOT", ",", "bypass_scf", "=", "bypass_scf", ",", "*", "*", "kwargs", ")", "time_needed", "=", "time", ".", "time", "(", ")", "-", "start", "self", ".", "timing", "[", "LOT", "]", "=", "self", ".", "timing", ".", "get", "(", "LOT", ",", "[", "]", ")", "+", "[", "time_needed", "]" ]

[ "Init", "the", "converter", "given", "the", "reference", "origin", "." ]

[ "def", "__init__", "(", "self", ",", "reflat", ",", "reflon", ",", "refalt", ")", ":", "self", ".", "lat", "=", "reflat", "self", ".", "lon", "=", "reflon", "self", ".", "alt", "=", "refalt" ]

[ "Modify", "the", "base", "class", "with", "our", "new", "methods", "at", "time", "of", "instantiation", "." ]

[ "def", "__call__", "(", "mcs", ",", "base", ",", "buff", ")", ":", "obj", "=", "type", ".", "__call__", "(", "mcs", ",", "base", ",", "buff", ")", "# Set/override attributes on the new completer object.", "setattr", "(", "obj", ",", "'BaseGetAutoCompList'", ",", "obj", ".", "GetAutoCompList", ")", "setattr", "(", "obj", ",", "'GetAutoCompList'", ",", "lambda", "cmd", ":", "GetAutoCompList", "(", "obj", ",", "cmd", ")", ")", "setattr", "(", "obj", ",", "'scomp'", ",", "simplecomp", ".", "Completer", "(", "buff", ")", ")", "# Return the new augmented completer", "return", "obj" ]

[ "Assign", "new", "instance", "of", "direct", "property", "manager", "to", "provide", "DirectEnergyConversion", "parameters" ]

[ "def", "prop_man", "(", "self", ",", "value", ")", ":", "if", "isinstance", "(", "value", ",", "PropertyManager", ")", ":", "self", ".", "_propMan", "=", "value", "else", ":", "raise", "KeyError", "(", "\"Property manager can be initialized by an instance of ProperyManager only\"", ")" ]

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

[ "def", "__next__", "(", "self", ")", ":", "return", "next", "(", "self", ".", "reader", ")" ]

[ "This", "should", "be", "overridden", "by", "a", "derived", "class", "to", "handle", "an", "unexpectedly", "lost", "connection", "to", "the", "gameserver", "." ]

[ "def", "lostConnection", "(", "self", ")", ":", "# Handle the disconnection from the server. This can be a reconnect,", "# simply exiting the application or anything else.", "exit", "(", ")" ]

[ "Authenticate", "the", "next", "chunk", "of", "message", "." ]

[ "def", "update", "(", "self", ",", "msg", ")", ":", "if", "self", ".", "_mac_tag", "is", "not", "None", "and", "not", "self", ".", "_update_after_digest", ":", "raise", "TypeError", "(", "\"update() cannot be called after digest() or verify()\"", ")", "self", ".", "_data_size", "+=", "len", "(", "msg", ")", "bs", "=", "self", ".", "_block_size", "if", "self", ".", "_cache_n", ">", "0", ":", "filler", "=", "min", "(", "bs", "-", "self", ".", "_cache_n", ",", "len", "(", "msg", ")", ")", "self", ".", "_cache", "[", "self", ".", "_cache_n", ":", "self", ".", "_cache_n", "+", "filler", "]", "=", "msg", "[", ":", "filler", "]", "self", ".", "_cache_n", "+=", "filler", "if", "self", ".", "_cache_n", "<", "bs", ":", "return", "self", "msg", "=", "memoryview", "(", "msg", ")", "[", "filler", ":", "]", "self", ".", "_update", "(", "self", ".", "_cache", ")", "self", ".", "_cache_n", "=", "0", "remain", "=", "len", "(", "msg", ")", "%", "bs", "if", "remain", ">", "0", ":", "self", ".", "_update", "(", "msg", "[", ":", "-", "remain", "]", ")", "self", ".", "_cache", "[", ":", "remain", "]", "=", "msg", "[", "-", "remain", ":", "]", "else", ":", "self", ".", "_update", "(", "msg", ")", "self", ".", "_cache_n", "=", "remain", "return", "self" ]

[ "Derive", "one", "key", "from", "a", "password", "(", "or", "passphrase", ")", "." ]

[ "def", "PBKDF1", "(", "password", ",", "salt", ",", "dkLen", ",", "count", "=", "1000", ",", "hashAlgo", "=", "None", ")", ":", "if", "not", "hashAlgo", ":", "hashAlgo", "=", "SHA1", "password", "=", "tobytes", "(", "password", ")", "pHash", "=", "hashAlgo", ".", "new", "(", "password", "+", "salt", ")", "digest", "=", "pHash", ".", "digest_size", "if", "dkLen", ">", "digest", ":", "raise", "TypeError", "(", "\"Selected hash algorithm has a too short digest (%d bytes).\"", "%", "digest", ")", "if", "len", "(", "salt", ")", "!=", "8", ":", "raise", "ValueError", "(", "\"Salt is not 8 bytes long (%d bytes instead).\"", "%", "len", "(", "salt", ")", ")", "for", "i", "in", "iter_range", "(", "count", "-", "1", ")", ":", "pHash", "=", "pHash", ".", "new", "(", "pHash", ".", "digest", "(", ")", ")", "return", "pHash", ".", "digest", "(", ")", "[", ":", "dkLen", "]" ]

[ "Returns", "path", "for", "different", "suffix", "(", "same", "parent", "and", "stem", ")", "." ]

[ "def", "with_suffix", "(", "self", ",", "suffix", ")", ":", "if", "isinstance", "(", "suffix", ",", "bytes", ")", ":", "suffix", "=", "suffix", ".", "decode", "(", ")", "return", "self", ".", "parent", ".", "joinpath", "(", "self", ".", "stem", "+", "suffix", ")" ]

[ "Reads", "checksums", "from", "a", "text", "file", "produced", "by", "WriteLLVMChecksums", "." ]

[ "def", "ReadLLVMChecksums", "(", "f", ")", ":", "checksums", "=", "{", "}", "while", "True", ":", "line", "=", "f", ".", "readline", "(", ")", "if", "line", "==", "\"\"", ":", "break", "checksum", ",", "proj", "=", "line", ".", "split", "(", ")", "checksums", "[", "proj", "]", "=", "checksum", "return", "checksums" ]

[ "Get", "the", "name", "of", "the", "task", "that", "runs", "one", "of", "the", "generated", "sub", "-", "suites", "." ]

[ "def", "sub_suite_task_name", "(", "self", ",", "index", ":", "Optional", "[", "int", "]", "=", "None", ")", "->", "str", ":", "return", "taskname", ".", "name_generated_task", "(", "self", ".", "task_name", ",", "index", ",", "len", "(", "self", ".", "sub_suites", ")", ",", "self", ".", "build_variant", ")" ]

[ "Run", "checks", "that", "applies", "to", "text", "up", "to", "the", "opening", "brace", "." ]

[ "def", "CheckBegin", "(", "self", ",", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "pass" ]

[ "check", "so", "that", "the", "text", "poly", "is", "in", "the", "same", "direction", "and", "also", "filter", "some", "invalid", "polygons", ":", "param", "polys", ":", ":", "param", "tags", ":", ":", "return", ":" ]

[ "def", "check_and_validate_polys", "(", "polys", ",", "tags", ",", "xxx_todo_changeme", ")", ":", "(", "h", ",", "w", ")", "=", "xxx_todo_changeme", "if", "polys", ".", "shape", "[", "0", "]", "==", "0", ":", "return", "polys", "polys", "[", ":", ",", ":", ",", "0", "]", "=", "np", ".", "clip", "(", "polys", "[", ":", ",", ":", ",", "0", "]", ",", "0", ",", "w", "-", "1", ")", "polys", "[", ":", ",", ":", ",", "1", "]", "=", "np", ".", "clip", "(", "polys", "[", ":", ",", ":", ",", "1", "]", ",", "0", ",", "h", "-", "1", ")", "validated_polys", "=", "[", "]", "validated_tags", "=", "[", "]", "for", "poly", ",", "tag", "in", "zip", "(", "polys", ",", "tags", ")", ":", "p_area", "=", "polygon_area", "(", "poly", ")", "if", "abs", "(", "p_area", ")", "<", "1", ":", "# print poly", "print", "(", "'invalid poly'", ")", "continue", "if", "p_area", ">", "0", ":", "print", "(", "'poly in wrong direction'", ")", "poly", "=", "poly", "[", "(", "0", ",", "3", ",", "2", ",", "1", ")", ",", ":", "]", "validated_polys", ".", "append", "(", "poly", ")", "validated_tags", ".", "append", "(", "tag", ")", "return", "np", ".", "array", "(", "validated_polys", ")", ",", "np", ".", "array", "(", "validated_tags", ")" ]

[ "Returns", "the", "lib", "dir", "according", "to", "the", "debian", "system", "." ]

[ "def", "GetDebLibDir", "(", ")", ":", "# We're on Debian or Ubuntu, which use multiarch directories.", "# Call dpkg-architecture to get the multiarch libdir.", "handle", "=", "os", ".", "popen", "(", "\"dpkg-architecture -qDEB_HOST_MULTIARCH\"", ")", "multiarch", "=", "handle", ".", "read", "(", ")", ".", "strip", "(", ")", "if", "handle", ".", "close", "(", ")", ":", "# It failed. Old Debian/Ubuntu version?", "pass", "elif", "len", "(", "multiarch", ")", ">", "0", ":", "return", "\"lib/\"", "+", "multiarch", "return", "\"lib\"" ]

[ "Generate", "the", "Friedman", "\\", "#2", "regression", "problem" ]

[ "def", "make_friedman2", "(", "n_samples", "=", "100", ",", "noise", "=", "0.0", ",", "random_state", "=", "None", ")", ":", "generator", "=", "check_random_state", "(", "random_state", ")", "X", "=", "generator", ".", "rand", "(", "n_samples", ",", "4", ")", "X", "[", ":", ",", "0", "]", "*=", "100", "X", "[", ":", ",", "1", "]", "*=", "520", "*", "np", ".", "pi", "X", "[", ":", ",", "1", "]", "+=", "40", "*", "np", ".", "pi", "X", "[", ":", ",", "3", "]", "*=", "10", "X", "[", ":", ",", "3", "]", "+=", "1", "y", "=", "(", "X", "[", ":", ",", "0", "]", "**", "2", "+", "(", "X", "[", ":", ",", "1", "]", "*", "X", "[", ":", ",", "2", "]", "-", "1", "/", "(", "X", "[", ":", ",", "1", "]", "*", "X", "[", ":", ",", "3", "]", ")", ")", "**", "2", ")", "**", "0.5", "+", "noise", "*", "generator", ".", "randn", "(", "n_samples", ")", "return", "X", ",", "y" ]

[ "Initializes", "a", "SummarySaver", "monitor", "." ]

[ "def", "__init__", "(", "self", ",", "save_steps", "=", "100", ",", "output_dir", "=", "None", ",", "summary_writer", "=", "None", ",", "scaffold", "=", "None", ",", "summary_op", "=", "None", ")", ":", "# TODO(ipolosukhin): Implement every N seconds.", "self", ".", "_summary_op", "=", "summary_op", "self", ".", "_summary_writer", "=", "summary_writer", "if", "summary_writer", "is", "None", "and", "output_dir", ":", "self", ".", "_summary_writer", "=", "SummaryWriterCache", ".", "get", "(", "output_dir", ")", "self", ".", "_scaffold", "=", "scaffold", "self", ".", "_save_steps", "=", "save_steps" ]

[ "Find", "the", "beginning", "marker", "for", "a", "multiline", "comment", "." ]

[ "def", "FindNextMultiLineCommentStart", "(", "lines", ",", "lineix", ")", ":", "while", "lineix", "<", "len", "(", "lines", ")", ":", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "startswith", "(", "'/*'", ")", ":", "# Only return this marker if the comment goes beyond this line", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "find", "(", "'*/'", ",", "2", ")", "<", "0", ":", "return", "lineix", "lineix", "+=", "1", "return", "len", "(", "lines", ")" ]

[ "Return", "the", "list", "of", "node", "field", "values", "for", "the", "given", "field", "and", "timestep", "." ]

[ "def", "get_node_field_values", "(", "self", ",", "node_field_name", ",", "timestep", "=", "'last'", ")", ":", "[", "node_field_name", "]", "=", "self", ".", "_format_id_list", "(", "[", "node_field_name", "]", ",", "self", ".", "get_node_field_names", "(", ")", ",", "'node field'", ",", "single", "=", "True", ")", "timestep_index", "=", "self", ".", "_get_internal_timestep_index", "(", "timestep", ")", "return", "self", ".", "node_fields", "[", "node_field_name", "]", "[", "timestep_index", "]" ]

[ "Wraps", "the", "XLA", "ReduceWindow", "operator", "." ]

[ "def", "reduce_window", "(", "operand", ",", "init", ",", "reducer", ",", "window_dimensions", ",", "window_strides", "=", "None", ",", "base_dilations", "=", "None", ",", "window_dilations", "=", "None", ",", "padding", "=", "None", ",", "name", "=", "None", ")", ":", "window_strides", "=", "window_strides", "or", "[", "1", "]", "*", "len", "(", "window_dimensions", ")", "base_dilations", "=", "base_dilations", "or", "[", "1", "]", "*", "len", "(", "window_dimensions", ")", "window_dilations", "=", "window_dilations", "or", "[", "1", "]", "*", "len", "(", "window_dimensions", ")", "padding", "=", "padding", "or", "[", "(", "0", ",", "0", ")", "]", "*", "len", "(", "window_dimensions", ")", "return", "gen_xla_ops", ".", "xla_reduce_window", "(", "input", "=", "operand", ",", "init_value", "=", "init", ",", "window_dimensions", "=", "window_dimensions", ",", "window_strides", "=", "window_strides", ",", "base_dilations", "=", "base_dilations", ",", "window_dilations", "=", "window_dilations", ",", "padding", "=", "padding", ",", "computation", "=", "reducer", ",", "name", "=", "name", ")" ]

[ "Registers", "the", "given", "message", "type", "in", "the", "local", "database", "." ]

[ "def", "RegisterMessage", "(", "self", ",", "message", ")", ":", "desc", "=", "message", ".", "DESCRIPTOR", "self", ".", "_classes", "[", "desc", "]", "=", "message", "self", ".", "RegisterMessageDescriptor", "(", "desc", ")", "return", "message" ]

[ "Initialize", "metrics", "once", "right", "after", "the", "browser", "has", "been", "launched", "." ]

[ "def", "DidStartBrowser", "(", "self", ",", "browser", ")", ":", "self", ".", "_memory_metric", "=", "memory", ".", "MemoryMetric", "(", "browser", ")", "self", ".", "_v8_object_stats_metric", "=", "(", "v8_object_stats", ".", "V8ObjectStatsMetric", "(", "_V8_COUNTER_NAMES", ")", ")" ]

[ "Switch", "on", "the", "generation", "of", "line", "number", "for", "elements", "nodes", "." ]

[ "def", "lineNumbers", "(", "self", ",", "linenumbers", ")", ":", "libxml2mod", ".", "xmlParserSetLineNumbers", "(", "self", ".", "_o", ",", "linenumbers", ")" ]

[ "See", "module", "docstring", "." ]

[ "def", "MoveExtendPropertiesBackIntoClassesInPlace", "(", "ast", ",", "class_decls_by_fq_native", ")", ":", "extend_properties_orig_decl_indices", "=", "[", "]", "for", "orig_decl_index", ",", "decl", "in", "enumerate", "(", "ast", ".", "decls", ")", ":", "if", "decl", ".", "decltype", "!=", "ast_pb2", ".", "Decl", ".", "Type", ".", "VAR", ":", "continue", "if", "not", "decl", ".", "var", ".", "is_extend_variable", ":", "continue", "fq_native_from_var", ",", "property_name_from_var", "=", "decl", ".", "var", ".", "name", ".", "native", ".", "split", "(", "EXTEND_INFIX", ",", "1", ")", "target_class_decl", "=", "class_decls_by_fq_native", "[", "fq_native_from_var", "]", "property_decl", "=", "ast_pb2", ".", "Decl", "(", ")", "property_decl", ".", "CopyFrom", "(", "decl", ")", "property_decl", ".", "var", ".", "name", ".", "native", "=", "property_name_from_var", "if", "property_decl", ".", "var", ".", "HasField", "(", "'cpp_set'", ")", ":", "del", "property_decl", ".", "var", ".", "cpp_set", ".", "params", "[", "0", "]", "target_class_decl", ".", "members", ".", "append", "(", "property_decl", ")", "extend_properties_orig_decl_indices", ".", "append", "(", "orig_decl_index", ")", "for", "orig_decl_index", "in", "reversed", "(", "extend_properties_orig_decl_indices", ")", ":", "del", "ast", ".", "decls", "[", "orig_decl_index", "]" ]

[ "Construct", "Protobuf", "message", "for", "Python", "data", "reader", "." ]

[ "def", "construct_data_reader", "(", "run_args", ")", ":", "module_file", "=", "os", ".", "path", ".", "abspath", "(", "run_args", ".", "data_module_file", ")", "os", ".", "environ", "[", "\"DATA_CONFIG\"", "]", "=", "os", ".", "path", ".", "abspath", "(", "run_args", ".", "data_config", ")", "module_name", "=", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "module_file", ")", ")", "[", "0", "]", "module_dir", "=", "os", ".", "path", ".", "dirname", "(", "module_file", ")", "print", "(", "\"module_name: {}\\tmodule_dir: {}\"", ".", "format", "(", "module_name", ",", "module_dir", ")", ")", "# Base data reader message", "message", "=", "lbann", ".", "reader_pb2", ".", "DataReader", "(", ")", "# Training set data reader", "data_reader", "=", "message", ".", "reader", ".", "add", "(", ")", "data_reader", ".", "name", "=", "\"python\"", "data_reader", ".", "role", "=", "\"train\"", "data_reader", ".", "shuffle", "=", "True", "data_reader", ".", "percent_of_data_to_use", "=", "1.0", "data_reader", ".", "python", ".", "module", "=", "module_name", "data_reader", ".", "python", ".", "module_dir", "=", "module_dir", "data_reader", ".", "python", ".", "sample_function", "=", "\"get_sample\"", "data_reader", ".", "python", ".", "num_samples_function", "=", "\"num_samples\"", "data_reader", ".", "python", ".", "sample_dims_function", "=", "\"sample_dims\"", "return", "message" ]

[ "Checks", "for", "calls", "to", "thread", "-", "unsafe", "functions", "." ]

[ "def", "CheckPosixThreading", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "for", "single_thread_function", ",", "multithread_safe_function", "in", "threading_list", ":", "ix", "=", "line", ".", "find", "(", "single_thread_function", ")", "# Comparisons made explicit for clarity -- pylint: disable=g-explicit-bool-comparison", "if", "ix", ">=", "0", "and", "(", "ix", "==", "0", "or", "(", "not", "line", "[", "ix", "-", "1", "]", ".", "isalnum", "(", ")", "and", "line", "[", "ix", "-", "1", "]", "not", "in", "(", "'_'", ",", "'.'", ",", "'>'", ")", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/threadsafe_fn'", ",", "2", ",", "'Consider using '", "+", "multithread_safe_function", "+", "'...) instead of '", "+", "single_thread_function", "+", "'...) for improved thread safety.'", ")" ]

[ "GetDefaultStyle", "(", "self", ")", "-", ">", "RichTextAttr" ]

[ "def", "GetDefaultStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextCtrl_GetDefaultStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Remove", "all", "asserted", "constraints", "and", "backtracking", "points", "created", "using", "push", "()", "." ]

[ "def", "reset", "(", "self", ")", ":", "Z3_solver_reset", "(", "self", ".", "ctx", ".", "ref", "(", ")", ",", "self", ".", "solver", ")" ]

[ "Read", "warnings", "from", "HTML", "pages", ".", "-", "root", "pages", "are", "defined", "in", "URLS", "-", "special", "property", "values", "are", "defined", "in", "RULE_MAP" ]

[ "def", "read_warnings", "(", ")", ":", "# page contains JavaScript. Use Firefox to create HTML page", "# you have to download and install https://github.com/mozilla/geckodriver/releases", "browser", "=", "webdriver", ".", "Firefox", "(", "executable_path", "=", "r'C:\\Program Files\\geckodriver\\geckodriver.exe'", ")", "# read links to warning pages from menu of overview pages", "warnings", "=", "{", "}", "for", "url", ",", "properties", "in", "URLS", ".", "items", "(", ")", ":", "page_source", "=", "read_page_source", "(", "browser", ",", "url", ")", "parse_warning_hrefs", "(", "page_source", ",", "warnings", ")", "for", "key", ",", "warning", "in", "warnings", ".", "items", "(", ")", ":", "assign_warning_properties", "(", "warning", ",", "properties", ",", "False", ")", "# warnings = dict(list(warnings.items())[:1]) # for testing only", "# sort warnings ascending by message number", "warnings", "=", "dict", "(", "sorted", "(", "warnings", ".", "items", "(", ")", ",", "key", "=", "sorter", ")", ")", "# read cotent of warning pages", "read_warning_pages", "(", "browser", ",", "warnings", ")", "# override defaults", "for", "key", ",", "defaults", "in", "RULE_MAP", ".", "items", "(", ")", ":", "if", "key", "in", "warnings", ":", "warning", "=", "warnings", "[", "key", "]", "assign_warning_properties", "(", "warning", ",", "defaults", ",", "True", ")", "# close browser", "browser", ".", "quit", "(", ")", "return", "warnings" ]

[ "Locate", "an", "object", "by", "name", "or", "dotted", "path", "importing", "as", "necessary", "." ]

[ "def", "locate", "(", "path", ",", "forceload", "=", "0", ")", ":", "parts", "=", "[", "part", "for", "part", "in", "path", ".", "split", "(", "'.'", ")", "if", "part", "]", "module", ",", "n", "=", "None", ",", "0", "while", "n", "<", "len", "(", "parts", ")", ":", "nextmodule", "=", "safeimport", "(", "'.'", ".", "join", "(", "parts", "[", ":", "n", "+", "1", "]", ")", ",", "forceload", ")", "if", "nextmodule", ":", "module", ",", "n", "=", "nextmodule", ",", "n", "+", "1", "else", ":", "break", "if", "module", ":", "object", "=", "module", "else", ":", "object", "=", "builtins", "for", "part", "in", "parts", "[", "n", ":", "]", ":", "try", ":", "object", "=", "getattr", "(", "object", ",", "part", ")", "except", "AttributeError", ":", "return", "None", "return", "object" ]

[ "AssignButtonsImageList", "(", "self", "ImageList", "imageList", ")" ]

[ "def", "AssignButtonsImageList", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "TreeListCtrl_AssignButtonsImageList", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Encodes", "a", "unicode", "value", "to", "UTF", "-", "8", "if", "not", "yet", "encoded", "." ]

[ "def", "_to_utf8", "(", "value", ")", ":", "if", "isinstance", "(", "value", ",", "str", ")", ":", "return", "value", "return", "value", ".", "encode", "(", "'utf-8'", ")" ]

[ "Gets", "all", "levels", "of", "nested", "message", "types", "as", "a", "flattened", "list", "of", "descriptors", "." ]

[ "def", "_GetAllDescriptors", "(", "desc_protos", ",", "package", ")", ":", "for", "desc_proto", "in", "desc_protos", ":", "name", "=", "'.'", ".", "join", "(", "(", "package", ",", "desc_proto", ".", "name", ")", ")", "yield", "_POOL", ".", "FindMessageTypeByName", "(", "name", ")", "for", "nested_desc", "in", "_GetAllDescriptors", "(", "desc_proto", ".", "nested_type", ",", "name", ")", ":", "yield", "nested_desc" ]

[ "Enables", "batch", "request", "for", "the", "method", "classname", ".", "name", "." ]

[ "def", "_batchnize", "(", "classname", ",", "name", ")", ":", "func", "=", "getattr", "(", "classname", ",", "name", ",", "None", ")", "def", "_func", "(", "v", ",", "n", ")", ":", "if", "type", "(", "n", ")", "is", "int", "and", "(", "n", "<", "0", "or", "n", ">=", "v", ".", "piece_size", "(", ")", ")", ":", "raise", "IndexError", "(", "'piece id is out of range.'", ")", "return", "func", "(", "v", ",", "n", ")", "def", "_batched_func", "(", "self", ",", "arg", ")", ":", "if", "type", "(", "arg", ")", "is", "list", ":", "return", "[", "_func", "(", "self", ",", "n", ")", "for", "n", "in", "arg", "]", "else", ":", "return", "_func", "(", "self", ",", "arg", ")", "setattr", "(", "classname", ",", "name", ",", "_batched_func", ")" ]

[ "Mean", "of", "a", "tensor", "alongside", "the", "specified", "axis", "." ]

[ "def", "mean", "(", "x", ",", "axis", "=", "None", ",", "keepdims", "=", "False", ")", ":", "axis", "=", "_normalize_axis", "(", "axis", ",", "ndim", "(", "x", ")", ")", "if", "x", ".", "dtype", ".", "base_dtype", "==", "dtypes_module", ".", "bool", ":", "x", "=", "math_ops", ".", "cast", "(", "x", ",", "floatx", "(", ")", ")", "return", "math_ops", ".", "reduce_mean", "(", "x", ",", "axis", "=", "axis", ",", "keep_dims", "=", "keepdims", ")" ]

[ "Callback", "to", "toggle", "capture", "." ]

[ "def", "on_toggle_capture", "(", "self", ",", "is_enabled", ")", ":", "self", ".", "pipeline_model", ".", "flag_capture", "=", "is_enabled", "if", "not", "is_enabled", ":", "self", ".", "on_toggle_record", "(", "False", ")", "if", "self", ".", "pipeline_view", ".", "toggle_record", "is", "not", "None", ":", "self", ".", "pipeline_view", ".", "toggle_record", ".", "is_on", "=", "False", "else", ":", "with", "self", ".", "pipeline_model", ".", "cv_capture", ":", "self", ".", "pipeline_model", ".", "cv_capture", ".", "notify", "(", ")" ]

[ "Returns", "the", "build", "type", "of", "the", "system", "(", "e", ".", "g", ".", "eng", ")", "." ]

[ "def", "GetBuildType", "(", "self", ")", ":", "build_type", "=", "self", ".", "system_properties", "[", "'ro.build.type'", "]", "assert", "build_type", "return", "build_type" ]

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

[ "Enable", "or", "disable", "bold", "depending", "on", "the", "on", "parameter", "." ]

[ "def", "bold", "(", "self", ",", "on", "=", "True", ")", ":", "if", "self", ".", "enabled", ":", "if", "on", ":", "return", "\"\\x1b[1m\"", "else", ":", "return", "\"\\x1b[22m\"", "return", "''" ]

[ "getNetBoundary", "()", "-", ">", "((", "double", "double", ")", "(", "double", "double", "))" ]

[ "def", "getNetBoundary", "(", "self", ")", ":", "return", "self", ".", "_getUniversal", "(", "tc", ".", "VAR_NET_BOUNDING_BOX", ")" ]

[ "Removes", "all", "conditional", "properties", "which", "conditions", "are", "not", "met", "For", "those", "with", "met", "conditions", "removes", "the", "condition", ".", "Properies", "in", "conditions", "are", "looked", "up", "in", "context" ]

[ "def", "evaluate_conditionals_in_context", "(", "properties", ",", "context", ")", ":", "if", "__debug__", ":", "from", ".", "property_set", "import", "PropertySet", "assert", "is_iterable_typed", "(", "properties", ",", "Property", ")", "assert", "isinstance", "(", "context", ",", "PropertySet", ")", "base", "=", "[", "]", "conditional", "=", "[", "]", "for", "p", "in", "properties", ":", "if", "p", ".", "condition", ":", "conditional", ".", "append", "(", "p", ")", "else", ":", "base", ".", "append", "(", "p", ")", "result", "=", "base", "[", ":", "]", "for", "p", "in", "conditional", ":", "# Evaluate condition", "# FIXME: probably inefficient", "if", "all", "(", "x", "in", "context", "for", "x", "in", "p", ".", "condition", ")", ":", "result", ".", "append", "(", "Property", "(", "p", ".", "feature", ",", "p", ".", "value", ")", ")", "return", "result" ]

[ "Return", "a", "tuple", "of", "the", "installation", "directory", "of", "the", "module", "s", ".", "sip", "files", "and", "a", "sequence", "of", "the", "names", "of", "each", "of", "the", ".", "sip", "files", "relative", "to", "the", "directory", "containing", "this", "configuration", "script", ".", "None", "is", "returned", "if", "the", "module", "s", ".", "sip", "files", "are", "not", "to", "be", "installed", ".", "target_configuration", "is", "the", "target", "configuration", "." ]

[ "def", "get_sip_installs", "(", "self", ",", "target_configuration", ")", ":", "if", "target_configuration", ".", "qsci_sip_dir", "==", "''", ":", "return", "None", "path", "=", "os", ".", "path", ".", "join", "(", "target_configuration", ".", "qsci_sip_dir", ",", "'Qsci'", ")", "files", "=", "glob", ".", "glob", "(", "'sip/*.sip'", ")", "return", "path", ",", "files" ]

[ "Gets", "a", "dict", "of", "test", "suite", "path", "to", "sub", "test", "dict", "." ]

[ "def", "_GetSubTestDict", "(", "test_paths", ")", ":", "subtests", "=", "{", "}", "for", "test_path", "in", "test_paths", ":", "path_parts", "=", "test_path", ".", "split", "(", "'/'", ")", "bot_path", "=", "'/'", ".", "join", "(", "path_parts", "[", "0", ":", "2", "]", ")", "test_suite_path", "=", "'/'", ".", "join", "(", "path_parts", "[", "0", ":", "3", "]", ")", "test_suite", "=", "path_parts", "[", "2", "]", "if", "test_suite_path", "not", "in", "subtests", ":", "subtests", "[", "test_suite_path", "]", "=", "{", "}", "subtests", "[", "test_suite_path", "]", "=", "list_tests", ".", "GetSubTests", "(", "test_suite", ",", "[", "bot_path", "]", ")", "return", "subtests" ]

[ "Define", "operators", "in", "each", "step", ".", "step", "is", "used", "in", ":", "code", ":", "with", "block", "OP", "in", ":", "code", ":", "with", "block", "will", "be", "executed", "sequence_len", "times", "(", "sequence_len", "is", "the", "length", "of", "input", ")" ]

[ "def", "step", "(", "self", ")", ":", "return", "BlockGuardWithCompletion", "(", "self", ")" ]