Datasets:

sia-precision-education

/

pile_cpp

like 1

[ "Send", "and", "log", "an", "error", "reply", "." ]

[ "def", "send_error", "(", "self", ",", "code", ",", "message", "=", "None", ",", "explain", "=", "None", ")", ":", "try", ":", "shortmsg", ",", "longmsg", "=", "self", ".", "responses", "[", "code", "]", "except", "KeyError", ":", "shortmsg", ",", "longmsg", "=", "'???'", ",", "'???'", "if", "message", "is", "None", ":", "message", "=", "shortmsg", "if", "explain", "is", "None", ":", "explain", "=", "longmsg", "self", ".", "log_error", "(", "\"code %d, message %s\"", ",", "code", ",", "message", ")", "self", ".", "send_response", "(", "code", ",", "message", ")", "self", ".", "send_header", "(", "'Connection'", ",", "'close'", ")", "# Message body is omitted for cases described in:", "# - RFC7230: 3.3. 1xx, 204(No Content), 304(Not Modified)", "# - RFC7231: 6.3.6. 205(Reset Content)", "body", "=", "None", "if", "(", "code", ">=", "200", "and", "code", "not", "in", "(", "HTTPStatus", ".", "NO_CONTENT", ",", "HTTPStatus", ".", "RESET_CONTENT", ",", "HTTPStatus", ".", "NOT_MODIFIED", ")", ")", ":", "# HTML encode to prevent Cross Site Scripting attacks", "# (see bug #1100201)", "content", "=", "(", "self", ".", "error_message_format", "%", "{", "'code'", ":", "code", ",", "'message'", ":", "html", ".", "escape", "(", "message", ",", "quote", "=", "False", ")", ",", "'explain'", ":", "html", ".", "escape", "(", "explain", ",", "quote", "=", "False", ")", "}", ")", "body", "=", "content", ".", "encode", "(", "'UTF-8'", ",", "'replace'", ")", "self", ".", "send_header", "(", "\"Content-Type\"", ",", "self", ".", "error_content_type", ")", "self", ".", "send_header", "(", "'Content-Length'", ",", "str", "(", "len", "(", "body", ")", ")", ")", "self", ".", "end_headers", "(", ")", "if", "self", ".", "command", "!=", "'HEAD'", "and", "body", ":", "self", ".", "wfile", ".", "write", "(", "body", ")" ]

[ "Writes", "an", "rst", "file", "for", "module", "name", "into", "f_name", "." ]

[ "def", "_write_module", "(", "name", ",", "f_name", ")", ":", "if", "verbose", "(", ")", ":", "print", "(", "\"Write: {}\"", ".", "format", "(", "name", ")", ")", "subs", "=", "_get_submodules", "(", "name", ")", "with", "open", "(", "f_name", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "\"\\n\"", ")", "rst_name", "=", "name", ".", "replace", "(", "\"_\"", ",", "\"\\\\_\"", ")", "f", ".", "write", "(", "\"{}\\n\"", ".", "format", "(", "rst_name", ")", ")", "f", ".", "write", "(", "\"=\"", "*", "len", "(", "rst_name", ")", "+", "\"\\n\"", ")", "f", ".", "write", "(", "\"\\n\"", ")", "if", "len", "(", "subs", ")", ">", "0", ":", "f", ".", "write", "(", "\".. toctree::\\n\"", ")", "f", ".", "write", "(", "\" :maxdepth: 1\\n\"", ")", "f", ".", "write", "(", "\"\\n\"", ")", "for", "sub", "in", "subs", ":", "f", ".", "write", "(", "\" {}\\n\"", ".", "format", "(", "sub", ")", ")", "f", ".", "write", "(", "\"\\n\\n\"", ")", "f", ".", "write", "(", "\".. automodule:: {}\\n\"", ".", "format", "(", "name", ")", ")", "f", ".", "write", "(", "\" :members:\\n\"", ")", "# See if there's a corresponding private CcPybind library.", "if", "_has_cc_imported_symbols", "(", "name", ")", ":", "f", ".", "write", "(", "\" :imported-members:\\n\"", ")", "f", ".", "write", "(", "\" :undoc-members:\\n\"", ")", "f", ".", "write", "(", "\" :show-inheritance:\\n\"", ")" ]

[ "Delete", "a", "directory", "on", "the", "remote", "machine", "." ]

[ "def", "rmdir", "(", "self", ",", "remote_path", ",", "recursive", "=", "False", ")", ":", "if", "recursive", ":", "self", ".", "rmall", "(", "remote_path", ")", "else", ":", "self", ".", "_simple_command", "(", "\"rmdir {0}\\n\"", ".", "format", "(", "quote", "(", "remote_path", ")", ")", ")" ]

[ "Repeatedly", "issue", "a", "prompt", "accept", "input", "parse", "an", "initial", "prefix", "off", "the", "received", "input", "and", "dispatch", "to", "action", "methods", "passing", "them", "the", "remainder", "of", "the", "line", "as", "argument", "." ]

[ "def", "cmdloop", "(", "self", ")", ":", "self", ".", "preloop", "(", ")", "self", ".", "io", ".", "pre_input", "(", "self", ".", "complete", ")", "try", ":", "stop", "=", "None", "while", "not", "stop", ":", "if", "self", ".", "cmdqueue", ":", "# First, clear out anything we have in the command queue", "line", "=", "self", ".", "cmdqueue", ".", "pop", "(", "0", ")", "else", ":", "# Then, accept input", "line", "=", "self", ".", "io", ".", "get_input", "(", "self", ".", "prompt", ")", "stop", "=", "self", ".", "runcmd", "(", "line", ")", "self", ".", "postloop", "(", ")", "finally", ":", "self", ".", "io", ".", "post_input", "(", ")" ]

[ "Returns", "list", "of", "additional", "gyp", "variables", "." ]

[ "def", "GetAdditionalGypGeneratorFlags", "(", "self", ")", ":", "return", "self", ".", "GetCommandLineOptions", "(", ")", ".", "G" ]

[ "Executed", "by", "msvs", "-", "ninja", "projects", "when", "the", "ClCompile", "target", "is", "used", "to", "build", "selected", "C", "/", "C", "++", "files", "." ]

[ "def", "ExecClCompile", "(", "self", ",", "project_dir", ",", "selected_files", ")", ":", "project_dir", "=", "os", ".", "path", ".", "relpath", "(", "project_dir", ",", "BASE_DIR", ")", "selected_files", "=", "selected_files", ".", "split", "(", "\";\"", ")", "ninja_targets", "=", "[", "os", ".", "path", ".", "join", "(", "project_dir", ",", "filename", ")", "+", "\"^^\"", "for", "filename", "in", "selected_files", "]", "cmd", "=", "[", "\"ninja.exe\"", "]", "cmd", ".", "extend", "(", "ninja_targets", ")", "return", "subprocess", ".", "call", "(", "cmd", ",", "shell", "=", "True", ",", "cwd", "=", "BASE_DIR", ")" ]

[ "Returns", "scaling", "process", "types", "for", "use", "in", "the", "ResumeProcesses", "and", "SuspendProcesses", "actions", "." ]

[ "def", "get_all_scaling_process_types", "(", "self", ")", ":", "return", "self", ".", "get_list", "(", "'DescribeScalingProcessTypes'", ",", "{", "}", ",", "[", "(", "'member'", ",", "ProcessType", ")", "]", ")" ]

[ "Parses", "options", "and", "changes", "default", "object", "ACLs", "on", "specified", "buckets", "." ]

[ "def", "_ChDefAcl", "(", "self", ")", ":", "self", ".", "parse_versions", "=", "True", "self", ".", "changes", "=", "[", "]", "if", "self", ".", "sub_opts", ":", "for", "o", ",", "a", "in", "self", ".", "sub_opts", ":", "if", "o", "==", "'-g'", ":", "self", ".", "changes", ".", "append", "(", "aclhelpers", ".", "AclChange", "(", "a", ",", "scope_type", "=", "aclhelpers", ".", "ChangeType", ".", "GROUP", ")", ")", "if", "o", "==", "'-u'", ":", "self", ".", "changes", ".", "append", "(", "aclhelpers", ".", "AclChange", "(", "a", ",", "scope_type", "=", "aclhelpers", ".", "ChangeType", ".", "USER", ")", ")", "if", "o", "==", "'-p'", ":", "self", ".", "changes", ".", "append", "(", "aclhelpers", ".", "AclChange", "(", "a", ",", "scope_type", "=", "aclhelpers", ".", "ChangeType", ".", "PROJECT", ")", ")", "if", "o", "==", "'-d'", ":", "self", ".", "changes", ".", "append", "(", "aclhelpers", ".", "AclDel", "(", "a", ")", ")", "if", "not", "self", ".", "changes", ":", "raise", "CommandException", "(", "'Please specify at least one access change '", "'with the -g, -u, or -d flags'", ")", "if", "(", "not", "UrlsAreForSingleProvider", "(", "self", ".", "args", ")", "or", "StorageUrlFromString", "(", "self", ".", "args", "[", "0", "]", ")", ".", "scheme", "!=", "'gs'", ")", ":", "raise", "CommandException", "(", "'The \"{0}\" command can only be used with gs:// URLs'", ".", "format", "(", "self", ".", "command_name", ")", ")", "bucket_urls", "=", "set", "(", ")", "for", "url_arg", "in", "self", ".", "args", ":", "for", "result", "in", "self", ".", "WildcardIterator", "(", "url_arg", ")", ":", "if", "not", "result", ".", "storage_url", ".", "IsBucket", "(", ")", ":", "raise", "CommandException", "(", "'The defacl ch command can only be applied to buckets.'", ")", "bucket_urls", ".", "add", "(", "result", ".", "storage_url", ")", "for", "storage_url", "in", "bucket_urls", ":", "self", ".", "ApplyAclChanges", "(", "storage_url", ")" ]

[ "Return", "the", "buffer", "contents", "of", "the", "frame", "." ]

[ "def", "return_buffer_contents", "(", "self", ",", "frame", ":", "Frame", ",", "force_unescaped", ":", "bool", "=", "False", ")", "->", "None", ":", "if", "not", "force_unescaped", ":", "if", "frame", ".", "eval_ctx", ".", "volatile", ":", "self", ".", "writeline", "(", "\"if context.eval_ctx.autoescape:\"", ")", "self", ".", "indent", "(", ")", "self", ".", "writeline", "(", "f\"return Markup(concat({frame.buffer}))\"", ")", "self", ".", "outdent", "(", ")", "self", ".", "writeline", "(", "\"else:\"", ")", "self", ".", "indent", "(", ")", "self", ".", "writeline", "(", "f\"return concat({frame.buffer})\"", ")", "self", ".", "outdent", "(", ")", "return", "elif", "frame", ".", "eval_ctx", ".", "autoescape", ":", "self", ".", "writeline", "(", "f\"return Markup(concat({frame.buffer}))\"", ")", "return", "self", ".", "writeline", "(", "f\"return concat({frame.buffer})\"", ")" ]

[ "MoveTo", "(", "self", "AlphaPixelData", "data", "int", "x", "int", "y", ")" ]

