Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Return", "the", "location", "where", "we", "store", "the", "downloaded", "tarball", "for", "this", "package" ]

[ "def", "tarfile", "(", "build_os", ",", "arch", ",", "spec", ")", ":", "return", "\"dl/mongodb-linux-%s-enterprise-%s-%s.tar.gz\"", "%", "(", "spec", ".", "version", "(", ")", ",", "build_os", ",", "arch", ")" ]

[ "Call", "this", "at", "the", "end", "of", "any", "layer", "or", "block", "that", "takes", "an", "optional", "name", "argument", "." ]

[ "def", "_inject_name", "(", "f", ",", "name", ")", ":", "if", "name", ":", "if", "not", "isinstance", "(", "f", ",", "Function", ")", ":", "f", "=", "Function", "(", "f", ")", "if", "len", "(", "f", ".", "outputs", ")", "==", "1", ":", "f", "=", "alias", "(", "f", ",", "name", "=", "name", ")", "else", ":", "f", "=", "combine", "(", "list", "(", "f", ".", "outputs", ")", ",", "name", "=", "name", ")", "# BUGBUG: Does this actually name things?", "return", "f" ]

[ "Initialize", "a", "message", "publisher" ]

[ "def", "__init__", "(", "self", ",", "name", ",", "topic_type", "=", "\"\"", ",", "topic_descriptor", "=", "\"\"", ")", ":", "self", ".", "c_publisher", "=", "ecal_core", ".", "publisher", "(", "name", ",", "topic_type", ",", "topic_descriptor", ")" ]

[ "Compute", "hash", "in", "a", "way", "which", "matches", "the", "equality", "test", "." ]

[ "def", "__hash__", "(", "self", ")", ":", "return", "hash", "(", "self", ".", "name", ")", "+", "hash", "(", "self", ".", "version", ")", "+", "hash", "(", "self", ".", "source_url", ")" ]

[ "Register", "a", "view", "for", "image", "capture", "with", "extra", "meta", "-", "data", "such", "as", "magnification", "size", "and", "frequency", "." ]

[ "def", "RegisterView", "(", "self", ",", "view", ",", "filename", ",", "freq", ",", "fittoscreen", ",", "magnification", ",", "width", ",", "height", ",", "cinema", "=", "None", ",", "compression", "=", "None", ")", ":", "if", "not", "isinstance", "(", "view", ",", "servermanager", ".", "Proxy", ")", ":", "raise", "RuntimeError", "(", "\"Invalid 'view' argument passed to RegisterView.\"", ")", "view", ".", "add_attribute", "(", "\"cpFileName\"", ",", "filename", ")", "view", ".", "add_attribute", "(", "\"cpFrequency\"", ",", "freq", ")", "view", ".", "add_attribute", "(", "\"cpFitToScreen\"", ",", "fittoscreen", ")", "view", ".", "add_attribute", "(", "\"cpMagnification\"", ",", "magnification", ")", "view", ".", "add_attribute", "(", "\"cpCinemaOptions\"", ",", "cinema", ")", "view", ".", "add_attribute", "(", "\"cpCompression\"", ",", "compression", ")", "view", ".", "ViewSize", "=", "[", "width", ",", "height", "]", "self", ".", "__ViewsList", ".", "append", "(", "view", ")", "return", "view" ]

[ "Remove", "trailing", "coefficients" ]

[ "def", "trim", "(", "self", ",", "tol", "=", "0", ")", ":", "coef", "=", "pu", ".", "trimcoef", "(", "self", ".", "coef", ",", "tol", ")", "return", "self", ".", "__class__", "(", "coef", ",", "self", ".", "domain", ",", "self", ".", "window", ")" ]

[ ":", "type", "answers", ":", "List", "[", "int", "]", ":", "rtype", ":", "int" ]

[ "def", "numRabbits", "(", "self", ",", "answers", ")", ":", "count", "=", "collections", ".", "Counter", "(", "answers", ")", "return", "sum", "(", "(", "(", "(", "k", "+", "1", ")", "+", "v", "-", "1", ")", "//", "(", "k", "+", "1", ")", ")", "*", "(", "k", "+", "1", ")", "for", "k", ",", "v", "in", "count", ".", "iteritems", "(", ")", ")" ]

[ "Finalize", "the", "PassManager", "after", "which", "no", "more", "passes", "may", "be", "added", "without", "re", "-", "finalization", "." ]

[ "def", "finalize", "(", "self", ")", ":", "self", ".", "_analysis", "=", "self", ".", "dependency_analysis", "(", ")", "self", ".", "_print_after", ",", "self", ".", "_print_before", ",", "self", ".", "_print_wrap", "=", "self", ".", "_debug_init", "(", ")", "self", ".", "_finalized", "=", "True" ]

[ "This", "is", "a", "fancy", "raw_input", "function", ".", "If", "the", "user", "enters", "?", "then", "the", "contents", "of", "help", "is", "printed", "." ]

[ "def", "input_option", "(", "message", ",", "default_value", "=", "\"\"", ",", "help", "=", "None", ",", "level", "=", "0", ",", "max_level", "=", "0", ")", ":", "if", "default_value", "!=", "''", ":", "message", "=", "\"%s [%s] \"", "%", "(", "message", ",", "default_value", ")", "if", "level", ">", "max_level", ":", "return", "default_value", "while", "True", ":", "user_input", "=", "raw_input", "(", "message", ")", "if", "user_input", "==", "'?'", ":", "print", "help", "elif", "user_input", "==", "''", ":", "return", "default_value", "else", ":", "break", "return", "user_input" ]

[ "Check", "whether", "the", "node", "has", "the", "specified", "property", "." ]

[ "def", "has_property", "(", "self", ",", "identifier", ")", ":", "return", "identifier", "in", "self", ".", "_property_map" ]

[ "Phase", "I", "in", "the", "SCP", "-", "algorithm", "." ]

[ "def", "kcliquesByEdges", "(", "edges", ",", "k", ")", ":", "newNet", "=", "SymmNet", "(", ")", "# Edges are added to a empty network one by one", "for", "edge", "in", "edges", ":", "if", "isinstance", "(", "edge", ",", "EvaluationEvent", ")", ":", "yield", "edge", "else", ":", "# First we find all new triangles that are born when the new edge is added", "triangleEnds", "=", "set", "(", ")", "# We keep track of the tip nodes of the new triangles", "for", "adjacendNode", "in", "newNet", "[", "edge", "[", "0", "]", "]", ":", "# Neighbor of one node of the edge ...", "if", "newNet", "[", "adjacendNode", ",", "edge", "[", "1", "]", "]", "!=", "0", ":", "# ...is a neighbor of the other node of the edge...", "triangleEnds", ".", "add", "(", "adjacendNode", ")", "# ...then the neighbor is a tip of a new triangle", "# New k-cliques are now (k-2)-cliques at the triangle end points plus", "# the two nodes at the tips of the edge we are adding to the network", "for", "kclique", "in", "kcliquesAtSubnet", "(", "triangleEnds", ",", "newNet", ",", "k", "-", "2", ")", ":", "yield", "kclique", "+", "KClique", "(", "[", "edge", "[", "0", "]", ",", "edge", "[", "1", "]", "]", ")", "newNet", "[", "edge", "[", "0", "]", ",", "edge", "[", "1", "]", "]", "=", "edge", "[", "2", "]" ]

[ "Shape", "of", "the", "state", "of", "Cudnn", "RNN", "cells", "w", "/", "o", ".", "input_c", "." ]

[ "def", "state_shape", "(", "self", ",", "batch_size", ")", ":", "return", "[", "self", ".", "num_layers", "*", "self", ".", "num_dirs", ",", "batch_size", ",", "self", ".", "num_units", "]", "," ]

[ "Return", "the", "width", "of", "this", "widget", "." ]

[ "def", "winfo_width", "(", "self", ")", ":", "return", "getint", "(", "self", ".", "tk", ".", "call", "(", "'winfo'", ",", "'width'", ",", "self", ".", "_w", ")", ")" ]

[ "Send", "break", "condition", ".", "Timed", "returns", "to", "idle", "state", "after", "given", "duration", "." ]

[ "def", "sendBreak", "(", "self", ",", "duration", "=", "0.25", ")", ":", "if", "not", "self", ".", "_isOpen", ":", "raise", "portNotOpenError", "termios", ".", "tcsendbreak", "(", "self", ".", "fd", ",", "int", "(", "duration", "/", "0.25", ")", ")" ]

[ "expression", ":", "MINUS", "expression", "%prec", "UMINUS" ]

[ "def", "p_expression_uminus", "(", "self", ",", "p", ")", ":", "p", "[", "0", "]", "=", "-", "p", "[", "2", "]" ]

[ "Initialize", "a", "MulticlassLabel", "instance", "." ]

[ "def", "__init__", "(", "self", ",", "label", ":", "Hashable", ",", "weight", ":", "Optional", "[", "Hashable", "]", "=", "None", ")", ":", "self", ".", "label", "=", "label", "self", ".", "weight", "=", "weight" ]

[ "SetPortId", "(", "self", "int", "n", ")" ]

