Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Return", "a", "string", "which", "is", "the", "concatenation", "of", "the", "strings", "in", "the", "sequence", ".", "The", "separator", "between", "elements", "is", "an", "empty", "string", "per", "default", "you", "can", "define", "it", "with", "the", "optional", "parameter", ":" ]

[ "def", "do_join", "(", "eval_ctx", ",", "value", ",", "d", "=", "u''", ",", "attribute", "=", "None", ")", ":", "if", "attribute", "is", "not", "None", ":", "value", "=", "imap", "(", "make_attrgetter", "(", "eval_ctx", ".", "environment", ",", "attribute", ")", ",", "value", ")", "# no automatic escaping? joining is a lot eaiser then", "if", "not", "eval_ctx", ".", "autoescape", ":", "return", "text_type", "(", "d", ")", ".", "join", "(", "imap", "(", "text_type", ",", "value", ")", ")", "# if the delimiter doesn't have an html representation we check", "# if any of the items has. If yes we do a coercion to Markup", "if", "not", "hasattr", "(", "d", ",", "'__html__'", ")", ":", "value", "=", "list", "(", "value", ")", "do_escape", "=", "False", "for", "idx", ",", "item", "in", "enumerate", "(", "value", ")", ":", "if", "hasattr", "(", "item", ",", "'__html__'", ")", ":", "do_escape", "=", "True", "else", ":", "value", "[", "idx", "]", "=", "text_type", "(", "item", ")", "if", "do_escape", ":", "d", "=", "escape", "(", "d", ")", "else", ":", "d", "=", "text_type", "(", "d", ")", "return", "d", ".", "join", "(", "value", ")", "# no html involved, to normal joining", "return", "soft_unicode", "(", "d", ")", ".", "join", "(", "imap", "(", "soft_unicode", ",", "value", ")", ")" ]

[ "The", "whitespace", "and", "comments", "preceding", "this", "node", "in", "the", "input", "." ]

[ "def", "prefix", "(", "self", ")", ":", "if", "not", "self", ".", "children", ":", "return", "\"\"", "return", "self", ".", "children", "[", "0", "]", ".", "prefix" ]

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

[ "def", "_get_train_ops", "(", "self", ",", "features", ",", "targets", ")", ":", "self", ".", "_validate_dnn_feature_columns", "(", "features", ")", "return", "super", "(", "DNNClassifier", ",", "self", ")", ".", "_get_train_ops", "(", "features", ",", "targets", ")" ]

[ "Apply", "the", "given", "list", "of", "type", "recognizers", "to", "the", "type", "TYPE_OBJ", ".", "If", "any", "recognizer", "in", "the", "list", "recognizes", "TYPE_OBJ", "returns", "the", "name", "given", "by", "the", "recognizer", ".", "Otherwise", "this", "returns", "None", "." ]

[ "def", "apply_type_recognizers", "(", "recognizers", ",", "type_obj", ")", ":", "for", "r", "in", "recognizers", ":", "result", "=", "r", ".", "recognize", "(", "type_obj", ")", "if", "result", "is", "not", "None", ":", "return", "result", "return", "None" ]

[ "Return", "the", "maximum", "distance", "between", "input", "and", "points", "in", "the", "hyperrectangle", "." ]

[ "def", "max_distance_point", "(", "self", ",", "x", ",", "p", "=", "2.", ")", ":", "return", "minkowski_distance", "(", "0", ",", "np", ".", "maximum", "(", "self", ".", "maxes", "-", "x", ",", "x", "-", "self", ".", "mins", ")", ",", "p", ")" ]

[ "Return", "long", "version", "(", "X", ".", "Y", ".", "Z", ")", "for", "the", "Python", "distribution", "located", "in", "*", "path", "*" ]

[ "def", "get_python_long_version", "(", "path", ")", ":", "ver", "=", "python_query", "(", "\"import sys; print('%d.%d.%d' % \"", "\"(sys.version_info.major, sys.version_info.minor,\"", "\"sys.version_info.micro))\"", ",", "path", ")", "if", "re", ".", "match", "(", "r'([0-9]*)\\.([0-9]*)\\.([0-9]*)'", ",", "ver", ")", "is", "None", ":", "ver", "=", "None", "return", "ver" ]

[ "The", "last", "highlight", "created", "will", "be", "removed", "after", "FLASH_DELAY", "millisecs" ]

[ "def", "set_timeout_last", "(", "self", ")", ":", "# associate a counter with an event; only disable the \"paren\"", "# tag if the event is for the most recent timer.", "self", ".", "counter", "+=", "1", "self", ".", "editwin", ".", "text_frame", ".", "after", "(", "self", ".", "FLASH_DELAY", ",", "lambda", "self", "=", "self", ",", "c", "=", "self", ".", "counter", ":", "self", ".", "handle_restore_timer", "(", "c", ")", ")" ]

[ "r", "Return", "Regex", "with", "an", "attached", "parse", "action", "to", "transform", "the", "parsed", "result", "as", "if", "called", "using", "re", ".", "sub", "(", "expr", "repl", "string", ")", "<https", ":", "//", "docs", ".", "python", ".", "org", "/", "3", "/", "library", "/", "re", ".", "html#re", ".", "sub", ">", "_", "." ]

[ "def", "sub", "(", "self", ",", "repl", ")", ":", "if", "self", ".", "asGroupList", ":", "warnings", ".", "warn", "(", "\"cannot use sub() with Regex(asGroupList=True)\"", ",", "SyntaxWarning", ",", "stacklevel", "=", "2", ")", "raise", "SyntaxError", "(", ")", "if", "self", ".", "asMatch", "and", "callable", "(", "repl", ")", ":", "warnings", ".", "warn", "(", "\"cannot use sub() with a callable with Regex(asMatch=True)\"", ",", "SyntaxWarning", ",", "stacklevel", "=", "2", ")", "raise", "SyntaxError", "(", ")", "if", "self", ".", "asMatch", ":", "def", "pa", "(", "tokens", ")", ":", "return", "tokens", "[", "0", "]", ".", "expand", "(", "repl", ")", "else", ":", "def", "pa", "(", "tokens", ")", ":", "return", "self", ".", "re", ".", "sub", "(", "repl", ",", "tokens", "[", "0", "]", ")", "return", "self", ".", "addParseAction", "(", "pa", ")" ]

[ "Sets", "the", "status", "of", "entryPath", "to", "be", "status", ".", "A", "bitmap", "will", "be", "displayed", "next", "to", "the", "entry", "its", "status", "is", "on", "off", "or", "default", "." ]

[ "def", "setstatus", "(", "self", ",", "entrypath", ",", "mode", "=", "'on'", ")", ":", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'setstatus'", ",", "entrypath", ",", "mode", ")" ]

[ "Reverse", "the", "object", "or", "return", "an", "iterator", "that", "iterates", "over", "it", "the", "other", "way", "round", "." ]

[ "def", "do_reverse", "(", "value", ":", "t", ".", "Union", "[", "str", ",", "t", ".", "Iterable", "[", "V", "]", "]", ")", "->", "t", ".", "Union", "[", "str", ",", "t", ".", "Iterable", "[", "V", "]", "]", ":", "if", "isinstance", "(", "value", ",", "str", ")", ":", "return", "value", "[", ":", ":", "-", "1", "]", "try", ":", "return", "reversed", "(", "value", ")", "# type: ignore", "except", "TypeError", ":", "try", ":", "rv", "=", "list", "(", "value", ")", "rv", ".", "reverse", "(", ")", "return", "rv", "except", "TypeError", "as", "e", ":", "raise", "FilterArgumentError", "(", "\"argument must be iterable\"", ")", "from", "e" ]

[ "Sets", "the", "return", "value", "of", "work", "associated", "with", "the", "future", "." ]

[ "def", "set_result", "(", "self", ",", "result", ")", ":", "with", "self", ".", "_condition", ":", "if", "self", ".", "_state", "in", "{", "CANCELLED", ",", "CANCELLED_AND_NOTIFIED", ",", "FINISHED", "}", ":", "raise", "InvalidStateError", "(", "'{}: {!r}'", ".", "format", "(", "self", ".", "_state", ",", "self", ")", ")", "self", ".", "_result", "=", "result", "self", ".", "_state", "=", "FINISHED", "for", "waiter", "in", "self", ".", "_waiters", ":", "waiter", ".", "add_result", "(", "self", ")", "self", ".", "_condition", ".", "notify_all", "(", ")", "self", ".", "_invoke_callbacks", "(", ")" ]

[ "The", "user", "selected", "the", "menu", "entry", "or", "hotkey", "open", "the", "tip", "." ]

[ "def", "force_open_calltip_event", "(", "self", ",", "event", ")", ":", "self", ".", "open_calltip", "(", "True", ")", "return", "\"break\"" ]

[ "Grep", "for", "search", "pattern", "in", "file", "path", ".", "The", "default", "command", "is", "bound", "to", "<Return", ">", "." ]

[ "def", "default_command", "(", "self", ",", "event", "=", "None", ")", ":", "prog", "=", "self", ".", "engine", ".", "getprog", "(", ")", "if", "not", "prog", ":", "return", "path", "=", "self", ".", "globvar", ".", "get", "(", ")", "if", "not", "path", ":", "self", ".", "top", ".", "bell", "(", ")", "return", "from", "idlelib", ".", "outwin", "import", "OutputWindow", "# leave here!", "save", "=", "sys", ".", "stdout", "try", ":", "sys", ".", "stdout", "=", "OutputWindow", "(", "self", ".", "flist", ")", "self", ".", "grep_it", "(", "prog", ",", "path", ")", "finally", ":", "sys", ".", "stdout", "=", "save" ]

[ "Clear", "(", "self", ")" ]