[ "def", "MoveTo", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "AlphaPixelData_Accessor_MoveTo", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Create", "akg", "processor" ]

[ "def", "create", "(", "self", ",", "process_num", ",", "waitime", ")", ":", "self", ".", "akg_processor", "=", "create_akg_parallel_process", "(", "process_num", ",", "waitime", ",", "self", ".", "platform", ")" ]

[ "Add", "joining", "players", "to", "the", "list", "of", "players", "." ]

[ "def", "_muc_online", "(", "self", ",", "presence", ")", ":", "nick", "=", "str", "(", "presence", "[", "'muc'", "]", "[", "'nick'", "]", ")", "jid", "=", "sleekxmpp", ".", "jid", ".", "JID", "(", "presence", "[", "'muc'", "]", "[", "'jid'", "]", ")", "if", "nick", "==", "self", ".", "nick", ":", "return", "if", "jid", ".", "resource", "!=", "'0ad'", ":", "return", "self", ".", "leaderboard", ".", "get_or_create_player", "(", "jid", ")", "self", ".", "_broadcast_rating_list", "(", ")", "logging", ".", "debug", "(", "\"Client '%s' connected with a nick of '%s'.\"", ",", "jid", ",", "nick", ")" ]

[ "Calls", "hasttr", "()", "with", "the", "given", "parameters", "and", "preserves", "the", "legacy", "(", "pre", "-", "Python", "3", ".", "2", ")", "functionality", "of", "silently", "catching", "exceptions", "." ]

[ "def", "hasattr_silent", "(", "object", ",", "name", ")", ":", "try", ":", "if", "not", "object", ":", "return", "False", "return", "hasattr", "(", "object", ",", "name", ")", "except", "AttributeError", ":", "return", "False" ]

[ "For", "a", "given", "set", "of", "nodes", "report", "what", "nodes", "depend", "on", "all", "nodes", "from", "that", "set", "." ]

[ "def", "run", "(", "self", ")", ":", "neighbor_sets", "=", "[", "set", "(", "self", ".", "_dependents_graph", "[", "node", "]", ")", "for", "node", "in", "self", ".", "_nodes", "]", "return", "sorted", "(", "list", "(", "set", ".", "intersection", "(", "*", "neighbor_sets", ")", ")", ")" ]

[ "Returns", "true", "if", "the", "page", "appears", "to", "be", "the", "index", "page", "of", "an", "svn", "repository" ]

[ "def", "is_svn_page", "(", "html", ")", ":", "# type: (Union[str, Text]) -> Optional[Match[Union[str, Text]]]", "return", "(", "re", ".", "search", "(", "r'<title>[^<]*Revision \\d+:'", ",", "html", ")", "and", "re", ".", "search", "(", "r'Powered by (?:<a[^>]*?>)?Subversion'", ",", "html", ",", "re", ".", "I", ")", ")" ]

[ "Display", "sample", "of", "new", "color", "selection", "on", "the", "dialog", "." ]

[ "def", "on_new_color_set", "(", "self", ")", ":", "new_color", "=", "self", ".", "color", ".", "get", "(", ")", "self", ".", "style", ".", "configure", "(", "'frame_color_set.TFrame'", ",", "background", "=", "new_color", ")", "plane", "=", "'foreground'", "if", "self", ".", "fg_bg_toggle", ".", "get", "(", ")", "else", "'background'", "sample_element", "=", "self", ".", "theme_elements", "[", "self", ".", "highlight_target", ".", "get", "(", ")", "]", "[", "0", "]", "self", ".", "highlight_sample", ".", "tag_config", "(", "sample_element", ",", "*", "*", "{", "plane", ":", "new_color", "}", ")", "theme", "=", "self", ".", "custom_name", ".", "get", "(", ")", "theme_element", "=", "sample_element", "+", "'-'", "+", "plane", "changes", ".", "add_option", "(", "'highlight'", ",", "theme", ",", "theme_element", ",", "new_color", ")" ]

[ "Recomputes", "the", "original", "view", "." ]

[ "def", "_callbackResetButton", "(", "self", ")", ":", "if", "self", ".", "_result", ":", "renderer", "=", "self", ".", "_result", ".", "getVTKRenderer", "(", ")", "renderer", ".", "ResetCamera", "(", ")", "camera", "=", "renderer", ".", "GetActiveCamera", "(", ")", "fp", "=", "camera", ".", "GetFocalPoint", "(", ")", "p", "=", "camera", ".", "GetPosition", "(", ")", "dist", "=", "math", ".", "sqrt", "(", "(", "p", "[", "0", "]", "-", "fp", "[", "0", "]", ")", "**", "2", "+", "(", "p", "[", "1", "]", "-", "fp", "[", "1", "]", ")", "**", "2", "+", "(", "p", "[", "2", "]", "-", "fp", "[", "2", "]", ")", "**", "2", ")", "camera", ".", "SetPosition", "(", "fp", "[", "0", "]", ",", "fp", "[", "1", "]", ",", "fp", "[", "2", "]", "+", "dist", ")", "camera", ".", "SetViewUp", "(", "0.0", ",", "1.0", ",", "0.0", ")", "self", ".", "_result", ".", "setNeedsUpdate", "(", "True", ")", "self", ".", "windowRequiresUpdate", ".", "emit", "(", ")" ]

[ "get", "total", "weight", "for", "this", "task", "and", "all", "the", "subtasks" ]

[ "def", "_get_weight", "(", "self", ")", ":", "subtasks_weight", "=", "[", "s", ".", "_get_weight", "(", ")", "for", "s", "in", "self", ".", "subtasks", "]", "return", "float", "(", "self", ".", "size", "*", "self", ".", "weight", ")", "+", "sum", "(", "subtasks_weight", ")" ]

[ "empty", "the", "trash" ]

[ "def", "emptytrash", "(", ")", ":", "finder", "=", "_getfinder", "(", ")", "args", "=", "{", "}", "attrs", "=", "{", "}", "args", "[", "'----'", "]", "=", "aetypes", ".", "ObjectSpecifier", "(", "want", "=", "aetypes", ".", "Type", "(", "'prop'", ")", ",", "form", "=", "\"prop\"", ",", "seld", "=", "aetypes", ".", "Type", "(", "'trsh'", ")", ",", "fr", "=", "None", ")", "_reply", ",", "args", ",", "attrs", "=", "finder", ".", "send", "(", "\"fndr\"", ",", "\"empt\"", ",", "args", ",", "attrs", ")", "if", "'errn'", "in", "args", ":", "raise", "aetools", ".", "Error", ",", "aetools", ".", "decodeerror", "(", "args", ")" ]

[ "Check", "if", "patterns", "contains", "a", "pattern", "that", "matches", "filename", "." ]

[ "def", "filename_match", "(", "filename", ",", "patterns", ",", "default", "=", "True", ")", ":", "if", "not", "patterns", ":", "return", "default", "return", "any", "(", "fnmatch", "(", "filename", ",", "pattern", ")", "for", "pattern", "in", "patterns", ")" ]

[ "Callback", "before", "training", "step", "begins", "." ]

[ "def", "step_begin", "(", "self", ",", "step", ")", ":", "if", "(", "step", "<", "0", ")", "or", "(", "(", "self", ".", "_max_steps", "is", "not", "None", ")", "and", "(", "step", ">", "self", ".", "_max_steps", ")", ")", ":", "raise", "ValueError", "(", "\"Invalid step %s.\"", "%", "step", ")", "self", ".", "_current_step", "=", "step", "return", "[", "]" ]

[ "setProgram", "(", "string", "string", ")", "-", ">", "None" ]

[ "def", "setProgram", "(", "self", ",", "tlsID", ",", "programID", ")", ":", "self", ".", "_setCmd", "(", "tc", ".", "TL_PROGRAM", ",", "tlsID", ",", "\"s\"", ",", "programID", ")" ]

[ "We", "create", ".", "dSYM", "bundles", "on", "the", "fly", "but", "if", "someone", "runs", "buildsymbols", "twice", "we", "should", "skip", "any", "bundles", "we", "created", "previously", "otherwise", "we", "ll", "recurse", "into", "them", "and", "try", "to", "dump", "the", "inner", "bits", "again", "." ]

[ "def", "ShouldSkipDir", "(", "self", ",", "dir", ")", ":", "if", "dir", ".", "endswith", "(", "\".dSYM\"", ")", ":", "return", "True", "return", "False" ]

[ "Calculate", "automatic", "size", "if", "allowed", ";", "use", "base", "mixin", "function", "." ]

[ "def", "_CalcSize", "(", "self", ",", "size", "=", "None", ")", ":", "return", "self", ".", "_calcSize", "(", "size", ")" ]

[ "This", "command", "performs", "RSA", "decryption", "using", "the", "indicated", "padding", "scheme", "according", "to", "IETF", "RFC", "8017", "((", "PKCS#1", ")", "." ]

[ "def", "__init__", "(", "self", ",", "keyHandle", "=", "TPM_HANDLE", "(", ")", ",", "cipherText", "=", "None", ",", "inScheme", "=", "None", ",", "label", "=", "None", ")", ":", "self", ".", "keyHandle", "=", "keyHandle", "self", ".", "cipherText", "=", "cipherText", "self", ".", "inScheme", "=", "inScheme", "self", ".", "label", "=", "label" ]

[ "Adds", "Mox", "cleanup", "code", "to", "any", "MoxTestBase", "method", "." ]

[ "def", "CleanUpTest", "(", "cls", ",", "func", ")", ":", "def", "new_method", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "mox_obj", "=", "getattr", "(", "self", ",", "'mox'", ",", "None", ")", "cleanup_mox", "=", "False", "if", "mox_obj", "and", "isinstance", "(", "mox_obj", ",", "Mox", ")", ":", "cleanup_mox", "=", "True", "try", ":", "func", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", "finally", ":", "if", "cleanup_mox", ":", "mox_obj", ".", "UnsetStubs", "(", ")", "if", "cleanup_mox", ":", "mox_obj", ".", "VerifyAll", "(", ")", "new_method", ".", "__name__", "=", "func", ".", "__name__", "new_method", ".", "__doc__", "=", "func", ".", "__doc__", "new_method", ".", "__module__", "=", "func", ".", "__module__", "return", "new_method" ]

[ "Depth", "-", "first", "preorder", "walk", "over", "the", "cursor", "and", "its", "descendants", "." ]

[ "def", "walk_preorder", "(", "self", ")", ":", "yield", "self", "for", "child", "in", "self", ".", "get_children", "(", ")", ":", "for", "descendant", "in", "child", ".", "walk_preorder", "(", ")", ":", "yield", "descendant" ]

[ "The", "gpu", "buffer", "for", "the", "null", "-", "mask" ]

[ "def", "nullmask", "(", "self", ")", "->", "Buffer", ":", "if", "not", "self", ".", "nullable", ":", "raise", "ValueError", "(", "\"Column has no null mask\"", ")", "return", "self", ".", "mask_array_view" ]

[ "Get", "all", "available", "expression", "groups", "." ]

[ "def", "expressionGroups", "(", "self", ",", "origin", ")", ":", "alembicGroups", "=", "pm", ".", "walterStandin", "(", "alembicAllGroups", "=", "origin", ")", "if", "alembicGroups", ":", "groupSet", "=", "set", "(", "alembicGroups", ")", "else", ":", "groupSet", "=", "set", "(", ")", "for", "exp", ",", "grp", ",", "_", "in", "self", ".", "iterateExpressionGroups", "(", "origin", ")", ":", "if", "exp", "and", "grp", ":", "groupSet", ".", "add", "(", "grp", ")", "return", "sorted", "(", "groupSet", ")" ]

[ "Emit", "a", "raw", "memcpy", "()", "call", "for", "count", "items", "of", "size", "itemsize", "from", "src", "to", "dest", "." ]

[ "def", "raw_memcpy", "(", "builder", ",", "dst", ",", "src", ",", "count", ",", "itemsize", ",", "align", "=", "1", ")", ":", "return", "_raw_memcpy", "(", "builder", ",", "'llvm.memcpy'", ",", "dst", ",", "src", ",", "count", ",", "itemsize", ",", "align", ")" ]

[ "Helper", "function", "that", "maps", "the", "given", "func", "over", "the", "iterables", "and", "then", "creates", "a", "single", "flat", "iterable", "from", "the", "results", "." ]

[ "def", "_flatmap", "(", "func", ",", "*", "iterables", ")", ":", "return", "itertools", ".", "chain", ".", "from_iterable", "(", "map", "(", "func", ",", "*", "iterables", ")", ")" ]

[ "Calculate", "the", "generator", "specific", "info", "that", "gets", "fed", "to", "input", "(", "called", "by", "gyp", ")", "." ]

[ "def", "CalculateGeneratorInputInfo", "(", "params", ")", ":", "generator_flags", "=", "params", ".", "get", "(", "'generator_flags'", ",", "{", "}", ")", "if", "generator_flags", ".", "get", "(", "'adjust_static_libraries'", ",", "False", ")", ":", "global", "generator_wants_static_library_dependencies_adjusted", "generator_wants_static_library_dependencies_adjusted", "=", "True" ]

[ "Convierte", "un", "parametro", "de", "color", "del", "texto", "para", "que", "sea", "usable", "por", "QT" ]

[ "def", "QTcolorTexto", "(", "self", ",", "rgb", ")", ":", "if", "rgb", "==", "-", "1", ":", "return", "None", "else", ":", "return", "QtGui", ".", "QColor", "(", "rgb", ")" ]

[ "Negate", "a", "filter", "." ]

[ "def", "negation", "(", "f", ")", ":", "def", "keep", "(", "paths", ")", ":", "l", "=", "set", "(", "paths", ")", "r", "=", "set", "(", "f", "(", "paths", ")", ")", "return", "sorted", "(", "list", "(", "l", "-", "r", ")", ")", "return", "keep" ]

[ "Memoized", "Value", "()", "node", "factory", "." ]

[ "def", "ValueWithMemo", "(", "value", ",", "built_value", "=", "None", ",", "name", "=", "None", ")", ":", "global", "_memo_lookup_map", "# No current support for memoizing a value that needs to be built.", "if", "built_value", ":", "return", "Value", "(", "value", ",", "built_value", ",", "name", "=", "name", ")", "try", ":", "memo_lookup_key", "=", "hash", "(", "(", "value", ",", "name", ")", ")", "except", "TypeError", ":", "# Non-primitive types will hit this codepath.", "return", "Value", "(", "value", ",", "name", "=", "name", ")", "try", ":", "return", "_memo_lookup_map", "[", "memo_lookup_key", "]", "except", "KeyError", ":", "v", "=", "Value", "(", "value", ",", "built_value", ",", "name", ")", "_memo_lookup_map", "[", "memo_lookup_key", "]", "=", "v", "return", "v" ]

[ "Quote", "a", "string", "such", "that", "it", "will", "be", "interpreted", "as", "a", "single", "argument", "by", "the", "shell", "." ]

[ "def", "QuoteShellArgument", "(", "arg", ",", "flavor", ")", ":", "# Rather than attempting to enumerate the bad shell characters, just", "# whitelist common OK ones and quote anything else.", "if", "re", ".", "match", "(", "r'^[a-zA-Z0-9_=.\\\\/-]+$'", ",", "arg", ")", ":", "return", "arg", "# No quoting necessary.", "if", "flavor", "==", "'win'", ":", "return", "gyp", ".", "msvs_emulation", ".", "QuoteForRspFile", "(", "arg", ")", "return", "\"'\"", "+", "arg", ".", "replace", "(", "\"'\"", ",", "\"'\"", "+", "'\"\\'\"'", "+", "\"'\"", ")", "+", "\"'\"" ]

[ "Add", "state", "transition", "noise", "to", "catch", "state", "up", "to", "current_times", "." ]

[ "def", "_imputation_step", "(", "self", ",", "current_times", ",", "state", ")", ":", "estimated_state", ",", "estimated_state_var", ",", "previous_times", "=", "state", "catchup_times", "=", "current_times", "-", "previous_times", "non_negative_assertion", "=", "control_flow_ops", ".", "Assert", "(", "math_ops", ".", "reduce_all", "(", "catchup_times", ">=", "0", ")", ",", "[", "\"Negative imputation interval\"", ",", "catchup_times", ",", "current_times", ",", "previous_times", "]", ",", "summarize", "=", "100", ")", "with", "ops", ".", "control_dependencies", "(", "[", "non_negative_assertion", "]", ")", ":", "transition_matrices", ",", "transition_noise_sums", "=", "(", "# pylint: disable=unbalanced-tuple-unpacking", "self", ".", "_cached_transition_powers_and_sums", "(", "catchup_times", ")", ")", "estimated_state", "=", "self", ".", "_kalman_filter", ".", "predict_state_mean", "(", "estimated_state", ",", "transition_matrices", ")", "estimated_state_var", "=", "self", ".", "_kalman_filter", ".", "predict_state_var", "(", "estimated_state_var", ",", "transition_matrices", ",", "transition_noise_sums", ")", "return", "(", "estimated_state", ",", "estimated_state_var", ",", "previous_times", "+", "catchup_times", ")" ]

[ "Given", "an", "Operation", "org_instance", "from", "one", "Graph", "initializes", "and", "returns", "a", "copy", "of", "it", "from", "another", "Graph", "under", "the", "specified", "scope", "(", "default", ")", "." ]

[ "def", "copy_op_to_graph", "(", "org_instance", ",", "to_graph", ",", "variables", ",", "scope", "=", "\"\"", ")", ":", "#The name of the new instance", "if", "scope", "!=", "''", ":", "new_name", "=", "scope", "+", "'/'", "+", "org_instance", ".", "name", "else", ":", "new_name", "=", "org_instance", ".", "name", "#Extract names of variables", "copied_variables", "=", "dict", "(", "(", "x", ".", "name", ",", "x", ")", "for", "x", "in", "variables", ")", "#If a variable by the new name already exists, return the", "#correspondng tensor that will act as an input", "if", "new_name", "in", "copied_variables", ":", "return", "to_graph", ".", "get_tensor_by_name", "(", "copied_variables", "[", "new_name", "]", ".", "name", ")", "#If an instance of the same name exists, return appropriately", "try", ":", "already_present", "=", "to_graph", ".", "as_graph_element", "(", "new_name", ",", "allow_tensor", "=", "True", ",", "allow_operation", "=", "True", ")", "return", "already_present", "except", ":", "pass", "#Get the collections that the new instance needs to be added to.", "#The new collections will also be a part of the given scope.", "collections", "=", "[", "]", "for", "name", ",", "collection", "in", "org_instance", ".", "graph", ".", "_collections", ".", "items", "(", ")", ":", "if", "org_instance", "in", "collection", ":", "if", "scope", "==", "''", ":", "collections", ".", "append", "(", "name", ")", "else", ":", "collections", ".", "append", "(", "scope", "+", "'/'", "+", "name", ")", "#Take action based on the class of the instance", "if", "isinstance", "(", "org_instance", ",", "ops", ".", "Tensor", ")", ":", "#If its a Tensor, it is one of the outputs of the underlying", "#op. Therefore, copy the op itself and return the appropriate", "#output.", "op", "=", "org_instance", ".", "op", "new_op", "=", "copy_op_to_graph", "(", "op", ",", "to_graph", ",", "variables", ",", "scope", ")", "output_index", "=", "op", ".", "outputs", ".", "index", "(", "org_instance", ")", "new_tensor", "=", "new_op", ".", "outputs", "[", "output_index", "]", "#Add to collections if any", "for", "collection", "in", "collections", ":", "to_graph", ".", "add_to_collection", "(", "collection", ",", "new_tensor", ")", "return", "new_tensor", "elif", "isinstance", "(", "org_instance", ",", "ops", ".", "Operation", ")", ":", "op", "=", "org_instance", "#If it has an original_op parameter, copy it", "if", "op", ".", "_original_op", "is", "not", "None", ":", "new_original_op", "=", "copy_op_to_graph", "(", "op", ".", "_original_op", ",", "to_graph", ",", "variables", ",", "scope", ")", "else", ":", "new_original_op", "=", "None", "#If it has control inputs, call this function recursively on each.", "new_control_inputs", "=", "[", "copy_op_to_graph", "(", "x", ",", "to_graph", ",", "variables", ",", "scope", ")", "for", "x", "in", "op", ".", "control_inputs", "]", "#If it has inputs, call this function recursively on each.", "new_inputs", "=", "[", "copy_op_to_graph", "(", "x", ",", "to_graph", ",", "variables", ",", "scope", ")", "for", "x", "in", "op", ".", "inputs", "]", "#Make a new node_def based on that of the original.", "#An instance of tensorflow.core.framework.graph_pb2.NodeDef, it", "#stores String-based info such as name, device and type of the op.", "#Unique to every Operation instance.", "new_node_def", "=", "deepcopy", "(", "op", ".", "_node_def", ")", "#Change the name", "new_node_def", ".", "name", "=", "new_name", "#Copy the other inputs needed for initialization", "output_types", "=", "op", ".", "_output_types", "[", ":", "]", "input_types", "=", "op", ".", "_input_types", "[", ":", "]", "#Make a copy of the op_def too.", "#Its unique to every _type_ of Operation.", "op_def", "=", "deepcopy", "(", "op", ".", "_op_def", ")", "#Initialize a new Operation instance", "new_op", "=", "ops", ".", "Operation", "(", "new_node_def", ",", "to_graph", ",", "new_inputs", ",", "output_types", ",", "new_control_inputs", ",", "input_types", ",", "new_original_op", ",", "op_def", ")", "#Use Graph's hidden methods to add the op", "to_graph", ".", "_add_op", "(", "new_op", ")", "to_graph", ".", "_record_op_seen_by_control_dependencies", "(", "new_op", ")", "for", "device_function", "in", "reversed", "(", "to_graph", ".", "_device_function_stack", ")", ":", "new_op", ".", "_set_device", "(", "device_function", "(", "new_op", ")", ")", "return", "new_op", "else", ":", "raise", "TypeError", "(", "\"Could not copy instance: \"", "+", "str", "(", "org_instance", ")", ")" ]

[ "Return", "the", "month", "names", "of", "the", "DateTimeIndex", "with", "specified", "locale", "." ]

[ "def", "month_name", "(", "self", ",", "locale", "=", "None", ")", ":", "if", "self", ".", "tz", "is", "not", "None", "and", "not", "timezones", ".", "is_utc", "(", "self", ".", "tz", ")", ":", "values", "=", "self", ".", "_local_timestamps", "(", ")", "else", ":", "values", "=", "self", ".", "asi8", "result", "=", "fields", ".", "get_date_name_field", "(", "values", ",", "\"month_name\"", ",", "locale", "=", "locale", ")", "result", "=", "self", ".", "_maybe_mask_results", "(", "result", ",", "fill_value", "=", "None", ")", "return", "result" ]

[ "Use", "regex", "to", "find", "class", "names", "in", "header", "files", "of", "source", "nodes" ]

[ "def", "extract_classname_source_node", "(", "header_content", ")", ":", "return", "re", ".", "findall", "(", "r\"(?<=class )[\\w\\d_]+(?=Node : )\"", ",", "header_content", ")" ]

[ "Get", "list", "of", "installer", "keys", "registered", "for", "the", "specified", "OS", ".", "These", "keys", "can", "be", "resolved", "by", "calling", ":", "meth", ":", "InstallerContext", ".", "get_installer", ".", ":", "param", "os_key", ":", "Key", "for", "OS", ":", "raises", ":", ":", "exc", ":", "KeyError", ":", "if", "no", "information", "for", "OS", "*", "os_key", "*", "is", "registered", "." ]

[ "def", "get_os_installer_keys", "(", "self", ",", "os_key", ")", ":", "if", "os_key", "in", "self", ".", "os_installers", ":", "return", "self", ".", "os_installers", "[", "os_key", "]", "[", ":", "]", "else", ":", "raise", "KeyError", "(", "os_key", ")" ]

[ "select", "all", "quantization_candidates", "op", "type", "nodes", "input", "/", "output", "tensors", ".", "returns", ":", "tensors", "(", "set", ")", ":", "set", "of", "tensor", "name", ".", "value_infos", "(", "dict", ")", ":", "tensor", "name", "to", "value", "info", "." ]

[ "def", "select_tensors_to_calibrate", "(", "self", ",", "model", ")", ":", "value_infos", "=", "{", "vi", ".", "name", ":", "vi", "for", "vi", "in", "model", ".", "graph", ".", "value_info", "}", "value_infos", ".", "update", "(", "{", "ot", ".", "name", ":", "ot", "for", "ot", "in", "model", ".", "graph", ".", "output", "}", ")", "value_infos", ".", "update", "(", "{", "it", ".", "name", ":", "it", "for", "it", "in", "model", ".", "graph", ".", "input", "}", ")", "initializer", "=", "set", "(", "init", ".", "name", "for", "init", "in", "model", ".", "graph", ".", "initializer", ")", "tensors_to_calibrate", "=", "set", "(", ")", "tensor_type_to_calibrate", "=", "set", "(", "[", "TensorProto", ".", "FLOAT", ",", "TensorProto", ".", "FLOAT16", "]", ")", "for", "node", "in", "model", ".", "graph", ".", "node", ":", "if", "len", "(", "self", ".", "op_types_to_calibrate", ")", "==", "0", "or", "node", ".", "op_type", "in", "self", ".", "op_types_to_calibrate", ":", "for", "tensor_name", "in", "itertools", ".", "chain", "(", "node", ".", "input", ",", "node", ".", "output", ")", ":", "if", "tensor_name", "in", "value_infos", ".", "keys", "(", ")", ":", "vi", "=", "value_infos", "[", "tensor_name", "]", "if", "vi", ".", "type", ".", "HasField", "(", "'tensor_type'", ")", "and", "(", "vi", ".", "type", ".", "tensor_type", ".", "elem_type", "in", "tensor_type_to_calibrate", ")", "and", "(", "tensor_name", "not", "in", "initializer", ")", ":", "tensors_to_calibrate", ".", "add", "(", "tensor_name", ")", "return", "tensors_to_calibrate", ",", "value_infos" ]

[ "Return", "(", "self", "//", "other", "self", "%", "other", ")" ]

[ "def", "__divmod__", "(", "self", ",", "other", ",", "context", "=", "None", ")", ":", "other", "=", "_convert_other", "(", "other", ")", "if", "other", "is", "NotImplemented", ":", "return", "other", "if", "context", "is", "None", ":", "context", "=", "getcontext", "(", ")", "ans", "=", "self", ".", "_check_nans", "(", "other", ",", "context", ")", "if", "ans", ":", "return", "(", "ans", ",", "ans", ")", "sign", "=", "self", ".", "_sign", "^", "other", ".", "_sign", "if", "self", ".", "_isinfinity", "(", ")", ":", "if", "other", ".", "_isinfinity", "(", ")", ":", "ans", "=", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'divmod(INF, INF)'", ")", "return", "ans", ",", "ans", "else", ":", "return", "(", "_SignedInfinity", "[", "sign", "]", ",", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'INF % x'", ")", ")", "if", "not", "other", ":", "if", "not", "self", ":", "ans", "=", "context", ".", "_raise_error", "(", "DivisionUndefined", ",", "'divmod(0, 0)'", ")", "return", "ans", ",", "ans", "else", ":", "return", "(", "context", ".", "_raise_error", "(", "DivisionByZero", ",", "'x // 0'", ",", "sign", ")", ",", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'x % 0'", ")", ")", "quotient", ",", "remainder", "=", "self", ".", "_divide", "(", "other", ",", "context", ")", "remainder", "=", "remainder", ".", "_fix", "(", "context", ")", "return", "quotient", ",", "remainder" ]

[ "Add", "a", "max_broadcastable", "layer", "to", "the", "model", "that", "performs", "element", "-", "wise", "maximum", "operation", "with", "broadcast", "support", ".", "Refer", "to", "the", "**", "MaxBroadcastableLayerParams", "**", "message", "in", "specification", "(", "NeuralNetwork", ".", "proto", ")", "for", "more", "details", "." ]

[ "def", "add_max_broadcastable", "(", "self", ",", "name", ",", "input_names", ",", "output_name", ")", ":", "spec_layer", "=", "self", ".", "_add_generic_layer", "(", "name", ",", "input_names", ",", "[", "output_name", "]", ")", "spec_layer", ".", "maxBroadcastable", ".", "MergeFromString", "(", "b\"\"", ")", "self", ".", "_set_max_input_rank", "(", "input_names", ",", "output_name", ")", "return", "spec_layer" ]

[ "List", "objects", "at", "path", "." ]

[ "def", "ls", "(", "self", ",", "path", ",", "detail", "=", "True", ",", "*", "*", "kwargs", ")", ":", "raise", "NotImplementedError" ]

[ "Returns", "the", "active", "developer", "directory", "as", "reported", "by", "xcode", "-", "select", "-", "p", ".", "Returns", "None", "if", "none", "is", "set", "." ]

[ "def", "GetXcodeDeveloperDirectory", "(", ")", ":", "if", "not", "MacOS", "(", ")", ":", "return", "None", "return", "GetCommandOutput", "(", "\"xcode-select -p\"", ")" ]

[ "Filter", "out", "hosts", "with", "more", "nodes", "per", "IP" ]

[ "def", "filtermultiport", "(", "ips", ")", ":", "hist", "=", "collections", ".", "defaultdict", "(", "list", ")", "for", "ip", "in", "ips", ":", "hist", "[", "ip", "[", "'sortkey'", "]", "]", ".", "append", "(", "ip", ")", "return", "[", "value", "[", "0", "]", "for", "(", "key", ",", "value", ")", "in", "list", "(", "hist", ".", "items", "(", ")", ")", "if", "len", "(", "value", ")", "==", "1", "]" ]

[ "track", "(", "string", "string", ")", "-", ">", "None", "Start", "visually", "tracking", "the", "given", "vehicle", "or", "person", "on", "the", "given", "view", "." ]

[ "def", "track", "(", "self", ",", "objID", ",", "viewID", "=", "DEFAULT_VIEW", ")", ":", "self", ".", "_setCmd", "(", "tc", ".", "VAR_TRACK_VEHICLE", ",", "viewID", ",", "\"s\"", ",", "objID", ")" ]

[ "sets", "the", "preshape", "on", "the", "robot", "assumes", "environment", "is", "locked" ]

[ "def", "setPreshape", "(", "self", ",", "grasp", ")", ":", "self", ".", "robot", ".", "SetDOFValues", "(", "grasp", "[", "self", ".", "graspindices", "[", "'igrasppreshape'", "]", "]", ",", "self", ".", "manip", ".", "GetGripperIndices", "(", ")", ")" ]

[ "get", "weighted", "sum", "of", "percent", "completed", "for", "this", "task", "and", "all", "the", "subtasks" ]

[ "def", "_get_completed", "(", "self", ")", ":", "completed_subtasks", "=", "[", "s", ".", "_get_completed", "(", ")", "for", "s", "in", "self", ".", "subtasks", "]", "return", "float", "(", "self", ".", "completed", "*", "self", ".", "weight", ")", "+", "sum", "(", "completed_subtasks", ")" ]

[ "Find", "appropriate", "C", "compiler", "for", "extension", "module", "builds" ]

[ "def", "_find_appropriate_compiler", "(", "_config_vars", ")", ":", "# Issue #13590:", "# The OSX location for the compiler varies between OSX", "# (or rather Xcode) releases. With older releases (up-to 10.5)", "# the compiler is in /usr/bin, with newer releases the compiler", "# can only be found inside Xcode.app if the \"Command Line Tools\"", "# are not installed.", "#", "# Furthermore, the compiler that can be used varies between", "# Xcode releases. Up to Xcode 4 it was possible to use 'gcc-4.2'", "# as the compiler, after that 'clang' should be used because", "# gcc-4.2 is either not present, or a copy of 'llvm-gcc' that", "# miscompiles Python.", "# skip checks if the compiler was overridden with a CC env variable", "if", "'CC'", "in", "os", ".", "environ", ":", "return", "_config_vars", "# The CC config var might contain additional arguments.", "# Ignore them while searching.", "cc", "=", "oldcc", "=", "_config_vars", "[", "'CC'", "]", ".", "split", "(", ")", "[", "0", "]", "if", "not", "_find_executable", "(", "cc", ")", ":", "# Compiler is not found on the shell search PATH.", "# Now search for clang, first on PATH (if the Command LIne", "# Tools have been installed in / or if the user has provided", "# another location via CC). If not found, try using xcrun", "# to find an uninstalled clang (within a selected Xcode).", "# NOTE: Cannot use subprocess here because of bootstrap", "# issues when building Python itself (and os.popen is", "# implemented on top of subprocess and is therefore not", "# usable as well)", "cc", "=", "_find_build_tool", "(", "'clang'", ")", "elif", "os", ".", "path", ".", "basename", "(", "cc", ")", ".", "startswith", "(", "'gcc'", ")", ":", "# Compiler is GCC, check if it is LLVM-GCC", "data", "=", "_read_output", "(", "\"'%s' --version\"", "%", "(", "cc", ".", "replace", "(", "\"'\"", ",", "\"'\\\"'\\\"'\"", ")", ",", ")", ")", "if", "data", "and", "'llvm-gcc'", "in", "data", ":", "# Found LLVM-GCC, fall back to clang", "cc", "=", "_find_build_tool", "(", "'clang'", ")", "if", "not", "cc", ":", "raise", "SystemError", "(", "\"Cannot locate working compiler\"", ")", "if", "cc", "!=", "oldcc", ":", "# Found a replacement compiler.", "# Modify config vars using new compiler, if not already explicitly", "# overridden by an env variable, preserving additional arguments.", "for", "cv", "in", "_COMPILER_CONFIG_VARS", ":", "if", "cv", "in", "_config_vars", "and", "cv", "not", "in", "os", ".", "environ", ":", "cv_split", "=", "_config_vars", "[", "cv", "]", ".", "split", "(", ")", "cv_split", "[", "0", "]", "=", "cc", "if", "cv", "!=", "'CXX'", "else", "cc", "+", "'++'", "_save_modified_value", "(", "_config_vars", ",", "cv", ",", "' '", ".", "join", "(", "cv_split", ")", ")", "return", "_config_vars" ]

[ "Implementation", "of", "the", "PY2", "dictionary", "API" ]

[ "def", "iteritems", "(", "self", ")", ":", "return", "FieldDataInformationIterator", "(", "self", ",", "True", ")" ]

[ "Creates", "a", "_DictFetchMapper", "." ]

[ "def", "__init__", "(", "self", ",", "fetches", ")", ":", "self", ".", "_fetch_type", "=", "type", "(", "fetches", ")", "if", "isinstance", "(", "fetches", ",", "collections", ".", "defaultdict", ")", ":", "self", ".", "_type_ctor", "=", "functools", ".", "partial", "(", "collections", ".", "defaultdict", ",", "fetches", ".", "default_factory", ")", "else", ":", "self", ".", "_type_ctor", "=", "self", ".", "_fetch_type", "self", ".", "_keys", "=", "fetches", ".", "keys", "(", ")", "self", ".", "_mappers", "=", "[", "_FetchMapper", ".", "for_fetch", "(", "fetch", ")", "for", "fetch", "in", "fetches", ".", "values", "(", ")", "]", "self", ".", "_unique_fetches", ",", "self", ".", "_value_indices", "=", "_uniquify_fetches", "(", "self", ".", "_mappers", ")" ]

[ "Calculate", "the", "normalization", "workspaces", "and", "then", "call", "the", "chosen", "Q", "conversion", "algorithm", "." ]

[ "def", "execute", "(", "self", ",", "reducer", ",", "workspace", ")", ":", "wavepixeladj", "=", "\"\"", "if", "reducer", ".", "wide_angle_correction", "and", "reducer", ".", "transmission_calculator", ".", "output_wksp", ":", "# calculate the transmission wide angle correction", "_issueWarning", "(", "\"sans solid angle correction execution\"", ")", "SANSWideAngleCorrection", "(", "SampleData", "=", "workspace", ",", "TransmissionData", "=", "reducer", ".", "transmission_calculator", ".", "output_wksp", ",", "OutputWorkspace", "=", "'transmissionWorkspace'", ")", "wavepixeladj", "=", "'transmissionWorkspace'", "# create normalization workspaces", "if", "self", ".", "_norms", ":", "# the empty list at the end appears to be needed (the system test SANS2DWaveloops) is this a bug in Python?", "wave_adj", ",", "pixel_adj", "=", "self", ".", "_norms", ".", "calculate", "(", "reducer", ",", "[", "]", ")", "else", ":", "raise", "RuntimeError", "(", "'Normalization workspaces must be created by CalculateNorm() and passed to this step'", ")", "# Create the QResolution workspace, but only if it A) is requested by the user and does not exist", "# B) is requested by the user, exists, but does not", "# have the correct binning --> This is currently not implemented,", "# but should be addressed in an optimization step", "qResolution", "=", "self", ".", "_get_q_resolution_workspace", "(", "det_bank_workspace", "=", "workspace", ")", "# Debug output", "if", "DEBUG", ":", "sanslog", ".", "warning", "(", "\"###############################################\"", ")", "sanslog", ".", "warning", "(", "\"File : %s\"", "%", "str", "(", "self", ".", "_q_resolution_moderator_file_name", ")", ")", "sanslog", ".", "warning", "(", "\"A1 : %s\"", "%", "str", "(", "self", ".", "_q_resolution_a1", ")", ")", "sanslog", ".", "warning", "(", "\"A2 : %s\"", "%", "str", "(", "self", ".", "_q_resolution_a2", ")", ")", "sanslog", ".", "warning", "(", "\"H1 : %s\"", "%", "str", "(", "self", ".", "_q_resolution_h1", ")", ")", "sanslog", ".", "warning", "(", "\"H2 : %s\"", "%", "str", "(", "self", ".", "_q_resolution_h1", ")", ")", "sanslog", ".", "warning", "(", "\"W1 : %s\"", "%", "str", "(", "self", ".", "_q_resolution_w1", ")", ")", "sanslog", ".", "warning", "(", "\"W2 : %s\"", "%", "str", "(", "self", ".", "_q_resolution_w2", ")", ")", "sanslog", ".", "warning", "(", "\"LCol: %s\"", "%", "str", "(", "self", ".", "_q_resolution_collimation_length", ")", ")", "sanslog", ".", "warning", "(", "\"DR : %s\"", "%", "str", "(", "self", ".", "_q_resolution_delta_r", ")", ")", "sanslog", ".", "warning", "(", "\"Exists: %s\"", "%", "str", "(", "qResolution", "is", "not", "None", ")", ")", "try", ":", "if", "self", ".", "_Q_alg", "==", "'Q1D'", ":", "Q1D", "(", "DetBankWorkspace", "=", "workspace", ",", "OutputWorkspace", "=", "workspace", ",", "OutputBinning", "=", "self", ".", "binning", ",", "WavelengthAdj", "=", "wave_adj", ",", "PixelAdj", "=", "pixel_adj", ",", "AccountForGravity", "=", "self", ".", "_use_gravity", ",", "RadiusCut", "=", "self", ".", "r_cut", "*", "1000.0", ",", "WaveCut", "=", "self", ".", "w_cut", ",", "OutputParts", "=", "self", ".", "outputParts", ",", "WavePixelAdj", "=", "wavepixeladj", ",", "ExtraLength", "=", "self", ".", "_grav_extra_length", ",", "QResolution", "=", "qResolution", ")", "elif", "self", ".", "_Q_alg", "==", "'Qxy'", ":", "Qxy", "(", "InputWorkspace", "=", "workspace", ",", "OutputWorkspace", "=", "workspace", ",", "MaxQxy", "=", "reducer", ".", "QXY2", ",", "DeltaQ", "=", "reducer", ".", "DQXY", ",", "WavelengthAdj", "=", "wave_adj", ",", "PixelAdj", "=", "pixel_adj", ",", "AccountForGravity", "=", "self", ".", "_use_gravity", ",", "RadiusCut", "=", "self", ".", "r_cut", "*", "1000.0", ",", "WaveCut", "=", "self", ".", "w_cut", ",", "OutputParts", "=", "self", ".", "outputParts", ",", "ExtraLength", "=", "self", ".", "_grav_extra_length", ")", "ReplaceSpecialValues", "(", "InputWorkspace", "=", "workspace", ",", "OutputWorkspace", "=", "workspace", ",", "NaNValue", "=", "\"0\"", ",", "InfinityValue", "=", "\"0\"", ")", "# We need to correct for special values in the partial outputs. The", "# counts seem to have NANS.", "if", "self", ".", "outputParts", ":", "sum_of_counts", "=", "workspace", "+", "\"_sumOfCounts\"", "sum_of_norm", "=", "workspace", "+", "\"_sumOfNormFactors\"", "ReplaceSpecialValues", "(", "InputWorkspace", "=", "sum_of_counts", ",", "OutputWorkspace", "=", "sum_of_counts", ",", "NaNValue", "=", "\"0\"", ",", "InfinityValue", "=", "\"0\"", ")", "ReplaceSpecialValues", "(", "InputWorkspace", "=", "sum_of_norm", ",", "OutputWorkspace", "=", "sum_of_norm", ",", "NaNValue", "=", "\"0\"", ",", "InfinityValue", "=", "\"0\"", ")", "else", ":", "raise", "NotImplementedError", "(", "'The type of Q reduction has not been set, e.g. 1D or 2D'", ")", "except", ":", "# when we are all up to Python 2.5 replace the duplicated code below with one finally:", "reducer", ".", "deleteWorkspaces", "(", "[", "wave_adj", ",", "pixel_adj", ",", "wavepixeladj", "]", ")", "raise", "reducer", ".", "deleteWorkspaces", "(", "[", "wave_adj", ",", "pixel_adj", ",", "wavepixeladj", "]", ")" ]

[ "Generate", "struct", "implementation", "for", "source", "file", "." ]

[ "def", "_gen_struct_impl", "(", "self", ",", "struct", ",", "namespace", ",", "class_name", ")", ":", "processed_enums", "=", "[", "]", "return", "self", ".", "_struct_impl_template", ".", "substitute", "(", "namespace", "=", "namespace", ",", "class_name", "=", "class_name", ",", "struct_name", "=", "struct", ".", "name", ",", "code", "=", "self", ".", "_indent_code", "(", "self", ".", "_struct_impl_code_tempate", ".", "substitute", "(", "struct_name", "=", "struct", ".", "name", ",", "schema_loc_decl", "=", "self", ".", "_gen_schema_loc_decls", "(", "struct", ".", "members", ".", "values", "(", ")", ",", "processed_enums", ")", ",", "schema_items_decl", "=", "self", ".", "_gen_schema_items_decls", "(", "struct", ".", "members", ".", "values", "(", ")", ")", ",", "schema_item_fill", "=", "self", ".", "_gen_schema_items_fill", "(", "struct", ".", "members", ".", "values", "(", ")", ",", "struct", ".", "since", ",", "struct", ".", "until", ",", "struct", ".", "deprecated", ",", "struct", ".", "removed", ")", ")", ",", "1", ")", ")" ]

[ ":", "type", "A", ":", "List", "[", "int", "]", ":", "rtype", ":", "bool" ]

[ "def", "isIdealPermutation", "(", "self", ",", "A", ")", ":", "size", ",", "m", "=", "len", "(", "A", ")", ",", "0", "for", "i", "in", "range", "(", "size", "-", "2", ")", ":", "m", "=", "max", "(", "m", ",", "A", "[", "i", "]", ")", "if", "m", ">", "A", "[", "i", "+", "2", "]", ":", "return", "False", "return", "True" ]

[ "Creates", "a", "string", "used", "by", "the", "Fit", "algorithm", "for", "this", "profile" ]

[ "def", "create_fit_function_str", "(", "self", ",", "param_vals", "=", "None", ",", "param_prefix", "=", "\"\"", ")", ":", "vals_provided", "=", "(", "param_vals", "is", "not", "None", ")", "if", "vals_provided", ":", "def_width", "=", "param_vals", "[", "param_prefix", "+", "\"Width\"", "]", "else", ":", "def_width", "=", "self", ".", "width", "if", "isinstance", "(", "def_width", ",", "list", ")", ":", "def_width", "=", "def_width", "[", "1", "]", "fitting_str", "=", "\"name={0},Mass={1:f},Width={2:f}\"", ".", "format", "(", "self", ".", "cfunction", ",", "self", ".", "mass", ",", "def_width", ")", "if", "vals_provided", ":", "param_name", "=", "\"Intensity\"", "intensity_str", "=", "\"{0}={1:f}\"", ".", "format", "(", "param_name", ",", "param_vals", "[", "param_prefix", "+", "param_name", "]", ")", "fitting_str", "+=", "\",\"", "+", "intensity_str", "elif", "self", ".", "intensity", "is", "not", "None", ":", "fitting_str", "+=", "\",Intensity={0:f}\"", ".", "format", "(", "self", ".", "intensity", ")", "logger", ".", "debug", "(", "\"Gaussian profile fit function string: {0}\"", ".", "format", "(", "fitting_str", ")", ")", "return", "fitting_str", "+", "\";\"" ]

[ "!", "Initializer", "function" ]

[ "def", "__init__", "(", "self", ",", "viz", ")", ":", "self", ".", "viz", "=", "viz", "self", ".", "color", "=", "0x8080C0FF", "self", ".", "hlines", "=", "GooCanvas", ".", "CanvasPath", "(", "parent", "=", "viz", ".", "canvas", ".", "get_root_item", "(", ")", ",", "stroke_color_rgba", "=", "self", ".", "color", ")", "self", ".", "hlines", ".", "lower", "(", "None", ")", "self", ".", "vlines", "=", "GooCanvas", ".", "CanvasPath", "(", "parent", "=", "viz", ".", "canvas", ".", "get_root_item", "(", ")", ",", "stroke_color_rgba", "=", "self", ".", "color", ")", "self", ".", "vlines", ".", "lower", "(", "None", ")", "self", ".", "labels", "=", "[", "]", "hadj", "=", "self", ".", "viz", ".", "get_hadjustment", "(", ")", "vadj", "=", "self", ".", "viz", ".", "get_vadjustment", "(", ")", "def", "update", "(", "adj", ")", ":", "if", "self", ".", "visible", ":", "self", ".", "update_view", "(", ")", "hadj", ".", "connect", "(", "\"value-changed\"", ",", "update", ")", "vadj", ".", "connect", "(", "\"value-changed\"", ",", "update", ")", "hadj", ".", "connect", "(", "\"changed\"", ",", "update", ")", "vadj", ".", "connect", "(", "\"changed\"", ",", "update", ")", "self", ".", "visible", "=", "True", "self", ".", "update_view", "(", ")" ]

[ "Creates", "an", "UnimplementedError", "." ]

[ "def", "__init__", "(", "self", ",", "node_def", ",", "op", ",", "message", ")", ":", "super", "(", "UnimplementedError", ",", "self", ")", ".", "__init__", "(", "node_def", ",", "op", ",", "message", ",", "UNIMPLEMENTED", ")" ]

[ "GetWidth", "(", "self", ")", "-", ">", "int" ]

[ "def", "GetWidth", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_html", ".", "HtmlCell_GetWidth", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Correct", "initial", "value", "of", "learning", "rate" ]

[ "def", "fix_initial_nan_learning_rate", "(", "dict_list", ")", ":", "if", "len", "(", "dict_list", ")", ">", "1", ":", "dict_list", "[", "0", "]", "[", "'LearningRate'", "]", "=", "dict_list", "[", "1", "]", "[", "'LearningRate'", "]" ]

[ "Looks", "up", "a", "concrete", "function", "based", "on", "the", "key", "." ]

[ "def", "lookup", "(", "self", ",", "key", ":", "FunctionCacheKey", ",", "use_function_subtyping", ":", "bool", ")", ":", "if", "not", "use_function_subtyping", ":", "return", "self", ".", "_primary", ".", "get", "(", "key", ",", "None", ")", "dispatch_key", "=", "self", ".", "_dispatch_table", ".", "dispatch", "(", "key", ")", "if", "dispatch_key", "is", "not", "None", ":", "return", "self", ".", "_primary", "[", "dispatch_key", "]", "return", "None" ]

[ "Defined", "to", "generate", "includes", "within", "a", "file", ".", "Usually", "used", "for", "the", "base", "classes", "but", "also", "for", "Port", "types" ]

[ "def", "includes1Write", "(", "self", ",", "obj", ")", ":", "raise", "Exception", "(", "\"# AbstractWriter.includesWrite1() - Implementation Error: you must supply your own concrete implementation.\"", ")" ]

[ "Translates", "Windows", "pathnames", "to", "cloud", "pathnames", "." ]

[ "def", "FixWindowsNaming", "(", "src_url", ",", "dst_url", ")", ":", "if", "(", "src_url", ".", "IsFileUrl", "(", ")", "and", "src_url", ".", "delim", "==", "'\\\\'", "and", "dst_url", ".", "IsCloudUrl", "(", ")", ")", ":", "trans_url_str", "=", "re", ".", "sub", "(", "r'\\\\'", ",", "'/'", ",", "dst_url", ".", "url_string", ")", "dst_url", "=", "StorageUrlFromString", "(", "trans_url_str", ")", "return", "dst_url" ]

[ "Replaces", "instances", "of", "pattern", "in", "a", "string", "with", "a", "replacement", "." ]

[ "def", "ReplaceAll", "(", "pattern", ",", "rep", ",", "s", ")", ":", "if", "pattern", "not", "in", "_regexp_compile_cache", ":", "_regexp_compile_cache", "[", "pattern", "]", "=", "sre_compile", ".", "compile", "(", "pattern", ")", "return", "_regexp_compile_cache", "[", "pattern", "]", ".", "sub", "(", "rep", ",", "s", ")" ]

[ "Check", "end", "of", "namespace", "comments", "." ]

[ "def", "CheckEnd", "(", "self", ",", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "raw_lines", "[", "linenum", "]", "# Check how many lines is enclosed in this namespace. Don't issue", "# warning for missing namespace comments if there aren't enough", "# lines. However, do apply checks if there is already an end of", "# namespace comment and it's incorrect.", "#", "# TODO(unknown): We always want to check end of namespace comments", "# if a namespace is large, but sometimes we also want to apply the", "# check if a short namespace contained nontrivial things (something", "# other than forward declarations). There is currently no logic on", "# deciding what these nontrivial things are, so this check is", "# triggered by namespace size only, which works most of the time.", "if", "(", "linenum", "-", "self", ".", "starting_linenum", "<", "10", "and", "not", "Match", "(", "r'^\\s*};*\\s*(//|/\\*).*\\bnamespace\\b'", ",", "line", ")", ")", ":", "return", "# Look for matching comment at end of namespace.", "#", "# Note that we accept C style \"/* */\" comments for terminating", "# namespaces, so that code that terminate namespaces inside", "# preprocessor macros can be cpplint clean.", "#", "# We also accept stuff like \"// end of namespace <name>.\" with the", "# period at the end.", "#", "# Besides these, we don't accept anything else, otherwise we might", "# get false negatives when existing comment is a substring of the", "# expected namespace.", "if", "self", ".", "name", ":", "# Named namespace", "if", "not", "Match", "(", "(", "r'^\\s*};*\\s*(//|/\\*).*\\bnamespace\\s+'", "+", "re", ".", "escape", "(", "self", ".", "name", ")", "+", "r'[\\*/\\.\\\\\\s]*$'", ")", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/namespace'", ",", "5", ",", "'Namespace should be terminated with \"// namespace %s\"'", "%", "self", ".", "name", ")", "else", ":", "# Anonymous namespace", "if", "not", "Match", "(", "r'^\\s*};*\\s*(//|/\\*).*\\bnamespace[\\*/\\.\\\\\\s]*$'", ",", "line", ")", ":", "# If \"// namespace anonymous\" or \"// anonymous namespace (more text)\",", "# mention \"// anonymous namespace\" as an acceptable form", "if", "Match", "(", "r'^\\s*}.*\\b(namespace anonymous|anonymous namespace)\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/namespace'", ",", "5", ",", "'Anonymous namespace should be terminated with \"// namespace\"'", "' or \"// anonymous namespace\"'", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/namespace'", ",", "5", ",", "'Anonymous namespace should be terminated with \"// namespace\"'", ")" ]

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

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

[ "Recursively", "copy", "a", "directory", "tree", "." ]

[ "def", "copytree", "(", "src", ",", "dst", ",", "symlinks", "=", "False", ",", "ignore", "=", "None", ",", "copy_function", "=", "copy2", ",", "ignore_dangling_symlinks", "=", "False", ")", ":", "names", "=", "os", ".", "listdir", "(", "src", ")", "if", "ignore", "is", "not", "None", ":", "ignored_names", "=", "ignore", "(", "src", ",", "names", ")", "else", ":", "ignored_names", "=", "set", "(", ")", "os", ".", "makedirs", "(", "dst", ")", "errors", "=", "[", "]", "for", "name", "in", "names", ":", "if", "name", "in", "ignored_names", ":", "continue", "srcname", "=", "os", ".", "path", ".", "join", "(", "src", ",", "name", ")", "dstname", "=", "os", ".", "path", ".", "join", "(", "dst", ",", "name", ")", "try", ":", "if", "os", ".", "path", ".", "islink", "(", "srcname", ")", ":", "linkto", "=", "os", ".", "readlink", "(", "srcname", ")", "if", "symlinks", ":", "# We can't just leave it to `copy_function` because legacy", "# code with a custom `copy_function` may rely on copytree", "# doing the right thing.", "os", ".", "symlink", "(", "linkto", ",", "dstname", ")", "copystat", "(", "srcname", ",", "dstname", ",", "follow_symlinks", "=", "not", "symlinks", ")", "else", ":", "# ignore dangling symlink if the flag is on", "if", "not", "os", ".", "path", ".", "exists", "(", "linkto", ")", "and", "ignore_dangling_symlinks", ":", "continue", "# otherwise let the copy occurs. copy2 will raise an error", "if", "os", ".", "path", ".", "isdir", "(", "srcname", ")", ":", "copytree", "(", "srcname", ",", "dstname", ",", "symlinks", ",", "ignore", ",", "copy_function", ")", "else", ":", "copy_function", "(", "srcname", ",", "dstname", ")", "elif", "os", ".", "path", ".", "isdir", "(", "srcname", ")", ":", "copytree", "(", "srcname", ",", "dstname", ",", "symlinks", ",", "ignore", ",", "copy_function", ")", "else", ":", "# Will raise a SpecialFileError for unsupported file types", "copy_function", "(", "srcname", ",", "dstname", ")", "# catch the Error from the recursive copytree so that we can", "# continue with other files", "except", "Error", "as", "err", ":", "errors", ".", "extend", "(", "err", ".", "args", "[", "0", "]", ")", "except", "OSError", "as", "why", ":", "errors", ".", "append", "(", "(", "srcname", ",", "dstname", ",", "str", "(", "why", ")", ")", ")", "try", ":", "copystat", "(", "src", ",", "dst", ")", "except", "OSError", "as", "why", ":", "# Copying file access times may fail on Windows", "if", "getattr", "(", "why", ",", "'winerror'", ",", "None", ")", "is", "None", ":", "errors", ".", "append", "(", "(", "src", ",", "dst", ",", "str", "(", "why", ")", ")", ")", "if", "errors", ":", "raise", "Error", "(", "errors", ")", "return", "dst" ]

[ "Check", "whether", "traceback", "filtering", "is", "currently", "enabled", "." ]

[ "def", "is_traceback_filtering_enabled", "(", ")", ":", "value", "=", "getattr", "(", "_ENABLE_TRACEBACK_FILTERING", ",", "'value'", ",", "True", ")", "return", "value" ]

[ "Parse", "/", "proc", "/", "timer_list", "output", "and", "returns", "the", "first", "jiffies", "attribute", "." ]

[ "def", "_GetProcJiffies", "(", "self", ",", "timer_list", ")", ":", "if", "isinstance", "(", "timer_list", ",", "str", ")", ":", "timer_list", "=", "timer_list", ".", "splitlines", "(", ")", "for", "line", "in", "timer_list", ":", "if", "line", ".", "startswith", "(", "'jiffies:'", ")", ":", "_", ",", "value", "=", "line", ".", "split", "(", "':'", ")", "return", "value", "raise", "Exception", "(", "'Unable to find jiffies from /proc/timer_list'", ")" ]

[ "Begin", "write", "transaction", "for", "deferring", "files", "non", "-", "context", "version" ]

[ "def", "start_transaction", "(", "self", ")", ":", "self", ".", "_intrans", "=", "True", "self", ".", "_transaction", "=", "Transaction", "(", "self", ")", "return", "self", ".", "transaction" ]

[ "Maintains", "a", "list", "of", "functions", "that", "will", "actually", "be", "called" ]

[ "def", "updateCalledFunctionList", "(", "self", ",", "callee", ")", ":", "# Update the total call count", "self", ".", "updateTotalCallCount", "(", "callee", ")", "# If this function is already in the list, don't do anything else", "if", "callee", "in", "self", ".", "calledFunctions", ":", "return", "# Add this function to the list of those that will be called.", "self", ".", "calledFunctions", ".", "append", "(", "callee", ")", "# If this function calls other functions, add them too", "if", "callee", "in", "self", ".", "calledFunctionTable", ":", "for", "subCallee", "in", "self", ".", "calledFunctionTable", "[", "callee", "]", ":", "self", ".", "updateCalledFunctionList", "(", "subCallee", ")" ]

[ "Parse", "an", "MH", "sequence", "specification", "into", "a", "message", "list", ".", "Attempt", "to", "mimic", "mh", "-", "sequence", "(", "5", ")", "as", "close", "as", "possible", ".", "Also", "attempt", "to", "mimic", "observed", "behavior", "regarding", "which", "conditions", "cause", "which", "error", "messages", "." ]

[ "def", "parsesequence", "(", "self", ",", "seq", ")", ":", "# XXX Still not complete (see mh-format(5)).", "# Missing are:", "# - 'prev', 'next' as count", "# - Sequence-Negation option", "all", "=", "self", ".", "listmessages", "(", ")", "# Observed behavior: test for empty folder is done first", "if", "not", "all", ":", "raise", "Error", ",", "\"no messages in %s\"", "%", "self", ".", "name", "# Common case first: all is frequently the default", "if", "seq", "==", "'all'", ":", "return", "all", "# Test for X:Y before X-Y because 'seq:-n' matches both", "i", "=", "seq", ".", "find", "(", "':'", ")", "if", "i", ">=", "0", ":", "head", ",", "dir", ",", "tail", "=", "seq", "[", ":", "i", "]", ",", "''", ",", "seq", "[", "i", "+", "1", ":", "]", "if", "tail", "[", ":", "1", "]", "in", "'-+'", ":", "dir", ",", "tail", "=", "tail", "[", ":", "1", "]", ",", "tail", "[", "1", ":", "]", "if", "not", "isnumeric", "(", "tail", ")", ":", "raise", "Error", ",", "\"bad message list %s\"", "%", "seq", "try", ":", "count", "=", "int", "(", "tail", ")", "except", "(", "ValueError", ",", "OverflowError", ")", ":", "# Can't use sys.maxint because of i+count below", "count", "=", "len", "(", "all", ")", "try", ":", "anchor", "=", "self", ".", "_parseindex", "(", "head", ",", "all", ")", "except", "Error", ",", "msg", ":", "seqs", "=", "self", ".", "getsequences", "(", ")", "if", "not", "head", "in", "seqs", ":", "if", "not", "msg", ":", "msg", "=", "\"bad message list %s\"", "%", "seq", "raise", "Error", ",", "msg", ",", "sys", ".", "exc_info", "(", ")", "[", "2", "]", "msgs", "=", "seqs", "[", "head", "]", "if", "not", "msgs", ":", "raise", "Error", ",", "\"sequence %s empty\"", "%", "head", "if", "dir", "==", "'-'", ":", "return", "msgs", "[", "-", "count", ":", "]", "else", ":", "return", "msgs", "[", ":", "count", "]", "else", ":", "if", "not", "dir", ":", "if", "head", "in", "(", "'prev'", ",", "'last'", ")", ":", "dir", "=", "'-'", "if", "dir", "==", "'-'", ":", "i", "=", "bisect", "(", "all", ",", "anchor", ")", "return", "all", "[", "max", "(", "0", ",", "i", "-", "count", ")", ":", "i", "]", "else", ":", "i", "=", "bisect", "(", "all", ",", "anchor", "-", "1", ")", "return", "all", "[", "i", ":", "i", "+", "count", "]", "# Test for X-Y next", "i", "=", "seq", ".", "find", "(", "'-'", ")", "if", "i", ">=", "0", ":", "begin", "=", "self", ".", "_parseindex", "(", "seq", "[", ":", "i", "]", ",", "all", ")", "end", "=", "self", ".", "_parseindex", "(", "seq", "[", "i", "+", "1", ":", "]", ",", "all", ")", "i", "=", "bisect", "(", "all", ",", "begin", "-", "1", ")", "j", "=", "bisect", "(", "all", ",", "end", ")", "r", "=", "all", "[", "i", ":", "j", "]", "if", "not", "r", ":", "raise", "Error", ",", "\"bad message list %s\"", "%", "seq", "return", "r", "# Neither X:Y nor X-Y; must be a number or a (pseudo-)sequence", "try", ":", "n", "=", "self", ".", "_parseindex", "(", "seq", ",", "all", ")", "except", "Error", ",", "msg", ":", "seqs", "=", "self", ".", "getsequences", "(", ")", "if", "not", "seq", "in", "seqs", ":", "if", "not", "msg", ":", "msg", "=", "\"bad message list %s\"", "%", "seq", "raise", "Error", ",", "msg", "return", "seqs", "[", "seq", "]", "else", ":", "if", "n", "not", "in", "all", ":", "if", "isnumeric", "(", "seq", ")", ":", "raise", "Error", ",", "\"message %d doesn't exist\"", "%", "n", "else", ":", "raise", "Error", ",", "\"no %s message\"", "%", "seq", "else", ":", "return", "[", "n", "]" ]

[ "Adds", "a", "depthwise", "convolution", "block", "." ]

[ "def", "_depthwise_conv_block", "(", "inputs", ",", "pointwise_conv_filters", ",", "alpha", ",", "depth_multiplier", "=", "1", ",", "strides", "=", "(", "1", ",", "1", ")", ",", "block_id", "=", "1", ")", ":", "channel_axis", "=", "1", "if", "K", ".", "image_data_format", "(", ")", "==", "'channels_first'", "else", "-", "1", "pointwise_conv_filters", "=", "int", "(", "pointwise_conv_filters", "*", "alpha", ")", "x", "=", "DepthwiseConv2D", "(", "# pylint: disable=not-callable", "(", "3", ",", "3", ")", ",", "padding", "=", "'same'", ",", "depth_multiplier", "=", "depth_multiplier", ",", "strides", "=", "strides", ",", "use_bias", "=", "False", ",", "name", "=", "'conv_dw_%d'", "%", "block_id", ")", "(", "inputs", ")", "x", "=", "BatchNormalization", "(", "axis", "=", "channel_axis", ",", "name", "=", "'conv_dw_%d_bn'", "%", "block_id", ")", "(", "x", ")", "x", "=", "Activation", "(", "relu6", ",", "name", "=", "'conv_dw_%d_relu'", "%", "block_id", ")", "(", "x", ")", "x", "=", "Conv2D", "(", "pointwise_conv_filters", ",", "(", "1", ",", "1", ")", ",", "padding", "=", "'same'", ",", "use_bias", "=", "False", ",", "strides", "=", "(", "1", ",", "1", ")", ",", "name", "=", "'conv_pw_%d'", "%", "block_id", ")", "(", "x", ")", "x", "=", "BatchNormalization", "(", "axis", "=", "channel_axis", ",", "name", "=", "'conv_pw_%d_bn'", "%", "block_id", ")", "(", "x", ")", "return", "Activation", "(", "relu6", ",", "name", "=", "'conv_pw_%d_relu'", "%", "block_id", ")", "(", "x", ")" ]

[ "Update", "a", "dict", "or", "an", "object", "with", "according", "to", "entries", ".", ">>>", "update", "(", "{", "a", ":", "1", "}", "a", "=", "10", "b", "=", "20", ")", "{", "a", ":", "10", "b", ":", "20", "}", ">>>", "update", "(", "Struct", "(", "a", "=", "1", ")", "a", "=", "10", "b", "=", "20", ")", "Struct", "(", "a", "=", "10", "b", "=", "20", ")" ]

[ "def", "update", "(", "x", ",", "*", "*", "entries", ")", ":", "if", "isinstance", "(", "x", ",", "dict", ")", ":", "x", ".", "update", "(", "entries", ")", "else", ":", "for", "attribute", "in", "entries", ":", "setattr", "(", "x", ",", "attribute", ",", "entries", "[", "attribute", "]", ")" ]

[ "returns", "true", "if", "this", "is", "an", "FB", "first", "-", "party", "project" ]

[ "def", "is_first_party_project", "(", "self", ")", ":", "return", "self", ".", "shipit_project", "is", "not", "None" ]

[ "Reset", "the", "initial", "pose", "for", "the", "leg", "." ]

[ "def", "_ResetPoseForLeg", "(", "self", ",", "leg_id", ",", "add_constraint", ")", ":", "knee_friction_force", "=", "0", "half_pi", "=", "math", ".", "pi", "/", "2.0", "knee_angle", "=", "-", "2.1834", "leg_position", "=", "LEG_POSITION", "[", "leg_id", "]", "self", ".", "_pybullet_client", ".", "resetJointState", "(", "self", ".", "quadruped", ",", "self", ".", "_joint_name_to_id", "[", "\"motor_\"", "+", "leg_position", "+", "\"L_joint\"", "]", ",", "self", ".", "_motor_direction", "[", "2", "*", "leg_id", "]", "*", "half_pi", ",", "targetVelocity", "=", "0", ")", "self", ".", "_pybullet_client", ".", "resetJointState", "(", "self", ".", "quadruped", ",", "self", ".", "_joint_name_to_id", "[", "\"knee_\"", "+", "leg_position", "+", "\"L_link\"", "]", ",", "self", ".", "_motor_direction", "[", "2", "*", "leg_id", "]", "*", "knee_angle", ",", "targetVelocity", "=", "0", ")", "self", ".", "_pybullet_client", ".", "resetJointState", "(", "self", ".", "quadruped", ",", "self", ".", "_joint_name_to_id", "[", "\"motor_\"", "+", "leg_position", "+", "\"R_joint\"", "]", ",", "self", ".", "_motor_direction", "[", "2", "*", "leg_id", "+", "1", "]", "*", "half_pi", ",", "targetVelocity", "=", "0", ")", "self", ".", "_pybullet_client", ".", "resetJointState", "(", "self", ".", "quadruped", ",", "self", ".", "_joint_name_to_id", "[", "\"knee_\"", "+", "leg_position", "+", "\"R_link\"", "]", ",", "self", ".", "_motor_direction", "[", "2", "*", "leg_id", "+", "1", "]", "*", "knee_angle", ",", "targetVelocity", "=", "0", ")", "if", "add_constraint", ":", "self", ".", "_pybullet_client", ".", "createConstraint", "(", "self", ".", "quadruped", ",", "self", ".", "_joint_name_to_id", "[", "\"knee_\"", "+", "leg_position", "+", "\"R_link\"", "]", ",", "self", ".", "quadruped", ",", "self", ".", "_joint_name_to_id", "[", "\"knee_\"", "+", "leg_position", "+", "\"L_link\"", "]", ",", "self", ".", "_pybullet_client", ".", "JOINT_POINT2POINT", ",", "[", "0", ",", "0", ",", "0", "]", ",", "KNEE_CONSTRAINT_POINT_RIGHT", ",", "KNEE_CONSTRAINT_POINT_LEFT", ")", "if", "self", ".", "_accurate_motor_model_enabled", "or", "self", ".", "_pd_control_enabled", ":", "# Disable the default motor in pybullet.", "self", ".", "_pybullet_client", ".", "setJointMotorControl2", "(", "bodyIndex", "=", "self", ".", "quadruped", ",", "jointIndex", "=", "(", "self", ".", "_joint_name_to_id", "[", "\"motor_\"", "+", "leg_position", "+", "\"L_joint\"", "]", ")", ",", "controlMode", "=", "self", ".", "_pybullet_client", ".", "VELOCITY_CONTROL", ",", "targetVelocity", "=", "0", ",", "force", "=", "knee_friction_force", ")", "self", ".", "_pybullet_client", ".", "setJointMotorControl2", "(", "bodyIndex", "=", "self", ".", "quadruped", ",", "jointIndex", "=", "(", "self", ".", "_joint_name_to_id", "[", "\"motor_\"", "+", "leg_position", "+", "\"R_joint\"", "]", ")", ",", "controlMode", "=", "self", ".", "_pybullet_client", ".", "VELOCITY_CONTROL", ",", "targetVelocity", "=", "0", ",", "force", "=", "knee_friction_force", ")", "else", ":", "self", ".", "_SetDesiredMotorAngleByName", "(", "\"motor_\"", "+", "leg_position", "+", "\"L_joint\"", ",", "self", ".", "_motor_direction", "[", "2", "*", "leg_id", "]", "*", "half_pi", ")", "self", ".", "_SetDesiredMotorAngleByName", "(", "\"motor_\"", "+", "leg_position", "+", "\"R_joint\"", ",", "self", ".", "_motor_direction", "[", "2", "*", "leg_id", "+", "1", "]", "*", "half_pi", ")", "self", ".", "_pybullet_client", ".", "setJointMotorControl2", "(", "bodyIndex", "=", "self", ".", "quadruped", ",", "jointIndex", "=", "(", "self", ".", "_joint_name_to_id", "[", "\"knee_\"", "+", "leg_position", "+", "\"L_link\"", "]", ")", ",", "controlMode", "=", "self", ".", "_pybullet_client", ".", "VELOCITY_CONTROL", ",", "targetVelocity", "=", "0", ",", "force", "=", "knee_friction_force", ")", "self", ".", "_pybullet_client", ".", "setJointMotorControl2", "(", "bodyIndex", "=", "self", ".", "quadruped", ",", "jointIndex", "=", "(", "self", ".", "_joint_name_to_id", "[", "\"knee_\"", "+", "leg_position", "+", "\"R_link\"", "]", ")", ",", "controlMode", "=", "self", ".", "_pybullet_client", ".", "VELOCITY_CONTROL", ",", "targetVelocity", "=", "0", ",", "force", "=", "knee_friction_force", ")" ]

[ "Returns", "the", "imaginary", "part", "of", "a", "complex", "number", "." ]

[ "def", "imag", "(", "input", ",", "name", "=", "None", ")", ":", "with", "ops", ".", "op_scope", "(", "[", "input", "]", ",", "name", ",", "\"Imag\"", ")", "as", "name", ":", "return", "gen_math_ops", ".", "imag", "(", "input", ",", "Tout", "=", "input", ".", "dtype", ".", "real_dtype", ",", "name", "=", "name", ")" ]

[ "Handles", "the", "wx", ".", "EVT_IDLE", "event", "for", ":", "class", ":", "AuiToolBar", "." ]

[ "def", "OnIdle", "(", "self", ",", "event", ")", ":", "self", ".", "DoIdleUpdate", "(", ")", "event", ".", "Skip", "(", ")" ]

[ "Overwrite", "for", "special", "checks", "to", "return", "data", "values" ]

[ "def", "checkData", "(", "self", ",", "data", ")", ":", "# if self._dataToken == 'nan':", "# pg.critical('self._dataToken nan, should be set in class', self)", "# return data(self._dataToken)", "return", "data" ]

[ "For", "a", "given", "gmsh", "model", "extract", "the", "mesh", "geometry", "as", "a", "numpy", "(", "N", "3", ")", "array", "where", "the", "i", "-", "th", "row", "corresponds", "to", "the", "i", "-", "th", "node", "in", "the", "mesh", "." ]

[ "def", "extract_gmsh_geometry", "(", "gmsh_model", ",", "model_name", "=", "None", ")", ":", "if", "model_name", "is", "not", "None", ":", "gmsh_model", ".", "setCurrent", "(", "model_name", ")", "# Get the unique tag and coordinates for nodes", "# in mesh", "indices", ",", "points", ",", "_", "=", "gmsh_model", ".", "mesh", ".", "getNodes", "(", ")", "points", "=", "points", ".", "reshape", "(", "-", "1", ",", "3", ")", "# GMSH indices starts at 1", "indices", "-=", "1", "# Sort nodes in geometry according to the unique index", "perm_sort", "=", "np", ".", "argsort", "(", "indices", ")", "assert", "np", ".", "all", "(", "indices", "[", "perm_sort", "]", "==", "np", ".", "arange", "(", "len", "(", "indices", ")", ")", ")", "return", "points", "[", "perm_sort", "]" ]

[ "Return", "the", ".", "sconsign", "file", "info", "for", "this", "directory", "creating", "it", "first", "if", "necessary", "." ]

[ "def", "sconsign_dir", "(", "node", ")", ":", "if", "not", "node", ".", "_sconsign", ":", "import", "SCons", ".", "SConsign", "node", ".", "_sconsign", "=", "SCons", ".", "SConsign", ".", "ForDirectory", "(", "node", ")", "return", "node", ".", "_sconsign" ]

[ "Reindexes", "the", "bag", "file", ".", "Yields", "position", "of", "each", "chunk", "for", "progress", "." ]

[ "def", "reindex", "(", "self", ")", ":", "self", ".", "_clear_index", "(", ")", "return", "self", ".", "_reader", ".", "reindex", "(", ")" ]

[ "Skipping", "an", "END_GROUP", "tag", "returns", "-", "1", "to", "tell", "the", "parent", "loop", "to", "break", "." ]

[ "def", "_EndGroup", "(", "buffer", ",", "pos", ",", "end", ")", ":", "return", "-", "1" ]

[ "Helper", "for", "computing", "the", "expectation", "value", "of", "fun", "." ]

[ "def", "_expect", "(", "fun", ",", "lb", ",", "ub", ",", "x0", ",", "inc", ",", "maxcount", "=", "1000", ",", "tolerance", "=", "1e-10", ",", "chunksize", "=", "32", ")", ":", "# short-circuit if the support size is small enough", "if", "(", "ub", "-", "lb", ")", "<=", "chunksize", ":", "supp", "=", "np", ".", "arange", "(", "lb", ",", "ub", "+", "1", ",", "inc", ")", "vals", "=", "fun", "(", "supp", ")", "return", "np", ".", "sum", "(", "vals", ")", "# otherwise, iterate starting from x0", "if", "x0", "<", "lb", ":", "x0", "=", "lb", "if", "x0", ">", "ub", ":", "x0", "=", "ub", "count", ",", "tot", "=", "0", ",", "0.", "# iterate over [x0, ub] inclusive", "for", "x", "in", "_iter_chunked", "(", "x0", ",", "ub", "+", "1", ",", "chunksize", "=", "chunksize", ",", "inc", "=", "inc", ")", ":", "count", "+=", "x", ".", "size", "delta", "=", "np", ".", "sum", "(", "fun", "(", "x", ")", ")", "tot", "+=", "delta", "if", "abs", "(", "delta", ")", "<", "tolerance", "*", "x", ".", "size", ":", "break", "if", "count", ">", "maxcount", ":", "warnings", ".", "warn", "(", "'expect(): sum did not converge'", ",", "RuntimeWarning", ")", "return", "tot", "# iterate over [lb, x0)", "for", "x", "in", "_iter_chunked", "(", "x0", "-", "1", ",", "lb", "-", "1", ",", "chunksize", "=", "chunksize", ",", "inc", "=", "-", "inc", ")", ":", "count", "+=", "x", ".", "size", "delta", "=", "np", ".", "sum", "(", "fun", "(", "x", ")", ")", "tot", "+=", "delta", "if", "abs", "(", "delta", ")", "<", "tolerance", "*", "x", ".", "size", ":", "break", "if", "count", ">", "maxcount", ":", "warnings", ".", "warn", "(", "'expect(): sum did not converge'", ",", "RuntimeWarning", ")", "break", "return", "tot" ]

[ "Writes", "a", "common", "preamble", "that", "is", "used", "by", "root", "and", "block", "functions", ".", "Primarily", "this", "sets", "up", "common", "local", "helpers", "and", "enforces", "a", "generator", "through", "a", "dead", "branch", "." ]

[ "def", "write_commons", "(", "self", ")", ":", "self", ".", "writeline", "(", "'resolve = context.resolve_or_missing'", ")", "self", ".", "writeline", "(", "'undefined = environment.undefined'", ")", "self", ".", "writeline", "(", "'if 0: yield None'", ")" ]

[ "Destroy", "this", "and", "all", "descendants", "widgets", "." ]

[ "def", "destroy", "(", "self", ")", ":", "for", "c", "in", "self", ".", "children", ".", "values", "(", ")", ":", "c", ".", "destroy", "(", ")", "self", ".", "tk", ".", "call", "(", "'destroy'", ",", "self", ".", "_w", ")", "if", "self", ".", "_name", "in", "self", ".", "master", ".", "children", ":", "del", "self", ".", "master", ".", "children", "[", "self", ".", "_name", "]", "Misc", ".", "destroy", "(", "self", ")" ]

[ "Extracts", "CFBundleIdentifier", "value", "from", "Info", ".", "plist", "in", "the", "bundle", "." ]

[ "def", "_GetCFBundleIdentifier", "(", "self", ")", ":", "info_plist_path", "=", "os", ".", "path", ".", "join", "(", "os", ".", "environ", "[", "'TARGET_BUILD_DIR'", "]", ",", "os", ".", "environ", "[", "'INFOPLIST_PATH'", "]", ")", "info_plist_data", "=", "self", ".", "_LoadPlistMaybeBinary", "(", "info_plist_path", ")", "return", "info_plist_data", "[", "'CFBundleIdentifier'", "]" ]

[ "r", "Removes", "any", "internal", "structure", "(", "s", ")", "from", "a", "voxelgrids", "." ]

[ "def", "extract_surface", "(", "voxelgrids", ",", "mode", "=", "\"wide\"", ")", ":", "voxelgrids", "=", "_force_float", "(", "voxelgrids", ")", "if", "voxelgrids", ".", "ndim", "!=", "4", ":", "voxelgrids_dim", "=", "voxelgrids", ".", "ndim", "raise", "ValueError", "(", "f\"Expected voxelgrids to have 4 dimensions \"", "f\"but got {voxelgrids_dim} dimensions.\"", ")", "if", "mode", "==", "\"wide\"", ":", "output", "=", "F", ".", "avg_pool3d", "(", "voxelgrids", ".", "unsqueeze", "(", "1", ")", ",", "kernel_size", "=", "(", "3", ",", "3", ",", "3", ")", ",", "padding", "=", "1", ",", "stride", "=", "1", ")", ".", "squeeze", "(", "1", ")", "output", "=", "(", "output", "<", "1", ")", "*", "voxelgrids", ".", "bool", "(", ")", "elif", "mode", "==", "\"thin\"", ":", "output_x", "=", "F", ".", "avg_pool3d", "(", "voxelgrids", ".", "unsqueeze", "(", "1", ")", ",", "kernel_size", "=", "(", "3", ",", "1", ",", "1", ")", ",", "padding", "=", "(", "1", ",", "0", ",", "0", ")", ",", "stride", "=", "1", ")", ".", "squeeze", "(", "1", ")", "output_y", "=", "F", ".", "avg_pool3d", "(", "voxelgrids", ".", "unsqueeze", "(", "1", ")", ",", "kernel_size", "=", "(", "1", ",", "3", ",", "1", ")", ",", "padding", "=", "(", "0", ",", "1", ",", "0", ")", ",", "stride", "=", "1", ")", ".", "squeeze", "(", "1", ")", "output_z", "=", "F", ".", "avg_pool3d", "(", "voxelgrids", ".", "unsqueeze", "(", "1", ")", ",", "kernel_size", "=", "(", "1", ",", "1", ",", "3", ")", ",", "padding", "=", "(", "0", ",", "0", ",", "1", ")", ",", "stride", "=", "1", ")", ".", "squeeze", "(", "1", ")", "output", "=", "(", "(", "output_x", "<", "1", ")", "|", "(", "output_y", "<", "1", ")", "|", "(", "output_z", "<", "1", ")", ")", "*", "voxelgrids", ".", "bool", "(", ")", "else", ":", "raise", "ValueError", "(", "f'mode \"{mode}\" is not supported.'", ")", "return", "output" ]

[ "Returns", "true", "if", "the", "call", "failed", "." ]

[ "def", "Failed", "(", "self", ")", ":", "raise", "NotImplementedError" ]

[ "Set", "the", "receive", "buffer", "size", ".", "The", "exact", "meaning", "of", "this", "is", "transport", "dependent", "." ]

[ "def", "set_buff_size", "(", "self", ",", "buff_size", ")", ":", "if", "type", "(", "buff_size", ")", "!=", "int", ":", "raise", "ROSException", "(", "\"buffer size must be an integer\"", ")", "elif", "buff_size", "<=", "0", ":", "raise", "ROSException", "(", "\"buffer size must be a positive integer\"", ")", "self", ".", "buff_size", "=", "buff_size" ]

[ "Converts", "a", "4", "-", "dimensional", "array", "to", "blob", "proto", ".", "If", "diff", "is", "given", "also", "convert", "the", "diff", ".", "You", "need", "to", "make", "sure", "that", "arr", "and", "diff", "have", "the", "same", "shape", "and", "this", "function", "does", "not", "do", "sanity", "check", "." ]

[ "def", "array_to_blobproto", "(", "arr", ",", "diff", "=", "None", ")", ":", "if", "arr", ".", "ndim", "!=", "4", ":", "raise", "ValueError", "(", "'Incorrect array shape.'", ")", "blob", "=", "caffe_pb2", ".", "BlobProto", "(", ")", "blob", ".", "num", ",", "blob", ".", "channels", ",", "blob", ".", "height", ",", "blob", ".", "width", "=", "arr", ".", "shape", "blob", ".", "data", ".", "extend", "(", "arr", ".", "astype", "(", "float", ")", ".", "flat", ")", "if", "diff", "is", "not", "None", ":", "blob", ".", "diff", ".", "extend", "(", "diff", ".", "astype", "(", "float", ")", ".", "flat", ")", "return", "blob" ]

[ "Perform", "a", "TLS", "/", "SSL", "handshake", "." ]

[ "def", "do_handshake", "(", "self", ")", ":", "self", ".", "_sslobj", ".", "do_handshake", "(", ")" ]

[ "Set", "the", "value", "of", "the", "points", "." ]

[ "def", "setValue", "(", "self", ",", "val", "=", "None", ")", ":", "if", "self", ".", "lock", ".", "isChecked", "(", ")", ":", "if", "not", "self", ".", "xValue", ".", "hasFocus", "(", ")", ":", "self", ".", "xValue", ".", "setValue", "(", "val", ")", "if", "not", "self", ".", "yValue", ".", "hasFocus", "(", ")", ":", "self", ".", "yValue", ".", "setValue", "(", "val", ")", "if", "not", "self", ".", "zValue", ".", "hasFocus", "(", ")", ":", "self", ".", "zValue", ".", "setValue", "(", "val", ")", "if", "self", ".", "sourceCmd", ":", "self", ".", "sourceCmd", ".", "scaleGhost", "(", "self", ".", "xValue", ".", "value", "(", ")", ",", "self", ".", "yValue", ".", "value", "(", ")", ",", "self", ".", "zValue", ".", "value", "(", ")", ",", "self", ".", "relative", ".", "isChecked", "(", ")", ")" ]

[ "Gets", "sizes", "of", "ticks", "." ]

[ "def", "GetTickSize", "(", "self", ",", "target", "=", "ALL", ")", ":", "return", "self", ".", "Box", ".", "GetTickSize", "(", "target", ")" ]

[ "Compresses", "a", "to", "-", "be", "-", "uploaded", "local", "file", "to", "save", "bandwidth", "." ]

[ "def", "_CompressFileForUpload", "(", "src_url", ",", "src_obj_filestream", ",", "src_obj_size", ",", "logger", ")", ":", "# TODO: Compress using a streaming model as opposed to all at once here.", "if", "src_obj_size", ">=", "MIN_SIZE_COMPUTE_LOGGING", ":", "logger", ".", "info", "(", "'Compressing %s (to tmp)...'", ",", "src_url", ")", "(", "gzip_fh", ",", "gzip_path", ")", "=", "tempfile", ".", "mkstemp", "(", ")", "gzip_fp", "=", "None", "try", ":", "# Check for temp space. Assume the compressed object is at most 2x", "# the size of the object (normally should compress to smaller than", "# the object)", "if", "CheckFreeSpace", "(", "gzip_path", ")", "<", "2", "*", "int", "(", "src_obj_size", ")", ":", "raise", "CommandException", "(", "'Inadequate temp space available to compress '", "'%s. See the CHANGING TEMP DIRECTORIES section '", "'of \"gsutil help cp\" for more info.'", "%", "src_url", ")", "gzip_fp", "=", "gzip", ".", "open", "(", "gzip_path", ",", "'wb'", ")", "data", "=", "src_obj_filestream", ".", "read", "(", "GZIP_CHUNK_SIZE", ")", "while", "data", ":", "gzip_fp", ".", "write", "(", "data", ")", "data", "=", "src_obj_filestream", ".", "read", "(", "GZIP_CHUNK_SIZE", ")", "finally", ":", "if", "gzip_fp", ":", "gzip_fp", ".", "close", "(", ")", "os", ".", "close", "(", "gzip_fh", ")", "src_obj_filestream", ".", "close", "(", ")", "gzip_size", "=", "os", ".", "path", ".", "getsize", "(", "gzip_path", ")", "return", "StorageUrlFromString", "(", "gzip_path", ")", ",", "gzip_size" ]

[ "Creates", "a", "new", "property", "set", "containing", "the", "properties", "in", "this", "one", "plus", "the", "ones", "of", "the", "property", "set", "passed", "as", "argument", "." ]

[ "def", "add", "(", "self", ",", "ps", ")", ":", "if", "not", "self", ".", "added_", ".", "has_key", "(", "ps", ")", ":", "self", ".", "added_", "[", "ps", "]", "=", "create", "(", "self", ".", "all_", "+", "ps", ".", "all", "(", ")", ")", "return", "self", ".", "added_", "[", "ps", "]" ]

[ "Create", "a", "dependency", "graph", "from", "an", "ast", "node", "." ]

[ "def", "make_graph", "(", "node", ",", "call_deps", "=", "False", ")", ":", "gen", "=", "GraphGen", "(", "call_deps", "=", "call_deps", ")", "gen", ".", "visit", "(", "node", ")", "return", "gen", ".", "graph", ",", "gen", ".", "undefined" ]

[ "Returns", "the", "list", "of", "directories", "to", "be", "used", "for", "library", "search", "paths", "." ]

[ "def", "_GetLibraryDirs", "(", "config", ")", ":", "library_dirs", "=", "config", ".", "get", "(", "'library_dirs'", ",", "[", "]", ")", "library_dirs", "=", "_FixPaths", "(", "library_dirs", ")", "return", "library_dirs" ]

[ "DrawHintRect", "(", "self", "Window", "paneWindow", "Point", "pt", "Point", "offset", ")" ]

[ "def", "DrawHintRect", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiManager_DrawHintRect", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]