[ "def", "SetPortId", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "PlatformInformation_SetPortId", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Set", "the", "properties", "only", "if", "they", "don", "t", "already", "exist", "." ]

[ "def", "set_properties", "(", "self", ",", "vobj", ")", ":", "properties", "=", "vobj", ".", "PropertiesList", "self", ".", "set_annotation_properties", "(", "vobj", ",", "properties", ")", "self", ".", "set_graphics_properties", "(", "vobj", ",", "properties", ")" ]

[ "Generate", "C", "function", "pointer", "typedef", "for", "<command", ">", "Element" ]

[ "def", "makeThreadUseBlock", "(", "self", ",", "cmd", ",", "name", ",", "functionprefix", ")", ":", "paramdecl", "=", "''", "# Find and add any parameters that are thread unsafe", "params", "=", "cmd", ".", "findall", "(", "'param'", ")", "for", "param", "in", "params", ":", "paramname", "=", "param", ".", "find", "(", "'name'", ")", "if", "False", ":", "# self.paramIsPointer(param):", "paramdecl", "+=", "' // not watching use of pointer '", "+", "paramname", ".", "text", "+", "'\\n'", "else", ":", "externsync", "=", "param", ".", "attrib", ".", "get", "(", "'externsync'", ")", "if", "externsync", "==", "'true'", ":", "if", "self", ".", "paramIsArray", "(", "param", ")", ":", "paramdecl", "+=", "'if ('", "+", "paramname", ".", "text", "+", "') {\\n'", "paramdecl", "+=", "' for (uint32_t index=0; index < '", "+", "param", ".", "attrib", ".", "get", "(", "'len'", ")", "+", "'; index++) {\\n'", "paramdecl", "+=", "' '", "+", "functionprefix", "+", "'WriteObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'('", "+", "paramname", ".", "text", "+", "'[index], \"'", "+", "name", "+", "'\");\\n'", "paramdecl", "+=", "' }\\n'", "paramdecl", "+=", "'}\\n'", "else", ":", "paramdecl", "+=", "functionprefix", "+", "'WriteObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'('", "+", "paramname", ".", "text", "+", "', \"'", "+", "name", "+", "'\");\\n'", "if", "(", "'Destroy'", "in", "name", "or", "'Free'", "in", "name", "or", "'ReleasePerformanceConfigurationINTEL'", "in", "name", ")", "and", "functionprefix", "==", "'Finish'", ":", "paramdecl", "+=", "'DestroyObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'('", "+", "paramname", ".", "text", "+", "');\\n'", "elif", "(", "param", ".", "attrib", ".", "get", "(", "'externsync'", ")", ")", ":", "if", "self", ".", "paramIsArray", "(", "param", ")", ":", "# Externsync can list pointers to arrays of members to synchronize", "paramdecl", "+=", "'if ('", "+", "paramname", ".", "text", "+", "') {\\n'", "paramdecl", "+=", "' for (uint32_t index=0; index < '", "+", "param", ".", "attrib", ".", "get", "(", "'len'", ")", "+", "'; index++) {\\n'", "second_indent", "=", "' '", "for", "member", "in", "externsync", ".", "split", "(", "\",\"", ")", ":", "# Replace first empty [] in member name with index", "element", "=", "member", ".", "replace", "(", "'[]'", ",", "'[index]'", ",", "1", ")", "# XXX TODO: Can we do better to lookup types of externsync members?", "suffix", "=", "''", "if", "'surface'", "in", "member", "or", "'swapchain'", "in", "member", ".", "lower", "(", ")", ":", "suffix", "=", "'ParentInstance'", "if", "'[]'", "in", "element", ":", "# TODO: These null checks can be removed if threading ends up behind parameter", "# validation in layer order", "element_ptr", "=", "element", ".", "split", "(", "'[]'", ")", "[", "0", "]", "paramdecl", "+=", "' if ('", "+", "element_ptr", "+", "') {\\n'", "# Replace any second empty [] in element name with inner array index based on mapping array", "# names like \"pSomeThings[]\" to \"someThingCount\" array size. This could be more robust by", "# mapping a param member name to a struct type and \"len\" attribute.", "limit", "=", "element", "[", "0", ":", "element", ".", "find", "(", "'s[]'", ")", "]", "+", "'Count'", "dotp", "=", "limit", ".", "rfind", "(", "'.p'", ")", "limit", "=", "limit", "[", "0", ":", "dotp", "+", "1", "]", "+", "limit", "[", "dotp", "+", "2", ":", "dotp", "+", "3", "]", ".", "lower", "(", ")", "+", "limit", "[", "dotp", "+", "3", ":", "]", "paramdecl", "+=", "' for (uint32_t index2=0; index2 < '", "+", "limit", "+", "'; index2++) {\\n'", "element", "=", "element", ".", "replace", "(", "'[]'", ",", "'[index2]'", ")", "second_indent", "=", "' '", "paramdecl", "+=", "' '", "+", "second_indent", "+", "functionprefix", "+", "'WriteObject'", "+", "suffix", "+", "'('", "+", "element", "+", "', \"'", "+", "name", "+", "'\");\\n'", "paramdecl", "+=", "' }\\n'", "paramdecl", "+=", "' }\\n'", "else", ":", "paramdecl", "+=", "' '", "+", "second_indent", "+", "functionprefix", "+", "'WriteObject'", "+", "suffix", "+", "'('", "+", "element", "+", "', \"'", "+", "name", "+", "'\");\\n'", "paramdecl", "+=", "' }\\n'", "paramdecl", "+=", "'}\\n'", "else", ":", "# externsync can list members to synchronize", "for", "member", "in", "externsync", ".", "split", "(", "\",\"", ")", ":", "member", "=", "str", "(", "member", ")", ".", "replace", "(", "\"::\"", ",", "\"->\"", ")", "member", "=", "str", "(", "member", ")", ".", "replace", "(", "\".\"", ",", "\"->\"", ")", "# XXX TODO: Can we do better to lookup types of externsync members?", "suffix", "=", "''", "if", "'surface'", "in", "member", "or", "'swapchain'", "in", "member", ".", "lower", "(", ")", ":", "suffix", "=", "'ParentInstance'", "paramdecl", "+=", "' '", "+", "functionprefix", "+", "'WriteObject'", "+", "suffix", "+", "'('", "+", "member", "+", "', \"'", "+", "name", "+", "'\");\\n'", "elif", "self", ".", "paramIsPointer", "(", "param", ")", "and", "(", "'Create'", "in", "name", "or", "'Allocate'", "in", "name", "or", "'AcquirePerformanceConfigurationINTEL'", "in", "name", ")", "and", "functionprefix", "==", "'Finish'", ":", "paramtype", "=", "param", ".", "find", "(", "'type'", ")", "if", "paramtype", "is", "not", "None", ":", "paramtype", "=", "paramtype", ".", "text", "else", ":", "paramtype", "=", "'None'", "if", "paramtype", "in", "self", ".", "handle_types", ":", "indent", "=", "''", "create_pipelines_call", "=", "True", "# The CreateXxxPipelines APIs can return a list of partly created pipelines upon failure", "if", "not", "(", "'Create'", "in", "name", "and", "'Pipelines'", "in", "name", ")", ":", "paramdecl", "+=", "'if (result == VK_SUCCESS) {\\n'", "create_pipelines_call", "=", "False", "indent", "=", "' '", "if", "self", ".", "paramIsArray", "(", "param", ")", ":", "# Add pointer dereference for array counts that are pointer values", "dereference", "=", "''", "for", "candidate", "in", "params", ":", "if", "param", ".", "attrib", ".", "get", "(", "'len'", ")", "==", "candidate", ".", "find", "(", "'name'", ")", ".", "text", ":", "if", "self", ".", "paramIsPointer", "(", "candidate", ")", ":", "dereference", "=", "'*'", "param_len", "=", "str", "(", "param", ".", "attrib", ".", "get", "(", "'len'", ")", ")", ".", "replace", "(", "\"::\"", ",", "\"->\"", ")", "paramdecl", "+=", "indent", "+", "'if ('", "+", "paramname", ".", "text", "+", "') {\\n'", "paramdecl", "+=", "indent", "+", "' for (uint32_t index = 0; index < '", "+", "dereference", "+", "param_len", "+", "'; index++) {\\n'", "if", "create_pipelines_call", ":", "paramdecl", "+=", "indent", "+", "' if (!pPipelines[index]) continue;\\n'", "paramdecl", "+=", "indent", "+", "' CreateObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'('", "+", "paramname", ".", "text", "+", "'[index]);\\n'", "paramdecl", "+=", "indent", "+", "' }\\n'", "paramdecl", "+=", "indent", "+", "'}\\n'", "else", ":", "paramdecl", "+=", "' CreateObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'(*'", "+", "paramname", ".", "text", "+", "');\\n'", "if", "not", "create_pipelines_call", ":", "paramdecl", "+=", "'}\\n'", "else", ":", "paramtype", "=", "param", ".", "find", "(", "'type'", ")", "if", "paramtype", "is", "not", "None", ":", "paramtype", "=", "paramtype", ".", "text", "else", ":", "paramtype", "=", "'None'", "if", "paramtype", "in", "self", ".", "handle_types", "and", "paramtype", "!=", "'VkPhysicalDevice'", ":", "if", "self", ".", "paramIsArray", "(", "param", ")", "and", "(", "'pPipelines'", "!=", "paramname", ".", "text", ")", ":", "# Add pointer dereference for array counts that are pointer values", "dereference", "=", "''", "for", "candidate", "in", "params", ":", "if", "param", ".", "attrib", ".", "get", "(", "'len'", ")", "==", "candidate", ".", "find", "(", "'name'", ")", ".", "text", ":", "if", "self", ".", "paramIsPointer", "(", "candidate", ")", ":", "dereference", "=", "'*'", "param_len", "=", "str", "(", "param", ".", "attrib", ".", "get", "(", "'len'", ")", ")", ".", "replace", "(", "\"::\"", ",", "\"->\"", ")", "paramdecl", "+=", "'if ('", "+", "paramname", ".", "text", "+", "') {\\n'", "paramdecl", "+=", "' for (uint32_t index = 0; index < '", "+", "dereference", "+", "param_len", "+", "'; index++) {\\n'", "paramdecl", "+=", "' '", "+", "functionprefix", "+", "'ReadObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'('", "+", "paramname", ".", "text", "+", "'[index], \"'", "+", "name", "+", "'\");\\n'", "paramdecl", "+=", "' }\\n'", "paramdecl", "+=", "'}\\n'", "elif", "not", "self", ".", "paramIsPointer", "(", "param", ")", ":", "# Pointer params are often being created.", "# They are not being read from.", "paramdecl", "+=", "functionprefix", "+", "'ReadObject'", "+", "self", ".", "paramSuffix", "(", "param", ".", "find", "(", "'type'", ")", ")", "+", "'('", "+", "paramname", ".", "text", "+", "', \"'", "+", "name", "+", "'\");\\n'", "explicitexternsyncparams", "=", "cmd", ".", "findall", "(", "\"param[@externsync]\"", ")", "if", "(", "explicitexternsyncparams", "is", "not", "None", ")", ":", "for", "param", "in", "explicitexternsyncparams", ":", "externsyncattrib", "=", "param", ".", "attrib", ".", "get", "(", "'externsync'", ")", "paramname", "=", "param", ".", "find", "(", "'name'", ")", "paramdecl", "+=", "'// Host access to '", "if", "externsyncattrib", "==", "'true'", ":", "if", "self", ".", "paramIsArray", "(", "param", ")", ":", "paramdecl", "+=", "'each member of '", "+", "paramname", ".", "text", "elif", "self", ".", "paramIsPointer", "(", "param", ")", ":", "paramdecl", "+=", "'the object referenced by '", "+", "paramname", ".", "text", "else", ":", "paramdecl", "+=", "paramname", ".", "text", "else", ":", "paramdecl", "+=", "externsyncattrib", "paramdecl", "+=", "' must be externally synchronized\\n'", "# Find and add any \"implicit\" parameters that are thread unsafe", "implicitexternsyncparams", "=", "cmd", ".", "find", "(", "'implicitexternsyncparams'", ")", "if", "(", "implicitexternsyncparams", "is", "not", "None", ")", ":", "for", "elem", "in", "implicitexternsyncparams", ":", "paramdecl", "+=", "'// '", "paramdecl", "+=", "elem", ".", "text", "paramdecl", "+=", "' must be externally synchronized between host accesses\\n'", "if", "(", "paramdecl", "==", "''", ")", ":", "return", "None", "else", ":", "return", "paramdecl" ]

[ "Return", "leaf", "names", "in", "the", "specified", "directory", "which", "match", "the", "pattern", "." ]

[ "def", "globpattern", "(", "dir", ",", "pattern", ")", ":", "if", "not", "hasglob", "(", "pattern", ")", ":", "if", "pattern", "==", "''", ":", "if", "os", ".", "path", ".", "isdir", "(", "dir", ")", ":", "return", "[", "''", "]", "return", "[", "]", "if", "os", ".", "path", ".", "exists", "(", "util", ".", "normaljoin", "(", "dir", ",", "pattern", ")", ")", ":", "return", "[", "pattern", "]", "return", "[", "]", "leaves", "=", "os", ".", "listdir", "(", "dir", ")", "+", "[", "'.'", ",", "'..'", "]", "# \"hidden\" filenames are a bit special", "if", "not", "pattern", ".", "startswith", "(", "'.'", ")", ":", "leaves", "=", "[", "leaf", "for", "leaf", "in", "leaves", "if", "not", "leaf", ".", "startswith", "(", "'.'", ")", "]", "leaves", "=", "fnmatch", ".", "filter", "(", "leaves", ",", "pattern", ")", "leaves", "=", "filter", "(", "lambda", "l", ":", "os", ".", "path", ".", "exists", "(", "util", ".", "normaljoin", "(", "dir", ",", "l", ")", ")", ",", "leaves", ")", "leaves", ".", "sort", "(", ")", "return", "leaves" ]

[ "Retrieves", "this", "service", "s", "descriptor", "." ]

[ "def", "GetDescriptor", "(", ")", ":", "raise", "NotImplementedError" ]

[ "Plots", "the", "guess", "workspace", "from", "a", "fit" ]

[ "def", "plot_guess_workspace", "(", "self", ",", "guess_ws_name", ":", "str", ")", ":", "pass" ]

[ "This", "sets", "the", "current_state", "to", "the", "initial_state", "and", "sets", "input_symbol", "to", "None", ".", "The", "initial", "state", "was", "set", "by", "the", "constructor", "__init__", "()", "." ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "current_state", "=", "self", ".", "initial_state", "self", ".", "input_symbol", "=", "None" ]

[ "Method", "for", "ending", "the", "sniffer", "capture", ".", "Should", "stop", "background", "capturing", "No", "further", "file", "I", "/", "O", "in", "capture", "file", "." ]

[ "def", "stopSniffer", "(", "self", ")", ":", "if", "self", ".", "is_active", ":", "self", ".", "is_active", "=", "False", "if", "self", ".", "subprocess", ":", "self", ".", "subprocess", ".", "terminate", "(", ")", "self", ".", "subprocess", ".", "wait", "(", ")" ]

[ "Returns", "true", "if", "the", "current", "token", "is", "within", "parentheses", "." ]

[ "def", "InParentheses", "(", "self", ")", ":", "return", "bool", "(", "self", ".", "_paren_depth", ")" ]

[ "Return", "the", "parameter", "value", "if", "found", "in", "the", "Content", "-", "Type", "header", "." ]

[ "def", "get_param", "(", "self", ",", "param", ",", "failobj", "=", "None", ",", "header", "=", "'content-type'", ",", "unquote", "=", "True", ")", ":", "if", "header", "not", "in", "self", ":", "return", "failobj", "for", "k", ",", "v", "in", "self", ".", "_get_params_preserve", "(", "failobj", ",", "header", ")", ":", "if", "k", ".", "lower", "(", ")", "==", "param", ".", "lower", "(", ")", ":", "if", "unquote", ":", "return", "_unquotevalue", "(", "v", ")", "else", ":", "return", "v", "return", "failobj" ]

[ "Calculate", "the", "mode", "permissions", "for", "a", "bytecode", "file", "." ]

[ "def", "_calc_mode", "(", "path", ")", ":", "try", ":", "mode", "=", "_path_stat", "(", "path", ")", ".", "st_mode", "except", "OSError", ":", "mode", "=", "0o666", "# We always ensure write access so we can update cached files", "# later even when the source files are read-only on Windows (#6074)", "mode", "|=", "0o200", "return", "mode" ]

[ "Reports", "unused", "cycle", "suppressions", "." ]

[ "def", "report_unused_cycle_suppressions", "(", "self", ",", "reporter", ")", ":", "for", "module", "in", "self", ".", "get_modules", "(", ")", ":", "for", "dep", "in", "module", ".", "get_dependencies", "(", ")", ":", "if", "not", "dep", ".", "suppression_used", ":", "reporter", ".", "cyclic_issue", "(", "\"unused cycle suppression: {0} -> {1}\"", ".", "format", "(", "module", ".", "get_name", "(", ")", "[", "7", ":", "]", ",", "dep", ".", "get_other_module", "(", ")", ".", "get_name", "(", ")", "[", "7", ":", "]", ")", ")" ]

[ "Return", "a", "node", "which", "performs", "AdaptiveAvgPool", "operation", "." ]

[ "def", "adaptive_avg_pool", "(", "data", ":", "NodeInput", ",", "output_shape", ":", "NodeInput", ")", "->", "Node", ":", "inputs", "=", "as_nodes", "(", "data", ",", "output_shape", ")", "return", "_get_node_factory_opset8", "(", ")", ".", "create", "(", "\"AdaptiveAvgPool\"", ",", "inputs", ")" ]

[ "Returns", "a", "PropertyGroup", "definition", "for", "the", "specified", "properties", "." ]

[ "def", "_GetMSBuildPropertyGroup", "(", "spec", ",", "label", ",", "properties", ")", ":", "group", "=", "[", "\"PropertyGroup\"", "]", "if", "label", ":", "group", ".", "append", "(", "{", "\"Label\"", ":", "label", "}", ")", "num_configurations", "=", "len", "(", "spec", "[", "\"configurations\"", "]", ")", "def", "GetEdges", "(", "node", ")", ":", "# Use a definition of edges such that user_of_variable -> used_varible.", "# This happens to be easier in this case, since a variable's", "# definition contains all variables it references in a single string.", "edges", "=", "set", "(", ")", "for", "value", "in", "sorted", "(", "properties", "[", "node", "]", ".", "keys", "(", ")", ")", ":", "# Add to edges all $(...) references to variables.", "#", "# Variable references that refer to names not in properties are excluded", "# These can exist for instance to refer built in definitions like", "# $(SolutionDir).", "#", "# Self references are ignored. Self reference is used in a few places to", "# append to the default value. I.e. PATH=$(PATH);other_path", "edges", ".", "update", "(", "{", "v", "for", "v", "in", "MSVS_VARIABLE_REFERENCE", ".", "findall", "(", "value", ")", "if", "v", "in", "properties", "and", "v", "!=", "node", "}", ")", "return", "edges", "properties_ordered", "=", "gyp", ".", "common", ".", "TopologicallySorted", "(", "properties", ".", "keys", "(", ")", ",", "GetEdges", ")", "# Walk properties in the reverse of a topological sort on", "# user_of_variable -> used_variable as this ensures variables are", "# defined before they are used.", "# NOTE: reverse(topsort(DAG)) = topsort(reverse_edges(DAG))", "for", "name", "in", "reversed", "(", "properties_ordered", ")", ":", "values", "=", "properties", "[", "name", "]", "for", "value", ",", "conditions", "in", "sorted", "(", "values", ".", "items", "(", ")", ")", ":", "if", "len", "(", "conditions", ")", "==", "num_configurations", ":", "# If the value is the same all configurations,", "# just add one unconditional entry.", "group", ".", "append", "(", "[", "name", ",", "value", "]", ")", "else", ":", "for", "condition", "in", "conditions", ":", "group", ".", "append", "(", "[", "name", ",", "{", "\"Condition\"", ":", "condition", "}", ",", "value", "]", ")", "return", "[", "group", "]" ]

[ "Enable", "(", "self", "bool", "enable", ")" ]

[ "def", "Enable", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "UpdateUIEvent_Enable", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Defines", "the", "common", "arguments", "on", "subparser", "rather", "than", "the", "main", "one", ".", "This", "allows", "to", "put", "arguments", "after", "the", "command", ":", "foo", ".", "py", "upload", "--", "debug", "--", "force", "instead", "of", "foo", ".", "py", "--", "debug", "upload", "--", "force" ]

[ "def", "AddBasicArguments", "(", "parser", ")", ":", "parser", ".", "add_argument", "(", "'--sdk-root'", ",", "help", "=", "'base path to the Android SDK tools root'", ",", "default", "=", "constants", ".", "ANDROID_SDK_ROOT", ")", "parser", ".", "add_argument", "(", "'-v'", ",", "'--verbose'", ",", "action", "=", "'store_true'", ",", "help", "=", "'print debug information'", ")" ]

[ "Checks", "to", "make", "sure", "no", "files", "in", "libbase", ".", "a", "have", "|" ]

[ "def", "_CheckNoInterfacesInBase", "(", "input_api", ",", "output_api", ")", ":", "pattern", "=", "input_api", ".", "re", ".", "compile", "(", "r'^\\s*@interface'", ",", "input_api", ".", "re", ".", "MULTILINE", ")", "files", "=", "[", "]", "for", "f", "in", "input_api", ".", "AffectedSourceFiles", "(", "input_api", ".", "FilterSourceFile", ")", ":", "if", "(", "f", ".", "LocalPath", "(", ")", ".", "startswith", "(", "'base/'", ")", "and", "not", "\"/ios/\"", "in", "f", ".", "LocalPath", "(", ")", "and", "not", "\"/test/\"", "in", "f", ".", "LocalPath", "(", ")", "and", "not", "f", ".", "LocalPath", "(", ")", ".", "endswith", "(", "'_unittest.mm'", ")", "and", "not", "f", ".", "LocalPath", "(", ")", ".", "endswith", "(", "'mac/sdk_forward_declarations.h'", ")", ")", ":", "contents", "=", "input_api", ".", "ReadFile", "(", "f", ")", "if", "pattern", ".", "search", "(", "contents", ")", ":", "files", ".", "append", "(", "f", ")", "if", "len", "(", "files", ")", ":", "return", "[", "output_api", ".", "PresubmitError", "(", "'Objective-C interfaces or categories are forbidden in libbase. '", "+", "'See http://groups.google.com/a/chromium.org/group/chromium-dev/'", "+", "'browse_thread/thread/efb28c10435987fd'", ",", "files", ")", "]", "return", "[", "]" ]

[ "load_model", "(", "model_file_name", ")", "-", ">", "model" ]

[ "def", "load_model", "(", "model_file_name", ")", ":", "model", "=", "liblinear", ".", "load_model", "(", "model_file_name", ".", "encode", "(", ")", ")", "if", "not", "model", ":", "print", "(", "\"can't open model file %s\"", "%", "model_file_name", ")", "return", "None", "model", "=", "toPyModel", "(", "model", ")", "return", "model" ]

[ "Set", "the", "class", "to", "be", "used", "when", "instantiating", "a", "logger", ".", "The", "class", "should", "define", "__init__", "()", "such", "that", "only", "a", "name", "argument", "is", "required", "and", "the", "__init__", "()", "should", "call", "Logger", ".", "__init__", "()" ]

[ "def", "setLoggerClass", "(", "klass", ")", ":", "if", "klass", "!=", "Logger", ":", "if", "not", "issubclass", "(", "klass", ",", "Logger", ")", ":", "raise", "TypeError", "(", "\"logger not derived from logging.Logger: \"", "+", "klass", ".", "__name__", ")", "global", "_loggerClass", "_loggerClass", "=", "klass" ]

[ "Test", "whether", "a", "symbol", "is", "within", "the", "range", "of", "a", "section", "." ]

[ "def", "in_range", "(", "symbol", ",", "section", ")", ":", "symSA", "=", "symbol", ".", "GetStartAddress", "(", ")", ".", "GetFileAddress", "(", ")", "symEA", "=", "symbol", ".", "GetEndAddress", "(", ")", ".", "GetFileAddress", "(", ")", "secSA", "=", "section", ".", "GetFileAddress", "(", ")", "secEA", "=", "secSA", "+", "section", ".", "GetByteSize", "(", ")", "if", "symEA", "!=", "LLDB_INVALID_ADDRESS", ":", "if", "secSA", "<=", "symSA", "and", "symEA", "<=", "secEA", ":", "return", "True", "else", ":", "return", "False", "else", ":", "if", "secSA", "<=", "symSA", "and", "symSA", "<", "secEA", ":", "return", "True", "else", ":", "return", "False" ]

[ "Enables", "the", "pile", "-", "up", "correction", "for", "jets", "in", "a", "PF2PAT", "+", "PAT", "sequence", "to", "be", "called", "after", "the", "usePF2PAT", "function", "." ]

[ "def", "enablePileUpCorrection", "(", "process", ",", "postfix", ",", "sequence", "=", "'patPF2PATSequence'", ")", ":", "enablePileUpCorrectionInPF2PAT", "(", "process", ",", "postfix", ",", "sequence", ")", "enablePileUpCorrectionInPAT", "(", "process", ",", "postfix", ",", "sequence", ")" ]

[ "Return", "all", "trace", "callback", "information", "." ]

[ "def", "trace_vinfo", "(", "self", ")", ":", "return", "map", "(", "self", ".", "_tk", ".", "split", ",", "self", ".", "_tk", ".", "splitlist", "(", "self", ".", "_tk", ".", "call", "(", "\"trace\"", ",", "\"vinfo\"", ",", "self", ".", "_name", ")", ")", ")" ]

[ "Iterate", "over", "the", "parts", "returning", "string", "payloads", "line", "-", "by", "-", "line", "." ]

[ "def", "body_line_iterator", "(", "msg", ",", "decode", "=", "False", ")", ":", "for", "subpart", "in", "msg", ".", "walk", "(", ")", ":", "payload", "=", "subpart", ".", "get_payload", "(", "decode", "=", "decode", ")", "if", "isinstance", "(", "payload", ",", "basestring", ")", ":", "for", "line", "in", "StringIO", "(", "payload", ")", ":", "yield", "line" ]

[ "Convenience", "function", "to", "both", "clear", "and", "update", "the", "known", "list", "of", "module", "specifications", "and", "update", "the", "current", "configuration", "on", "the", "server", "side", ".", "There", "are", "a", "few", "cases", "where", "the", "caller", "might", "only", "want", "to", "run", "one", "of", "these", "tasks", "but", "often", "they", "are", "both", "needed", "." ]

[ "def", "update_specs_and_config", "(", "self", ")", ":", "self", ".", "request_specifications", "(", ")", "self", ".", "request_current_config", "(", ")" ]

[ "Returns", "all", "files", "that", "are", "tracked", "by", "git", "in", "the", "given", "paths", "." ]

[ "async", "def", "get_all_files", "(", "paths", ":", "List", "[", "str", "]", ")", "->", "List", "[", "str", "]", ":", "output", "=", "await", "run_shell_command", "(", "[", "\"git\"", ",", "\"ls-files\"", "]", "+", "paths", ")", "return", "str", "(", "output", ")", ".", "strip", "(", ")", ".", "splitlines", "(", ")" ]

[ "Link", "the", "objects", "." ]

[ "def", "link", "(", "self", ",", "target_desc", ",", "objects", ",", "output_filename", ",", "output_dir", "=", "None", ",", "libraries", "=", "None", ",", "library_dirs", "=", "None", ",", "runtime_library_dirs", "=", "None", ",", "export_symbols", "=", "None", ",", "debug", "=", "0", ",", "extra_preargs", "=", "None", ",", "extra_postargs", "=", "None", ",", "build_temp", "=", "None", ",", "target_lang", "=", "None", ")", ":", "# use separate copies, so we can modify the lists", "extra_preargs", "=", "copy", ".", "copy", "(", "extra_preargs", "or", "[", "]", ")", "libraries", "=", "copy", ".", "copy", "(", "libraries", "or", "[", "]", ")", "objects", "=", "copy", ".", "copy", "(", "objects", "or", "[", "]", ")", "# Additional libraries", "libraries", ".", "extend", "(", "self", ".", "dll_libraries", ")", "# handle export symbols by creating a def-file", "# with executables this only works with gcc/ld as linker", "if", "(", "(", "export_symbols", "is", "not", "None", ")", "and", "(", "target_desc", "!=", "self", ".", "EXECUTABLE", "or", "self", ".", "linker_dll", "==", "\"gcc\"", ")", ")", ":", "# (The linker doesn't do anything if output is up-to-date.", "# So it would probably better to check if we really need this,", "# but for this we had to insert some unchanged parts of", "# UnixCCompiler, and this is not what we want.)", "# we want to put some files in the same directory as the", "# object files are, build_temp doesn't help much", "# where are the object files", "temp_dir", "=", "os", ".", "path", ".", "dirname", "(", "objects", "[", "0", "]", ")", "# name of dll to give the helper files the same base name", "(", "dll_name", ",", "dll_extension", ")", "=", "os", ".", "path", ".", "splitext", "(", "os", ".", "path", ".", "basename", "(", "output_filename", ")", ")", "# generate the filenames for these files", "def_file", "=", "os", ".", "path", ".", "join", "(", "temp_dir", ",", "dll_name", "+", "\".def\"", ")", "lib_file", "=", "os", ".", "path", ".", "join", "(", "temp_dir", ",", "'lib'", "+", "dll_name", "+", "\".a\"", ")", "# Generate .def file", "contents", "=", "[", "\"LIBRARY %s\"", "%", "os", ".", "path", ".", "basename", "(", "output_filename", ")", ",", "\"EXPORTS\"", "]", "for", "sym", "in", "export_symbols", ":", "contents", ".", "append", "(", "sym", ")", "self", ".", "execute", "(", "write_file", ",", "(", "def_file", ",", "contents", ")", ",", "\"writing %s\"", "%", "def_file", ")", "# next add options for def-file and to creating import libraries", "# dllwrap uses different options than gcc/ld", "if", "self", ".", "linker_dll", "==", "\"dllwrap\"", ":", "extra_preargs", ".", "extend", "(", "[", "\"--output-lib\"", ",", "lib_file", "]", ")", "# for dllwrap we have to use a special option", "extra_preargs", ".", "extend", "(", "[", "\"--def\"", ",", "def_file", "]", ")", "# we use gcc/ld here and can be sure ld is >= 2.9.10", "else", ":", "# doesn't work: bfd_close build\\...\\libfoo.a: Invalid operation", "#extra_preargs.extend([\"-Wl,--out-implib,%s\" % lib_file])", "# for gcc/ld the def-file is specified as any object files", "objects", ".", "append", "(", "def_file", ")", "#end: if ((export_symbols is not None) and", "# (target_desc != self.EXECUTABLE or self.linker_dll == \"gcc\")):", "# who wants symbols and a many times larger output file", "# should explicitly switch the debug mode on", "# otherwise we let dllwrap/ld strip the output file", "# (On my machine: 10KiB < stripped_file < ??100KiB", "# unstripped_file = stripped_file + XXX KiB", "# ( XXX=254 for a typical python extension))", "if", "not", "debug", ":", "extra_preargs", ".", "append", "(", "\"-s\"", ")", "UnixCCompiler", ".", "link", "(", "self", ",", "target_desc", ",", "objects", ",", "output_filename", ",", "output_dir", ",", "libraries", ",", "library_dirs", ",", "runtime_library_dirs", ",", "None", ",", "# export_symbols, we do this in our def-file", "debug", ",", "extra_preargs", ",", "extra_postargs", ",", "build_temp", ",", "target_lang", ")" ]

[ "Stacked", "Swin", "Transformers", "that", "share", "the", "same", "token", "size", ".", "Alternated", "Window", "-", "MSA", "and", "Swin", "-", "MSA", "will", "be", "configured", "if", "shift_window", "=", "True", "Window", "-", "MSA", "only", "otherwise", ".", "*", "Dropout", "is", "turned", "off", "." ]

[ "def", "swin_transformer_stack", "(", "X", ",", "stack_num", ",", "embed_dim", ",", "num_patch", ",", "num_heads", ",", "window_size", ",", "num_mlp", ",", "shift_window", "=", "True", ",", "name", "=", "''", ")", ":", "# Turn-off dropouts", "mlp_drop_rate", "=", "0", "# Droupout after each MLP layer", "attn_drop_rate", "=", "0", "# Dropout after Swin-Attention", "proj_drop_rate", "=", "0", "# Dropout at the end of each Swin-Attention block, i.e., after linear projections", "drop_path_rate", "=", "0", "# Drop-path within skip-connections", "qkv_bias", "=", "True", "# Convert embedded patches to query, key, and values with a learnable additive value", "qk_scale", "=", "None", "# None: Re-scale query based on embed dimensions per attention head # Float for user specified scaling factor", "if", "shift_window", ":", "shift_size", "=", "window_size", "//", "2", "else", ":", "shift_size", "=", "0", "for", "i", "in", "range", "(", "stack_num", ")", ":", "if", "i", "%", "2", "==", "0", ":", "shift_size_temp", "=", "0", "else", ":", "shift_size_temp", "=", "shift_size", "X", "=", "swin_layers", ".", "SwinTransformerBlock", "(", "dim", "=", "embed_dim", ",", "num_patch", "=", "num_patch", ",", "num_heads", "=", "num_heads", ",", "window_size", "=", "window_size", ",", "shift_size", "=", "shift_size_temp", ",", "num_mlp", "=", "num_mlp", ",", "qkv_bias", "=", "qkv_bias", ",", "qk_scale", "=", "qk_scale", ",", "mlp_drop", "=", "mlp_drop_rate", ",", "attn_drop", "=", "attn_drop_rate", ",", "proj_drop", "=", "proj_drop_rate", ",", "drop_path_prob", "=", "drop_path_rate", ",", "name", "=", "'name{}'", ".", "format", "(", "i", ")", ")", "(", "X", ")", "return", "X" ]

[ "Return", "the", "public", "identifier", "for", "the", "current", "event", "." ]

[ "def", "getPublicId", "(", "self", ")", ":", "return", "None" ]

[ "Return", "x", "coordinate", "of", "upper", "left", "corner", "of", "this", "widget", "on", "the", "root", "window", "." ]

[ "def", "winfo_rootx", "(", "self", ")", ":", "return", "getint", "(", "self", ".", "tk", ".", "call", "(", "'winfo'", ",", "'rootx'", ",", "self", ".", "_w", ")", ")" ]

[ "Determine", "if", "a", "road", "has", "the", "same", "graphical", "shape", "than", "another", "in", "order", "to", "be", "merged", "." ]

[ "def", "is_similar", "(", "self", ",", "other", ")", ":", "if", "(", "self", ".", "oneway", "and", "not", "other", ".", "oneway", ")", "or", "(", "not", "self", ".", "oneway", "and", "other", ".", "oneway", ")", ":", "return", "False", "# reject if the oneway attribute is not matching", "if", "self", ".", "oneway", ":", "# both roads are oneway", "return", "(", "self", ".", "lanes", "==", "other", ".", "lanes", "and", "self", ".", "forwardLanes", "==", "other", ".", "forwardLanes", "and", "self", ".", "backwardLanes", "==", "other", ".", "backwardLanes", "and", "abs", "(", "self", ".", "width", "-", "other", ".", "width", ")", "<=", "0.01", ")", "else", ":", "# both roads are bidirectional", "return", "(", "self", ".", "lanes", "==", "other", ".", "lanes", "and", "self", ".", "forwardLanes", "==", "other", ".", "backwardLanes", "and", "self", ".", "backwardLanes", "==", "other", ".", "forwardLanes", "and", "abs", "(", "self", ".", "width", "-", "other", ".", "width", ")", "<=", "0.01", ")" ]

[ "Strip", "-", "l", "from", "library", "if", "it", "s", "specified", "with", "that", "." ]

[ "def", "AdjustLibraries", "(", "self", ",", "libraries", ")", ":", "libs", "=", "[", "lib", "[", "2", ":", "]", "if", "lib", ".", "startswith", "(", "'-l'", ")", "else", "lib", "for", "lib", "in", "libraries", "]", "return", "[", "lib", "+", "'.lib'", "if", "not", "lib", ".", "lower", "(", ")", ".", "endswith", "(", "'.lib'", ")", "and", "not", "lib", ".", "lower", "(", ")", ".", "endswith", "(", "'.obj'", ")", "else", "lib", "for", "lib", "in", "libs", "]" ]

[ "Feed", "a", "block", "of", "data", "to", "the", "hash", "." ]

[ "def", "feed", "(", "self", ",", "block", ")", ":", "return" ]

[ "Turns", "turtle", "animation", "on", "/", "off", "and", "set", "delay", "for", "update", "drawings", "." ]

[ "def", "_tracer", "(", "self", ",", "flag", "=", "None", ",", "delay", "=", "None", ")", ":", "return", "self", ".", "screen", ".", "tracer", "(", "flag", ",", "delay", ")" ]

[ "Return", "True", "if", "the", "given", "side", "set", "exists", "." ]

[ "def", "side_set_exists", "(", "self", ",", "side_set_id", ")", ":", "if", "isinstance", "(", "side_set_id", ",", "str", ")", ":", "return", "side_set_id", "in", "self", ".", "get_all_side_set_names", "(", ")", "return", "side_set_id", "in", "self", ".", "get_side_set_ids", "(", ")" ]

[ "Put", "text", "to", "image", "using", "pillow", "." ]

[ "def", "put_text_to_image", "(", "img", ",", "text", ",", "pos", ",", "font_path", ",", "font_size", ",", "color", ",", "background_color", "=", "None", ",", "offset_x", "=", "0", ",", "offset_y", "=", "0", ")", ":", "if", "sys", ".", "version_info", "<", "(", "3", ",", "0", ")", ":", "text", "=", "text", ".", "decode", "(", "'utf-8'", ")", "pil_font", "=", "ImageFont", ".", "truetype", "(", "font", "=", "font_path", ",", "size", "=", "font_size", ")", "dummy_draw", "=", "ImageDraw", ".", "Draw", "(", "Image", ".", "new", "(", "\"RGB\"", ",", "(", "0", ",", "0", ")", ")", ")", "text_w", ",", "text_h", "=", "dummy_draw", ".", "textsize", "(", "text", ",", "font", "=", "pil_font", ")", "text_bottom_offset", "=", "int", "(", "0.1", "*", "text_h", ")", "x", ",", "y", "=", "pos", "offset_y", "=", "(", "text_h", "+", "text_bottom_offset", ")", "+", "offset_y", "x0", "=", "x", "-", "offset_x", "y0", "=", "y", "-", "offset_y", "img_h", ",", "img_w", "=", "img", ".", "shape", "[", ":", "2", "]", "# check outside of image.", "if", "not", "(", "(", "-", "text_w", "<", "x0", "<", "img_w", ")", "and", "(", "-", "text_bottom_offset", "-", "text_h", "<", "y0", "<", "img_h", ")", ")", ":", "return", "img", "x1", ",", "y1", "=", "max", "(", "x0", ",", "0", ")", ",", "max", "(", "y0", ",", "0", ")", "x2", "=", "min", "(", "x0", "+", "text_w", ",", "img_w", ")", "y2", "=", "min", "(", "y0", "+", "text_h", "+", "text_bottom_offset", ",", "img_h", ")", "x0", "=", "int", "(", "x0", ")", "y0", "=", "int", "(", "y0", ")", "x1", "=", "int", "(", "x1", ")", "y1", "=", "int", "(", "y1", ")", "x2", "=", "int", "(", "x2", ")", "y2", "=", "int", "(", "y2", ")", "# Create a black image of the same size as the text area.", "text_area", "=", "np", ".", "full", "(", "(", "text_h", "+", "text_bottom_offset", ",", "text_w", ",", "3", ")", ",", "(", "0", ",", "0", ",", "0", ")", ",", "dtype", "=", "np", ".", "uint8", ")", "if", "background_color", "is", "not", "None", ":", "img", "[", "y1", ":", "y2", ",", "x1", ":", "x2", "]", "=", "np", ".", "array", "(", "background_color", ",", "dtype", "=", "np", ".", "uint8", ")", "# paste the original image on all or part of it.", "text_area", "[", "y1", "-", "y0", ":", "y2", "-", "y0", ",", "x1", "-", "x0", ":", "x2", "-", "x0", "]", "=", "img", "[", "y1", ":", "y2", ",", "x1", ":", "x2", "]", "# convert pil image to cv2 image.", "pil_img", "=", "Image", ".", "fromarray", "(", "text_area", ")", "draw", "=", "ImageDraw", ".", "Draw", "(", "pil_img", ")", "draw", ".", "text", "(", "xy", "=", "(", "0", ",", "0", ")", ",", "text", "=", "text", ",", "fill", "=", "color", ",", "font", "=", "pil_font", ")", "text_area", "=", "np", ".", "array", "(", "pil_img", ",", "dtype", "=", "np", ".", "uint8", ")", "img", "[", "y1", ":", "y2", ",", "x1", ":", "x2", "]", "=", "text_area", "[", "y1", "-", "y0", ":", "y2", "-", "y0", ",", "x1", "-", "x0", ":", "x2", "-", "x0", "]", "return", "img" ]

[ "r", "SetDefaultRAT", "(", "Band", "self", "RasterAttributeTable", "table", ")", "-", ">", "int" ]

[ "def", "SetDefaultRAT", "(", "self", ",", "*", "args", ")", ":", "return", "_gdal", ".", "Band_SetDefaultRAT", "(", "self", ",", "*", "args", ")" ]

[ "Recursively", "yield", "all", "descendant", "nodes", "in", "the", "tree", "starting", "at", "*", "node", "*", "(", "including", "*", "node", "*", "itself", ")", "in", "no", "specified", "order", ".", "This", "is", "useful", "if", "you", "only", "want", "to", "modify", "nodes", "in", "place", "and", "don", "t", "care", "about", "the", "context", "." ]

[ "def", "walk", "(", "node", ")", ":", "from", "collections", "import", "deque", "todo", "=", "deque", "(", "[", "node", "]", ")", "while", "todo", ":", "node", "=", "todo", ".", "popleft", "(", ")", "todo", ".", "extend", "(", "iter_child_nodes", "(", "node", ")", ")", "yield", "node" ]

[ "Convert", "a", "measurement", "with", "a", "range", "suffix", "into", "a", "suitably", "scaled", "value" ]

[ "def", "extractSI", "(", "s", ")", ":", "du", "=", "s", ".", "split", "(", ")", "num", "=", "float", "(", "du", "[", "0", "]", ")", "units", "=", "du", "[", "1", "]", "if", "len", "(", "du", ")", "==", "2", "else", "' '", "# http://physics.nist.gov/cuu/Units/prefixes.html", "factor", "=", "{", "'Y'", ":", "1e24", ",", "'Z'", ":", "1e21", ",", "'E'", ":", "1e18", ",", "'P'", ":", "1e15", ",", "'T'", ":", "1e12", ",", "'G'", ":", "1e9", ",", "'M'", ":", "1e6", ",", "'k'", ":", "1e3", ",", "' '", ":", "1", ",", "'m'", ":", "-", "1e3", ",", "# Yes, I do mean that, see below for the explanation.", "'u'", ":", "-", "1e6", ",", "'n'", ":", "-", "1e9", ",", "'p'", ":", "-", "1e12", ",", "'f'", ":", "-", "1e15", ",", "'a'", ":", "-", "1e18", ",", "'z'", ":", "-", "1e21", ",", "'y'", ":", "-", "1e24", "}", "[", "units", "[", "0", "]", "]", "# Minor trickery here is an attempt to preserve accuracy by using a single", "# divide, rather than multiplying by 1/x, which introduces two roundings", "# since 1/10 is not representable perfectly in IEEE floating point. (Not", "# that this really matters, other than for cleanliness, since we're likely", "# reading numbers with at most five decimal digits of precision).", "return", "num", "*", "factor", "if", "factor", ">", "0", "else", "num", "/", "-", "factor" ]

[ "Parameters", "----------", "func_nm", ":", "str", "The", "name", "of", "the", "aggregation", "function", "being", "performed" ]

[ "def", "_transform_should_cast", "(", "self", ",", "func_nm", ":", "str", ")", "->", "bool", ":", "return", "(", "self", ".", "size", "(", ")", ".", "fillna", "(", "0", ")", ">", "0", ")", ".", "any", "(", ")", "and", "(", "func_nm", "not", "in", "base", ".", "cython_cast_blacklist", ")" ]

[ "Encodes", "the", "object", "input", "and", "returns", "a", "tuple", "(", "output", "object", "length", "consumed", ")", "." ]

[ "def", "encode", "(", "self", ",", "input", ",", "errors", "=", "'strict'", ")", ":", "raise", "NotImplementedError" ]

[ "//", "Update", "Pixel", "dmx", "dmy", "On", "The", "Texture" ]

[ "def", "UpdateTex", "(", "dmx", ",", "dmy", ")", ":", "global", "tex_data", "tex_data", "[", "0", "+", "(", "(", "dmx", "+", "(", "width", "*", "dmy", ")", ")", "*", "3", ")", "]", "=", "255", "# // Set Red Pixel To Full Bright", "tex_data", "[", "1", "+", "(", "(", "dmx", "+", "(", "width", "*", "dmy", ")", ")", "*", "3", ")", "]", "=", "255", "# // Set Green Pixel To Full Bright", "tex_data", "[", "2", "+", "(", "(", "dmx", "+", "(", "width", "*", "dmy", ")", ")", "*", "3", ")", "]", "=", "255", "# // Set Blue Pixel To Full Bright", "return" ]

[ "Implements", "name", "-", "based", "weight", "loading", "." ]

[ "def", "load_weights_from_hdf5_group_by_name", "(", "f", ",", "layers", ")", ":", "if", "'keras_version'", "in", "f", ".", "attrs", ":", "original_keras_version", "=", "f", ".", "attrs", "[", "'keras_version'", "]", ".", "decode", "(", "'utf8'", ")", "else", ":", "original_keras_version", "=", "'1'", "if", "'backend'", "in", "f", ".", "attrs", ":", "original_backend", "=", "f", ".", "attrs", "[", "'backend'", "]", ".", "decode", "(", "'utf8'", ")", "else", ":", "original_backend", "=", "None", "# New file format.", "layer_names", "=", "[", "n", ".", "decode", "(", "'utf8'", ")", "for", "n", "in", "f", ".", "attrs", "[", "'layer_names'", "]", "]", "# Reverse index of layer name to list of layers with name.", "index", "=", "{", "}", "for", "layer", "in", "layers", ":", "if", "layer", ".", "name", ":", "index", ".", "setdefault", "(", "layer", ".", "name", ",", "[", "]", ")", ".", "append", "(", "layer", ")", "# We batch weight value assignments in a single backend call", "# which provides a speedup in TensorFlow.", "weight_value_tuples", "=", "[", "]", "for", "k", ",", "name", "in", "enumerate", "(", "layer_names", ")", ":", "g", "=", "f", "[", "name", "]", "weight_names", "=", "[", "n", ".", "decode", "(", "'utf8'", ")", "for", "n", "in", "g", ".", "attrs", "[", "'weight_names'", "]", "]", "weight_values", "=", "[", "g", "[", "weight_name", "]", "for", "weight_name", "in", "weight_names", "]", "for", "layer", "in", "index", ".", "get", "(", "name", ",", "[", "]", ")", ":", "symbolic_weights", "=", "layer", ".", "weights", "weight_values", "=", "preprocess_weights_for_loading", "(", "layer", ",", "weight_values", ",", "original_keras_version", ",", "original_backend", ")", "if", "len", "(", "weight_values", ")", "!=", "len", "(", "symbolic_weights", ")", ":", "raise", "ValueError", "(", "'Layer #'", "+", "str", "(", "k", ")", "+", "' (named \"'", "+", "layer", ".", "name", "+", "'\") expects '", "+", "str", "(", "len", "(", "symbolic_weights", ")", ")", "+", "' weight(s), but the saved weights'", "+", "' have '", "+", "str", "(", "len", "(", "weight_values", ")", ")", "+", "' element(s).'", ")", "# Set values.", "for", "i", "in", "range", "(", "len", "(", "weight_values", ")", ")", ":", "weight_value_tuples", ".", "append", "(", "(", "symbolic_weights", "[", "i", "]", ",", "weight_values", "[", "i", "]", ")", ")", "K", ".", "batch_set_value", "(", "weight_value_tuples", ")" ]

[ "__init__", "(", "self", "int", "x", "=", "0", "int", "y", "=", "0", "int", "width", "=", "0", "int", "height", "=", "0", ")", "-", ">", "Rect" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_core_", ".", "Rect_swiginit", "(", "self", ",", "_core_", ".", "new_Rect", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Emit", "a", "record", "." ]

[ "def", "emit", "(", "self", ",", "record", ")", ":", "if", "self", ".", "_welu", ":", "try", ":", "id", "=", "self", ".", "getMessageID", "(", "record", ")", "cat", "=", "self", ".", "getEventCategory", "(", "record", ")", "type", "=", "self", ".", "getEventType", "(", "record", ")", "msg", "=", "self", ".", "format", "(", "record", ")", "self", ".", "_welu", ".", "ReportEvent", "(", "self", ".", "appname", ",", "id", ",", "cat", ",", "type", ",", "[", "msg", "]", ")", "except", "(", "KeyboardInterrupt", ",", "SystemExit", ")", ":", "raise", "except", ":", "self", ".", "handleError", "(", "record", ")" ]

[ "Factory", "for", "the", "RecoverableSession", "." ]

[ "def", "_create_session", "(", "self", ")", ":", "if", "self", ".", "_is_chief", ":", "tf_sess", "=", "self", ".", "_session_manager", ".", "prepare_session", "(", "self", ".", "_master", ",", "saver", "=", "self", ".", "_scaffold", ".", "saver", ",", "checkpoint_dir", "=", "self", ".", "_checkpoint_dir", ",", "config", "=", "self", ".", "_config", ",", "init_op", "=", "self", ".", "_scaffold", ".", "init_op", ",", "init_feed_dict", "=", "self", ".", "_scaffold", ".", "init_feed_dict", ",", "init_fn", "=", "self", ".", "_scaffold", ".", "init_fn", ")", "else", ":", "tf_sess", "=", "self", ".", "_session_manager", ".", "wait_for_session", "(", "self", ".", "_master", ",", "config", "=", "self", ".", "_config", ")", "# Keep the tf_sess for quick runs of global step when needed.", "self", ".", "_tf_sess", "=", "tf_sess", "# We don't want coordinator to suppress any exception.", "coord", "=", "coordinator", ".", "Coordinator", "(", "clean_stop_exception_types", "=", "[", "]", ")", "coordinated_threads_to_join", "=", "queue_runner", ".", "start_queue_runners", "(", "sess", "=", "tf_sess", ",", "coord", "=", "coord", ")", "return", "coordinated_session", ".", "CoordinatedSession", "(", "monitored_session", ".", "MonitoredSession", "(", "tf_sess", ",", "self", ".", "_monitors", ",", "self", ".", "_scaffold", ".", "global_step_tensor", ")", ",", "coord", ",", "coordinated_threads_to_join", ")" ]

[ "Returns", "whether", "a", "Symbol", "instance", "is", "present", "in", "this", "Section", "." ]

[ "def", "has_symbol", "(", "self", ",", "symbol", ")", ":", "if", "self", ".", "expired", ":", "raise", "Exception", "(", "'Section instance has expired.'", ")", "assert", "isinstance", "(", "symbol", ",", "Symbol", ")", "return", "lib", ".", "LLVMGetSectionContainsSymbol", "(", "self", ",", "symbol", ")" ]

[ "GetToolToggled", "(", "self", "int", "toolId", ")", "-", ">", "bool" ]

[ "def", "GetToolToggled", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBar_GetToolToggled", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "GetValue", "(", "self", "DataViewItem", "item", "unsigned", "int", "col", ")", "-", ">", "wxVariant" ]

[ "def", "GetValue", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewModel_GetValue", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Query", "or", "modify", "the", "management", "options", "for", "window", "." ]

[ "def", "paneconfigure", "(", "self", ",", "tagOrId", ",", "cnf", "=", "None", ",", "*", "*", "kw", ")", ":", "if", "cnf", "is", "None", "and", "not", "kw", ":", "cnf", "=", "{", "}", "for", "x", "in", "self", ".", "tk", ".", "split", "(", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'paneconfigure'", ",", "tagOrId", ")", ")", ":", "cnf", "[", "x", "[", "0", "]", "[", "1", ":", "]", "]", "=", "(", "x", "[", "0", "]", "[", "1", ":", "]", ",", ")", "+", "x", "[", "1", ":", "]", "return", "cnf", "if", "type", "(", "cnf", ")", "==", "StringType", "and", "not", "kw", ":", "x", "=", "self", ".", "tk", ".", "split", "(", "self", ".", "tk", ".", "call", "(", "self", ".", "_w", ",", "'paneconfigure'", ",", "tagOrId", ",", "'-'", "+", "cnf", ")", ")", "return", "(", "x", "[", "0", "]", "[", "1", ":", "]", ",", ")", "+", "x", "[", "1", ":", "]", "self", ".", "tk", ".", "call", "(", "(", "self", ".", "_w", ",", "'paneconfigure'", ",", "tagOrId", ")", "+", "self", ".", "_options", "(", "cnf", ",", "kw", ")", ")" ]

[ "Modify", "proto", "buffers", "when", "all", "quantization", "infos", "are", "set", "correctly", ":", "param", "m", ":", "the", "model", ":", "param", "quant_layers", ":", "layers", "need", "to", "be", "quantized" ]

[ "def", "modify_pb", "(", "m", ":", "onnx", ".", "ModelProto", ",", "quant_layers", ":", "List", "[", "str", "]", ")", "->", "None", ":", "for", "node", "in", "m", ".", "graph", ".", "node", ":", "if", "node", ".", "name", "not", "in", "quant_layers", ":", "continue", "if", "node", ".", "op_type", "==", "'Conv'", ":", "weight", "=", "node", ".", "input", "[", "1", "]", "if", "len", "(", "node", ".", "input", ")", "==", "3", ":", "bias", "=", "node", ".", "input", "[", "2", "]", "for", "t", "in", "m", ".", "graph", ".", "initializer", ":", "if", "t", ".", "name", "==", "weight", ":", "assert", "len", "(", "t", ".", "raw_data", ")", "==", "0", "w", "=", "np", ".", "array", "(", "t", ".", "float_data", ")", "w", "=", "zps", "[", "weight", "]", "+", "w", "/", "scales", "[", "weight", "]", "w", "=", "np", ".", "round", "(", "np", ".", "clip", "(", "w", ",", "qmin", ",", "qmax", ")", ")", "t", ".", "raw_data", "=", "w", ".", "astype", "(", "np", ".", "uint8", ")", ".", "tobytes", "(", ")", "t", ".", "data_type", "=", "onnx", ".", "TensorProto", ".", "UINT8", "del", "t", ".", "float_data", "[", ":", "]", "if", "len", "(", "node", ".", "input", ")", "==", "3", "and", "t", ".", "name", "==", "bias", ":", "assert", "len", "(", "t", ".", "raw_data", ")", "==", "0", "b", "=", "np", ".", "array", "(", "t", ".", "float_data", ")", "b", "/=", "scales", "[", "bias", "]", "t", ".", "raw_data", "=", "np", ".", "round", "(", "b", ")", ".", "astype", "(", "np", ".", "int32", ")", ".", "tobytes", "(", ")", "t", ".", "data_type", "=", "onnx", ".", "TensorProto", ".", "INT32", "del", "t", ".", "float_data", "[", ":", "]" ]

[ "Updates", "the", "names", "of", "parameters", "with", "given", "prefix", "string", "." ]

[ "def", "update_parameters_name", "(", "self", ",", "prefix", "=", "''", ",", "recurse", "=", "True", ")", ":", "Validator", ".", "check_str_by_regular", "(", "prefix", ")", "for", "name", ",", "param", "in", "self", ".", "parameters_and_names", "(", "expand", "=", "recurse", ")", ":", "if", "prefix", "!=", "''", ":", "param", ".", "is_init", "=", "False", "param", ".", "name", "=", "prefix", "+", "name" ]

[ "filtering", "parameters", ".", "default", "skips", "that", "filter", ".", ":", "param", "catNms", "(", "str", "array", ")", ":", "get", "cats", "for", "given", "cat", "names", ":", "param", "supNms", "(", "str", "array", ")", ":", "get", "cats", "for", "given", "supercategory", "names", ":", "param", "catIds", "(", "int", "array", ")", ":", "get", "cats", "for", "given", "cat", "ids", ":", "return", ":", "ids", "(", "int", "array", ")", ":", "integer", "array", "of", "cat", "ids" ]

[ "def", "getCatIds", "(", "self", ",", "catNms", "=", "[", "]", ",", "supNms", "=", "[", "]", ",", "catIds", "=", "[", "]", ")", ":", "catNms", "=", "catNms", "if", "type", "(", "catNms", ")", "==", "list", "else", "[", "catNms", "]", "supNms", "=", "supNms", "if", "type", "(", "supNms", ")", "==", "list", "else", "[", "supNms", "]", "catIds", "=", "catIds", "if", "type", "(", "catIds", ")", "==", "list", "else", "[", "catIds", "]", "if", "len", "(", "catNms", ")", "==", "len", "(", "supNms", ")", "==", "len", "(", "catIds", ")", "==", "0", ":", "cats", "=", "self", ".", "dataset", "[", "'categories'", "]", "else", ":", "cats", "=", "self", ".", "dataset", "[", "'categories'", "]", "cats", "=", "cats", "if", "len", "(", "catNms", ")", "==", "0", "else", "[", "cat", "for", "cat", "in", "cats", "if", "cat", "[", "'name'", "]", "in", "catNms", "]", "cats", "=", "cats", "if", "len", "(", "supNms", ")", "==", "0", "else", "[", "cat", "for", "cat", "in", "cats", "if", "cat", "[", "'supercategory'", "]", "in", "supNms", "]", "cats", "=", "cats", "if", "len", "(", "catIds", ")", "==", "0", "else", "[", "cat", "for", "cat", "in", "cats", "if", "cat", "[", "'id'", "]", "in", "catIds", "]", "ids", "=", "[", "cat", "[", "'id'", "]", "for", "cat", "in", "cats", "]", "return", "ids" ]

[ "GetName", "(", "self", ")", "-", ">", "String" ]

[ "def", "GetName", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextFileHandler_GetName", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Setup", "the", "parser", "context", "to", "parse", "a", "new", "buffer", ";", "Clears", "any", "prior", "contents", "from", "the", "parser", "context", ".", "The", "buffer", "parameter", "must", "not", "be", "None", "but", "the", "filename", "parameter", "can", "be" ]

[ "def", "setupParserForBuffer", "(", "self", ",", "buffer", ",", "filename", ")", ":", "libxml2mod", ".", "xmlSetupParserForBuffer", "(", "self", ".", "_o", ",", "buffer", ",", "filename", ")" ]

[ "Returns", "the", "policy", "for", "a", "player", "in", "a", "state", "." ]

[ "def", "action_probabilities", "(", "self", ",", "state", ",", "player_id", "=", "None", ")", ":", "# If self._player_id is None, or if self.player_id == current_player, add", "# noise.", "if", "(", "(", "self", ".", "player_id", "is", "None", ")", "or", "(", "state", ".", "current_player", "(", ")", "==", "self", ".", "player_id", ")", "or", "(", "player_id", "==", "self", ".", "player_id", ")", ")", ":", "noise_probs", "=", "self", ".", "get_or_create_noise", "(", "state", ",", "player_id", ")", "probs", "=", "self", ".", "_policy", ".", "action_probabilities", "(", "state", ",", "player_id", ")", "probs", "=", "self", ".", "mix_probs", "(", "probs", ",", "noise_probs", ")", "return", "probs", "# Send the default probabilities for all other players", "return", "self", ".", "_policy", ".", "action_probabilities", "(", "state", ",", "player_id", ")" ]

[ "Defines", "the", "total", "log", "-", "likelihood", "of", "current", "iteration", "." ]

[ "def", "_define_loglikelihood_operation", "(", "self", ")", ":", "self", ".", "_ll_op", "=", "[", "]", "for", "prior_probs", "in", "self", ".", "_prior_probs", ":", "self", ".", "_ll_op", ".", "append", "(", "tf", ".", "reduce_sum", "(", "tf", ".", "log", "(", "prior_probs", ")", ")", ")", "tf", ".", "scalar_summary", "(", "'ll'", ",", "tf", ".", "reduce_sum", "(", "self", ".", "_ll_op", ")", ")" ]

[ "Returns", "the", "sign", "of", "x", "." ]

[ "def", "numeric", "(", "self", ",", "values", ")", ":", "x", "=", "values", "[", "0", "]", ".", "copy", "(", ")", "x", "[", "x", ">", "0", "]", "=", "1.0", "x", "[", "x", "<=", "0", "]", "=", "-", "1.0", "return", "x" ]

[ "Analyse", "buffer", "indexing", "and", "memoryview", "indexing", "/", "slicing" ]

[ "def", "analyse_as_buffer_operation", "(", "self", ",", "env", ",", "getting", ")", ":", "if", "isinstance", "(", "self", ".", "index", ",", "TupleNode", ")", ":", "indices", "=", "self", ".", "index", ".", "args", "else", ":", "indices", "=", "[", "self", ".", "index", "]", "base", "=", "self", ".", "base", "base_type", "=", "base", ".", "type", "replacement_node", "=", "None", "if", "base_type", ".", "is_memoryviewslice", ":", "# memoryviewslice indexing or slicing", "from", ".", "import", "MemoryView", "if", "base", ".", "is_memview_slice", ":", "# For memory views, \"view[i][j]\" is the same as \"view[i, j]\" => use the latter for speed.", "merged_indices", "=", "base", ".", "merged_indices", "(", "indices", ")", "if", "merged_indices", "is", "not", "None", ":", "base", "=", "base", ".", "base", "base_type", "=", "base", ".", "type", "indices", "=", "merged_indices", "have_slices", ",", "indices", ",", "newaxes", "=", "MemoryView", ".", "unellipsify", "(", "indices", ",", "base_type", ".", "ndim", ")", "if", "have_slices", ":", "replacement_node", "=", "MemoryViewSliceNode", "(", "self", ".", "pos", ",", "indices", "=", "indices", ",", "base", "=", "base", ")", "else", ":", "replacement_node", "=", "MemoryViewIndexNode", "(", "self", ".", "pos", ",", "indices", "=", "indices", ",", "base", "=", "base", ")", "elif", "base_type", ".", "is_buffer", "or", "base_type", ".", "is_pythran_expr", ":", "if", "base_type", ".", "is_pythran_expr", "or", "len", "(", "indices", ")", "==", "base_type", ".", "ndim", ":", "# Buffer indexing", "is_buffer_access", "=", "True", "indices", "=", "[", "index", ".", "analyse_types", "(", "env", ")", "for", "index", "in", "indices", "]", "if", "base_type", ".", "is_pythran_expr", ":", "do_replacement", "=", "all", "(", "index", ".", "type", ".", "is_int", "or", "index", ".", "is_slice", "or", "index", ".", "type", ".", "is_pythran_expr", "for", "index", "in", "indices", ")", "if", "do_replacement", ":", "for", "i", ",", "index", "in", "enumerate", "(", "indices", ")", ":", "if", "index", ".", "is_slice", ":", "index", "=", "SliceIntNode", "(", "index", ".", "pos", ",", "start", "=", "index", ".", "start", ",", "stop", "=", "index", ".", "stop", ",", "step", "=", "index", ".", "step", ")", "index", "=", "index", ".", "analyse_types", "(", "env", ")", "indices", "[", "i", "]", "=", "index", "else", ":", "do_replacement", "=", "all", "(", "index", ".", "type", ".", "is_int", "for", "index", "in", "indices", ")", "if", "do_replacement", ":", "replacement_node", "=", "BufferIndexNode", "(", "self", ".", "pos", ",", "indices", "=", "indices", ",", "base", "=", "base", ")", "# On cloning, indices is cloned. Otherwise, unpack index into indices.", "assert", "not", "isinstance", "(", "self", ".", "index", ",", "CloneNode", ")", "if", "replacement_node", "is", "not", "None", ":", "replacement_node", "=", "replacement_node", ".", "analyse_types", "(", "env", ",", "getting", ")", "return", "replacement_node" ]

[ "r", "Return", "1", "for", "ignorable", "character", ":", "iff", "ch", "is", "a", "space", "or", "tab", "." ]

[ "def", "IS_CHARACTER_JUNK", "(", "ch", ",", "ws", "=", "\" \\t\"", ")", ":", "return", "ch", "in", "ws" ]

[ "Return", "the", "list", "of", "FileRender", "objects", "to", "process", "." ]

[ "def", "get_file_renders", "(", "self", ",", "args", ")", ":", "return", "[", "]" ]

[ "Method", "the", "write", "JSON", "progress", "message", ".", "Implemented", "by", "subclass", "." ]

[ "def", "write", "(", "self", ",", "data", ")", ":" ]

[ "The", "set", "of", "ops", "that", "terminate", "the", "gradient", "computation", "." ]

[ "def", "_StopOps", "(", "from_ops", ",", "pending_count", ")", ":", "stop_ops", "=", "set", "(", ")", "for", "op", "in", "from_ops", ":", "is_stop_op", "=", "True", "for", "inp", "in", "op", ".", "inputs", ":", "if", "pending_count", "[", "inp", ".", "op", ".", "_id", "]", ">", "0", ":", "is_stop_op", "=", "False", "break", "if", "is_stop_op", ":", "stop_ops", ".", "add", "(", "op", ".", "_id", ")", "return", "stop_ops" ]

[ "Return", "dict", "of", "core", "virtual", "-", "key", "keybindings", "for", "keySetName", "." ]

[ "def", "GetCoreKeys", "(", "self", ",", "keySetName", "=", "None", ")", ":", "keyBindings", "=", "{", "'<<copy>>'", ":", "[", "'<Control-c>'", ",", "'<Control-C>'", "]", ",", "'<<cut>>'", ":", "[", "'<Control-x>'", ",", "'<Control-X>'", "]", ",", "'<<paste>>'", ":", "[", "'<Control-v>'", ",", "'<Control-V>'", "]", ",", "'<<beginning-of-line>>'", ":", "[", "'<Control-a>'", ",", "'<Home>'", "]", ",", "'<<center-insert>>'", ":", "[", "'<Control-l>'", "]", ",", "'<<close-all-windows>>'", ":", "[", "'<Control-q>'", "]", ",", "'<<close-window>>'", ":", "[", "'<Alt-F4>'", "]", ",", "'<<do-nothing>>'", ":", "[", "'<Control-x>'", "]", ",", "'<<end-of-file>>'", ":", "[", "'<Control-d>'", "]", ",", "'<<python-docs>>'", ":", "[", "'<F1>'", "]", ",", "'<<python-context-help>>'", ":", "[", "'<Shift-F1>'", "]", ",", "'<<history-next>>'", ":", "[", "'<Alt-n>'", "]", ",", "'<<history-previous>>'", ":", "[", "'<Alt-p>'", "]", ",", "'<<interrupt-execution>>'", ":", "[", "'<Control-c>'", "]", ",", "'<<view-restart>>'", ":", "[", "'<F6>'", "]", ",", "'<<restart-shell>>'", ":", "[", "'<Control-F6>'", "]", ",", "'<<open-class-browser>>'", ":", "[", "'<Alt-c>'", "]", ",", "'<<open-module>>'", ":", "[", "'<Alt-m>'", "]", ",", "'<<open-new-window>>'", ":", "[", "'<Control-n>'", "]", ",", "'<<open-window-from-file>>'", ":", "[", "'<Control-o>'", "]", ",", "'<<plain-newline-and-indent>>'", ":", "[", "'<Control-j>'", "]", ",", "'<<print-window>>'", ":", "[", "'<Control-p>'", "]", ",", "'<<redo>>'", ":", "[", "'<Control-y>'", "]", ",", "'<<remove-selection>>'", ":", "[", "'<Escape>'", "]", ",", "'<<save-copy-of-window-as-file>>'", ":", "[", "'<Alt-Shift-S>'", "]", ",", "'<<save-window-as-file>>'", ":", "[", "'<Alt-s>'", "]", ",", "'<<save-window>>'", ":", "[", "'<Control-s>'", "]", ",", "'<<select-all>>'", ":", "[", "'<Alt-a>'", "]", ",", "'<<toggle-auto-coloring>>'", ":", "[", "'<Control-slash>'", "]", ",", "'<<undo>>'", ":", "[", "'<Control-z>'", "]", ",", "'<<find-again>>'", ":", "[", "'<Control-g>'", ",", "'<F3>'", "]", ",", "'<<find-in-files>>'", ":", "[", "'<Alt-F3>'", "]", ",", "'<<find-selection>>'", ":", "[", "'<Control-F3>'", "]", ",", "'<<find>>'", ":", "[", "'<Control-f>'", "]", ",", "'<<replace>>'", ":", "[", "'<Control-h>'", "]", ",", "'<<goto-line>>'", ":", "[", "'<Alt-g>'", "]", ",", "'<<smart-backspace>>'", ":", "[", "'<Key-BackSpace>'", "]", ",", "'<<newline-and-indent>>'", ":", "[", "'<Key-Return>'", ",", "'<Key-KP_Enter>'", "]", ",", "'<<smart-indent>>'", ":", "[", "'<Key-Tab>'", "]", ",", "'<<indent-region>>'", ":", "[", "'<Control-Key-bracketright>'", "]", ",", "'<<dedent-region>>'", ":", "[", "'<Control-Key-bracketleft>'", "]", ",", "'<<comment-region>>'", ":", "[", "'<Alt-Key-3>'", "]", ",", "'<<uncomment-region>>'", ":", "[", "'<Alt-Key-4>'", "]", ",", "'<<tabify-region>>'", ":", "[", "'<Alt-Key-5>'", "]", ",", "'<<untabify-region>>'", ":", "[", "'<Alt-Key-6>'", "]", ",", "'<<toggle-tabs>>'", ":", "[", "'<Alt-Key-t>'", "]", ",", "'<<change-indentwidth>>'", ":", "[", "'<Alt-Key-u>'", "]", ",", "'<<del-word-left>>'", ":", "[", "'<Control-Key-BackSpace>'", "]", ",", "'<<del-word-right>>'", ":", "[", "'<Control-Key-Delete>'", "]", ",", "'<<force-open-completions>>'", ":", "[", "'<Control-Key-space>'", "]", ",", "'<<expand-word>>'", ":", "[", "'<Alt-Key-slash>'", "]", ",", "'<<force-open-calltip>>'", ":", "[", "'<Control-Key-backslash>'", "]", ",", "'<<flash-paren>>'", ":", "[", "'<Control-Key-0>'", "]", ",", "'<<format-paragraph>>'", ":", "[", "'<Alt-Key-q>'", "]", ",", "'<<run-module>>'", ":", "[", "'<Key-F5>'", "]", ",", "'<<run-custom>>'", ":", "[", "'<Shift-Key-F5>'", "]", ",", "'<<check-module>>'", ":", "[", "'<Alt-Key-x>'", "]", ",", "'<<zoom-height>>'", ":", "[", "'<Alt-Key-2>'", "]", ",", "}", "if", "keySetName", ":", "if", "not", "(", "self", ".", "userCfg", "[", "'keys'", "]", ".", "has_section", "(", "keySetName", ")", "or", "self", ".", "defaultCfg", "[", "'keys'", "]", ".", "has_section", "(", "keySetName", ")", ")", ":", "warning", "=", "(", "'\\n Warning: config.py - IdleConf.GetCoreKeys -\\n'", "' key set %r is not defined, using default bindings.'", "%", "(", "keySetName", ",", ")", ")", "_warn", "(", "warning", ",", "'keys'", ",", "keySetName", ")", "else", ":", "for", "event", "in", "keyBindings", ":", "binding", "=", "self", ".", "GetKeyBinding", "(", "keySetName", ",", "event", ")", "if", "binding", ":", "keyBindings", "[", "event", "]", "=", "binding", "# Otherwise return default in keyBindings.", "elif", "event", "not", "in", "self", ".", "former_extension_events", ":", "warning", "=", "(", "'\\n Warning: config.py - IdleConf.GetCoreKeys -\\n'", "' problem retrieving key binding for event %r\\n'", "' from key set %r.\\n'", "' returning default value: %r'", "%", "(", "event", ",", "keySetName", ",", "keyBindings", "[", "event", "]", ")", ")", "_warn", "(", "warning", ",", "'keys'", ",", "keySetName", ",", "event", ")", "return", "keyBindings" ]

[ "Retrieve", "attributes", "without", "triggering", "dynamic", "lookup", "via", "the", "descriptor", "protocol", "__getattr__", "or", "__getattribute__", "." ]

[ "def", "getattr_static", "(", "obj", ",", "attr", ",", "default", "=", "_sentinel", ")", ":", "instance_result", "=", "_sentinel", "if", "not", "_is_type", "(", "obj", ")", ":", "klass", "=", "type", "(", "obj", ")", "dict_attr", "=", "_shadowed_dict", "(", "klass", ")", "if", "(", "dict_attr", "is", "_sentinel", "or", "type", "(", "dict_attr", ")", "is", "types", ".", "MemberDescriptorType", ")", ":", "instance_result", "=", "_check_instance", "(", "obj", ",", "attr", ")", "else", ":", "klass", "=", "obj", "klass_result", "=", "_check_class", "(", "klass", ",", "attr", ")", "if", "instance_result", "is", "not", "_sentinel", "and", "klass_result", "is", "not", "_sentinel", ":", "if", "(", "_check_class", "(", "type", "(", "klass_result", ")", ",", "'__get__'", ")", "is", "not", "_sentinel", "and", "_check_class", "(", "type", "(", "klass_result", ")", ",", "'__set__'", ")", "is", "not", "_sentinel", ")", ":", "return", "klass_result", "if", "instance_result", "is", "not", "_sentinel", ":", "return", "instance_result", "if", "klass_result", "is", "not", "_sentinel", ":", "return", "klass_result", "if", "obj", "is", "klass", ":", "# for types we check the metaclass too", "for", "entry", "in", "_static_getmro", "(", "type", "(", "klass", ")", ")", ":", "if", "_shadowed_dict", "(", "type", "(", "entry", ")", ")", "is", "_sentinel", ":", "try", ":", "return", "entry", ".", "__dict__", "[", "attr", "]", "except", "KeyError", ":", "pass", "if", "default", "is", "not", "_sentinel", ":", "return", "default", "raise", "AttributeError", "(", "attr", ")" ]

[ "Returns", "all", "locally", "included", "files", "." ]

[ "def", "extract_includes", "(", "srcdir", ",", "source", ")", ":", "includes", "=", "set", "(", ")", "for", "line", "in", "io", ".", "open", "(", "source", ",", "encoding", "=", "'utf-8'", ")", ":", "match", "=", "__INCLUDE", ".", "match", "(", "line", ")", "if", "match", ":", "includes", ".", "add", "(", "path", ".", "join", "(", "srcdir", ",", "match", ".", "group", "(", "1", ")", ")", ")", "return", "includes" ]

[ "Returns", "a", "sequence", "of", "symbols", "for", "this", "thread", "." ]

[ "def", "get_symbol_names", "(", "thread", ")", ":", "def", "GetSymbol", "(", "i", ")", ":", "return", "thread", ".", "GetFrameAtIndex", "(", "i", ")", ".", "GetSymbol", "(", ")", ".", "GetName", "(", ")", "return", "[", "GetSymbol", "(", "i", ")", "for", "i", "in", "range", "(", "thread", ".", "GetNumFrames", "(", ")", ")", "]" ]

[ "Compute", "set", "difference", "of", "elements", "in", "last", "dimension", "of", "a", "and", "b", "." ]

[ "def", "set_difference", "(", "a", ",", "b", ",", "aminusb", "=", "True", ",", "validate_indices", "=", "True", ")", ":", "return", "_set_operation", "(", "a", ",", "b", ",", "\"a-b\"", "if", "aminusb", "else", "\"b-a\"", ",", "validate_indices", ")" ]

[ "Read", "terminal", "status", "line", ":", "Clear", "To", "Send", "." ]

[ "def", "getCTS", "(", "self", ")", ":", "if", "not", "self", ".", "_isOpen", ":", "raise", "portNotOpenError", "return", "bool", "(", "self", ".", "getModemState", "(", ")", "&", "MODEMSTATE_MASK_CTS", ")" ]

[ "Returns", "kernel", "banner", "." ]

[ "def", "banner", "(", "self", ")", ":", "# Just a placeholder.", "return", "\"mlir-opt kernel %s\"", "%", "__version__" ]

[ "Return", "a", "tensor", "with", "the", "same", "shape", "and", "contents", "as", "the", "input", "tensor", "." ]

[ "def", "_Identity", "(", "tensor", ",", "name", "=", "None", ")", ":", "tensor", "=", "ops", ".", "internal_convert_to_tensor_or_composite", "(", "tensor", ",", "as_ref", "=", "True", ")", "if", "isinstance", "(", "tensor", ",", "ops", ".", "Tensor", ")", ":", "if", "tensor", ".", "dtype", ".", "_is_ref_dtype", ":", "# pylint: disable=protected-access", "return", "gen_array_ops", ".", "ref_identity", "(", "tensor", ",", "name", "=", "name", ")", "else", ":", "return", "array_ops", ".", "identity", "(", "tensor", ",", "name", "=", "name", ")", "elif", "isinstance", "(", "tensor", ",", "composite_tensor", ".", "CompositeTensor", ")", ":", "return", "nest", ".", "map_structure", "(", "_Identity", ",", "tensor", ",", "expand_composites", "=", "True", ")", "else", ":", "raise", "TypeError", "(", "\"'tensor' must be a Tensor or CompositeTensor. \"", "f\"Received: {type(tensor)}.\"", ")" ]

[ "j", "(", "ump", ")", "lineno", "Set", "the", "next", "line", "that", "will", "be", "executed", ".", "Only", "available", "in", "the", "bottom", "-", "most", "frame", ".", "This", "lets", "you", "jump", "back", "and", "execute", "code", "again", "or", "jump", "forward", "to", "skip", "code", "that", "you", "don", "t", "want", "to", "run", "." ]

[ "def", "do_jump", "(", "self", ",", "arg", ")", ":", "if", "self", ".", "curindex", "+", "1", "!=", "len", "(", "self", ".", "stack", ")", ":", "self", ".", "error", "(", "'You can only jump within the bottom frame'", ")", "return", "try", ":", "arg", "=", "int", "(", "arg", ")", "except", "ValueError", ":", "self", ".", "error", "(", "\"The 'jump' command requires a line number\"", ")", "else", ":", "try", ":", "# Do the jump, fix up our copy of the stack, and display the", "# new position", "self", ".", "curframe", ".", "f_lineno", "=", "arg", "self", ".", "stack", "[", "self", ".", "curindex", "]", "=", "self", ".", "stack", "[", "self", ".", "curindex", "]", "[", "0", "]", ",", "arg", "self", ".", "print_stack_entry", "(", "self", ".", "stack", "[", "self", ".", "curindex", "]", ")", "except", "ValueError", "as", "e", ":", "self", ".", "error", "(", "'Jump failed: %s'", "%", "e", ")" ]

[ "Loss", "for", "Mask", "R", "-", "CNN", "bounding", "box", "refinement", "." ]

[ "def", "mrcnn_bbox_loss_graph", "(", "target_bbox", ",", "target_class_ids", ",", "pred_bbox", ")", ":", "# Reshape to merge batch and roi dimensions for simplicity.", "target_class_ids", "=", "K", ".", "reshape", "(", "target_class_ids", ",", "(", "-", "1", ",", ")", ")", "target_bbox", "=", "K", ".", "reshape", "(", "target_bbox", ",", "(", "-", "1", ",", "4", ")", ")", "pred_bbox", "=", "K", ".", "reshape", "(", "pred_bbox", ",", "(", "-", "1", ",", "K", ".", "int_shape", "(", "pred_bbox", ")", "[", "2", "]", ",", "4", ")", ")", "# Only positive ROIs contribute to the loss. And only", "# the right class_id of each ROI. Get their indicies.", "positive_roi_ix", "=", "tf", ".", "where", "(", "target_class_ids", ">", "0", ")", "[", ":", ",", "0", "]", "positive_roi_class_ids", "=", "tf", ".", "cast", "(", "tf", ".", "gather", "(", "target_class_ids", ",", "positive_roi_ix", ")", ",", "tf", ".", "int64", ")", "indices", "=", "tf", ".", "stack", "(", "[", "positive_roi_ix", ",", "positive_roi_class_ids", "]", ",", "axis", "=", "1", ")", "# Gather the deltas (predicted and true) that contribute to loss", "target_bbox", "=", "tf", ".", "gather", "(", "target_bbox", ",", "positive_roi_ix", ")", "pred_bbox", "=", "tf", ".", "gather_nd", "(", "pred_bbox", ",", "indices", ")", "# Smooth-L1 Loss", "loss", "=", "K", ".", "switch", "(", "tf", ".", "size", "(", "target_bbox", ")", ">", "0", ",", "smooth_l1_loss", "(", "y_true", "=", "target_bbox", ",", "y_pred", "=", "pred_bbox", ")", ",", "tf", ".", "constant", "(", "0.0", ")", ")", "loss", "=", "K", ".", "mean", "(", "loss", ")", "loss", "=", "K", ".", "reshape", "(", "loss", ",", "[", "1", ",", "1", "]", ")", "return", "loss" ]

[ "Mirrors", "ResourcePrefetchPredictorTables", "::", "ResourceRow", "::", "UpdateScore", "." ]

[ "def", "_Score", "(", "self", ")", ":", "multiplier", "=", "1", "if", "self", ".", "resource_type", "in", "(", "ResourceType", ".", "STYLESHEET", ",", "ResourceType", ".", "SCRIPT", ",", "ResourceType", ".", "FONT_RESOURCE", ")", ":", "multiplier", "=", "2", "return", "multiplier", "*", "100", "-", "self", ".", "average_position" ]

[ "Copies", "the", "gradient", "to", "all", "inputs", "." ]

[ "def", "_AddNGrad", "(", "op", ",", "grad", ")", ":", "# Not broadcasting.", "return", "[", "grad", "]", "*", "len", "(", "op", ".", "inputs", ")" ]

[ "SelectionToText", "(", "self", ")", "-", ">", "String" ]

[ "def", "SelectionToText", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html", ".", "HtmlWindow_SelectionToText", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Adds", "search", "servers", "into", "end_snippet", "proto", "section", "." ]

[ "def", "_AddSearchServers", "(", "dbroot", ",", "search_def_list", ",", "search_tab_id", ",", "supplemental_search_label", ",", "supplemental_search_url", ",", "log", ")", ":", "if", "not", "search_def_list", ":", "search_server", "=", "dbroot", ".", "end_snippet", ".", "search_config", ".", "search_server", ".", "add", "(", ")", "search_server", ".", "name", ".", "value", "=", "\"\"", "search_server", ".", "url", ".", "value", "=", "\"about:blank\"", "search_server", ".", "html_transform_url", ".", "value", "=", "\"about:blank\"", "search_server", ".", "kml_transform_url", ".", "value", "=", "\"about:blank\"", "search_server", ".", "suggest_server", ".", "value", "=", "\"about:blank\"", "return", "log", ".", "debug", "(", "\"_AddSearchServers()...\"", ")", "for", "search_def", "in", "search_def_list", ":", "log", ".", "debug", "(", "\"Configure search server: %s\"", ",", "search_def", ".", "label", ")", "search_server", "=", "dbroot", ".", "end_snippet", ".", "search_config", ".", "search_server", ".", "add", "(", ")", "search_server", ".", "name", ".", "value", "=", "(", "\"%s [%s]\"", "%", "(", "search_def", ".", "label", ",", "search_tab_id", ")", "if", "search_tab_id", "else", "search_def", ".", "label", ")", "search_server", ".", "url", ".", "value", "=", "search_def", ".", "service_url", "# Building query string and appending to search server URL.", "add_query", "=", "search_def", ".", "additional_query_param", "add_config", "=", "search_def", ".", "additional_config_param", "query_string", "=", "None", "if", "add_query", ":", "query_string", "=", "(", "\"%s&%s\"", "%", "(", "query_string", ",", "add_query", ")", "if", "query_string", "else", "add_query", ")", "if", "add_config", ":", "query_string", "=", "(", "\"%s&%s\"", "%", "(", "query_string", ",", "add_config", ")", "if", "query_string", "else", "add_config", ")", "if", "query_string", ":", "search_server", ".", "url", ".", "value", "=", "\"%s?%s\"", "%", "(", "search_server", ".", "url", ".", "value", ",", "query_string", ")", "if", "search_def", ".", "fields", "and", "search_def", ".", "fields", "[", "0", "]", ".", "suggestion", ":", "suggestion", "=", "search_server", ".", "suggestion", ".", "add", "(", ")", "suggestion", ".", "value", "=", "search_def", ".", "fields", "[", "0", "]", ".", "suggestion", "# Write 'html_transform_url' value to dbroot file.", "search_server", ".", "html_transform_url", ".", "value", "=", "search_def", ".", "html_transform_url", "# Write 'kml_transform_url' value to dbroot file.", "search_server", ".", "kml_transform_url", ".", "value", "=", "search_def", ".", "kml_transform_url", "# Write 'suggest_server' value to dbroot file.", "search_server", ".", "suggest_server", ".", "value", "=", "search_def", ".", "suggest_server", "# Write 'result_type' to dbroot file.", "if", "search_def", ".", "result_type", "==", "\"XML\"", ":", "search_server", ".", "type", "=", "ResultType", ".", "RESULT_TYPE_XML", "# Set supplemental UI properties.", "if", "supplemental_search_label", ":", "search_server", ".", "supplemental_ui", ".", "url", ".", "value", "=", "supplemental_search_url", "search_server", ".", "supplemental_ui", ".", "label", ".", "value", "=", "supplemental_search_label", "log", ".", "debug", "(", "\"_AddSearchServers() done.\"", ")" ]

[ "The", "last", "active", "model", "." ]

[ "def", "model", "(", "self", ")", ":", "if", "self", ".", "_model", "is", "None", ":", "if", "hasattr", "(", "self", ".", "inv", ",", "'model'", ")", ":", "# inv is RInversion()", "if", "len", "(", "self", ".", "inv", ".", "model", "(", ")", ")", ">", "0", ":", "return", "self", ".", "inv", ".", "model", "(", ")", "else", ":", "raise", "pg", ".", "critical", "(", "\"There was no inversion run so there is no last model\"", ")", "else", ":", "return", "self", ".", "inv", ".", "model", "return", "self", ".", "_model" ]

[ "Parse", "an", "XML", "or", "PEM", "-", "formatted", "private", "key", "." ]

[ "def", "parsePrivateKey", "(", "s", ")", ":", "try", ":", "return", "parsePEMKey", "(", "s", ",", "private", "=", "True", ")", "except", ":", "return", "parseXMLKey", "(", "s", ",", "private", "=", "True", ")" ]

[ "Enforce", "lower", "and", "upper", "bounds", "for", "numeric", "flags", "." ]

[ "def", "_RegisterBoundsValidatorIfNeeded", "(", "parser", ",", "name", ",", "flag_values", ")", ":", "if", "parser", ".", "lower_bound", "is", "not", "None", "or", "parser", ".", "upper_bound", "is", "not", "None", ":", "def", "Checker", "(", "value", ")", ":", "if", "value", "is", "not", "None", "and", "parser", ".", "IsOutsideBounds", "(", "value", ")", ":", "message", "=", "'%s is not %s'", "%", "(", "value", ",", "parser", ".", "syntactic_help", ")", "raise", "gflags_validators", ".", "Error", "(", "message", ")", "return", "True", "RegisterValidator", "(", "name", ",", "Checker", ",", "flag_values", "=", "flag_values", ")" ]

[ "Return", "whether", "the", "file", "should", "be", "checked", "for", "style", "." ]

[ "def", "should_process", "(", "self", ",", "file_path", ")", ":", "if", "self", ".", "_dispatcher", ".", "should_skip_without_warning", "(", "file_path", ")", ":", "return", "False", "if", "self", ".", "_dispatcher", ".", "should_skip_with_warning", "(", "file_path", ")", ":", "_log", ".", "warn", "(", "'File exempt from style guide. Skipping: \"%s\"'", "%", "file_path", ")", "return", "False", "return", "True" ]

[ "Return", "OriginalCommand", "(", "operation", ")", "after", "registering", "function", "." ]

[ "def", "register", "(", "self", ",", "operation", ",", "function", ")", ":", "self", ".", "_operations", "[", "operation", "]", "=", "function", "setattr", "(", "self", ".", "widget", ",", "operation", ",", "function", ")", "return", "OriginalCommand", "(", "self", ",", "operation", ")" ]

[ "left", "-", "multiplication", "either", "rotation", "concatenation", "or", "point", "-", "transform" ]

[ "def", "__mul__", "(", "self", ",", "right", ")", ":", "if", "isinstance", "(", "right", ",", "sympy", ".", "Matrix", ")", ":", "assert", "right", ".", "shape", "==", "(", "3", ",", "1", ")", ",", "right", ".", "shape", "return", "self", ".", "so3", "*", "right", "+", "self", ".", "t", "elif", "isinstance", "(", "right", ",", "Se3", ")", ":", "r", "=", "self", ".", "so3", "*", "right", ".", "so3", "t", "=", "self", ".", "t", "+", "self", ".", "so3", "*", "right", ".", "t", "return", "Se3", "(", "r", ",", "t", ")", "assert", "False", ",", "\"unsupported type: {0}\"", ".", "format", "(", "type", "(", "right", ")", ")" ]

[ "Automatically", "wrap", "NumPy", "arrays", "assigned", "to", "attributes", "." ]

[ "def", "__setattr__", "(", "self", ",", "name", ",", "value", ")", ":", "# TODO(allenl): Consider supporting lists/tuples, either ad-hoc or by making", "# ndarrays trackable natively and using standard trackable list", "# tracking.", "if", "isinstance", "(", "value", ",", "(", "numpy", ".", "ndarray", ",", "numpy", ".", "generic", ")", ")", ":", "try", ":", "existing", "=", "super", "(", "NumpyState", ",", "self", ")", ".", "__getattribute__", "(", "name", ")", "existing", ".", "array", "=", "value", "return", "except", "AttributeError", ":", "value", "=", "_NumpyWrapper", "(", "value", ")", "self", ".", "_track_trackable", "(", "value", ",", "name", "=", "name", ",", "overwrite", "=", "True", ")", "elif", "(", "name", "not", "in", "(", "\"_self_setattr_tracking\"", ",", "\"_self_update_uid\"", ")", "and", "getattr", "(", "self", ",", "\"_self_setattr_tracking\"", ",", "True", ")", ")", ":", "# Mixing restore()-created attributes with user-added trackable", "# objects is tricky, since we can't use the `_lookup_dependency` trick to", "# re-create attributes (we might accidentally steal the restoration for", "# another trackable object). For now `NumpyState` objects must be", "# leaf nodes. Theoretically we could add some extra arguments to", "# `_lookup_dependency` to figure out whether we should create a NumPy", "# array for the attribute or not.", "raise", "NotImplementedError", "(", "(", "\"Assigned %s to the %s property of %s, which is not a NumPy array. \"", "\"Currently mixing NumPy arrays and other trackable objects is \"", "\"not supported. File a feature request if this limitation bothers \"", "\"you.\"", ")", "%", "(", "value", ",", "name", ",", "self", ")", ")", "super", "(", "NumpyState", ",", "self", ")", ".", "__setattr__", "(", "name", ",", "value", ")" ]

[ "Test", "if", "a", "the", "current", "regex", "trigger", "matches", "trigger", ".", "If", "so", "set", "_last_re", "and", "_matched", "." ]

[ "def", "_re_match", "(", "self", ",", "trigger", ")", ":", "for", "match", "in", "re", ".", "finditer", "(", "self", ".", "_t", ",", "trigger", ")", ":", "if", "match", ".", "end", "(", ")", "!=", "len", "(", "trigger", ")", ":", "continue", "else", ":", "self", ".", "_matched", "=", "trigger", "[", "match", ".", "start", "(", ")", ":", "match", ".", "end", "(", ")", "]", "self", ".", "_last_re", "=", "match", "return", "match", "return", "False" ]