[ "def", "Clear", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "Clipboard_Clear", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Create", "the", "full", "SV", "locus", "graph" ]

[ "def", "runLocusGraph", "(", "self", ",", "taskPrefix", "=", "\"\"", ",", "dependencies", "=", "None", ")", ":", "statsPath", "=", "self", ".", "paths", ".", "getStatsPath", "(", ")", "graphPath", "=", "self", ".", "paths", ".", "getGraphPath", "(", ")", "graphStatsPath", "=", "self", ".", "paths", ".", "getGraphStatsPath", "(", ")", "tmpGraphDir", "=", "self", ".", "paths", ".", "getTmpGraphDir", "(", ")", "makeTmpGraphDirCmd", "=", "getMkdirCmd", "(", ")", "+", "[", "tmpGraphDir", "]", "dirTask", "=", "self", ".", "addTask", "(", "preJoin", "(", "taskPrefix", ",", "\"makeGraphTmpDir\"", ")", ",", "makeTmpGraphDirCmd", ",", "dependencies", "=", "dependencies", ",", "isForceLocal", "=", "True", ")", "tmpGraphFiles", "=", "[", "]", "graphTasks", "=", "set", "(", ")", "for", "gsegGroup", "in", "getGenomeSegmentGroups", "(", "getNextGenomeSegment", "(", "self", ".", "params", ")", ")", ":", "assert", "(", "len", "(", "gsegGroup", ")", "!=", "0", ")", "gid", "=", "gsegGroup", "[", "0", "]", ".", "id", "if", "len", "(", "gsegGroup", ")", ">", "1", ":", "gid", "+=", "\"_to_\"", "+", "gsegGroup", "[", "-", "1", "]", ".", "id", "tmpGraphFiles", ".", "append", "(", "self", ".", "paths", ".", "getTmpGraphFile", "(", "gid", ")", ")", "graphCmd", "=", "[", "self", ".", "params", ".", "mantaGraphBin", "]", "graphCmd", ".", "extend", "(", "[", "\"--output-file\"", ",", "tmpGraphFiles", "[", "-", "1", "]", "]", ")", "graphCmd", ".", "extend", "(", "[", "\"--align-stats\"", ",", "statsPath", "]", ")", "for", "gseg", "in", "gsegGroup", ":", "graphCmd", ".", "extend", "(", "[", "\"--region\"", ",", "gseg", ".", "bamRegion", "]", ")", "graphCmd", ".", "extend", "(", "[", "\"--min-candidate-sv-size\"", ",", "self", ".", "params", ".", "minCandidateVariantSize", "]", ")", "graphCmd", ".", "extend", "(", "[", "\"--min-edge-observations\"", ",", "self", ".", "params", ".", "minEdgeObservations", "]", ")", "graphCmd", ".", "extend", "(", "[", "\"--ref\"", ",", "self", ".", "params", ".", "referenceFasta", "]", ")", "for", "bamPath", "in", "self", ".", "params", ".", "normalBamList", ":", "graphCmd", ".", "extend", "(", "[", "\"--align-file\"", ",", "bamPath", "]", ")", "for", "bamPath", "in", "self", ".", "params", ".", "tumorBamList", ":", "graphCmd", ".", "extend", "(", "[", "\"--tumor-align-file\"", ",", "bamPath", "]", ")", "if", "self", ".", "params", ".", "isHighDepthFilter", ":", "graphCmd", ".", "extend", "(", "[", "\"--chrom-depth\"", ",", "self", ".", "paths", ".", "getChromDepth", "(", ")", "]", ")", "if", "self", ".", "params", ".", "isIgnoreAnomProperPair", ":", "graphCmd", ".", "append", "(", "\"--ignore-anom-proper-pair\"", ")", "if", "self", ".", "params", ".", "isRNA", ":", "graphCmd", ".", "append", "(", "\"--rna\"", ")", "graphTask", "=", "preJoin", "(", "taskPrefix", ",", "\"makeLocusGraph_\"", "+", "gid", ")", "graphTasks", ".", "add", "(", "self", ".", "addTask", "(", "graphTask", ",", "graphCmd", ",", "dependencies", "=", "dirTask", ",", "memMb", "=", "self", ".", "params", ".", "estimateMemMb", ")", ")", "if", "len", "(", "tmpGraphFiles", ")", "==", "0", ":", "raise", "Exception", "(", "\"No SV Locus graphs to create. Possible target region parse error.\"", ")", "tmpGraphFileList", "=", "self", ".", "paths", ".", "getTmpGraphFileListPath", "(", ")", "tmpGraphFileListTask", "=", "preJoin", "(", "taskPrefix", ",", "\"mergeLocusGraphInputList\"", ")", "self", ".", "addWorkflowTask", "(", "tmpGraphFileListTask", ",", "listFileWorkflow", "(", "tmpGraphFileList", ",", "tmpGraphFiles", ")", ",", "dependencies", "=", "graphTasks", ")", "mergeCmd", "=", "[", "self", ".", "params", ".", "mantaGraphMergeBin", "]", "mergeCmd", ".", "extend", "(", "[", "\"--output-file\"", ",", "graphPath", "]", ")", "mergeCmd", ".", "extend", "(", "[", "\"--graph-file-list\"", ",", "tmpGraphFileList", "]", ")", "mergeTask", "=", "self", ".", "addTask", "(", "preJoin", "(", "taskPrefix", ",", "\"mergeLocusGraph\"", ")", ",", "mergeCmd", ",", "dependencies", "=", "tmpGraphFileListTask", ",", "memMb", "=", "self", ".", "params", ".", "mergeMemMb", ")", "# Run a separate process to rigorously check that the final graph is valid, the sv candidate generators will check as well, but", "# this makes the check much more clear:", "checkCmd", "=", "[", "self", ".", "params", ".", "mantaGraphCheckBin", "]", "checkCmd", ".", "extend", "(", "[", "\"--graph-file\"", ",", "graphPath", "]", ")", "checkTask", "=", "self", ".", "addTask", "(", "preJoin", "(", "taskPrefix", ",", "\"checkLocusGraph\"", ")", ",", "checkCmd", ",", "dependencies", "=", "mergeTask", ",", "memMb", "=", "self", ".", "params", ".", "mergeMemMb", ")", "if", "not", "self", ".", "params", ".", "isRetainTempFiles", ":", "rmGraphTmpCmd", "=", "getRmdirCmd", "(", ")", "+", "[", "tmpGraphDir", "]", "rmTask", "=", "self", ".", "addTask", "(", "preJoin", "(", "taskPrefix", ",", "\"removeTmpDir\"", ")", ",", "rmGraphTmpCmd", ",", "dependencies", "=", "mergeTask", ")", "graphStatsCmd", "=", "[", "self", ".", "params", ".", "mantaGraphStatsBin", ",", "\"--global\"", "]", "graphStatsCmd", ".", "extend", "(", "[", "\"--graph-file\"", ",", "graphPath", "]", ")", "graphStatsCmd", ".", "extend", "(", "[", "\"--output-file\"", ",", "graphStatsPath", "]", ")", "graphStatsTask", "=", "self", ".", "addTask", "(", "preJoin", "(", "taskPrefix", ",", "\"locusGraphStats\"", ")", ",", "graphStatsCmd", ",", "dependencies", "=", "mergeTask", ",", "memMb", "=", "self", ".", "params", ".", "mergeMemMb", ")", "nextStepWait", "=", "set", "(", ")", "nextStepWait", ".", "add", "(", "checkTask", ")", "return", "nextStepWait" ]

[ "Format", "the", "changelog", "correctly", "and", "convert", "it", "to", "a", "list", "of", "strings" ]

[ "def", "_format_changelog", "(", "self", ",", "changelog", ")", ":", "if", "not", "changelog", ":", "return", "changelog", "new_changelog", "=", "[", "]", "for", "line", "in", "string", ".", "split", "(", "string", ".", "strip", "(", "changelog", ")", ",", "'\\n'", ")", ":", "line", "=", "string", ".", "strip", "(", "line", ")", "if", "line", "[", "0", "]", "==", "'*'", ":", "new_changelog", ".", "extend", "(", "[", "''", ",", "line", "]", ")", "elif", "line", "[", "0", "]", "==", "'-'", ":", "new_changelog", ".", "append", "(", "line", ")", "else", ":", "new_changelog", ".", "append", "(", "' '", "+", "line", ")", "# strip trailing newline inserted by first changelog entry", "if", "not", "new_changelog", "[", "0", "]", ":", "del", "new_changelog", "[", "0", "]", "return", "new_changelog" ]

[]

[ "def", "render", "(", "self", ",", "steps", ")", ":", "res", "=", "self", ".", "_render_impl", "(", "steps", ")", "# Implementation-dependent", "# Now that the output is rendered, we expect all options to have", "# been used.", "unused_options", "=", "set", "(", "self", ".", "_options_do_not_access", ")", "unused_options", "-=", "self", ".", "options_used", "if", "unused_options", ":", "raise", "RuntimeError", "(", "\"Unused options: {0} -- please check if you made a typo \"", "\"in any of them. Those that are truly not useful should \"", "\"be not be set so that this typo detection can be useful.\"", ".", "format", "(", "unused_options", ")", ")", "return", "res" ]

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

[ "Create", "filename", "from", "/", "prefix", "/", "filename" ]

[ "def", "chop", "(", "prefix", ",", "filename", ")", ":", "return", "filename", "if", "not", "len", "(", "prefix", ")", "else", "os", ".", "path", ".", "relpath", "(", "filename", ",", "prefix", ")" ]

[ "Send", "an", "EPRT", "command", "with", "the", "current", "host", "and", "the", "given", "port", "number", "." ]

[ "def", "sendeprt", "(", "self", ",", "host", ",", "port", ")", ":", "af", "=", "0", "if", "self", ".", "af", "==", "socket", ".", "AF_INET", ":", "af", "=", "1", "if", "self", ".", "af", "==", "socket", ".", "AF_INET6", ":", "af", "=", "2", "if", "af", "==", "0", ":", "raise", "error_proto", "(", "'unsupported address family'", ")", "fields", "=", "[", "''", ",", "repr", "(", "af", ")", ",", "host", ",", "repr", "(", "port", ")", ",", "''", "]", "cmd", "=", "'EPRT '", "+", "'|'", ".", "join", "(", "fields", ")", "return", "self", ".", "voidcmd", "(", "cmd", ")" ]

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

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

[ "Return", "system", "per", "-", "CPU", "times", "as", "a", "list", "of", "named", "tuples", "." ]

[ "def", "per_cpu_times", "(", ")", ":", "ret", "=", "[", "]", "for", "cpu_t", "in", "cext", ".", "per_cpu_times", "(", ")", ":", "user", ",", "system", ",", "idle", "=", "cpu_t", "item", "=", "scputimes", "(", "user", ",", "system", ",", "idle", ")", "ret", ".", "append", "(", "item", ")", "return", "ret" ]

[ "r", "Return", "the", "least", "-", "squares", "solution", "to", "a", "linear", "matrix", "equation", "." ]

[ "def", "lstsq", "(", "a", ",", "b", ",", "rcond", "=", "'warn'", ")", ":", "return", "_mx_nd_np", ".", "linalg", ".", "lstsq", "(", "a", ",", "b", ",", "rcond", ")" ]

[ "Augmenter", "body" ]

[ "def", "__call__", "(", "self", ",", "src", ")", ":", "src", "=", "src", ".", "astype", "(", "self", ".", "typ", ")", "return", "src" ]

[ "Decorator", "that", "allows", "to", "set", "the", "default", "for", "an", "attribute", "." ]

[ "def", "default", "(", "self", ",", "meth", ")", ":", "if", "self", ".", "_default", "is", "not", "NOTHING", ":", "raise", "DefaultAlreadySetError", "(", ")", "self", ".", "_default", "=", "Factory", "(", "meth", ",", "takes_self", "=", "True", ")", "return", "meth" ]

[ "Invoke", "the", "underlying", "file", "object", "s", "fileno", "()", "method", "." ]

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

[ "XmlNodeEasy", "(", "int", "type", "String", "name", "String", "content", "=", "EmptyString", ")", "-", ">", "XmlNode" ]

[ "def", "XmlNodeEasy", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_xrc", ".", "new_XmlNodeEasy", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Retrieve", "Add", "Black", "/", "Add", "White", "/", "Add", "Empty", "properties", "from", "a", "node", "." ]

[ "def", "get_setup_stones", "(", "self", ")", ":", "try", ":", "bp", "=", "self", ".", "get", "(", "\"AB\"", ")", "except", "KeyError", ":", "bp", "=", "set", "(", ")", "try", ":", "wp", "=", "self", ".", "get", "(", "\"AW\"", ")", "except", "KeyError", ":", "wp", "=", "set", "(", ")", "try", ":", "ep", "=", "self", ".", "get", "(", "\"AE\"", ")", "except", "KeyError", ":", "ep", "=", "set", "(", ")", "return", "bp", ",", "wp", ",", "ep" ]

[ "IntAttrValueEI", "(", "TNEANet", "self", "TInt", "EId", "TIntV", "Values", ")" ]

[ "def", "IntAttrValueEI", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TNEANet_IntAttrValueEI", "(", "self", ",", "*", "args", ")" ]

[ "Predict", "class", "for", "X", "." ]

[ "def", "predict", "(", "self", ",", "X", ")", ":", "y", "=", "self", ".", "predict_proba", "(", "X", ")", "y", "=", "np", ".", "argmax", "(", "y", ",", "axis", "=", "1", ")", "return", "np", ".", "asarray", "(", "list", "(", "self", ".", "_classes_map", ".", "values", "(", ")", ")", ")", "[", "np", ".", "searchsorted", "(", "list", "(", "self", ".", "_classes_map", ".", "keys", "(", ")", ")", ",", "y", ")", "]" ]

[ "Returns", "new", "TPM2B_DIGEST_SYMCIPHER", "object", "constructed", "from", "its", "marshaled", "representation", "in", "the", "given", "TpmBuffer", "buffer" ]

[ "def", "fromTpm", "(", "buf", ")", ":", "return", "buf", ".", "createObj", "(", "TPM2B_DIGEST_SYMCIPHER", ")" ]

[ "Adds", "builders", "and", "construction", "variables", "for", "Boost", ".", "Python", "to", "an", "Environment", "." ]

[ "def", "generate", "(", "env", ")", ":", "env", ".", "SetDefault", "(", "BOOST_PYTHON_TOOL_ERR", "=", "''", ",", "BOOST_PYTHON_CPPFLAGS", "=", "[", "'$PYTHON_BASECFLAGS'", "]", ",", "BOOST_PYTHON_CPPDEFINES", "=", "[", "]", ",", "BOOST_PYTHON_CPPPATH", "=", "[", "'$boostIncludeDir'", ",", "'$PYTHON_INCLUDEPY'", "]", ",", "BOOST_PYTHON_CXX_SUFFIX", "=", "'.boost.python.cpp'", ",", "BOOST_PYTHON_LIBPATH", "=", "[", "'$boostPythonLibDir'", "]", ",", "BOOST_PYTHON_LIBS", "=", "[", "'$boostPythonLib'", "]", ",", "BOOST_PYTHON_SHLINK", "=", "'$PYTHON_LDSHARED'", ",", "BOOST_PYTHON_LDMODULE", "=", "'$BOOST_PYTHON_SHLINK'", ",", "BOOST_PYTHON_LDMODULEFLAGS", "=", "''", ",", "_BOOST_PYTHON_CPPINCFLAGS", "=", "'$( ${_concat(INCPREFIX, BOOST_PYTHON_CPPPATH, INCSUFFIX, __env__, RDirs, TARGET)} $)'", ",", "_BOOST_PYTHON_CPPDEFFLAGS", "=", "'${_defines(CPPDEFPREFIX, BOOST_PYTHON_CPPDEFINES, CPPDEFSUFFIX, __env__)}'", ",", "_BOOST_PYTHON_LIBFLAGS", "=", "'${_stripixes(LIBLINKPREFIX, BOOST_PYTHON_LIBS, LIBLINKSUFFIX, LIBPREFIX, LIBSUFFIX, __env__)}'", ",", "_BOOST_PYTHON_LIBDIRFLAGS", "=", "'$( ${_concat(LIBDIRPREFIX, BOOST_PYTHON_LIBPATH, LIBDIRSUFFIX, __env__, RDirs, TARGET)} $)'", ",", "BOOST_PYTHON_SHCXXCOM", "=", "'$SHCXX $SHCXXFLAGS $CPPFLAGS $BOOST_PYTHON_CPPFLAGS $_CPPDEFFLAGS $_BOOST_PYTHON_CPPDEFFLAGS $_CPPINCFLAGS $_BOOST_PYTHON_CPPINCFLAGS -c -o $TARGET $SOURCES'", ",", "BOOST_PYTHON_LDMODULECOM", "=", "'$BOOST_PYTHON_LDMODULE $BOOST_PYTHON_LDMODULEFLAGS -o ${TARGET} $SOURCES $_LIBDIRFLAGS $_BOOST_PYTHON_LIBDIRFLAGS $_LIBFLAGS $_BOOST_PYTHON_LIBFLAGS'", ",", ")", "boost_python_ld_module_link_action", "=", "SCons", ".", "Action", ".", "Action", "(", "\"$BOOST_PYTHON_LDMODULECOM\"", ",", "\"$BOOST_PYTHON_LDMODULECOMSTR\"", ")", "boost_python_shared_object_builder", "=", "SCons", ".", "Builder", ".", "Builder", "(", "action", "=", "[", "ShCXXAction", "]", ",", "prefix", "=", "'$SHOBJPREFIX'", ",", "suffix", "=", "'$SHOBJSUFFIX'", ",", "src_suffix", "=", "'$BOOST_PYTHON_CXX_SUFFIX'", ",", "source_scanner", "=", "SCons", ".", "Tool", ".", "SourceFileScanner", ",", "single_source", "=", "True", ")", "boost_python_module_builder", "=", "SCons", ".", "Builder", ".", "Builder", "(", "action", "=", "[", "LdModuleLinkAction", "]", ",", "prefix", "=", "''", ",", "suffix", "=", "'$PYTHON_SO'", ",", "target_scanner", "=", "SCons", ".", "Tool", ".", "ProgramScanner", ",", "src_suffix", "=", "'$SHOBJSUFFIX'", ",", "src_builder", "=", "'BoostPythonSharedObject'", ",", "single_source", "=", "True", ")", "env", ".", "AppendUnique", "(", "BUILDERS", "=", "{", "'BoostPythonSharedObject'", ":", "boost_python_shared_object_builder", "}", ")", "env", ".", "AppendUnique", "(", "BUILDERS", "=", "{", "'BoostPythonModule'", ":", "boost_python_module_builder", "}", ")", "if", "env", ".", "subst", "(", "'$runConfTests'", ")", "in", "[", "'yes'", ",", "'1'", "]", ":", "find", "(", "env", ")" ]

[ "Print", "a", "warning", "when", "called", "." ]

[ "def", "_missing_warn", "(", ")", ":", "warnings", ".", "warn", "(", "\"One of the clusters is empty. \"", "\"Re-run kmeans with a different initialization.\"", ")" ]

[ "Helper", "to", "run", "code", "in", "nominated", "namespace" ]

[ "def", "_run_code", "(", "code", ",", "run_globals", ",", "init_globals", "=", "None", ",", "mod_name", "=", "None", ",", "mod_spec", "=", "None", ",", "pkg_name", "=", "None", ",", "script_name", "=", "None", ")", ":", "if", "init_globals", "is", "not", "None", ":", "run_globals", ".", "update", "(", "init_globals", ")", "if", "mod_spec", "is", "None", ":", "loader", "=", "None", "fname", "=", "script_name", "cached", "=", "None", "else", ":", "loader", "=", "mod_spec", ".", "loader", "fname", "=", "mod_spec", ".", "origin", "cached", "=", "mod_spec", ".", "cached", "if", "pkg_name", "is", "None", ":", "pkg_name", "=", "mod_spec", ".", "parent", "run_globals", ".", "update", "(", "__name__", "=", "mod_name", ",", "__file__", "=", "fname", ",", "__cached__", "=", "cached", ",", "__doc__", "=", "None", ",", "__loader__", "=", "loader", ",", "__package__", "=", "pkg_name", ",", "__spec__", "=", "mod_spec", ")", "exec", "(", "code", ",", "run_globals", ")", "return", "run_globals" ]

[ "_setCallbackInfo", "(", "self", "PyObject", "self", "PyObject", "_class", ")" ]

[ "def", "_setCallbackInfo", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_combo", ".", "ComboPopup__setCallbackInfo", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sort", "by", "the", "values", "." ]

[ "def", "sort_values", "(", "self", ",", "axis", "=", "0", ",", "ascending", "=", "True", ",", "inplace", "=", "False", ",", "kind", "=", "\"quicksort\"", ",", "na_position", "=", "\"last\"", ",", "ignore_index", "=", "False", ",", ")", ":", "inplace", "=", "validate_bool_kwarg", "(", "inplace", ",", "\"inplace\"", ")", "# Validate the axis parameter", "self", ".", "_get_axis_number", "(", "axis", ")", "# GH 5856/5853", "if", "inplace", "and", "self", ".", "_is_cached", ":", "raise", "ValueError", "(", "\"This Series is a view of some other array, to \"", "\"sort in-place you must create a copy\"", ")", "def", "_try_kind_sort", "(", "arr", ")", ":", "# easier to ask forgiveness than permission", "try", ":", "# if kind==mergesort, it can fail for object dtype", "return", "arr", ".", "argsort", "(", "kind", "=", "kind", ")", "except", "TypeError", ":", "# stable sort not available for object dtype", "# uses the argsort default quicksort", "return", "arr", ".", "argsort", "(", "kind", "=", "\"quicksort\"", ")", "arr", "=", "self", ".", "_values", "sorted_index", "=", "np", ".", "empty", "(", "len", "(", "self", ")", ",", "dtype", "=", "np", ".", "int32", ")", "bad", "=", "isna", "(", "arr", ")", "good", "=", "~", "bad", "idx", "=", "ibase", ".", "default_index", "(", "len", "(", "self", ")", ")", "argsorted", "=", "_try_kind_sort", "(", "arr", "[", "good", "]", ")", "if", "is_list_like", "(", "ascending", ")", ":", "if", "len", "(", "ascending", ")", "!=", "1", ":", "raise", "ValueError", "(", "f\"Length of ascending ({len(ascending)}) must be 1 for Series\"", ")", "ascending", "=", "ascending", "[", "0", "]", "if", "not", "is_bool", "(", "ascending", ")", ":", "raise", "ValueError", "(", "\"ascending must be boolean\"", ")", "if", "not", "ascending", ":", "argsorted", "=", "argsorted", "[", ":", ":", "-", "1", "]", "if", "na_position", "==", "\"last\"", ":", "n", "=", "good", ".", "sum", "(", ")", "sorted_index", "[", ":", "n", "]", "=", "idx", "[", "good", "]", "[", "argsorted", "]", "sorted_index", "[", "n", ":", "]", "=", "idx", "[", "bad", "]", "elif", "na_position", "==", "\"first\"", ":", "n", "=", "bad", ".", "sum", "(", ")", "sorted_index", "[", "n", ":", "]", "=", "idx", "[", "good", "]", "[", "argsorted", "]", "sorted_index", "[", ":", "n", "]", "=", "idx", "[", "bad", "]", "else", ":", "raise", "ValueError", "(", "f\"invalid na_position: {na_position}\"", ")", "result", "=", "self", ".", "_constructor", "(", "arr", "[", "sorted_index", "]", ",", "index", "=", "self", ".", "index", "[", "sorted_index", "]", ")", "if", "ignore_index", ":", "result", ".", "index", "=", "ibase", ".", "default_index", "(", "len", "(", "sorted_index", ")", ")", "if", "inplace", ":", "self", ".", "_update_inplace", "(", "result", ")", "else", ":", "return", "result", ".", "__finalize__", "(", "self", ")" ]

[ "This", "helper", "lets", "Facebook", "-", "internal", "CI", "special", "-", "cases", "FB", "projects" ]

[ "def", "fb_github_project_workdir", "(", "self", ",", "project_and_path", ",", "github_org", "=", "\"facebook\"", ")", ":", "project", ",", "path", "=", "project_and_path", ".", "split", "(", "\"/\"", ",", "1", ")", "return", "self", ".", "github_project_workdir", "(", "github_org", "+", "\"/\"", "+", "project", ",", "path", ")" ]

[ "Changes", "the", "element", "shape", "of", "the", "array", "given", "a", "shape", "to", "merge", "with", "." ]

[ "def", "_check_element_shape", "(", "self", ",", "shape", ")", ":", "if", "not", "shape", ".", "is_compatible_with", "(", "self", ".", "element_shape", ")", ":", "raise", "ValueError", "(", "\"Inconsistent shapes: saw %s but expected %s \"", "%", "(", "shape", ",", "self", ".", "element_shape", ")", ")", "if", "self", ".", "_infer_shape", ":", "self", ".", "_element_shape", "[", "0", "]", "=", "self", ".", "element_shape", ".", "merge_with", "(", "shape", ")" ]

[ "r", "Computes", "the", "npairs", "loss", "with", "multilabel", "data", "." ]

[ "def", "npairs_loss_multilabel", "(", "sparse_labels", ",", "embeddings_anchor", ",", "embeddings_positive", ",", "reg_lambda", "=", "0.002", ",", "print_losses", "=", "False", ")", ":", "if", "False", "in", "[", "isinstance", "(", "l", ",", "sparse_tensor", ".", "SparseTensor", ")", "for", "l", "in", "sparse_labels", "]", ":", "raise", "TypeError", "(", "'sparse_labels must be a list of SparseTensors, but got %s'", "%", "str", "(", "sparse_labels", ")", ")", "with", "ops", ".", "name_scope", "(", "'NpairsLossMultiLabel'", ")", ":", "# Add the regularizer on the embedding.", "reg_anchor", "=", "math_ops", ".", "reduce_mean", "(", "math_ops", ".", "reduce_sum", "(", "math_ops", ".", "square", "(", "embeddings_anchor", ")", ",", "1", ")", ")", "reg_positive", "=", "math_ops", ".", "reduce_mean", "(", "math_ops", ".", "reduce_sum", "(", "math_ops", ".", "square", "(", "embeddings_positive", ")", ",", "1", ")", ")", "l2loss", "=", "math_ops", ".", "multiply", "(", "0.25", "*", "reg_lambda", ",", "reg_anchor", "+", "reg_positive", ",", "name", "=", "'l2loss'", ")", "# Get per pair similarities.", "similarity_matrix", "=", "math_ops", ".", "matmul", "(", "embeddings_anchor", ",", "embeddings_positive", ",", "transpose_a", "=", "False", ",", "transpose_b", "=", "True", ")", "# TODO(coreylynch): need to check the sparse values", "# TODO(coreylynch): are composed only of 0's and 1's.", "multilabel_adjacency_matrix", "=", "_build_multilabel_adjacency", "(", "sparse_labels", ")", "labels_remapped", "=", "math_ops", ".", "cast", "(", "multilabel_adjacency_matrix", ",", "dtypes", ".", "float32", ")", "labels_remapped", "/=", "math_ops", ".", "reduce_sum", "(", "labels_remapped", ",", "1", ",", "keepdims", "=", "True", ")", "# Add the softmax loss.", "xent_loss", "=", "nn", ".", "softmax_cross_entropy_with_logits", "(", "logits", "=", "similarity_matrix", ",", "labels", "=", "labels_remapped", ")", "xent_loss", "=", "math_ops", ".", "reduce_mean", "(", "xent_loss", ",", "name", "=", "'xentropy'", ")", "if", "print_losses", ":", "xent_loss", "=", "logging_ops", ".", "Print", "(", "xent_loss", ",", "[", "'cross entropy:'", ",", "xent_loss", ",", "'l2loss:'", ",", "l2loss", "]", ")", "return", "l2loss", "+", "xent_loss" ]

[ "Get", "patient", "UID", "by", "patient", "name", "for", "easy", "loading", "of", "a", "patient" ]

[ "def", "getDatabasePatientUIDByPatientName", "(", "name", ")", ":", "if", "not", "slicer", ".", "dicomDatabase", ".", "isOpen", ":", "raise", "OSError", "(", "'DICOM module or database cannot be accessed'", ")", "patients", "=", "slicer", ".", "dicomDatabase", ".", "patients", "(", ")", "for", "patientUID", "in", "patients", ":", "currentName", "=", "slicer", ".", "dicomDatabase", ".", "nameForPatient", "(", "patientUID", ")", "if", "currentName", "==", "name", ":", "return", "patientUID", "return", "None" ]

[ "The", "indices", "of", "non", "-", "zero", "values", "in", "the", "represented", "dense", "tensor", "." ]

[ "def", "indices", "(", "self", ")", ":", "return", "self", ".", "_indices" ]

[ "Returns", "the", "greatest", "common", "divisor", "via", "Euclid", "s", "algorithm", "." ]

[ "def", "gcd", "(", "a", ",", "b", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "name", ",", "'gcd'", ",", "[", "a", ",", "b", "]", ")", ":", "a", "=", "ops", ".", "convert_to_tensor", "(", "a", ")", "b", "=", "ops", ".", "convert_to_tensor", "(", "b", ")", "a", ".", "shape", ".", "assert_has_rank", "(", "0", ")", "b", ".", "shape", ".", "assert_has_rank", "(", "0", ")", "if", "not", "a", ".", "dtype", ".", "is_integer", ":", "raise", "ValueError", "(", "'a must be an integer type. Got: %s'", "%", "a", ".", "dtype", ")", "if", "not", "b", ".", "dtype", ".", "is_integer", ":", "raise", "ValueError", "(", "'b must be an integer type. Got: %s'", "%", "b", ".", "dtype", ")", "# TPU requires static shape inference. GCD is used for subframe size", "# computation, so we should prefer static computation where possible.", "const_a", "=", "tensor_util", ".", "constant_value", "(", "a", ")", "const_b", "=", "tensor_util", ".", "constant_value", "(", "b", ")", "if", "const_a", "is", "not", "None", "and", "const_b", "is", "not", "None", ":", "return", "ops", ".", "convert_to_tensor", "(", "fractions", ".", "gcd", "(", "const_a", ",", "const_b", ")", ")", "cond", "=", "lambda", "_", ",", "b", ":", "math_ops", ".", "greater", "(", "b", ",", "array_ops", ".", "zeros_like", "(", "b", ")", ")", "body", "=", "lambda", "a", ",", "b", ":", "[", "b", ",", "math_ops", ".", "mod", "(", "a", ",", "b", ")", "]", "a", ",", "b", "=", "control_flow_ops", ".", "while_loop", "(", "cond", ",", "body", ",", "[", "a", ",", "b", "]", ",", "back_prop", "=", "False", ")", "return", "a" ]

[ "SetEmptySelection", "(", "self", "int", "pos", ")" ]

[ "def", "SetEmptySelection", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetEmptySelection", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Accepts", "a", "key", "as", "input", ".", "The", "corresponding", "value", "must", "be", "a", "string", "or", "the", "objects", "(", "True", "or", "1", ")", "or", "(", "False", "or", "0", ")", ".", "We", "allow", "0", "and", "1", "to", "retain", "compatibility", "with", "Python", "2", ".", "2", ".", "If", "the", "string", "is", "one", "of", "True", "On", "Yes", "or", "1", "it", "returns", "True", ".", "If", "the", "string", "is", "one", "of", "False", "Off", "No", "or", "0", "it", "returns", "False", ".", "as_bool", "is", "not", "case", "sensitive", ".", "Any", "other", "input", "will", "raise", "a", "ValueError", ".", ">>>", "a", "=", "ConfigObj", "()", ">>>", "a", "[", "a", "]", "=", "fish", ">>>", "a", ".", "as_bool", "(", "a", ")", "Traceback", "(", "most", "recent", "call", "last", ")", ":", "ValueError", ":", "Value", "fish", "is", "neither", "True", "nor", "False", ">>>", "a", "[", "b", "]", "=", "True", ">>>", "a", ".", "as_bool", "(", "b", ")", "1", ">>>", "a", "[", "b", "]", "=", "off", ">>>", "a", ".", "as_bool", "(", "b", ")", "0" ]

[ "def", "as_bool", "(", "self", ",", "key", ")", ":", "val", "=", "self", "[", "key", "]", "if", "val", "==", "True", ":", "return", "True", "elif", "val", "==", "False", ":", "return", "False", "else", ":", "try", ":", "if", "not", "isinstance", "(", "val", ",", "basestring", ")", ":", "# TODO: Why do we raise a KeyError here?", "raise", "KeyError", "(", ")", "else", ":", "return", "self", ".", "main", ".", "_bools", "[", "val", ".", "lower", "(", ")", "]", "except", "KeyError", ":", "raise", "ValueError", "(", "'Value \"%s\" is neither True nor False'", "%", "val", ")" ]

[ "Is", "distribution", "dist", "acceptable", "for", "this", "environment?" ]

[ "def", "can_add", "(", "self", ",", "dist", ")", ":", "py_compat", "=", "(", "self", ".", "python", "is", "None", "or", "dist", ".", "py_version", "is", "None", "or", "dist", ".", "py_version", "==", "self", ".", "python", ")", "return", "py_compat", "and", "compatible_platforms", "(", "dist", ".", "platform", ",", "self", ".", "platform", ")" ]

[ ":", "param", "pnt", ":", "type", "pnt", ":", "point" ]

[ "def", "gbsf_check_point", "(", "pnt", ",", ")", ":", "if", "(", "'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.CARTESIAN_POINT'", "==", "TYPEOF", "(", "pnt", ")", ")", ":", "return", "TRUE", "else", ":", "if", "(", "'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_CURVE'", "==", "TYPEOF", "(", "pnt", ")", ")", ":", "return", "gbsf_check_curve", "(", "pnt", ".", "point_on_curve", ".", "basis_curve", ")", "else", ":", "if", "(", "'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.POINT_ON_SURFACE'", "==", "TYPEOF", "(", "pnt", ")", ")", ":", "return", "gbsf_check_surface", "(", "pnt", ".", "point_on_surface", ".", "basis_surface", ")", "else", ":", "if", "(", "'AP203_CONFIGURATION_CONTROLLED_3D_DESIGN_OF_MECHANICAL_PARTS_AND_ASSEMBLIES_MIM_LF.DEGENERATE_PCURVE'", "==", "TYPEOF", "(", "pnt", ")", ")", ":", "return", "gbsf_check_curve", "(", "pnt", ".", "degenerate_pcurve", ".", "reference_to_curve", ".", "representation", ".", "items", "[", "1", "]", ")", "and", "gbsf_check_surface", "(", "pnt", ".", "degenerate_pcurve", ".", "basis_surface", ")", "return", "FALSE" ]

[ "Finds", "the", "ar", "program", "and", "sets", "the", "default", "flags", "in", "conf", ".", "env", ".", "ARFLAGS" ]

[ "def", "configure", "(", "conf", ")", ":", "conf", ".", "find_program", "(", "'ar'", ",", "var", "=", "'AR'", ")", "conf", ".", "add_os_flags", "(", "'ARFLAGS'", ")", "if", "not", "conf", ".", "env", ".", "ARFLAGS", ":", "conf", ".", "env", ".", "ARFLAGS", "=", "[", "'rcs'", "]" ]

[ "Downloads", "an", "attachment", "file", "to", "disk", "." ]

[ "def", "download_attachment", "(", "self", ",", "uri_or_entry", ",", "file_path", ")", ":", "uri", "=", "uri_or_entry", "if", "isinstance", "(", "uri_or_entry", ",", "gdata", ".", "sites", ".", "data", ".", "ContentEntry", ")", ":", "uri", "=", "uri_or_entry", ".", "content", ".", "src", "f", "=", "open", "(", "file_path", ",", "'wb'", ")", "try", ":", "f", ".", "write", "(", "self", ".", "_get_file_content", "(", "uri", ")", ")", "except", "gdata", ".", "client", ".", "RequestError", ",", "e", ":", "f", ".", "close", "(", ")", "raise", "e", "f", ".", "flush", "(", ")", "f", ".", "close", "(", ")" ]

[ "Forward", "network" ]

[ "def", "predict", "(", "self", ",", "left", ",", "right", ")", ":", "# embedding layer", "emb_layer", "=", "layers", ".", "EmbeddingLayer", "(", "self", ".", "dict_size", ",", "self", ".", "emb_dim", ",", "\"emb\"", ")", "left_emb", "=", "emb_layer", ".", "ops", "(", "left", ")", "right_emb", "=", "emb_layer", ".", "ops", "(", "right", ")", "# Presentation context", "gru_layer", "=", "layers", ".", "DynamicGRULayer", "(", "self", ".", "gru_dim", ",", "\"gru\"", ")", "left_gru", "=", "gru_layer", ".", "ops", "(", "left_emb", ")", "right_gru", "=", "gru_layer", ".", "ops", "(", "right_emb", ")", "last_layer", "=", "layers", ".", "SequenceLastStepLayer", "(", ")", "left_last", "=", "last_layer", ".", "ops", "(", "left_gru", ")", "right_last", "=", "last_layer", ".", "ops", "(", "right_gru", ")", "# matching layer", "if", "self", ".", "task_mode", "==", "\"pairwise\"", ":", "relu_layer", "=", "layers", ".", "FCLayer", "(", "self", ".", "hidden_dim", ",", "\"relu\"", ",", "\"relu\"", ")", "left_relu", "=", "relu_layer", ".", "ops", "(", "left_last", ")", "right_relu", "=", "relu_layer", ".", "ops", "(", "right_last", ")", "cos_sim_layer", "=", "layers", ".", "CosSimLayer", "(", ")", "pred", "=", "cos_sim_layer", ".", "ops", "(", "left_relu", ",", "right_relu", ")", "return", "left_relu", ",", "pred", "else", ":", "concat_layer", "=", "layers", ".", "ConcatLayer", "(", "1", ")", "concat", "=", "concat_layer", ".", "ops", "(", "[", "left_last", ",", "right_last", "]", ")", "relu_layer", "=", "layers", ".", "FCLayer", "(", "self", ".", "hidden_dim", ",", "\"relu\"", ",", "\"relu\"", ")", "concat_fc", "=", "relu_layer", ".", "ops", "(", "concat", ")", "softmax_layer", "=", "layers", ".", "FCLayer", "(", "2", ",", "\"softmax\"", ",", "\"cos_sim\"", ")", "pred", "=", "softmax_layer", ".", "ops", "(", "concat_fc", ")", "return", "left_last", ",", "pred" ]

[ "This", "puts", "a", "characters", "at", "the", "current", "cursor", "position", "." ]

[ "def", "put", "(", "self", ",", "ch", ")", ":", "if", "isinstance", "(", "ch", ",", "bytes", ")", ":", "ch", "=", "self", ".", "_decode", "(", "ch", ")", "self", ".", "put_abs", "(", "self", ".", "cur_r", ",", "self", ".", "cur_c", ",", "ch", ")" ]

[ "Clamp", "the", "index", "in", "[", "0", "size", "]", "." ]

[ "def", "clamp_index", "(", "self", ",", "idx", ")", ":", "builder", "=", "self", ".", "_builder", "idxptr", "=", "cgutils", ".", "alloca_once_value", "(", "builder", ",", "idx", ")", "zero", "=", "ir", ".", "Constant", "(", "idx", ".", "type", ",", "0", ")", "size", "=", "self", ".", "size", "underflow", "=", "self", ".", "_builder", ".", "icmp_signed", "(", "'<'", ",", "idx", ",", "zero", ")", "with", "builder", ".", "if_then", "(", "underflow", ",", "likely", "=", "False", ")", ":", "builder", ".", "store", "(", "zero", ",", "idxptr", ")", "overflow", "=", "self", ".", "_builder", ".", "icmp_signed", "(", "'>='", ",", "idx", ",", "size", ")", "with", "builder", ".", "if_then", "(", "overflow", ",", "likely", "=", "False", ")", ":", "builder", ".", "store", "(", "size", ",", "idxptr", ")", "return", "builder", ".", "load", "(", "idxptr", ")" ]

[ "r", "Sets", "the", "gradients", "of", "all", "optimized", ":", "class", ":", "torch", ".", "Tensor", "s", "to", "zero", "." ]

[ "def", "zero_grad", "(", "self", ",", "set_to_none", ":", "bool", "=", "False", ")", ":", "foreach", "=", "self", ".", "defaults", ".", "get", "(", "'foreach'", ",", "False", ")", "if", "not", "hasattr", "(", "self", ",", "\"_zero_grad_profile_name\"", ")", ":", "self", ".", "_hook_for_profile", "(", ")", "if", "foreach", ":", "per_device_and_dtype_grads", "=", "defaultdict", "(", "lambda", ":", "defaultdict", "(", "list", ")", ")", "with", "torch", ".", "autograd", ".", "profiler", ".", "record_function", "(", "self", ".", "_zero_grad_profile_name", ")", ":", "for", "group", "in", "self", ".", "param_groups", ":", "for", "p", "in", "group", "[", "'params'", "]", ":", "if", "p", ".", "grad", "is", "not", "None", ":", "if", "set_to_none", ":", "p", ".", "grad", "=", "None", "else", ":", "if", "p", ".", "grad", ".", "grad_fn", "is", "not", "None", ":", "p", ".", "grad", ".", "detach_", "(", ")", "else", ":", "p", ".", "grad", ".", "requires_grad_", "(", "False", ")", "if", "(", "not", "foreach", "or", "p", ".", "grad", ".", "is_sparse", ")", ":", "p", ".", "grad", ".", "zero_", "(", ")", "else", ":", "per_device_and_dtype_grads", "[", "p", ".", "grad", ".", "device", "]", "[", "p", ".", "grad", ".", "dtype", "]", ".", "append", "(", "p", ".", "grad", ")", "if", "foreach", ":", "for", "_", ",", "per_dtype_grads", "in", "per_device_and_dtype_grads", ".", "items", "(", ")", ":", "for", "grads", "in", "per_dtype_grads", ".", "values", "(", ")", ":", "torch", ".", "_foreach_zero_", "(", "grads", ")" ]

[ "The", "WSGI", "application", "interface", "." ]

[ "def", "__call__", "(", "self", ",", "environ", ",", "start_response", ")", ":", "# We want to be careful about not sending headers twice,", "# and the content type that the app has committed to (if there", "# is an exception in the iterator body of the response)", "if", "environ", ".", "get", "(", "'paste.throw_errors'", ")", ":", "return", "self", ".", "application", "(", "environ", ",", "start_response", ")", "environ", "[", "'paste.throw_errors'", "]", "=", "True", "try", ":", "__traceback_supplement__", "=", "Supplement", ",", "self", ",", "environ", "sr_checker", "=", "ResponseStartChecker", "(", "start_response", ")", "app_iter", "=", "self", ".", "application", "(", "environ", ",", "sr_checker", ")", "return", "self", ".", "make_catching_iter", "(", "app_iter", ",", "environ", ",", "sr_checker", ")", "except", ":", "exc_info", "=", "sys", ".", "exc_info", "(", ")", "try", ":", "for", "expect", "in", "environ", ".", "get", "(", "'paste.expected_exceptions'", ",", "[", "]", ")", ":", "if", "isinstance", "(", "exc_info", "[", "1", "]", ",", "expect", ")", ":", "raise", "start_response", "(", "'500 Internal Server Error'", ",", "[", "(", "'content-type'", ",", "'text/html'", ")", "]", ",", "exc_info", ")", "# @@: it would be nice to deal with bad content types here", "response", "=", "self", ".", "exception_handler", "(", "exc_info", ",", "environ", ")", "if", "six", ".", "PY3", ":", "response", "=", "response", ".", "encode", "(", "'utf8'", ")", "return", "[", "response", "]", "finally", ":", "# clean up locals...", "exc_info", "=", "None" ]

[ "Archives", "the", "atomic", "multilog", "until", "provided", "offset", "." ]

[ "def", "archive", "(", "self", ",", "offset", "=", "-", "1", ")", ":", "if", "self", ".", "cur_m_id_", "==", "-", "1", ":", "raise", "ValueError", "(", "\"Must set atomic multilog first.\"", ")", "self", ".", "client_", ".", "archive", "(", "self", ".", "cur_m_id_", ",", "offset", ")" ]

[ "Add", "tag", "NEWTAG", "to", "all", "items", "below", "TAGORID", "." ]

[ "def", "addtag_below", "(", "self", ",", "newtag", ",", "tagOrId", ")", ":", "self", ".", "addtag", "(", "newtag", ",", "'below'", ",", "tagOrId", ")" ]

[ "D", ".", "get", "(", "k", "[", "d", "]", ")", "-", ">", "D", "[", "k", "]", "if", "k", "in", "D", "else", "d", ".", "d", "defaults", "to", "None", "." ]

[ "def", "get", "(", "self", ",", "key", ",", "default", "=", "None", ")", ":", "try", ":", "return", "self", "[", "key", "]", "except", "KeyError", ":", "return", "default" ]

[ "Sets", "the", "module", "s", "counting", "options", "." ]

[ "def", "SetCountingStyle", "(", "self", ",", "counting_style", ")", ":", "self", ".", "counting", "=", "counting_style" ]

[ "r", ":", "api_attr", ":", "Static", "Graph" ]

[ "def", "simple_img_conv_pool", "(", "input", ",", "num_filters", ",", "filter_size", ",", "pool_size", ",", "pool_stride", ",", "pool_padding", "=", "0", ",", "pool_type", "=", "'max'", ",", "global_pooling", "=", "False", ",", "conv_stride", "=", "1", ",", "conv_padding", "=", "0", ",", "conv_dilation", "=", "1", ",", "conv_groups", "=", "1", ",", "param_attr", "=", "None", ",", "bias_attr", "=", "None", ",", "act", "=", "None", ",", "use_cudnn", "=", "True", ")", ":", "conv_out", "=", "layers", ".", "conv2d", "(", "input", "=", "input", ",", "num_filters", "=", "num_filters", ",", "filter_size", "=", "filter_size", ",", "stride", "=", "conv_stride", ",", "padding", "=", "conv_padding", ",", "dilation", "=", "conv_dilation", ",", "groups", "=", "conv_groups", ",", "param_attr", "=", "param_attr", ",", "bias_attr", "=", "bias_attr", ",", "act", "=", "act", ",", "use_cudnn", "=", "use_cudnn", ")", "pool_out", "=", "layers", ".", "pool2d", "(", "input", "=", "conv_out", ",", "pool_size", "=", "pool_size", ",", "pool_type", "=", "pool_type", ",", "pool_stride", "=", "pool_stride", ",", "pool_padding", "=", "pool_padding", ",", "global_pooling", "=", "global_pooling", ",", "use_cudnn", "=", "use_cudnn", ")", "return", "pool_out" ]

[ "Overridden", "from", "Argument", "." ]

[ "def", "GetLogArg", "(", "self", ")", ":", "return", "\"static_cast<const void*>(%s)\"", "%", "self", ".", "name" ]

[ "Calculates", "the", "barostat", "conserved", "quantity", "." ]

[ "def", "get_ebaro", "(", "self", ")", ":", "return", "self", ".", "thermostat", ".", "ethermo", "+", "self", ".", "kin", "+", "self", ".", "pot" ]

[ "read", "the", "runtimes", "out", "of", "map_times", ".", "txt", "assuming", "first", "line", "is", "a", "header" ]

[ "def", "load_mapeval_runtimes", "(", "map_times_path", ")", ":", "try", ":", "map_times_dict", "=", "{", "}", "with", "open", "(", "map_times_path", ")", "as", "map_times_file", ":", "lines", "=", "[", "line", "for", "line", "in", "map_times_file", "]", "for", "line", "in", "lines", "[", "1", ":", "]", ":", "toks", "=", "line", ".", "split", "(", "'\\t'", ")", "map_times_dict", "[", "toks", "[", "0", "]", "]", "=", "toks", "[", "1", "]", "return", "map_times_dict", "except", ":", "pass", "return", "None" ]

[ "Fuzzy", "diff", "two", "files", "." ]

[ "def", "_compare_files", "(", "self", ",", "file1", ",", "file2", ")", ":", "status", "=", "0", "file1_dup", "=", "False", "file2_dup", "=", "False", "if", "not", "self", ".", "filter_by_name", "or", "os", ".", "path", ".", "basename", "(", "file1", ")", "==", "os", ".", "path", ".", "basename", "(", "file2", ")", ":", "if", "os", ".", "path", ".", "exists", "(", "file1", ")", "and", "os", ".", "path", ".", "exists", "(", "file2", ")", ":", "hash1", "=", "ctypes", ".", "create_string_buffer", "(", "self", ".", "FUZZY_MAX_RESULT", ")", "hash2", "=", "ctypes", ".", "create_string_buffer", "(", "self", ".", "FUZZY_MAX_RESULT", ")", "# Check if the last file1 or file2 matches this file1 or file2; no need to re-hash if they match.", "if", "file1", "==", "self", ".", "last_file1", ".", "name", "and", "self", ".", "last_file1", ".", "hash", ":", "file1_dup", "=", "True", "else", ":", "self", ".", "last_file1", ".", "name", "=", "file1", "if", "file2", "==", "self", ".", "last_file2", ".", "name", "and", "self", ".", "last_file2", ".", "hash", ":", "file2_dup", "=", "True", "else", ":", "self", ".", "last_file2", ".", "name", "=", "file2", "try", ":", "if", "self", ".", "strings", ":", "if", "file1_dup", ":", "file1_strings", "=", "self", ".", "last_file1", ".", "strings", "else", ":", "self", ".", "last_file1", ".", "strings", "=", "file1_strings", "=", "self", ".", "_get_strings", "(", "file1", ")", "if", "file2_dup", ":", "file2_strings", "=", "self", ".", "last_file2", ".", "strings", "else", ":", "self", ".", "last_file2", ".", "strings", "=", "file2_strings", "=", "self", ".", "_get_strings", "(", "file2", ")", "if", "file1_strings", "==", "file2_strings", ":", "return", "100", "else", ":", "if", "file1_dup", ":", "hash1", "=", "self", ".", "last_file1", ".", "hash", "else", ":", "status", "|=", "self", ".", "lib", ".", "fuzzy_hash_buf", "(", "file1_strings", ",", "len", "(", "file1_strings", ")", ",", "hash1", ")", "if", "file2_dup", ":", "hash2", "=", "self", ".", "last_file2", ".", "hash", "else", ":", "status", "|=", "self", ".", "lib", ".", "fuzzy_hash_buf", "(", "file2_strings", ",", "len", "(", "file2_strings", ")", ",", "hash2", ")", "else", ":", "if", "file1_dup", ":", "hash1", "=", "self", ".", "last_file1", ".", "hash", "else", ":", "status", "|=", "self", ".", "lib", ".", "fuzzy_hash_filename", "(", "file1", ",", "hash1", ")", "if", "file2_dup", ":", "hash2", "=", "self", ".", "last_file2", ".", "hash", "else", ":", "status", "|=", "self", ".", "lib", ".", "fuzzy_hash_filename", "(", "file2", ",", "hash2", ")", "if", "status", "==", "0", ":", "if", "not", "file1_dup", ":", "self", ".", "last_file1", ".", "hash", "=", "hash1", "if", "not", "file2_dup", ":", "self", ".", "last_file2", ".", "hash", "=", "hash2", "if", "hash1", ".", "raw", "==", "hash2", ".", "raw", ":", "return", "100", "else", ":", "return", "self", ".", "lib", ".", "fuzzy_compare", "(", "hash1", ",", "hash2", ")", "except", "Exception", "as", "e", ":", "binwalk", ".", "core", ".", "common", ".", "warning", "(", "\"Exception while doing fuzzy hash: %s\"", "%", "str", "(", "e", ")", ")", "return", "None" ]

[ "Returns", "the", "nodes", "in", "an", "order", "that", "is", "suitable", "to", "import", ".", "That", "means", "each", "node", "is", "guaranteed", "to", "appear", "after", "the", "nodes", "it", "relies", "on", "." ]

[ "def", "get_nodes_in_import_order", "(", "self", ",", "nodes", ":", "typing", ".", "Mapping", "[", "str", ",", "typing", ".", "Any", "]", ")", ":", "pending_nodes", "=", "list", "(", "nodes", ".", "values", "(", ")", ")", "ordered_nodes", "=", "[", "]", "node_processed", "=", "len", "(", "pending_nodes", ")", ">", "0", "outputs_available", "=", "{", "}", "while", "node_processed", ":", "node_processed", "=", "False", "for", "current_node", "in", "pending_nodes", ":", "# Find a node which already has all of its input nodes in the ordered list.", "if", "current_node", ".", "operation_type", "!=", "\"Skip\"", ":", "if", "all", "(", "(", "input_id", "in", "outputs_available", ")", "for", "input_id", "in", "current_node", ".", "inputs", "if", "input_id", ")", ":", "pending_nodes", ".", "remove", "(", "current_node", ")", "ordered_nodes", ".", "append", "(", "current_node", ")", "node_processed", "=", "True", "for", "o", "in", "current_node", ".", "outputs", ":", "outputs_available", "[", "o", "]", "=", "True", "pending_nodes", "=", "[", "n", "for", "n", "in", "pending_nodes", "if", "n", ".", "operation_type", "!=", "\"Skip\"", "]", "if", "len", "(", "pending_nodes", ")", ">", "0", ":", "_logger", ".", "info", "(", "\"### ignoring the following nodes because their inputs are not satisfiable:\"", ")", "for", "node", "in", "pending_nodes", ":", "_logger", ".", "info", "(", "\" {}({})\"", ".", "format", "(", "node", ".", "operation_type", ",", "node", ".", "id", ")", ")", "result", "=", "[", "]", "for", "current_node", "in", "ordered_nodes", ":", "if", "current_node", ".", "operation_type", "!=", "\"Input\"", "or", "any", "(", "current_node", ".", "outputs", "[", "0", "]", "in", "node", ".", "inputs", "for", "node", "in", "ordered_nodes", ")", ":", "result", ".", "append", "(", "current_node", ")", "return", "result" ]

[ "GetDat", "(", "TIntHI", "self", ")", "-", ">", "TInt", "GetDat", "(", "TIntHI", "self", ")", "-", ">", "TInt" ]

[ "def", "GetDat", "(", "self", ",", "*", "args", ")", ":", "return", "_snap", ".", "TIntHI_GetDat", "(", "self", ",", "*", "args", ")" ]

[ "Instantaneous", "pressure", "tensor", "of", "the", "group", "\\", ":", "math", ":", "[", "\\\\", "mathrm", "{", "pressure", "}", "]", "." ]

[ "def", "pressure_tensor", "(", "self", ")", ":", "self", ".", "_cpp_obj", ".", "compute", "(", "self", ".", "_simulation", ".", "timestep", ")", "return", "self", ".", "_cpp_obj", ".", "pressure_tensor" ]

[ "Generate", "a", "new", "Message", "instance", "from", "this", "Descriptor", "and", "a", "byte", "string", "." ]

[ "def", "ParseMessage", "(", "descriptor", ",", "byte_str", ")", ":", "class", "_ResultClass", "(", "message", ".", "Message", ")", ":", "__metaclass__", "=", "GeneratedProtocolMessageType", "DESCRIPTOR", "=", "descriptor", "new_msg", "=", "_ResultClass", "(", ")", "new_msg", ".", "ParseFromString", "(", "byte_str", ")", "return", "new_msg" ]

[ "Return", "type", "hints", "for", "an", "object", "." ]

[ "def", "get_type_hints", "(", "obj", ",", "globalns", "=", "None", ",", "localns", "=", "None", ")", ":", "if", "getattr", "(", "obj", ",", "'__no_type_check__'", ",", "None", ")", ":", "return", "{", "}", "# Classes require a special treatment.", "if", "isinstance", "(", "obj", ",", "type", ")", ":", "hints", "=", "{", "}", "for", "base", "in", "reversed", "(", "obj", ".", "__mro__", ")", ":", "if", "globalns", "is", "None", ":", "base_globals", "=", "sys", ".", "modules", "[", "base", ".", "__module__", "]", ".", "__dict__", "else", ":", "base_globals", "=", "globalns", "ann", "=", "base", ".", "__dict__", ".", "get", "(", "'__annotations__'", ",", "{", "}", ")", "for", "name", ",", "value", "in", "ann", ".", "items", "(", ")", ":", "if", "value", "is", "None", ":", "value", "=", "type", "(", "None", ")", "if", "isinstance", "(", "value", ",", "str", ")", ":", "value", "=", "ForwardRef", "(", "value", ",", "is_argument", "=", "False", ")", "value", "=", "_eval_type", "(", "value", ",", "base_globals", ",", "localns", ")", "hints", "[", "name", "]", "=", "value", "return", "hints", "if", "globalns", "is", "None", ":", "if", "isinstance", "(", "obj", ",", "types", ".", "ModuleType", ")", ":", "globalns", "=", "obj", ".", "__dict__", "else", ":", "nsobj", "=", "obj", "# Find globalns for the unwrapped object.", "while", "hasattr", "(", "nsobj", ",", "'__wrapped__'", ")", ":", "nsobj", "=", "nsobj", ".", "__wrapped__", "globalns", "=", "getattr", "(", "nsobj", ",", "'__globals__'", ",", "{", "}", ")", "if", "localns", "is", "None", ":", "localns", "=", "globalns", "elif", "localns", "is", "None", ":", "localns", "=", "globalns", "hints", "=", "getattr", "(", "obj", ",", "'__annotations__'", ",", "None", ")", "if", "hints", "is", "None", ":", "# Return empty annotations for something that _could_ have them.", "if", "isinstance", "(", "obj", ",", "_allowed_types", ")", ":", "return", "{", "}", "else", ":", "raise", "TypeError", "(", "'{!r} is not a module, class, method, '", "'or function.'", ".", "format", "(", "obj", ")", ")", "defaults", "=", "_get_defaults", "(", "obj", ")", "hints", "=", "dict", "(", "hints", ")", "for", "name", ",", "value", "in", "hints", ".", "items", "(", ")", ":", "if", "value", "is", "None", ":", "value", "=", "type", "(", "None", ")", "if", "isinstance", "(", "value", ",", "str", ")", ":", "value", "=", "ForwardRef", "(", "value", ")", "value", "=", "_eval_type", "(", "value", ",", "globalns", ",", "localns", ")", "if", "name", "in", "defaults", "and", "defaults", "[", "name", "]", "is", "None", ":", "value", "=", "Optional", "[", "value", "]", "hints", "[", "name", "]", "=", "value", "return", "hints" ]

[ "Initializes", "the", "project", "." ]

[ "def", "__init__", "(", "self", ",", "path", ",", "name", "=", "None", ",", "dependencies", "=", "None", ",", "guid", "=", "None", ",", "spec", "=", "None", ",", "build_file", "=", "None", ",", "config_platform_overrides", "=", "None", ",", "fixpath_prefix", "=", "None", ")", ":", "self", ".", "path", "=", "path", "self", ".", "guid", "=", "guid", "self", ".", "spec", "=", "spec", "self", ".", "build_file", "=", "build_file", "# Use project filename if name not specified", "self", ".", "name", "=", "name", "or", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "path", ")", ")", "[", "0", "]", "# Copy passed lists (or set to empty lists)", "self", ".", "dependencies", "=", "list", "(", "dependencies", "or", "[", "]", ")", "self", ".", "entry_type_guid", "=", "ENTRY_TYPE_GUIDS", "[", "'project'", "]", "if", "config_platform_overrides", ":", "self", ".", "config_platform_overrides", "=", "config_platform_overrides", "else", ":", "self", ".", "config_platform_overrides", "=", "{", "}", "self", ".", "fixpath_prefix", "=", "fixpath_prefix", "self", ".", "msbuild_toolset", "=", "None" ]

[ "Delete", "selected", "locations", "in", "-", "place", "(", "new", "array", "same", "ArrayManager", ")" ]

[ "def", "idelete", "(", "self", ",", "indexer", ")", "->", "SingleArrayManager", ":", "to_keep", "=", "np", ".", "ones", "(", "self", ".", "shape", "[", "0", "]", ",", "dtype", "=", "np", ".", "bool_", ")", "to_keep", "[", "indexer", "]", "=", "False", "self", ".", "arrays", "=", "[", "self", ".", "arrays", "[", "0", "]", "[", "to_keep", "]", "]", "self", ".", "_axes", "=", "[", "self", ".", "_axes", "[", "0", "]", "[", "to_keep", "]", "]", "return", "self" ]

[ "Attempts", "to", "extract", "the", "average", "gradient", "from", "the", "accumulator", "." ]

[ "def", "take_grad", "(", "self", ",", "num_required", ",", "name", "=", "None", ")", ":", "out", "=", "gen_data_flow_ops", ".", "accumulator_take_gradient", "(", "self", ".", "_accumulator_ref", ",", "num_required", ",", "dtype", "=", "self", ".", "_dtype", ",", "name", "=", "name", ")", "out", ".", "set_shape", "(", "self", ".", "_shape", ")", "return", "out" ]

[ "GetDefaultEncoding", "()", "-", ">", "int" ]

[ "def", "GetDefaultEncoding", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "Font_GetDefaultEncoding", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Convert", "this", "matrix", "to", "Compressed", "Sparse", "Row", "format", "." ]

[ "def", "tocsr", "(", "self", ",", "copy", "=", "False", ")", ":", "return", "self", ".", "tocoo", "(", "copy", "=", "copy", ")", ".", "tocsr", "(", "copy", "=", "False", ")" ]

[ "Checks", "that", "the", "new", "block", "is", "directly", "in", "a", "namespace", "." ]

[ "def", "IsBlockInNameSpace", "(", "nesting_state", ",", "is_forward_declaration", ")", ":", "if", "is_forward_declaration", ":", "return", "len", "(", "nesting_state", ".", "stack", ")", ">=", "1", "and", "(", "isinstance", "(", "nesting_state", ".", "stack", "[", "-", "1", "]", ",", "_NamespaceInfo", ")", ")", "return", "(", "len", "(", "nesting_state", ".", "stack", ")", ">", "1", "and", "nesting_state", ".", "stack", "[", "-", "1", "]", ".", "check_namespace_indentation", "and", "isinstance", "(", "nesting_state", ".", "stack", "[", "-", "2", "]", ",", "_NamespaceInfo", ")", ")" ]

[ "Returns", "the", "node", "in", "the", "subtree", "parented", "by", "this", "node", "that", "has", "a", "name", "attribute", "matching", "id", ".", "Returns", "None", "if", "no", "such", "node", "is", "found", "." ]

[ "def", "GetNodeById", "(", "self", ",", "id", ")", ":", "for", "node", "in", "self", ":", "if", "'name'", "in", "node", ".", "attrs", "and", "node", ".", "attrs", "[", "'name'", "]", "==", "id", ":", "return", "node", "return", "None" ]

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

[ "def", "DisableAllWatchpoints", "(", "self", ")", ":", "return", "_lldb", ".", "SBTarget_DisableAllWatchpoints", "(", "self", ")" ]

[ "Return", "ResNeXt", "symbol", "of", "Parameters", "----------", "units", ":", "list", "Number", "of", "units", "in", "each", "stage", "num_stages", ":", "int", "Number", "of", "stage", "filter_list", ":", "list", "Channel", "size", "of", "each", "stage", "num_classes", ":", "int", "Ouput", "size", "of", "symbol", "num_groupes", ":", "int", "Number", "of", "conv", "groups", "dataset", ":", "str", "Dataset", "type", "only", "cifar10", "and", "imagenet", "supports", "workspace", ":", "int", "Workspace", "used", "in", "convolution", "operator", "dtype", ":", "str", "Precision", "(", "float32", "or", "float16", ")" ]

[ "def", "resnext", "(", "units", ",", "num_stages", ",", "filter_list", ",", "num_classes", ",", "num_group", ",", "image_shape", ",", "bottle_neck", "=", "True", ",", "bn_mom", "=", "0.9", ",", "workspace", "=", "256", ",", "dtype", "=", "'float32'", ",", "memonger", "=", "False", ")", ":", "num_unit", "=", "len", "(", "units", ")", "assert", "(", "num_unit", "==", "num_stages", ")", "data", "=", "mx", ".", "sym", ".", "Variable", "(", "name", "=", "'data'", ")", "if", "dtype", "==", "'float32'", ":", "data", "=", "mx", ".", "sym", ".", "identity", "(", "data", "=", "data", ",", "name", "=", "'id'", ")", "else", ":", "if", "dtype", "==", "'float16'", ":", "data", "=", "mx", ".", "sym", ".", "Cast", "(", "data", "=", "data", ",", "dtype", "=", "np", ".", "float16", ")", "data", "=", "mx", ".", "sym", ".", "BatchNorm", "(", "data", "=", "data", ",", "fix_gamma", "=", "True", ",", "eps", "=", "2e-5", ",", "momentum", "=", "bn_mom", ",", "name", "=", "'bn_data'", ")", "(", "nchannel", ",", "height", ",", "width", ")", "=", "image_shape", "if", "height", "<=", "32", ":", "# such as cifar10", "body", "=", "mx", ".", "sym", ".", "Convolution", "(", "data", "=", "data", ",", "num_filter", "=", "filter_list", "[", "0", "]", ",", "kernel", "=", "(", "3", ",", "3", ")", ",", "stride", "=", "(", "1", ",", "1", ")", ",", "pad", "=", "(", "1", ",", "1", ")", ",", "no_bias", "=", "True", ",", "name", "=", "\"conv0\"", ",", "workspace", "=", "workspace", ")", "else", ":", "# often expected to be 224 such as imagenet", "body", "=", "mx", ".", "sym", ".", "Convolution", "(", "data", "=", "data", ",", "num_filter", "=", "filter_list", "[", "0", "]", ",", "kernel", "=", "(", "7", ",", "7", ")", ",", "stride", "=", "(", "2", ",", "2", ")", ",", "pad", "=", "(", "3", ",", "3", ")", ",", "no_bias", "=", "True", ",", "name", "=", "\"conv0\"", ",", "workspace", "=", "workspace", ")", "body", "=", "mx", ".", "sym", ".", "BatchNorm", "(", "data", "=", "body", ",", "fix_gamma", "=", "False", ",", "eps", "=", "2e-5", ",", "momentum", "=", "bn_mom", ",", "name", "=", "'bn0'", ")", "body", "=", "mx", ".", "sym", ".", "Activation", "(", "data", "=", "body", ",", "act_type", "=", "'relu'", ",", "name", "=", "'relu0'", ")", "body", "=", "mx", ".", "sym", ".", "Pooling", "(", "data", "=", "body", ",", "kernel", "=", "(", "3", ",", "3", ")", ",", "stride", "=", "(", "2", ",", "2", ")", ",", "pad", "=", "(", "1", ",", "1", ")", ",", "pool_type", "=", "'max'", ")", "for", "i", "in", "range", "(", "num_stages", ")", ":", "body", "=", "residual_unit", "(", "body", ",", "filter_list", "[", "i", "+", "1", "]", ",", "(", "1", "if", "i", "==", "0", "else", "2", ",", "1", "if", "i", "==", "0", "else", "2", ")", ",", "False", ",", "name", "=", "'stage%d_unit%d'", "%", "(", "i", "+", "1", ",", "1", ")", ",", "bottle_neck", "=", "bottle_neck", ",", "num_group", "=", "num_group", ",", "bn_mom", "=", "bn_mom", ",", "workspace", "=", "workspace", ",", "memonger", "=", "memonger", ")", "for", "j", "in", "range", "(", "units", "[", "i", "]", "-", "1", ")", ":", "body", "=", "residual_unit", "(", "body", ",", "filter_list", "[", "i", "+", "1", "]", ",", "(", "1", ",", "1", ")", ",", "True", ",", "name", "=", "'stage%d_unit%d'", "%", "(", "i", "+", "1", ",", "j", "+", "2", ")", ",", "bottle_neck", "=", "bottle_neck", ",", "num_group", "=", "num_group", ",", "bn_mom", "=", "bn_mom", ",", "workspace", "=", "workspace", ",", "memonger", "=", "memonger", ")", "pool1", "=", "mx", ".", "sym", ".", "Pooling", "(", "data", "=", "body", ",", "global_pool", "=", "True", ",", "kernel", "=", "(", "7", ",", "7", ")", ",", "pool_type", "=", "'avg'", ",", "name", "=", "'pool1'", ")", "flat", "=", "mx", ".", "sym", ".", "Flatten", "(", "data", "=", "pool1", ")", "fc1", "=", "mx", ".", "sym", ".", "FullyConnected", "(", "data", "=", "flat", ",", "num_hidden", "=", "num_classes", ",", "name", "=", "'fc1'", ")", "if", "dtype", "==", "'float16'", ":", "fc1", "=", "mx", ".", "sym", ".", "Cast", "(", "data", "=", "fc1", ",", "dtype", "=", "np", ".", "float32", ")", "return", "mx", ".", "sym", ".", "SoftmaxOutput", "(", "data", "=", "fc1", ",", "name", "=", "'softmax'", ")" ]

[ "SetIncludeRecognizedArguments", "(", "SBVariablesOptions", "self", "bool", "arg2", ")" ]

[ "def", "SetIncludeRecognizedArguments", "(", "self", ",", "arg2", ")", ":", "return", "_lldb", ".", "SBVariablesOptions_SetIncludeRecognizedArguments", "(", "self", ",", "arg2", ")" ]

[ "If", "we", "can", "t", "access", "the", "cache", "then", "we", "can", "just", "skip", "caching", "and", "process" ]

[ "def", "suppressed_cache_errors", "(", ")", ":", "# type: () -> Iterator[None]", "try", ":", "yield", "except", "OSError", ":", "pass" ]

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

[ "def", "GetEnablePrinter", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PageSetupDialogData_GetEnablePrinter", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "internal", "state", ";", "can", "be", "passed", "to", "setstate", "()", "later", "." ]

[ "def", "getstate", "(", "self", ")", ":", "return", "self", ".", "VERSION", ",", "self", ".", "_seed", ",", "self", ".", "gauss_next" ]

[ "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", "(", "self", ",", "polys", ",", "tags", ",", "img_height", ",", "img_width", ")", ":", "h", ",", "w", "=", "img_height", ",", "img_width", "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", "=", "self", ".", "polygon_area", "(", "poly", ")", "#invalid poly", "if", "abs", "(", "p_area", ")", "<", "1", ":", "continue", "if", "p_area", ">", "0", ":", "#'poly in wrong direction'", "if", "not", "tag", ":", "tag", "=", "True", "#reversed cases should be ignore", "poly", "=", "poly", "[", "(", "0", ",", "3", ",", "2", ",", "1", ")", ",", ":", "]", "validated_polys", ".", "append", "(", "poly", ")", "validated_tags", ".", "append", "(", "tag", ")", "return", "np", ".", "array", "(", "validated_polys", ")", ",", "np", ".", "array", "(", "validated_tags", ")" ]

[ "Some", "Proton", "APIs", "expect", "a", "null", "terminated", "string", ".", "Convert", "python", "text", "types", "to", "UTF8", "to", "avoid", "zero", "bytes", "introduced", "by", "other", "multi", "-", "byte", "encodings", ".", "This", "method", "will", "throw", "if", "the", "string", "cannot", "be", "converted", "." ]

[ "def", "unicode2utf8", "(", "string", ":", "Optional", "[", "str", "]", ")", "->", "Optional", "[", "str", "]", ":", "if", "string", "is", "None", ":", "return", "None", "elif", "isinstance", "(", "string", ",", "str", ")", ":", "# The swig binding converts py3 str -> utf8 char* and back automatically", "return", "string", "# Anything else illegal - specifically python3 bytes", "raise", "TypeError", "(", "\"Unrecognized string type: %r (%s)\"", "%", "(", "string", ",", "type", "(", "string", ")", ")", ")" ]

[ "Set", "the", "given", "flags", "and", "unset", "all", "others", "." ]

[ "def", "set_flags", "(", "self", ",", "flags", ")", ":", "self", ".", "_info", "=", "'2,'", "+", "''", ".", "join", "(", "sorted", "(", "flags", ")", ")" ]

[ "r", "IdentifyDriver", "(", "char", "const", "*", "utf8_path", "char", "**", "papszSiblings", "=", "None", ")", "-", ">", "Driver" ]

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

[ "Handle", "process", "attach", "." ]

[ "def", "doAttach", "(", "self", ",", "process_name", ")", ":", "error", "=", "lldb", ".", "SBError", "(", ")", "self", ".", "processListener", "=", "lldb", ".", "SBListener", "(", "\"process_event_listener\"", ")", "self", ".", "target", "=", "self", ".", "dbg", ".", "CreateTarget", "(", "''", ")", "self", ".", "process", "=", "self", ".", "target", ".", "AttachToProcessWithName", "(", "self", ".", "processListener", ",", "process_name", ",", "False", ",", "error", ")", "if", "not", "error", ".", "Success", "(", ")", ":", "sys", ".", "stderr", ".", "write", "(", "\"Error during attach: \"", "+", "str", "(", "error", ")", ")", "return", "self", ".", "ui", ".", "activate", "(", ")", "self", ".", "pid", "=", "self", ".", "process", ".", "GetProcessID", "(", ")", "print", "(", "\"Attached to %s (pid=%d)\"", "%", "(", "process_name", ",", "self", ".", "pid", ")", ")" ]

[ "Parse", "a", "document", "from", "a", "string", "returning", "the", "document", "node", "." ]

[ "def", "parseString", "(", "self", ",", "string", ")", ":", "parser", "=", "self", ".", "getParser", "(", ")", "try", ":", "parser", ".", "Parse", "(", "string", ",", "True", ")", "self", ".", "_setup_subset", "(", "string", ")", "except", "ParseEscape", ":", "pass", "doc", "=", "self", ".", "document", "self", ".", "reset", "(", ")", "self", ".", "_parser", "=", "None", "return", "doc" ]

[ "Outputs", "random", "values", "from", "a", "truncated", "normal", "distribution", "." ]

[ "def", "parameterized_truncated_normal", "(", "shape", ",", "means", "=", "0.0", ",", "stddevs", "=", "1.0", ",", "minvals", "=", "-", "2.0", ",", "maxvals", "=", "2.0", ",", "dtype", "=", "dtypes", ".", "float32", ",", "seed", "=", "None", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "shape", ",", "means", ",", "stddevs", ",", "minvals", ",", "maxvals", "]", ",", "name", ",", "\"parameterized_truncated_normal\"", ")", "as", "name", ":", "shape_tensor", "=", "_ShapeTensor", "(", "shape", ")", "means_tensor", "=", "ops", ".", "convert_to_tensor", "(", "means", ",", "dtype", "=", "dtype", ",", "name", "=", "\"means\"", ")", "stddevs_tensor", "=", "ops", ".", "convert_to_tensor", "(", "stddevs", ",", "dtype", "=", "dtype", ",", "name", "=", "\"stddevs\"", ")", "minvals_tensor", "=", "ops", ".", "convert_to_tensor", "(", "minvals", ",", "dtype", "=", "dtype", ",", "name", "=", "\"minvals\"", ")", "maxvals_tensor", "=", "ops", ".", "convert_to_tensor", "(", "maxvals", ",", "dtype", "=", "dtype", ",", "name", "=", "\"maxvals\"", ")", "seed1", ",", "seed2", "=", "random_seed", ".", "get_seed", "(", "seed", ")", "rnd", "=", "gen_random_ops", ".", "_parameterized_truncated_normal", "(", "shape_tensor", ",", "means_tensor", ",", "stddevs_tensor", ",", "minvals_tensor", ",", "maxvals_tensor", ",", "seed", "=", "seed1", ",", "seed2", "=", "seed2", ")", "return", "rnd" ]

[ "Updates", "the", "start", "and", "end", "x", "in", "the", "view", "and", "model", "using", "the", "provided", "values", "." ]

[ "def", "_update_start_and_end_x_in_view_and_model", "(", "self", ",", "run", ":", "str", ",", "group", ":", "str", ",", "start_x", ":", "float", ",", "end_x", ":", "float", ")", "->", "None", ":", "if", "self", ".", "view", ".", "is_run_group_displayed", "(", "run", ",", "group", ")", ":", "self", ".", "view", ".", "set_start_x", "(", "run", ",", "group", ",", "start_x", ")", "self", ".", "view", ".", "set_end_x", "(", "run", ",", "group", ",", "end_x", ")", "self", ".", "model", ".", "set_start_x", "(", "run", ",", "group", ",", "start_x", ")", "self", ".", "model", ".", "set_end_x", "(", "run", ",", "group", ",", "end_x", ")" ]

[ "Create", "a", "new", "buffered", "reader", "using", "the", "given", "readable", "raw", "IO", "object", "." ]

[ "def", "__init__", "(", "self", ",", "raw", ",", "buffer_size", "=", "DEFAULT_BUFFER_SIZE", ")", ":", "if", "not", "raw", ".", "readable", "(", ")", ":", "raise", "OSError", "(", "'\"raw\" argument must be readable.'", ")", "_BufferedIOMixin", ".", "__init__", "(", "self", ",", "raw", ")", "if", "buffer_size", "<=", "0", ":", "raise", "ValueError", "(", "\"invalid buffer size\"", ")", "self", ".", "buffer_size", "=", "buffer_size", "self", ".", "_reset_read_buf", "(", ")", "self", ".", "_read_lock", "=", "Lock", "(", ")" ]

[ "Apply", "glob", "to", "paths", "and", "prepend", "local_path", "if", "needed", "." ]

[ "def", "gpaths", "(", "paths", ",", "local_path", "=", "''", ",", "include_non_existing", "=", "True", ")", ":", "if", "is_string", "(", "paths", ")", ":", "paths", "=", "(", "paths", ",", ")", "return", "_fix_paths", "(", "paths", ",", "local_path", ",", "include_non_existing", ")" ]

[ "Initialize", "an", "mbox", "mailbox", "." ]

[ "def", "__init__", "(", "self", ",", "path", ",", "factory", "=", "None", ",", "create", "=", "True", ")", ":", "self", ".", "_message_factory", "=", "mboxMessage", "_mboxMMDF", ".", "__init__", "(", "self", ",", "path", ",", "factory", ",", "create", ")" ]

[ "Factor", "out", "the", "magic", "user", "hack", "for", "use", "in", "other", "classes" ]

[ "def", "getUserAndArea", "(", "user", ")", ":", "area", "=", "'user'", "tokens", "=", "user", ".", "split", "(", "'_'", ")", "if", "tokens", "and", "len", "(", "tokens", ")", ">", "1", ":", "user", "=", "tokens", "[", "0", "]", "area", "=", "tokens", "[", "1", "]", "return", "user", ",", "area" ]

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

[ "Searches", "the", "string", "for", "the", "pattern", "caching", "the", "compiled", "regexp", "." ]

[ "def", "Search", "(", "pattern", ",", "s", ")", ":", "if", "pattern", "not", "in", "_regexp_compile_cache", ":", "_regexp_compile_cache", "[", "pattern", "]", "=", "sre_compile", ".", "compile", "(", "pattern", ")", "return", "_regexp_compile_cache", "[", "pattern", "]", ".", "search", "(", "s", ")" ]

[ "PreSplitterWindow", "()", "-", ">", "SplitterWindow" ]

[ "def", "PreSplitterWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "val", "=", "_windows_", ".", "new_PreSplitterWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "val" ]

[ "Generate", "HTML", "for", "properties", ":", "Domain", "range" ]

[ "def", "rdfsPropertyInfo", "(", "term", ",", "m", ")", ":", "global", "classranges", "global", "classdomains", "doc", "=", "\"\"", "range", "=", "\"\"", "domain", "=", "\"\"", "# Find subPropertyOf information", "rlist", "=", "''", "first", "=", "True", "for", "st", "in", "findStatements", "(", "m", ",", "term", ",", "rdfs", ".", "subPropertyOf", ",", "None", ")", ":", "k", "=", "getTermLink", "(", "getObject", "(", "st", ")", ",", "term", ",", "rdfs", ".", "subPropertyOf", ")", "rlist", "+=", "getProperty", "(", "k", ",", "first", ")", "first", "=", "False", "if", "rlist", "!=", "''", ":", "doc", "+=", "'<tr><th>Sub-property of</th>'", "+", "rlist", "# Domain stuff", "domains", "=", "findStatements", "(", "m", ",", "term", ",", "rdfs", ".", "domain", ",", "None", ")", "domainsdoc", "=", "\"\"", "first", "=", "True", "for", "d", "in", "domains", ":", "union", "=", "findOne", "(", "m", ",", "getObject", "(", "d", ")", ",", "owl", ".", "unionOf", ",", "None", ")", "if", "union", ":", "uris", "=", "parseCollection", "(", "m", ",", "getObject", "(", "union", ")", ")", "for", "uri", "in", "uris", ":", "domainsdoc", "+=", "getProperty", "(", "getTermLink", "(", "uri", ",", "term", ",", "rdfs", ".", "domain", ")", ",", "first", ")", "add", "(", "classdomains", ",", "uri", ",", "term", ")", "else", ":", "if", "not", "isBlank", "(", "getObject", "(", "d", ")", ")", ":", "domainsdoc", "+=", "getProperty", "(", "getTermLink", "(", "getObject", "(", "d", ")", ",", "term", ",", "rdfs", ".", "domain", ")", ",", "first", ")", "first", "=", "False", "if", "(", "len", "(", "domainsdoc", ")", ">", "0", ")", ":", "doc", "+=", "\"<tr><th>Domain</th>%s\"", "%", "domainsdoc", "# Range stuff", "ranges", "=", "findStatements", "(", "m", ",", "term", ",", "rdfs", ".", "range", ",", "None", ")", "rangesdoc", "=", "\"\"", "first", "=", "True", "for", "r", "in", "ranges", ":", "union", "=", "findOne", "(", "m", ",", "getObject", "(", "r", ")", ",", "owl", ".", "unionOf", ",", "None", ")", "if", "union", ":", "uris", "=", "parseCollection", "(", "m", ",", "getObject", "(", "union", ")", ")", "for", "uri", "in", "uris", ":", "rangesdoc", "+=", "getProperty", "(", "getTermLink", "(", "uri", ",", "term", ",", "rdfs", ".", "range", ")", ",", "first", ")", "add", "(", "classranges", ",", "uri", ",", "term", ")", "first", "=", "False", "else", ":", "if", "not", "isBlank", "(", "getObject", "(", "r", ")", ")", ":", "rangesdoc", "+=", "getProperty", "(", "getTermLink", "(", "getObject", "(", "r", ")", ",", "term", ",", "rdfs", ".", "range", ")", ",", "first", ")", "first", "=", "False", "if", "(", "len", "(", "rangesdoc", ")", ">", "0", ")", ":", "doc", "+=", "\"<tr><th>Range</th>%s\"", "%", "rangesdoc", "return", "doc" ]

[ "Return", "instance", "of", "ParquetFile", "." ]

[ "def", "open", "(", "self", ")", ":", "reader", "=", "self", ".", "open_file_func", "(", "self", ".", "path", ")", "if", "not", "isinstance", "(", "reader", ",", "ParquetFile", ")", ":", "reader", "=", "ParquetFile", "(", "reader", ",", "*", "*", "self", ".", "file_options", ")", "return", "reader" ]

[ "Create", "a", "84x84", "chessboard", "with", "small", "square", "size", "n", "pixels", "." ]

[ "def", "make_chessboard", "(", "n", ")", ":", "return", "make_chessboard_any_size", "(", "84", ",", "n", ")" ]

[ "Convert", "the", "Batch", "object", "into", "the", "format", "required", "for", "Layer1", "." ]

[ "def", "to_dict", "(", "self", ")", ":", "batch_dict", "=", "{", "}", "key_list", "=", "[", "]", "for", "key", "in", "self", ".", "keys", ":", "if", "isinstance", "(", "key", ",", "tuple", ")", ":", "hash_key", ",", "range_key", "=", "key", "else", ":", "hash_key", "=", "key", "range_key", "=", "None", "k", "=", "self", ".", "table", ".", "layer2", ".", "build_key_from_values", "(", "self", ".", "table", ".", "schema", ",", "hash_key", ",", "range_key", ")", "key_list", ".", "append", "(", "k", ")", "batch_dict", "[", "'Keys'", "]", "=", "key_list", "if", "self", ".", "attributes_to_get", ":", "batch_dict", "[", "'AttributesToGet'", "]", "=", "self", ".", "attributes_to_get", "if", "self", ".", "consistent_read", ":", "batch_dict", "[", "'ConsistentRead'", "]", "=", "True", "else", ":", "batch_dict", "[", "'ConsistentRead'", "]", "=", "False", "return", "batch_dict" ]

[ "..", "deprecated", "::", "3", ".", "4", "Do", "not", "use", "will", "be", "removed", "in", "QGIS", "4", ".", "0" ]

[ "def", "__init__", "(", "self", ",", "param", ",", "dialog", ",", "row", "=", "0", ",", "col", "=", "0", ",", "*", "*", "kwargs", ")", ":", "from", "warnings", "import", "warn", "warn", "(", "\"StringWidgetWrapper is deprecated and will be removed in QGIS 4.0\"", ",", "DeprecationWarning", ")", "super", "(", ")", ".", "__init__", "(", "param", ",", "dialog", ",", "row", ",", "col", ",", "*", "*", "kwargs", ")", "self", ".", "context", "=", "dataobjects", ".", "createContext", "(", ")" ]