Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Put", "a", "connection", "back", "into", "the", "pool", "." ]

[ "def", "_put_conn", "(", "self", ",", "conn", ")", ":", "try", ":", "self", ".", "pool", ".", "put", "(", "conn", ",", "block", "=", "False", ")", "return", "# Everything is dandy, done.", "except", "AttributeError", ":", "# self.pool is None.", "pass", "except", "queue", ".", "Full", ":", "# This should never happen if self.block == True", "log", ".", "warning", "(", "\"Connection pool is full, discarding connection: %s\"", ",", "self", ".", "host", ")", "# Connection never got put back into the pool, close it.", "if", "conn", ":", "conn", ".", "close", "(", ")" ]

[ "Perform", "forward", "to", "get", "the", "output", "." ]

[ "def", "forward", "(", "self", ",", "*", "*", "kwargs", ")", ":", "for", "k", ",", "v", "in", "kwargs", ".", "items", "(", ")", ":", "if", "not", "isinstance", "(", "v", ",", "np", ".", "ndarray", ")", ":", "raise", "ValueError", "(", "\"Expect numpy ndarray as input\"", ")", "v", "=", "np", ".", "asarray", "(", "v", ",", "dtype", "=", "np", ".", "float32", ",", "order", "=", "'C'", ")", "_check_call", "(", "_LIB", ".", "MXPredSetInput", "(", "self", ".", "handle", ",", "c_str", "(", "k", ")", ",", "v", ".", "ctypes", ".", "data_as", "(", "mx_float_p", ")", ",", "mx_uint", "(", "v", ".", "size", ")", ")", ")", "_check_call", "(", "_LIB", ".", "MXPredForward", "(", "self", ".", "handle", ")", ")" ]

[ "__init__", "(", "self", ")", "-", ">", "IdleEvent" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_core_", ".", "IdleEvent_swiginit", "(", "self", ",", "_core_", ".", "new_IdleEvent", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Looks", "up", "the", "gsutil", "version", "of", "the", "specified", "gsutil", "tarball", "URL", "." ]

[ "def", "LookUpGsutilVersion", "(", "gsutil_api", ",", "url_str", ")", ":", "url", "=", "StorageUrlFromString", "(", "url_str", ")", "if", "url", ".", "IsCloudUrl", "(", ")", ":", "obj", "=", "gsutil_api", ".", "GetObjectMetadata", "(", "url", ".", "bucket_name", ",", "url", ".", "object_name", ",", "provider", "=", "url", ".", "scheme", ",", "fields", "=", "[", "'metadata'", "]", ")", "if", "obj", ".", "metadata", "and", "obj", ".", "metadata", ".", "additionalProperties", ":", "for", "prop", "in", "obj", ".", "metadata", ".", "additionalProperties", ":", "if", "prop", ".", "key", "==", "'gsutil_version'", ":", "return", "prop", ".", "value" ]

[ "Open", "port", "with", "current", "settings", ".", "This", "may", "throw", "a", "SerialException", "if", "the", "port", "cannot", "be", "opened", "." ]

[ "def", "open", "(", "self", ")", ":", "if", "self", ".", "_port", "is", "None", ":", "raise", "SerialException", "(", "\"Port must be configured before it can be used.\"", ")", "if", "self", ".", "_isOpen", ":", "raise", "SerialException", "(", "\"Port is already open.\"", ")", "self", ".", "fd", "=", "None", "# open", "try", ":", "self", ".", "fd", "=", "os", ".", "open", "(", "self", ".", "portstr", ",", "os", ".", "O_RDWR", "|", "os", ".", "O_NOCTTY", "|", "os", ".", "O_NONBLOCK", ")", "except", "IOError", ",", "msg", ":", "self", ".", "fd", "=", "None", "raise", "SerialException", "(", "msg", ".", "errno", ",", "\"could not open port %s: %s\"", "%", "(", "self", ".", "_port", ",", "msg", ")", ")", "#~ fcntl.fcntl(self.fd, FCNTL.F_SETFL, 0) # set blocking", "try", ":", "self", ".", "_reconfigurePort", "(", ")", "except", ":", "try", ":", "os", ".", "close", "(", "self", ".", "fd", ")", "except", ":", "# ignore any exception when closing the port", "# also to keep original exception that happened when setting up", "pass", "self", ".", "fd", "=", "None", "raise", "else", ":", "self", ".", "_isOpen", "=", "True", "self", ".", "flushInput", "(", ")" ]

[ "Initialize", "Flatten", "." ]

[ "def", "__init__", "(", "self", ")", ":", "super", "(", "Flatten", ",", "self", ")", ".", "__init__", "(", ")" ]

[ "Resets", "the", "RpcController", "to", "its", "initial", "state", "." ]

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

[ "Checks", "for", "a", "C", "-", "style", "cast", "by", "looking", "for", "the", "pattern", "." ]

[ "def", "CheckCStyleCast", "(", "filename", ",", "linenum", ",", "line", ",", "raw_line", ",", "cast_type", ",", "pattern", ",", "error", ")", ":", "match", "=", "Search", "(", "pattern", ",", "line", ")", "if", "not", "match", ":", "return", "False", "# e.g., sizeof(int)", "sizeof_match", "=", "Match", "(", "r'.*sizeof\\s*$'", ",", "line", "[", "0", ":", "match", ".", "start", "(", "1", ")", "-", "1", "]", ")", "if", "sizeof_match", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/sizeof'", ",", "1", ",", "'Using sizeof(type). Use sizeof(varname) instead if possible'", ")", "return", "True", "remainder", "=", "line", "[", "match", ".", "end", "(", "0", ")", ":", "]", "# The close paren is for function pointers as arguments to a function.", "# eg, void foo(void (*bar)(int));", "# The semicolon check is a more basic function check; also possibly a", "# function pointer typedef.", "# eg, void foo(int); or void foo(int) const;", "# The equals check is for function pointer assignment.", "# eg, void *(*foo)(int) = ...", "# The > is for MockCallback<...> ...", "#", "# Right now, this will only catch cases where there's a single argument, and", "# it's unnamed. It should probably be expanded to check for multiple", "# arguments with some unnamed.", "function_match", "=", "Match", "(", "r'\\s*(\\)|=|(const)?\\s*(;|\\{|throw\\(\\)|>))'", ",", "remainder", ")", "if", "function_match", ":", "if", "(", "not", "function_match", ".", "group", "(", "3", ")", "or", "function_match", ".", "group", "(", "3", ")", "==", "';'", "or", "(", "'MockCallback<'", "not", "in", "raw_line", "and", "'/*'", "not", "in", "raw_line", ")", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'readability/function'", ",", "3", ",", "'All parameters should be named in a function'", ")", "return", "True", "# At this point, all that should be left is actual casts.", "error", "(", "filename", ",", "linenum", ",", "'readability/casting'", ",", "4", ",", "'Using C-style cast. Use %s<%s>(...) instead'", "%", "(", "cast_type", ",", "match", ".", "group", "(", "1", ")", ")", ")", "return", "True" ]

[ "sort", "survey", "table", "by", "pt", "number", "(", "with", "the", "maximum", "counts", "in", "the", "scan", ")", ":", "return", ":" ]

[ "def", "menu_sort_by_pt_number", "(", "self", ")", ":", "self", ".", "ui", ".", "tableWidget_surveyTable", ".", "filter_and_sort", "(", "start_scan", "=", "0", ",", "end_scan", "=", "100000", ",", "min_counts", "=", "0.", ",", "max_counts", "=", "10000000000.", ",", "sort_by_column", "=", "'Max Counts Pt'", ",", "sort_order", "=", "0", ")" ]

[]

[ "def", "is_third_party", "(", "request", ")", ":", "req_host", "=", "request_host", "(", "request", ")", "if", "not", "domain_match", "(", "req_host", ",", "reach", "(", "request", ".", "get_origin_req_host", "(", ")", ")", ")", ":", "return", "True", "else", ":", "return", "False" ]

[ "Return", "self", "upon", "entering", "the", "runtime", "context", "." ]

[ "def", "__enter__", "(", "self", ")", ":", "return", "self" ]

[ "Perform", "setup", ".", ":", "return", ":", "Error", "msg", "or", "none" ]

[ "def", "setup", "(", "self", ")", ":", "if", "not", "os", ".", "path", ".", "exists", "(", "self", ".", "c2xml_path", ")", ":", "return", "\"Provided c2xml path:\"", "+", "str", "(", "self", ".", "c2xml_path", ")", "+", "\" does not exist.\"", "if", "not", "os", ".", "path", ".", "isdir", "(", "self", ".", "kernel_src_dir", ")", "or", "not", "os", ".", "path", ".", "isdir", "(", "os", ".", "path", ".", "join", "(", "self", ".", "kernel_src_dir", ",", "'include'", ")", ")", ":", "return", "\"Provided kernel src directory is invalid. \"", "\"The base directory is not present or it does not contain include folder:\"", "+", "str", "(", "self", ".", "kernel_src_dir", ")", "+", "\", \"", "+", "os", ".", "path", ".", "join", "(", "self", ".", "kernel_src_dir", ",", "'include'", ")", "if", "self", ".", "hdr_file_list", "is", "None", ":", "return", "\"No file specified to output hdr file list.\"", "return", "None" ]

[ "Loads", "the", "named", "extension", "descriptor", "from", "the", "pool", "." ]

[ "def", "FindExtensionByName", "(", "self", ",", "full_name", ")", ":", "full_name", "=", "_NormalizeFullyQualifiedName", "(", "full_name", ")", "try", ":", "# The proto compiler does not give any link between the FileDescriptor", "# and top-level extensions unless the FileDescriptorProto is added to", "# the DescriptorDatabase, but this can impact memory usage.", "# So we registered these extensions by name explicitly.", "return", "self", ".", "_toplevel_extensions", "[", "full_name", "]", "except", "KeyError", ":", "pass", "message_name", ",", "_", ",", "extension_name", "=", "full_name", ".", "rpartition", "(", "'.'", ")", "try", ":", "# Most extensions are nested inside a message.", "scope", "=", "self", ".", "FindMessageTypeByName", "(", "message_name", ")", "except", "KeyError", ":", "# Some extensions are defined at file scope.", "scope", "=", "self", ".", "_FindFileContainingSymbolInDb", "(", "full_name", ")", "return", "scope", ".", "extensions_by_name", "[", "extension_name", "]" ]

[ "Set", "input", "arrays", "of", "the", "in", "-", "memory", "MemoryDataLayer", ".", "(", "Note", ":", "this", "is", "only", "for", "networks", "declared", "with", "the", "memory", "data", "layer", ".", ")" ]

[ "def", "_Net_set_input_arrays", "(", "self", ",", "data", ",", "labels", ")", ":", "if", "labels", ".", "ndim", "==", "1", ":", "labels", "=", "np", ".", "ascontiguousarray", "(", "labels", "[", ":", ",", "np", ".", "newaxis", ",", "np", ".", "newaxis", ",", "np", ".", "newaxis", "]", ")", "return", "self", ".", "_set_input_arrays", "(", "data", ",", "labels", ")" ]

[]

[ "def", "get_compatible_platform_to_toolset_maps", "(", "self", ",", "msvs_version", ",", "restricted_platforms", ")", ":", "# Go through the list of enabled platforms and track which ones 'compatible' toolsets apply to the current toolset", "compatible_platforms_map", "=", "{", "}", "ms_toolset_to_platform_map", "=", "{", "}", "enabled_platforms", "=", "self", ".", "get_all_target_platforms", "(", ")", "for", "enabled_platform", "in", "enabled_platforms", ":", "# Is this an msvs compatible platform at all?", "msvs_attributes", "=", "enabled_platform", ".", "attributes", ".", "get", "(", "'msvs'", ",", "None", ")", "if", "not", "msvs_attributes", ":", "continue", "if", "restricted_platforms", ":", "# If there is a platform restriction, then check if the platforms name or any of its aliases", "# conform to the list of restricted platforms", "if", "enabled_platform", ".", "platform", "not", "in", "restricted_platforms", "and", "enabled_platform", ".", "aliases", ".", "intersection", "(", "restricted_platforms", ")", ":", "continue", "# Get this platform's toolset name", "platform_toolset_name", "=", "msvs_attributes", ".", "get", "(", "'toolset_name'", ",", "None", ")", "if", "not", "platform_toolset_name", ":", "continue", "toolset_properties_file", "=", "self", ".", "get_msbuild_toolset_properties_file_path", "(", "msvs_version", ",", "platform_toolset_name", ")", "if", "not", "os", ".", "path", ".", "isfile", "(", "toolset_properties_file", ")", ":", "continue", "compatible_platforms_map", "[", "enabled_platform", ".", "platform", "]", "=", "enabled_platform", "if", "platform_toolset_name", "not", "in", "ms_toolset_to_platform_map", ":", "ms_toolset_to_platform_map", "[", "platform_toolset_name", "]", "=", "[", "]", "ms_toolset_to_platform_map", "[", "platform_toolset_name", "]", ".", "append", "(", "enabled_platform", ")", "return", "compatible_platforms_map", ",", "ms_toolset_to_platform_map" ]

[ "Get", "the", "current", "progress", "of", "the", "load" ]

[ "def", "GetProgress", "(", "self", ")", ":", "return", "self", ".", "_prog" ]

[ "Figures", "out", "what", "kind", "of", "header", "include", "is", "." ]

[ "def", "_ClassifyInclude", "(", "fileinfo", ",", "include", ",", "is_system", ")", ":", "# This is a list of all standard c++ header files, except", "# those already checked for above.", "is_cpp_h", "=", "include", "in", "_CPP_HEADERS", "if", "is_system", ":", "if", "is_cpp_h", ":", "return", "_CPP_SYS_HEADER", "else", ":", "return", "_C_SYS_HEADER", "# If the target file and the include we're checking share a", "# basename when we drop common extensions, and the include", "# lives in . , then it's likely to be owned by the target file.", "target_dir", ",", "target_base", "=", "(", "os", ".", "path", ".", "split", "(", "_DropCommonSuffixes", "(", "fileinfo", ".", "RepositoryName", "(", ")", ")", ")", ")", "include_dir", ",", "include_base", "=", "os", ".", "path", ".", "split", "(", "_DropCommonSuffixes", "(", "include", ")", ")", "if", "target_base", "==", "include_base", "and", "(", "include_dir", "==", "target_dir", "or", "include_dir", "==", "os", ".", "path", ".", "normpath", "(", "target_dir", "+", "'/../public'", ")", ")", ":", "return", "_LIKELY_MY_HEADER", "# If the target and include share some initial basename", "# component, it's possible the target is implementing the", "# include, so it's allowed to be first, but we'll never", "# complain if it's not there.", "target_first_component", "=", "_RE_FIRST_COMPONENT", ".", "match", "(", "target_base", ")", "include_first_component", "=", "_RE_FIRST_COMPONENT", ".", "match", "(", "include_base", ")", "if", "(", "target_first_component", "and", "include_first_component", "and", "target_first_component", ".", "group", "(", "0", ")", "==", "include_first_component", ".", "group", "(", "0", ")", ")", ":", "return", "_POSSIBLE_MY_HEADER", "return", "_OTHER_HEADER" ]

[ "write_cmake_fragment", "(", "output_path", ")", "-", ">", "None" ]

[ "def", "write_cmake_fragment", "(", "self", ",", "output_path", ",", "enabled_optional_components", ")", ":", "dependencies", "=", "list", "(", "self", ".", "get_fragment_dependencies", "(", ")", ")", "# Write out the CMake fragment.", "make_install_dir", "(", "os", ".", "path", ".", "dirname", "(", "output_path", ")", ")", "f", "=", "open", "(", "output_path", ",", "'w'", ")", "# Write the header.", "header_fmt", "=", "'\\\n#===-- %s - LLVMBuild Configuration for LLVM %s-*- CMake -*--===#'", "header_name", "=", "os", ".", "path", ".", "basename", "(", "output_path", ")", "header_pad", "=", "'-'", "*", "(", "80", "-", "len", "(", "header_fmt", "%", "(", "header_name", ",", "''", ")", ")", ")", "header_string", "=", "header_fmt", "%", "(", "header_name", ",", "header_pad", ")", "f", ".", "write", "(", "\"\"\"\\\n%s\n#\n# The LLVM Compiler Infrastructure\n#\n# This file is distributed under the University of Illinois Open Source\n# License. See LICENSE.TXT for details.\n#\n#===------------------------------------------------------------------------===#\n#\n# This file contains the LLVMBuild project information in a format easily\n# consumed by the CMake based build system.\n#\n# This file is autogenerated by llvm-build, do not edit!\n#\n#===------------------------------------------------------------------------===#\n\n\"\"\"", "%", "header_string", ")", "# Write the dependency information in the best way we can.", "f", ".", "write", "(", "\"\"\"\n# LLVMBuild CMake fragment dependencies.\n#\n# CMake has no builtin way to declare that the configuration depends on\n# a particular file. However, a side effect of configure_file is to add\n# said input file to CMake's internal dependency list. So, we use that\n# and a dummy output file to communicate the dependency information to\n# CMake.\n#\n# FIXME: File a CMake RFE to get a properly supported version of this\n# feature.\n\"\"\"", ")", "for", "dep", "in", "dependencies", ":", "f", ".", "write", "(", "\"\"\"\\\nconfigure_file(\\\"%s\\\"\n ${CMAKE_CURRENT_BINARY_DIR}/DummyConfigureOutput)\\n\"\"\"", "%", "(", "cmake_quote_path", "(", "dep", ")", ",", ")", ")", "# Write the properties we use to encode the required library dependency", "# information in a form CMake can easily use directly.", "f", ".", "write", "(", "\"\"\"\n# Explicit library dependency information.\n#\n# The following property assignments effectively create a map from component\n# names to required libraries, in a way that is easily accessed from CMake.\n\"\"\"", ")", "for", "ci", "in", "self", ".", "ordered_component_infos", ":", "# Skip optional components which are not enabled.", "if", "ci", ".", "type_name", "==", "'OptionalLibrary'", "and", "ci", ".", "name", "not", "in", "enabled_optional_components", ":", "continue", "# We only write the information for certain components currently.", "if", "ci", ".", "type_name", "not", "in", "(", "'Library'", ",", "'OptionalLibrary'", ")", ":", "continue", "f", ".", "write", "(", "\"\"\"\\\nset_property(GLOBAL PROPERTY LLVMBUILD_LIB_DEPS_%s %s)\\n\"\"\"", "%", "(", "ci", ".", "get_prefixed_library_name", "(", ")", ",", "\" \"", ".", "join", "(", "sorted", "(", "dep", ".", "get_prefixed_library_name", "(", ")", "for", "dep", "in", "self", ".", "get_required_libraries_for_component", "(", "ci", ")", ")", ")", ")", ")", "f", ".", "close", "(", ")" ]

[ "Truncate", "file", "to", "size", "bytes", "." ]

[ "def", "truncate", "(", "self", ",", "pos", "=", "None", ")", ":", "self", ".", "_unsupported", "(", "\"truncate\"", ")" ]

[ "Put", "an", "event", "object", "into", "event", "queue", "." ]

[ "def", "put", "(", "self", ",", "event", ":", "Event", ")", "->", "None", ":", "self", ".", "_queue", ".", "put", "(", "event", ")" ]

[ "Creates", "configuration", "object", "based", "on", "the", "default", "preset", "and", "the", "given", "one", "if", "present" ]

[ "def", "_load_preset", "(", "self", ",", "preset", "=", "None", ",", "preserve", "=", "False", ")", ":", "if", "SETTINGS", ".", "ptv", "is", "not", "None", ":", "preset_ptv", "=", "PTV", ".", "from_file", "(", "SETTINGS", ".", "ptv", ")", "self", ".", "ptv", "=", "PTV", "(", "preset_ptv", "[", "self", ".", "name", "]", ")", "else", ":", "self", ".", "ptv", "=", "PTV", ".", "from_file", "(", "self", ".", "_get_preset_filepath", "(", "defaults", ".", "SYSTEM_PRESETS_DIR_PATH", ",", "defaults", ".", "DEFAULT_PRESET_FILENAME_NOEXT", ")", ")", "if", "isinstance", "(", "preset", ",", "str", ")", "or", "isinstance", "(", "preset", ",", "unicode", ")", ":", "preset_ptv", "=", "PTV", ".", "from_file", "(", "self", ".", "_get_preset_filepath", "(", "defaults", ".", "USER_PRESETS_DIR_PATH", ",", "preset", ")", ")", "elif", "preset", "is", "not", "None", ":", "preset_ptv", "=", "PTV", "(", "preset", ")", "else", ":", "preset_ptv", "=", "None", "if", "preset_ptv", ":", "if", "preserve", "and", "self", ".", "preset", ":", "self", ".", "preset", ".", "merge", "(", "preset_ptv", ")", "else", ":", "self", ".", "preset", "=", "preset_ptv", "if", "self", ".", "preset", ":", "self", ".", "ptv", ".", "merge", "(", "self", ".", "preset", ")", "if", "self", ".", "additional_preset", ":", "self", ".", "ptv", ".", "merge", "(", "self", ".", "additional_preset", ")", "if", "self", ".", "ptv", "[", "\"channel_layout\"", "]", "==", "\"amb_wxyz\"", ":", "self", ".", "ptv", "[", "\"audio_bitrate\"", "]", "=", "self", ".", "ptv", "[", "\"ambisonic_audio_bitrate\"", "]" ]

[ "Return", "the", "list", "of", "sources", "to", "use", "if", "main", "target", "rule", "is", "invoked", "with", "sources", ".", "If", "there", "are", "any", "objects", "in", "sources", "they", "are", "treated", "as", "main", "target", "instances", "and", "the", "name", "of", "such", "targets", "are", "adjusted", "to", "be", "<name_of_this_target", ">", "__<name_of_source_target", ">", ".", "Such", "renaming", "is", "disabled", "is", "non", "-", "empty", "value", "is", "passed", "for", "no", "-", "renaming", "parameter", "." ]

[ "def", "main_target_sources", "(", "self", ",", "sources", ",", "main_target_name", ",", "no_renaming", "=", "0", ")", ":", "assert", "is_iterable_typed", "(", "sources", ",", "basestring", ")", "assert", "isinstance", "(", "main_target_name", ",", "basestring", ")", "assert", "isinstance", "(", "no_renaming", ",", "(", "int", ",", "bool", ")", ")", "result", "=", "[", "]", "for", "t", "in", "sources", ":", "t", "=", "b2", ".", "util", ".", "jam_to_value_maybe", "(", "t", ")", "if", "isinstance", "(", "t", ",", "AbstractTarget", ")", ":", "name", "=", "t", ".", "name", "(", ")", "if", "not", "no_renaming", ":", "name", "=", "main_target_name", "+", "'__'", "+", "name", "t", ".", "rename", "(", "name", ")", "# Inline targets are not built by default.", "p", "=", "t", ".", "project", "(", ")", "p", ".", "mark_targets_as_explicit", "(", "[", "name", "]", ")", "result", ".", "append", "(", "name", ")", "else", ":", "result", ".", "append", "(", "t", ")", "return", "result" ]

[ "AppendItem", "(", "self", "DataViewItem", "parent", "String", "text", "Icon", "icon", "=", "wxNullIcon", "wxClientData", "data", "=", "None", ")", "-", ">", "DataViewItem" ]

[ "def", "AppendItem", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewTreeStore_AppendItem", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "copy", "class", "attributes", "from", "an", "object", "to", "another" ]

[ "def", "copy_attrs", "(", "orig", ",", "dest", ",", "names", ",", "only_if_set", "=", "False", ")", ":", "for", "a", "in", "Utils", ".", "to_list", "(", "names", ")", ":", "u", "=", "getattr", "(", "orig", ",", "a", ",", "(", ")", ")", "if", "u", "or", "not", "only_if_set", ":", "setattr", "(", "dest", ",", "a", ",", "u", ")" ]

[ "convert", "to", "object", "if", "we", "are", "a", "categorical" ]

[ "def", "_to_safe_for_reshape", "(", "self", ")", ":", "return", "self", ".", "set_levels", "(", "[", "i", ".", "_to_safe_for_reshape", "(", ")", "for", "i", "in", "self", ".", "levels", "]", ")" ]

[ "Register", "pretty", "-", "printer", "PRINTER", "with", "OBJ", "." ]

[ "def", "register_pretty_printer", "(", "obj", ",", "printer", ",", "replace", "=", "False", ")", ":", "# Watch for both __name__ and name.", "# Functions get the former for free, but we don't want to use an", "# attribute named __foo__ for pretty-printers-as-objects.", "# If printer has both, we use `name'.", "if", "not", "hasattr", "(", "printer", ",", "\"__name__\"", ")", "and", "not", "hasattr", "(", "printer", ",", "\"name\"", ")", ":", "raise", "TypeError", "(", "\"printer missing attribute: name\"", ")", "if", "hasattr", "(", "printer", ",", "\"name\"", ")", "and", "not", "hasattr", "(", "printer", ",", "\"enabled\"", ")", ":", "raise", "TypeError", "(", "\"printer missing attribute: enabled\"", ")", "if", "not", "hasattr", "(", "printer", ",", "\"__call__\"", ")", ":", "raise", "TypeError", "(", "\"printer missing attribute: __call__\"", ")", "if", "obj", "is", "None", ":", "if", "gdb", ".", "parameter", "(", "\"verbose\"", ")", ":", "gdb", ".", "write", "(", "\"Registering global %s pretty-printer ...\\n\"", "%", "name", ")", "obj", "=", "gdb", "else", ":", "if", "gdb", ".", "parameter", "(", "\"verbose\"", ")", ":", "gdb", ".", "write", "(", "\"Registering %s pretty-printer for %s ...\\n\"", "%", "(", "printer", ".", "name", ",", "obj", ".", "filename", ")", ")", "if", "hasattr", "(", "printer", ",", "\"name\"", ")", ":", "if", "not", "isinstance", "(", "printer", ".", "name", ",", "basestring", ")", ":", "raise", "TypeError", "(", "\"printer name is not a string\"", ")", "# If printer provides a name, make sure it doesn't contain \";\".", "# Semicolon is used by the info/enable/disable pretty-printer commands", "# to delimit subprinters.", "if", "printer", ".", "name", ".", "find", "(", "\";\"", ")", ">=", "0", ":", "raise", "ValueError", "(", "\"semicolon ';' in printer name\"", ")", "# Also make sure the name is unique.", "# Alas, we can't do the same for functions and __name__, they could", "# all have a canonical name like \"lookup_function\".", "# PERF: gdb records printers in a list, making this inefficient.", "i", "=", "0", "for", "p", "in", "obj", ".", "pretty_printers", ":", "if", "hasattr", "(", "p", ",", "\"name\"", ")", "and", "p", ".", "name", "==", "printer", ".", "name", ":", "if", "replace", ":", "del", "obj", ".", "pretty_printers", "[", "i", "]", "break", "else", ":", "raise", "RuntimeError", "(", "\"pretty-printer already registered: %s\"", "%", "printer", ".", "name", ")", "i", "=", "i", "+", "1", "obj", ".", "pretty_printers", ".", "insert", "(", "0", ",", "printer", ")" ]

[ "addExtrudedEllipse", "(", "data", "extrusion", "[", "placement", "color", "]", ")", ":", "makes", "an", "extruded", "ellipse", "from", "the", "given", "data", "(", "center", "radiusx", "radiusy", ")", "and", "the", "given", "extrusion", "vector" ]

[ "def", "addExtrudedEllipse", "(", "self", ",", "data", ",", "extrusion", ",", "placement", "=", "None", ",", "color", "=", "None", ")", ":", "cir", "=", "self", ".", "addProfile", "(", "\"IfcEllipseProfileDef\"", ",", "[", "data", "[", "1", "]", ",", "data", "[", "2", "]", "]", ")", "if", "not", "placement", ":", "placement", "=", "self", ".", "addPlacement", "(", "origin", "=", "data", "[", "0", "]", ",", "local", "=", "False", ")", "exp", "=", "self", ".", "addExtrusion", "(", "cir", ",", "extrusion", ",", "placement", ")", "if", "color", ":", "self", ".", "addColor", "(", "color", ",", "exp", ")", "return", "exp" ]

[ "Add", "dependencies", "to", "the", "rule", "." ]

[ "def", "add_dependencies", "(", "self", ",", "deps", ")", ":", "assert", "isinstance", "(", "deps", ",", "Iterable", ")", "and", "not", "isinstance", "(", "deps", ",", "StringTypes", ")", "self", ".", "_dependencies", ".", "update", "(", "deps", ")", "return", "self" ]

[ "Generates", "ADMX", "XML", "elements", "for", "a", "List", "-", "Policy", "and", "adds", "them", "to", "the", "passed", "parent", "element", "." ]

[ "def", "_AddListPolicy", "(", "self", ",", "parent", ",", "key", ",", "name", ")", ":", "attributes", "=", "{", "# The ID must be in sync with ID of the corresponding element in the ADML", "# file.", "'id'", ":", "name", "+", "'Desc'", ",", "'valuePrefix'", ":", "''", ",", "'key'", ":", "key", "+", "'\\\\'", "+", "name", ",", "}", "self", ".", "AddElement", "(", "parent", ",", "'list'", ",", "attributes", ")" ]

[ "Analyse", "the", "privates", "for", "this", "block", "and", "set", "them", "in", "self", ".", "privates", ".", "This", "should", "be", "called", "in", "a", "post", "-", "order", "fashion", "during", "the", "analyse_expressions", "phase" ]

[ "def", "analyse_sharing_attributes", "(", "self", ",", "env", ")", ":", "for", "entry", ",", "(", "pos", ",", "op", ")", "in", "self", ".", "assignments", ".", "items", "(", ")", ":", "if", "self", ".", "is_prange", "and", "not", "self", ".", "is_parallel", ":", "# closely nested prange in a with parallel block, disallow", "# assigning to privates in the with parallel block (we", "# consider it too implicit and magicky for users)", "if", "entry", "in", "self", ".", "parent", ".", "assignments", ":", "error", "(", "pos", ",", "\"Cannot assign to private of outer parallel block\"", ")", "continue", "if", "not", "self", ".", "is_prange", "and", "op", ":", "# Again possible, but considered to magicky", "error", "(", "pos", ",", "\"Reductions not allowed for parallel blocks\"", ")", "continue", "# By default all variables should have the same values as if", "# executed sequentially", "lastprivate", "=", "True", "self", ".", "propagate_var_privatization", "(", "entry", ",", "pos", ",", "op", ",", "lastprivate", ")" ]

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

[ "def", "IsRecordingDefaults", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "ConfigBase_IsRecordingDefaults", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "GetSizeTuple", "()", "-", ">", "(", "width", "height", ")" ]

[ "def", "GetSizeTuple", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "DC_GetSizeTuple", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "year", "-", ">", "1", "if", "leap", "year", "else", "0", "." ]

[ "def", "_is_leap", "(", "year", ")", ":", "return", "year", "%", "4", "==", "0", "and", "(", "year", "%", "100", "!=", "0", "or", "year", "%", "400", "==", "0", ")" ]

[ "Create", "(", "self", "Window", "parent", "int", "id", "=", "-", "1", "Point", "pos", "=", "DefaultPosition", "Size", "size", "=", "DefaultSize", "long", "style", "=", "0", "String", "name", "=", "PanelNameStr", ")", "-", ">", "bool" ]

[ "def", "Create", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "Window_Create", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Assuming", "the", "QApplication", "instance", "exists", "ensure", "this", "object", "is", "on", "that", "thread" ]

[ "def", "_ensure_self_on_qapp_thread", "(", "self", ")", ":", "if", "self", ".", "_moved_to_app", ":", "return", "self", ".", "moveToThread", "(", "QApplication", ".", "instance", "(", ")", ".", "thread", "(", ")", ")", "self", ".", "_moved_to_app", "=", "True" ]

[ "GetPixelPoint", "(", "self", "Point", "pt", ")", "-", ">", "Colour" ]

[ "def", "GetPixelPoint", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "DC_GetPixelPoint", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "the", "selected", "Y", "parameter", "." ]

[ "def", "set_selected_y_parameter", "(", "self", ",", "y_parameter", ":", "str", ")", "->", "None", ":", "self", ".", "model_fitting_data_selector", ".", "set_selected_y_parameter", "(", "y_parameter", ")" ]

[ "Trains", "the", "model", "with", "a", "given", ":", "py", ":", "class", ":", "DataLoader", "for", "a", "specified", "number", "of", "epochs", "or", "batches", ".", "The", "batch", "size", "is", "inferred", "from", "the", "data", "loader", "s", "batch_size", "." ]

[ "def", "fit", "(", "self", ",", "train_data", ",", "val_data", "=", "None", ",", "epochs", "=", "None", ",", "event_handlers", "=", "None", ",", "batches", "=", "None", ",", "batch_axis", "=", "0", ")", ":", "if", "not", "isinstance", "(", "train_data", ",", "gluon", ".", "data", ".", "DataLoader", ")", ":", "raise", "ValueError", "(", "\"Estimator only support input as Gluon DataLoader. Alternatively, you \"", "\"can transform your DataIter or any NDArray into Gluon DataLoader. \"", "\"Refer to gluon.data.dataloader\"", ")", "# must specify one and only one of epochs or batches", "if", "(", "not", "epochs", ")", "==", "(", "not", "batches", ")", ":", "raise", "ValueError", "(", "\"Fit only support exactly one type of iteration, \"", "\"train by number of epochs or number of batches.\"", "\"Please specify one and only one of: epochs or batches.\"", ")", "self", ".", "max_epoch", "=", "epochs", "self", ".", "max_batch", "=", "batches", "# provide default handlers", "event_handlers", "=", "self", ".", "_prepare_default_handlers", "(", "val_data", ",", "event_handlers", ")", "train_begin", ",", "epoch_begin", ",", "batch_begin", ",", "batch_end", ",", "epoch_end", ",", "train_end", "=", "self", ".", "_categorize_handlers", "(", "event_handlers", ")", "# pass a reference to all event handlers", "estimator_ref", "=", "self", "# training begin", "for", "handler", "in", "train_begin", ":", "handler", ".", "train_begin", "(", "estimator_ref", ")", "while", "True", ":", "# epoch begin", "for", "handler", "in", "epoch_begin", ":", "handler", ".", "epoch_begin", "(", "estimator_ref", ")", "for", "i", ",", "batch", "in", "enumerate", "(", "train_data", ")", ":", "data", ",", "label", "=", "self", ".", "_get_data_and_label", "(", "batch", ",", "self", ".", "context", ",", "batch_axis", ")", "batch_size", "=", "batch", "[", "0", "]", ".", "shape", "[", "0", "]", "# batch begin", "for", "handler", "in", "batch_begin", ":", "handler", ".", "batch_begin", "(", "estimator_ref", ",", "batch", "=", "batch", ")", "with", "autograd", ".", "record", "(", ")", ":", "pred", "=", "[", "self", ".", "net", "(", "x", ")", "for", "x", "in", "data", "]", "loss", "=", "[", "self", ".", "loss", "[", "0", "]", "(", "y_hat", ",", "y", ")", "for", "y_hat", ",", "y", "in", "zip", "(", "pred", ",", "label", ")", "]", "for", "l", "in", "loss", ":", "l", ".", "backward", "(", ")", "self", ".", "trainer", ".", "step", "(", "batch_size", ")", "# batch end", "batch_end_result", "=", "[", "]", "for", "handler", "in", "batch_end", ":", "batch_end_result", ".", "append", "(", "handler", ".", "batch_end", "(", "estimator_ref", ",", "batch", "=", "batch", ",", "pred", "=", "pred", ",", "label", "=", "label", ",", "loss", "=", "loss", ")", ")", "# if any handler signaled to stop", "if", "any", "(", "batch_end_result", ")", ":", "break", "# epoch end", "epoch_end_result", "=", "[", "]", "for", "handler", "in", "epoch_end", ":", "epoch_end_result", ".", "append", "(", "handler", ".", "epoch_end", "(", "estimator_ref", ")", ")", "# if any handler signaled to stop", "if", "any", "(", "epoch_end_result", ")", ":", "break", "# train end", "for", "handler", "in", "train_end", ":", "handler", ".", "train_end", "(", "estimator_ref", ")" ]

[ "Takes", "filenames", "out", "of", "queue", "and", "runs", "clang", "-", "format", "on", "them", "." ]

[ "def", "run_format", "(", "args", ",", "file_queue", ",", "lock", ",", "return_codes", ")", ":", "while", "True", ":", "name", "=", "file_queue", ".", "get", "(", ")", "invocation", "=", "get_format_invocation", "(", "name", ",", "args", ".", "cmake_format_binary", ",", "args", ".", "check", ")", "proc", "=", "subprocess", ".", "Popen", "(", "invocation", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "PIPE", ")", "output", ",", "err", "=", "proc", ".", "communicate", "(", ")", "with", "lock", ":", "return_codes", ".", "append", "(", "proc", ".", "returncode", ")", "sys", ".", "stdout", ".", "write", "(", "\" \"", ".", "join", "(", "invocation", ")", "+", "\"\\n\"", "+", "output", ".", "decode", "(", "\"utf-8\"", ")", ")", "if", "len", "(", "err", ")", ">", "0", ":", "sys", ".", "stdout", ".", "flush", "(", ")", "sys", ".", "stderr", ".", "write", "(", "err", ".", "decode", "(", "\"utf-8\"", ")", ")", "file_queue", ".", "task_done", "(", ")" ]

[ "Given", "optional", "port", "and", "ssh", "key", "values", "append", "valid", "OpenSSH", "commandline", "arguments", "to", "the", "list", "cmdline", "if", "the", "values", "are", "not", "None", "." ]

[ "def", "AppendOptionalArgsToSSHCommandline", "(", "cmdline", ",", "port", ",", "ssh_key", ")", ":", "if", "port", "is", "not", "None", ":", "cmdline", ".", "append", "(", "\"-P%d\"", "%", "port", ")", "if", "ssh_key", "is", "not", "None", ":", "# Don't interpret ~ paths - ssh can handle that on its own", "if", "not", "ssh_key", ".", "startswith", "(", "'~'", ")", ":", "ssh_key", "=", "WindowsPathToMsysPath", "(", "ssh_key", ")", "cmdline", ".", "extend", "(", "[", "\"-o\"", ",", "\"IdentityFile=%s\"", "%", "ssh_key", "]", ")" ]

[ "Returns", "a", "single", "Summary", "op", "that", "would", "run", "all", "summaries", "." ]

[ "def", "get_summary_op", "(", ")", ":", "summary_op", "=", "ops", ".", "get_collection", "(", "ops", ".", "GraphKeys", ".", "SUMMARY_OP", ")", "if", "summary_op", "is", "not", "None", ":", "if", "summary_op", ":", "summary_op", "=", "summary_op", "[", "0", "]", "else", ":", "summary_op", "=", "None", "if", "summary_op", "is", "None", ":", "summary_op", "=", "merge_all_summaries", "(", ")", "if", "summary_op", "is", "not", "None", ":", "ops", ".", "add_to_collection", "(", "ops", ".", "GraphKeys", ".", "SUMMARY_OP", ",", "summary_op", ")", "return", "summary_op" ]

[ "Execute", "cmd", "and", "return", "err_code", "and", "output", "." ]

[ "def", "execute", "(", "self", ")", ":", "self", ".", "_process", "=", "subprocess", ".", "Popen", "(", "self", ".", "_cmd_list", "(", ")", ",", "stdout", "=", "subprocess", ".", "PIPE", ",", "stderr", "=", "subprocess", ".", "STDOUT", ",", "*", "*", "self", ".", "_preexec_kargs", ")", "output", ",", "_", "=", "self", ".", "_process", ".", "communicate", "(", ")", "error_code", "=", "self", ".", "_process", ".", "returncode", "return", "error_code", ",", "output" ]

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

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

[ "I", "know", "how", "to", "take", "a", "list", "of", "program", "arguments", "and", "start", "doing", "the", "right", "thing", "with", "them" ]

[ "def", "process_command", "(", "options", ",", "args", ")", ":", "cmd", "=", "args", "[", "0", "]", "cmd_args", "=", "args", "[", "1", ":", "]", "log", ".", "debug", "(", "\"processing '%s' command with args '%s'\"", "%", "(", "cmd", ",", "'\", \"'", ".", "join", "(", "cmd_args", ")", ")", ")", "log", ".", "debug", "(", "\"using options: %s\"", "%", "options", ")", "if", "cmd", "==", "'list'", ":", "return", "list_manifest", "(", "options", "[", "'manifest'", "]", ")", "if", "cmd", "==", "'validate'", ":", "return", "validate_manifest", "(", "options", "[", "'manifest'", "]", ")", "elif", "cmd", "==", "'add'", ":", "return", "add_files", "(", "options", "[", "'manifest'", "]", ",", "options", "[", "'algorithm'", "]", ",", "cmd_args", ")", "elif", "cmd", "==", "'fetch'", ":", "if", "not", "options", ".", "has_key", "(", "'base_url'", ")", "or", "options", ".", "get", "(", "'base_url'", ")", "is", "None", ":", "log", ".", "critical", "(", "'fetch command requires url option'", ")", "return", "False", "return", "fetch_files", "(", "options", "[", "'manifest'", "]", ",", "options", "[", "'base_url'", "]", ",", "options", "[", "'overwrite'", "]", ",", "cmd_args", ")", "else", ":", "log", ".", "critical", "(", "'command \"%s\" is not implemented'", "%", "cmd", ")", "return", "False" ]

[ "override", "zoom", "released", "method", "Parameters", "----------", "event" ]

[ "def", "release_zoom", "(", "self", ",", "event", ")", ":", "self", ".", "canvas_zoom_released", ".", "emit", "(", ")", "NavigationToolbar2", ".", "release_zoom", "(", "self", ",", "event", ")", "return" ]

[ "Pack", "data", "according", "to", "which", "plugin", "." ]

[ "def", "_pack_data", "(", "datadict", ",", "wall_time", ")", ":", "result", ",", "summaries", ",", "step", "=", "[", "]", ",", "[", "]", ",", "None", "for", "plugin", ",", "datalist", "in", "datadict", ".", "items", "(", ")", ":", "for", "data", "in", "datalist", ":", "if", "plugin", "==", "PluginEnum", ".", "GRAPH", ".", "value", ":", "result", ".", "append", "(", "[", "plugin", ",", "package_graph_event", "(", "data", ".", "get", "(", "'value'", ")", ")", ".", "SerializeToString", "(", ")", "]", ")", "elif", "plugin", "in", "(", "PluginEnum", ".", "TRAIN_LINEAGE", ".", "value", ",", "PluginEnum", ".", "EVAL_LINEAGE", ".", "value", ",", "PluginEnum", ".", "CUSTOM_LINEAGE_DATA", ".", "value", ",", "PluginEnum", ".", "DATASET_GRAPH", ".", "value", ")", ":", "result", ".", "append", "(", "[", "plugin", ",", "serialize_to_lineage_event", "(", "plugin", ",", "data", ".", "get", "(", "'value'", ")", ")", "]", ")", "elif", "plugin", "in", "(", "PluginEnum", ".", "SCALAR", ".", "value", ",", "PluginEnum", ".", "TENSOR", ".", "value", ",", "PluginEnum", ".", "HISTOGRAM", ".", "value", ",", "PluginEnum", ".", "IMAGE", ".", "value", ",", "PluginEnum", ".", "LANDSCAPE", ".", "value", ")", ":", "summaries", ".", "append", "(", "{", "'_type'", ":", "plugin", ".", "title", "(", ")", ",", "'name'", ":", "data", ".", "get", "(", "'tag'", ")", ",", "'data'", ":", "data", ".", "get", "(", "'value'", ")", "}", ")", "step", "=", "data", ".", "get", "(", "'step'", ")", "if", "'export_option'", "in", "data", ":", "result", ".", "append", "(", "[", "WriterPluginEnum", ".", "EXPORTER", ".", "value", ",", "data", "]", ")", "if", "summaries", ":", "result", ".", "append", "(", "[", "WriterPluginEnum", ".", "SUMMARY", ".", "value", ",", "package_summary_event", "(", "summaries", ",", "step", ",", "wall_time", ")", ".", "SerializeToString", "(", ")", "]", ")", "return", "result" ]

[ "Helper", "method", "that", "loads", "the", "contents", "of", "a", "empires", ".", "dat", "gzipped", "wrapper", "file", "." ]

[ "def", "load_gamespec", "(", "fileobj", ",", "game_version", ",", "cachefile_name", "=", "None", ",", "load_cache", "=", "False", ")", ":", "# try to use the cached result from a previous run", "if", "cachefile_name", "and", "load_cache", ":", "try", ":", "with", "open", "(", "cachefile_name", ",", "\"rb\"", ")", "as", "cachefile", ":", "# pickle.load() can fail in many ways, we need to catch all.", "# pylint: disable=broad-except", "try", ":", "gamespec", "=", "pickle", ".", "load", "(", "cachefile", ")", "info", "(", "\"using cached wrapper: %s\"", ",", "cachefile_name", ")", "return", "gamespec", "except", "Exception", ":", "warn", "(", "\"could not use cached wrapper:\"", ")", "import", "traceback", "traceback", ".", "print_exc", "(", ")", "warn", "(", "\"we will just skip the cache, no worries.\"", ")", "except", "FileNotFoundError", ":", "pass", "# read the file ourselves", "dbg", "(", "\"reading dat file\"", ")", "compressed_data", "=", "fileobj", ".", "read", "(", ")", "fileobj", ".", "close", "(", ")", "dbg", "(", "\"decompressing dat file\"", ")", "# -15: there's no header, window size is 15.", "file_data", "=", "decompress", "(", "compressed_data", ",", "-", "15", ")", "del", "compressed_data", "spam", "(", "\"length of decompressed data: %d\"", ",", "len", "(", "file_data", ")", ")", "wrapper", "=", "EmpiresDatWrapper", "(", ")", "_", ",", "gamespec", "=", "wrapper", ".", "read", "(", "file_data", ",", "0", ",", "game_version", ")", "# Remove the list sorrounding the converted data", "gamespec", "=", "gamespec", "[", "0", "]", "if", "cachefile_name", ":", "dbg", "(", "\"dumping dat file contents to cache file: %s\"", ",", "cachefile_name", ")", "with", "open", "(", "cachefile_name", ",", "\"wb\"", ")", "as", "cachefile", ":", "pickle", ".", "dump", "(", "gamespec", ",", "cachefile", ")", "return", "gamespec" ]

[ "Load", "the", "kernel", "vertical", "discretisation", "(", "z", ")", "vector", "." ]

[ "def", "loadZVector", "(", "self", ",", "filename", "=", "'zkernel.vec'", ")", ":", "self", ".", "z", "=", "pg", ".", "Vector", "(", "filename", ")" ]

[ "Automatically", "regenerate", "site", "upon", "file", "modification" ]

[ "def", "regenerate", "(", "c", ")", ":", "pelican_run", "(", "'-r -s {settings_base}'", ".", "format", "(", "*", "*", "CONFIG", ")", ")" ]

[ "Fast", "inline", "implementation", "of", "HMAC", "." ]

[ "def", "digest", "(", "key", ",", "msg", ",", "digest", ")", ":", "if", "(", "_hashopenssl", "is", "not", "None", "and", "isinstance", "(", "digest", ",", "str", ")", "and", "digest", "in", "_openssl_md_meths", ")", ":", "return", "_hashopenssl", ".", "hmac_digest", "(", "key", ",", "msg", ",", "digest", ")", "if", "callable", "(", "digest", ")", ":", "digest_cons", "=", "digest", "elif", "isinstance", "(", "digest", ",", "str", ")", ":", "digest_cons", "=", "lambda", "d", "=", "b''", ":", "_hashlib", ".", "new", "(", "digest", ",", "d", ")", "else", ":", "digest_cons", "=", "lambda", "d", "=", "b''", ":", "digest", ".", "new", "(", "d", ")", "inner", "=", "digest_cons", "(", ")", "outer", "=", "digest_cons", "(", ")", "blocksize", "=", "getattr", "(", "inner", ",", "'block_size'", ",", "64", ")", "if", "len", "(", "key", ")", ">", "blocksize", ":", "key", "=", "digest_cons", "(", "key", ")", ".", "digest", "(", ")", "key", "=", "key", "+", "b'\\x00'", "*", "(", "blocksize", "-", "len", "(", "key", ")", ")", "inner", ".", "update", "(", "key", ".", "translate", "(", "trans_36", ")", ")", "outer", ".", "update", "(", "key", ".", "translate", "(", "trans_5C", ")", ")", "inner", ".", "update", "(", "msg", ")", "outer", ".", "update", "(", "inner", ".", "digest", "(", ")", ")", "return", "outer", ".", "digest", "(", ")" ]

[ "Group", "the", "counters", "by", "the", "suffix", "of", "their", "name", "." ]

[ "def", "ComputeCounters", "(", "self", ")", ":", "names", "=", "{", "}", "for", "i", "in", "xrange", "(", "self", ".", "data", ".", "CountersInUse", "(", ")", ")", ":", "counter", "=", "self", ".", "data", ".", "Counter", "(", "i", ")", "name", "=", "counter", ".", "Name", "(", ")", "names", "[", "name", "]", "=", "counter", "# By sorting the keys we ensure that the prefixes always come in the", "# same order (\"c:\" before \"t:\") which looks more consistent in the", "# ui.", "sorted_keys", "=", "names", ".", "keys", "(", ")", "sorted_keys", ".", "sort", "(", ")", "# Group together the names whose suffix after a ':' are the same.", "groups", "=", "{", "}", "for", "name", "in", "sorted_keys", ":", "counter", "=", "names", "[", "name", "]", "if", "\":\"", "in", "name", ":", "name", "=", "name", "[", "name", ".", "find", "(", "\":\"", ")", "+", "1", ":", "]", "if", "not", "name", "in", "groups", ":", "groups", "[", "name", "]", "=", "[", "]", "groups", "[", "name", "]", ".", "append", "(", "counter", ")", "return", "groups" ]

[ "Gets", "the", "focal", "force", "multiplier", "." ]

[ "def", "force", "(", "self", ")", ":", "return", "self", ".", "_internal", ".", "get_force", "(", ")" ]

[ "part", "of", "public", "interface" ]

[ "def", "add_definitions", "(", "self", ",", "defines", ")", ":", "self", ".", "c_flags", ".", "extend", "(", "defines", ")" ]

[ "Supplies", "calibration", "data", "to", "TensorRT", "to", "calibrate", "the", "network", "for", "INT8", "inference", "." ]

[ "def", "Calibrator", "(", "data_loader", ",", "cache", "=", "None", ",", "BaseClass", "=", "None", ",", "batch_size", "=", "None", ",", "quantile", "=", "None", ",", "regression_cutoff", "=", "None", ",", "algo", "=", "None", ")", ":", "BaseClass", "=", "util", ".", "default", "(", "BaseClass", ",", "trt", ".", "IInt8EntropyCalibrator2", ")", "class", "CalibratorClass", "(", "BaseClass", ")", ":", "\"\"\"\n Calibrator that supplies calibration data to TensorRT to calibrate the network for INT8 inference.\n \"\"\"", "def", "__init__", "(", "self", ")", ":", "# Must explicitly initialize parent for any trampoline class! Will mysteriously segfault without this.", "BaseClass", ".", "__init__", "(", "self", ")", "self", ".", "is_active", "=", "False", "self", ".", "data_loader", "=", "data_loader", "self", ".", "_cache", "=", "cache", "self", ".", "device_buffers", "=", "OrderedDict", "(", ")", "self", ".", "reset", "(", ")", "G_LOGGER", ".", "verbose", "(", "\"Created calibrator [cache={:}]\"", ".", "format", "(", "self", ".", "_cache", ")", ")", "self", ".", "batch_size", "=", "util", ".", "default", "(", "batch_size", ",", "1", ")", "# The function that constructed this instance", "self", ".", "make_func", "=", "Calibrator", "def", "reset", "(", "self", ",", "input_metadata", "=", "None", ")", ":", "\"\"\"\n Reset this calibrator for reuse.\n The calibrator will clear any dynamic ranges cached from previous calibration runs, and will\n attempt to rewind the data loader (note that generators cannot be rewound).\n\n Args:\n input_metadata (TensorMetadata):\n Mapping of input names to their data types and shapes.\n Passed along to the data loader if provided. Generally should not be required\n unless using Polygraphy's included `DataLoader` for this calibrator.\n \"\"\"", "if", "input_metadata", "is", "not", "None", ":", "with", "contextlib", ".", "suppress", "(", "AttributeError", ")", ":", "self", ".", "data_loader", ".", "input_metadata", "=", "input_metadata", "# Attempt to reset data loader", "self", ".", "data_loader_iter", "=", "iter", "(", "self", ".", "data_loader", ")", "self", ".", "num_batches", "=", "0", "# Make sure calibrator will check the cache again when reset.", "self", ".", "cache_contents", "=", "None", "self", ".", "has_cached_scales", "=", "False", "def", "get_batch_size", "(", "self", ")", ":", "return", "self", ".", "batch_size", "def", "get_batch", "(", "self", ",", "names", ")", ":", "if", "not", "self", ".", "is_active", ":", "G_LOGGER", ".", "error", "(", "\"Calibrator must be activated prior to use. Please use a context manager. \"", "\"For example:\\nwith calibrator:\\n\\t# Use calibrator here\"", ")", "return", "None", "try", ":", "buffers", "=", "next", "(", "self", ".", "data_loader_iter", ")", "except", "StopIteration", ":", "if", "not", "self", ".", "num_batches", ":", "G_LOGGER", ".", "error", "(", "\"Calibrator data loader provided no data.\\nPossible reasons for this include:\\n(1) data loader \"", "\"has no data to provide\\n(2) data loader was a generator, and the calibrator is being \"", "\"used multiple times (generators cannot be rewound)\"", ")", "return", "None", "else", ":", "self", ".", "num_batches", "+=", "1", "if", "not", "util", ".", "check_dict_contains", "(", "buffers", ",", "names", ",", "dict_name", "=", "\"calibration data\"", ",", "log_func", "=", "G_LOGGER", ".", "error", ")", ":", "return", "None", "ptrs", "=", "[", "]", "for", "name", "in", "names", ":", "buf", "=", "buffers", "[", "name", "]", "if", "isinstance", "(", "buf", ",", "cuda", ".", "DeviceView", ")", ":", "ptrs", ".", "append", "(", "buf", ".", "ptr", ")", "elif", "isinstance", "(", "buf", ",", "np", ".", "ndarray", ")", ":", "if", "name", "not", "in", "self", ".", "device_buffers", ":", "self", ".", "device_buffers", "[", "name", "]", "=", "cuda", ".", "DeviceArray", "(", "shape", "=", "buf", ".", "shape", ",", "dtype", "=", "buf", ".", "dtype", ")", "G_LOGGER", ".", "verbose", "(", "\"Allocated: {:}\"", ".", "format", "(", "self", ".", "device_buffers", "[", "name", "]", ")", ")", "ptrs", ".", "append", "(", "self", ".", "device_buffers", "[", "name", "]", ".", "copy_from", "(", "buf", ")", ".", "ptr", ")", "elif", "isinstance", "(", "buf", ",", "int", ")", ":", "ptrs", ".", "append", "(", "buf", ")", "else", ":", "G_LOGGER", ".", "error", "(", "\"Calibration data loader provided an unrecognized type: {:} for input: {:}.\\n\"", "\"Please provide either a NumPy array, Polygraphy DeviceView, or GPU pointer. \"", ".", "format", "(", "type", "(", "buf", ")", ".", "__name__", ",", "name", ")", ")", "return", "None", "return", "ptrs", "def", "read_calibration_cache", "(", "self", ")", ":", "def", "load_from_cache", "(", ")", ":", "if", "self", ".", "_cache", "is", "None", "or", "not", "util", ".", "get_file_size", "(", "self", ".", "_cache", ")", ":", "return", "None", "try", ":", "return", "util", ".", "load_file", "(", "self", ".", "_cache", ",", "description", "=", "\"calibration cache\"", ")", "except", "Exception", "as", "err", ":", "G_LOGGER", ".", "error", "(", "\"Could not read from calibration cache: {:}\\nNote: Error was: {:}\"", ".", "format", "(", "self", ".", "_cache", ",", "err", ")", ")", "return", "None", "# Only attempt to read from the cache once.", "if", "self", ".", "has_cached_scales", ":", "return", "self", ".", "cache_contents", "self", ".", "cache_contents", "=", "load_from_cache", "(", ")", "if", "not", "self", ".", "cache_contents", ":", "if", "self", ".", "cache_contents", "is", "not", "None", ":", "G_LOGGER", ".", "warning", "(", "\"Calibration cache was provided, but is empty. \"", "\"Will regenerate scales by running calibration.\"", ",", "mode", "=", "LogMode", ".", "ONCE", ",", ")", "self", ".", "cache_contents", "=", "None", "else", ":", "self", ".", "has_cached_scales", "=", "True", "return", "self", ".", "cache_contents", "def", "write_calibration_cache", "(", "self", ",", "cache", ")", ":", "self", ".", "cache_contents", "=", "cache", ".", "tobytes", "(", ")", "self", ".", "has_cached_scales", "=", "True", "if", "self", ".", "_cache", "is", "None", ":", "return", "try", ":", "util", ".", "save_file", "(", "contents", "=", "self", ".", "cache_contents", ",", "dest", "=", "self", ".", "_cache", ",", "description", "=", "\"calibration cache\"", ")", "except", "Exception", "as", "err", ":", "G_LOGGER", ".", "error", "(", "\"Could not write to calibration cache: {:}.\\nNote: Error was: {:}\"", ".", "format", "(", "self", ".", "_cache", ",", "err", ")", ")", "def", "__enter__", "(", "self", ")", ":", "self", ".", "is_active", "=", "True", "return", "self", "def", "__exit__", "(", "self", ",", "exc_type", ",", "exc_value", ",", "traceback", ")", ":", "self", ".", "is_active", "=", "False", "for", "device_buffer", "in", "self", ".", "device_buffers", ".", "values", "(", ")", ":", "device_buffer", ".", "free", "(", ")", "# IInt8LegacyCalibrator methods", "def", "get_quantile", "(", "self", ")", ":", "return", "util", ".", "default", "(", "quantile", ",", "0.5", ")", "def", "get_regression_cutoff", "(", "self", ")", ":", "return", "util", ".", "default", "(", "regression_cutoff", ",", "0.5", ")", "def", "read_histogram_cache", "(", "self", ",", "length", ")", ":", "pass", "def", "write_histogram_cache", "(", "self", ",", "ptr", ",", "length", ")", ":", "pass", "# IInt8Calibrator methods", "def", "get_algorithm", "(", "self", ")", ":", "return", "util", ".", "default", "(", "algo", ",", "trt", ".", "CalibrationAlgoType", ".", "MINMAX_CALIBRATION", ")", "def", "__repr__", "(", "self", ")", ":", "return", "util", ".", "make_repr", "(", "\"Calibrator\"", ",", "data_loader", ",", "cache", "=", "cache", ",", "BaseClass", "=", "BaseClass", ",", "batch_size", "=", "batch_size", ",", "quantile", "=", "quantile", ",", "regression_cutoff", "=", "regression_cutoff", ",", "algo", "=", "algo", ",", ")", "[", "0", "]", "return", "CalibratorClass", "(", ")" ]

[ "Shows", "nearby", "vehicles", "of", "the", "hero", "actor" ]

[ "def", "_show_nearby_vehicles", "(", "self", ",", "vehicles", ")", ":", "info_text", "=", "[", "]", "if", "self", ".", "hero_actor", "is", "not", "None", "and", "len", "(", "vehicles", ")", ">", "1", ":", "location", "=", "self", ".", "hero_transform", ".", "location", "vehicle_list", "=", "[", "x", "[", "0", "]", "for", "x", "in", "vehicles", "if", "x", "[", "0", "]", ".", "id", "!=", "self", ".", "hero_actor", ".", "id", "]", "def", "distance", "(", "v", ")", ":", "return", "location", ".", "distance", "(", "v", ".", "get_location", "(", ")", ")", "for", "n", ",", "vehicle", "in", "enumerate", "(", "sorted", "(", "vehicle_list", ",", "key", "=", "distance", ")", ")", ":", "if", "n", ">", "15", ":", "break", "vehicle_type", "=", "get_actor_display_name", "(", "vehicle", ",", "truncate", "=", "22", ")", "info_text", ".", "append", "(", "'% 5d %s'", "%", "(", "vehicle", ".", "id", ",", "vehicle_type", ")", ")", "self", ".", "_hud", ".", "add_info", "(", "'NEARBY VEHICLES'", ",", "info_text", ")" ]

[ "Append", "a", "line", "to", "the", "pre", "-", "import", "prefix", "of", "the", "script", "." ]

[ "def", "append_preimport", "(", "self", ",", "line", ")", ":", "line", "=", "ensure_safe", "(", "line", ")", ".", "unwrap", "(", ")", "self", ".", "preimport", ".", "append", "(", "line", ")" ]

[ "UseMenu", "(", "self", "Menu", "menu", ")" ]

[ "def", "UseMenu", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_misc_", ".", "FileHistory_UseMenu", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Initializes", "the", "diff", "to", "a", "ready", "state", ".", "It", "checks", "the", "zone", "exists", "in", "the", "datasource", "and", "if", "not", "NoSuchZone", "is", "raised", ".", "This", "also", "creates", "a", "transaction", "in", "the", "data", "source", "." ]

[ "def", "__init__", "(", "self", ",", "ds_client", ",", "zone", ",", "replace", "=", "False", ",", "journaling", "=", "False", ",", "single_update_mode", "=", "False", ")", ":", "try", ":", "self", ".", "__updater", "=", "ds_client", ".", "get_updater", "(", "zone", ",", "replace", ",", "journaling", ")", "except", "bundy", ".", "datasrc", ".", "NotImplemented", "as", "ex", ":", "if", "not", "journaling", ":", "raise", "ex", "self", ".", "__updater", "=", "ds_client", ".", "get_updater", "(", "zone", ",", "replace", ",", "False", ")", "logger", ".", "info", "(", "LIBXFRIN_NO_JOURNAL", ",", "zone", ",", "ds_client", ")", "if", "self", ".", "__updater", "is", "None", ":", "# The no such zone case", "raise", "NoSuchZone", "(", "\"Zone \"", "+", "str", "(", "zone", ")", "+", "\" does not exist in the data source \"", "+", "str", "(", "ds_client", ")", ")", "self", ".", "__single_update_mode", "=", "single_update_mode", "if", "single_update_mode", ":", "self", ".", "__additions", "=", "[", "]", "self", ".", "__deletions", "=", "[", "]", "else", ":", "self", ".", "__buffer", "=", "[", "]" ]

[ "Generates", "a", "checkpoint", "state", "proto", "." ]

[ "def", "generate_checkpoint_state_proto", "(", "save_dir", ",", "model_checkpoint_path", ",", "all_model_checkpoint_paths", "=", "None", ")", ":", "if", "all_model_checkpoint_paths", "is", "None", ":", "all_model_checkpoint_paths", "=", "[", "]", "if", "(", "not", "all_model_checkpoint_paths", "or", "all_model_checkpoint_paths", "[", "-", "1", "]", "!=", "model_checkpoint_path", ")", ":", "logging", ".", "info", "(", "\"%s is not in all_model_checkpoint_paths. Manually adding it.\"", ",", "model_checkpoint_path", ")", "all_model_checkpoint_paths", ".", "append", "(", "model_checkpoint_path", ")", "# Relative paths need to be rewritten to be relative to the \"save_dir\"", "# if model_checkpoint_path already contains \"save_dir\".", "if", "not", "os", ".", "path", ".", "isabs", "(", "save_dir", ")", ":", "if", "not", "os", ".", "path", ".", "isabs", "(", "model_checkpoint_path", ")", ":", "model_checkpoint_path", "=", "os", ".", "path", ".", "relpath", "(", "model_checkpoint_path", ",", "save_dir", ")", "for", "i", "in", "range", "(", "len", "(", "all_model_checkpoint_paths", ")", ")", ":", "p", "=", "all_model_checkpoint_paths", "[", "i", "]", "if", "not", "os", ".", "path", ".", "isabs", "(", "p", ")", ":", "all_model_checkpoint_paths", "[", "i", "]", "=", "os", ".", "path", ".", "relpath", "(", "p", ",", "save_dir", ")", "coord_checkpoint_proto", "=", "CheckpointState", "(", "model_checkpoint_path", "=", "model_checkpoint_path", ",", "all_model_checkpoint_paths", "=", "all_model_checkpoint_paths", ")", "return", "coord_checkpoint_proto" ]

[ "SetWasModified", "(", "self", "bool", "set", "=", "True", ")" ]

[ "def", "SetWasModified", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PGProperty_SetWasModified", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Weibull", "distribution", "." ]

[ "def", "weibullvariate", "(", "self", ",", "alpha", ",", "beta", ")", ":", "# Jain, pg. 499; bug fix courtesy Bill Arms", "u", "=", "1.0", "-", "self", ".", "random", "(", ")", "return", "alpha", "*", "(", "-", "_log", "(", "u", ")", ")", "**", "(", "1.0", "/", "beta", ")" ]

[ "Write", "out", "HTML", "documentation", "for", "all", "modules", "in", "a", "directory", "tree", "." ]

[ "def", "writedocs", "(", "dir", ",", "pkgpath", "=", "''", ",", "done", "=", "None", ")", ":", "if", "done", "is", "None", ":", "done", "=", "{", "}", "for", "importer", ",", "modname", ",", "ispkg", "in", "pkgutil", ".", "walk_packages", "(", "[", "dir", "]", ",", "pkgpath", ")", ":", "writedoc", "(", "modname", ")", "return" ]

[ "Manipulate", "the", "data", "(", "parsed", "JSON", ")", "based", "on", "changes", "in", "format", "." ]

[ "def", "_PerformUpgrade", "(", "self", ",", "data", ")", ":", "while", "data", "[", "\"version\"", "]", "<", "self", ".", "_new_version", ":", "self", ".", "_upgrade_dispatch", "[", "data", "[", "\"version\"", "]", "]", "(", "data", ")", "data", "[", "\"version\"", "]", "+=", "1" ]

[ "Automatically", "find", "/", "download", "setuptools", "and", "make", "it", "available", "on", "sys", ".", "path" ]

[ "def", "use_setuptools", "(", "version", "=", "DEFAULT_VERSION", ",", "download_base", "=", "DEFAULT_URL", ",", "to_dir", "=", "os", ".", "curdir", ",", "download_delay", "=", "15", ")", ":", "was_imported", "=", "'pkg_resources'", "in", "sys", ".", "modules", "or", "'setuptools'", "in", "sys", ".", "modules", "def", "do_download", "(", ")", ":", "egg", "=", "download_setuptools", "(", "version", ",", "download_base", ",", "to_dir", ",", "download_delay", ")", "sys", ".", "path", ".", "insert", "(", "0", ",", "egg", ")", "import", "setuptools", "setuptools", ".", "bootstrap_install_from", "=", "egg", "try", ":", "import", "pkg_resources", "except", "ImportError", ":", "return", "do_download", "(", ")", "try", ":", "pkg_resources", ".", "require", "(", "\"setuptools>=\"", "+", "version", ")", "return", "except", "pkg_resources", ".", "VersionConflict", ",", "e", ":", "if", "was_imported", ":", "print", ">>", "sys", ".", "stderr", ",", "(", "\"The required version of setuptools (>=%s) is not available, and\\n\"", "\"can't be installed while this script is running. Please install\\n\"", "\" a more recent version first, using 'easy_install -U setuptools'.\"", "\"\\n\\n(Currently using %r)\"", ")", "%", "(", "version", ",", "e", ".", "args", "[", "0", "]", ")", "sys", ".", "exit", "(", "2", ")", "except", "pkg_resources", ".", "DistributionNotFound", ":", "pass", "del", "pkg_resources", ",", "sys", ".", "modules", "[", "'pkg_resources'", "]", "# reload ok", "return", "do_download", "(", ")" ]

[ "Calculates", "false", "negatives", "for", "recall@k", "." ]

[ "def", "_sparse_false_negative_at_k", "(", "labels", ",", "predictions_idx", ",", "class_id", "=", "None", ",", "weights", "=", "None", ")", ":", "with", "ops", ".", "name_scope", "(", "None", ",", "'false_negatives'", ",", "(", "predictions_idx", ",", "labels", ",", "weights", ")", ")", ":", "labels", ",", "predictions_idx", "=", "_maybe_select_class_id", "(", "labels", ",", "predictions_idx", ",", "class_id", ")", "fn", "=", "sets", ".", "set_size", "(", "sets", ".", "set_difference", "(", "predictions_idx", ",", "labels", ",", "aminusb", "=", "False", ")", ")", "fn", "=", "math_ops", ".", "cast", "(", "fn", ",", "dtypes", ".", "float64", ")", "if", "weights", "is", "not", "None", ":", "with", "ops", ".", "control_dependencies", "(", "(", "weights_broadcast_ops", ".", "assert_broadcastable", "(", "weights", ",", "fn", ")", ",", ")", ")", ":", "weights", "=", "math_ops", ".", "cast", "(", "weights", ",", "dtypes", ".", "float64", ")", "fn", "=", "math_ops", ".", "multiply", "(", "fn", ",", "weights", ")", "return", "fn" ]

[ "Generates", "files", "required", "to", "perform", "JNI", "registration", "." ]

[ "def", "_Generate", "(", "java_file_paths", ",", "srcjar_path", ",", "proxy_opts", ",", "header_path", "=", "None", ",", "namespace", "=", "''", ")", ":", "# Without multiprocessing, script takes ~13 seconds for chrome_public_apk", "# on a z620. With multiprocessing, takes ~2 seconds.", "pool", "=", "multiprocessing", ".", "Pool", "(", ")", "results", "=", "[", "]", "for", "d", "in", "pool", ".", "imap_unordered", "(", "functools", ".", "partial", "(", "_DictForPath", ",", "use_proxy_hash", "=", "proxy_opts", ".", "use_hash", ")", ",", "java_file_paths", ")", ":", "if", "d", ":", "results", ".", "append", "(", "d", ")", "pool", ".", "close", "(", ")", "# Sort to make output deterministic.", "results", ".", "sort", "(", "key", "=", "lambda", "d", ":", "d", "[", "'FULL_CLASS_NAME'", "]", ")", "combined_dict", "=", "{", "}", "for", "key", "in", "MERGEABLE_KEYS", ":", "combined_dict", "[", "key", "]", "=", "''", ".", "join", "(", "d", ".", "get", "(", "key", ",", "''", ")", "for", "d", "in", "results", ")", "if", "header_path", ":", "combined_dict", "[", "'HEADER_GUARD'", "]", "=", "os", ".", "path", ".", "splitext", "(", "header_path", ")", "[", "0", "]", ".", "replace", "(", "'/'", ",", "'_'", ")", ".", "upper", "(", ")", "+", "'_'", "combined_dict", "[", "'NAMESPACE'", "]", "=", "namespace", "header_content", "=", "CreateFromDict", "(", "combined_dict", ",", "proxy_opts", ".", "use_hash", ")", "with", "build_utils", ".", "AtomicOutput", "(", "header_path", ",", "mode", "=", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "header_content", ")", "with", "build_utils", ".", "AtomicOutput", "(", "srcjar_path", ")", "as", "f", ":", "with", "zipfile", ".", "ZipFile", "(", "f", ",", "'w'", ")", "as", "srcjar", ":", "if", "proxy_opts", ".", "use_hash", ":", "# J/N.java", "build_utils", ".", "AddToZipHermetic", "(", "srcjar", ",", "'%s.java'", "%", "jni_generator", ".", "ProxyHelpers", ".", "GetQualifiedClass", "(", "True", ")", ",", "data", "=", "CreateProxyJavaFromDict", "(", "combined_dict", ",", "proxy_opts", ")", ")", "# org/chromium/base/natives/GEN_JNI.java", "build_utils", ".", "AddToZipHermetic", "(", "srcjar", ",", "'%s.java'", "%", "jni_generator", ".", "ProxyHelpers", ".", "GetQualifiedClass", "(", "False", ")", ",", "data", "=", "CreateProxyJavaFromDict", "(", "combined_dict", ",", "proxy_opts", ",", "forwarding", "=", "True", ")", ")", "else", ":", "# org/chromium/base/natives/GEN_JNI.java", "build_utils", ".", "AddToZipHermetic", "(", "srcjar", ",", "'%s.java'", "%", "jni_generator", ".", "ProxyHelpers", ".", "GetQualifiedClass", "(", "False", ")", ",", "data", "=", "CreateProxyJavaFromDict", "(", "combined_dict", ",", "proxy_opts", ")", ")" ]

[ "r", "Avoid", "extraneous", "whitespace", "around", "keywords", "." ]

[ "def", "whitespace_around_keywords", "(", "logical_line", ")", ":", "for", "match", "in", "KEYWORD_REGEX", ".", "finditer", "(", "logical_line", ")", ":", "before", ",", "after", "=", "match", ".", "groups", "(", ")", "if", "'\\t'", "in", "before", ":", "yield", "match", ".", "start", "(", "1", ")", ",", "\"E274 tab before keyword\"", "elif", "len", "(", "before", ")", ">", "1", ":", "yield", "match", ".", "start", "(", "1", ")", ",", "\"E272 multiple spaces before keyword\"", "if", "'\\t'", "in", "after", ":", "yield", "match", ".", "start", "(", "2", ")", ",", "\"E273 tab after keyword\"", "elif", "len", "(", "after", ")", ">", "1", ":", "yield", "match", ".", "start", "(", "2", ")", ",", "\"E271 multiple spaces after keyword\"" ]

[ "called", "when", "freecad", "imports", "a", "file", "This", "insert", "expects", "parse", "to", "return", "a", "list", "of", "strings", "each", "string", "will", "become", "a", "separate", "path" ]

[ "def", "insert", "(", "filename", ",", "docname", ")", ":", "gfile", "=", "pythonopen", "(", "filename", ")", "gcode", "=", "gfile", ".", "read", "(", ")", "gfile", ".", "close", "(", ")", "gcode", "=", "parse", "(", "gcode", ")", "doc", "=", "FreeCAD", ".", "getDocument", "(", "docname", ")", "for", "subpath", "in", "gcode", ":", "obj", "=", "doc", ".", "addObject", "(", "\"Path::Feature\"", ",", "\"Path\"", ")", "path", "=", "Path", ".", "Path", "(", "subpath", ")", "obj", ".", "Path", "=", "path" ]

[ "r", "Repeatedly", "runs", "the", "main", "hooks", "until", "all", "processes", "join", ";", "then", "runs", "the", "post", "-", "hooks", "." ]

[ "def", "__exit__", "(", "self", ",", "type", ":", "Optional", "[", "Type", "[", "BaseException", "]", "]", ",", "value", ":", "Optional", "[", "BaseException", "]", ",", "traceback", ":", "Optional", "[", "TracebackType", "]", ")", ":", "if", "not", "self", ".", "_enable", "or", "type", ":", "return", "# propagate the exception directly if one was raised", "all_procs_joined", "=", "False", "is_last_joiner", "=", "True", "i", "=", "0", "WARN_THRESHOLD", "=", "1000", "warnings", ".", "simplefilter", "(", "\"once\"", ")", "while", "not", "all_procs_joined", ":", "if", "i", ">", "WARN_THRESHOLD", ":", "warnings", ".", "warn", "(", "\"Detected uneven input skew of greater than \"", "f\"{WARN_THRESHOLD}. This means that rank \"", "f\"{self._rank} has at least {WARN_THRESHOLD} \"", "f\"fewer inputs than other currently-active ranks. \"", "\"This level of skew could lead to performance \"", "\"degradataion during training.\"", ")", "# Shadow the all-reduce in non-joined processes", "num_nonjoined_procs", "=", "self", ".", "_get_num_nonjoined_procs", "(", ")", "if", "num_nonjoined_procs", "==", "0", ":", "all_procs_joined", "=", "True", "else", ":", "if", "self", ".", "_throw_on_early_termination", ":", "self", ".", "_notify_procs_to_terminate", "(", ")", "# Run main hooks", "for", "join_hook", "in", "self", ".", "_join_hooks", ":", "join_hook", ".", "main_hook", "(", ")", "is_last_joiner", "=", "False", "i", "+=", "1", "# Run post-hooks", "for", "join_hook", "in", "self", ".", "_join_hooks", ":", "join_hook", ".", "post_hook", "(", "is_last_joiner", ")" ]

[ "Set", "a", "color", "palette", "from", "a", "given", "RGB", "list", "stops", "red", "green", "and", "blue", "should", "all", "be", "lists", "of", "the", "same", "length", "see", "set_decent_colors", "for", "an", "example" ]

[ "def", "set_palette", "(", "name", "=", "None", ",", "ncontours", "=", "999", ")", ":", "if", "name", "==", "\"halfgray\"", ":", "stops", "=", "[", "0.00", ",", "0.34", ",", "0.61", ",", "0.84", ",", "1.00", "]", "red", "=", "map", "(", "lambda", "x", ":", "1.", "-", "(", "1.", "-", "x", ")", "/", "2.", ",", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", ")", "green", "=", "map", "(", "lambda", "x", ":", "1.", "-", "(", "1.", "-", "x", ")", "/", "2.", ",", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", ")", "blue", "=", "map", "(", "lambda", "x", ":", "1.", "-", "(", "1.", "-", "x", ")", "/", "2.", ",", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", ")", "elif", "name", "==", "\"gray\"", ":", "stops", "=", "[", "0.00", ",", "0.34", ",", "0.61", ",", "0.84", ",", "1.00", "]", "red", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "green", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "blue", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "elif", "name", "==", "\"blues\"", ":", "stops", "=", "[", "0.00", ",", "0.34", ",", "0.61", ",", "0.84", ",", "1.00", "]", "red", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "green", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "blue", "=", "[", "1.00", ",", "1.00", ",", "1.00", ",", "1.00", ",", "1.00", "]", "elif", "name", "==", "\"reds\"", ":", "stops", "=", "[", "0.00", ",", "0.34", ",", "0.61", ",", "0.84", ",", "1.00", "]", "red", "=", "[", "1.00", ",", "1.00", ",", "1.00", ",", "1.00", ",", "1.00", "]", "green", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "blue", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "elif", "name", "==", "\"antigray\"", ":", "stops", "=", "[", "0.00", ",", "0.34", ",", "0.61", ",", "0.84", ",", "1.00", "]", "red", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "green", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "blue", "=", "[", "1.00", ",", "0.84", ",", "0.61", ",", "0.34", ",", "0.00", "]", "red", ".", "reverse", "(", ")", "green", ".", "reverse", "(", ")", "blue", ".", "reverse", "(", ")", "elif", "name", "==", "\"fire\"", ":", "stops", "=", "[", "0.00", ",", "0.20", ",", "0.80", ",", "1.00", "]", "red", "=", "[", "1.00", ",", "1.00", ",", "1.00", ",", "0.50", "]", "green", "=", "[", "1.00", ",", "1.00", ",", "0.00", ",", "0.00", "]", "blue", "=", "[", "0.20", ",", "0.00", ",", "0.00", ",", "0.00", "]", "elif", "name", "==", "\"antifire\"", ":", "stops", "=", "[", "0.00", ",", "0.20", ",", "0.80", ",", "1.00", "]", "red", "=", "[", "0.50", ",", "1.00", ",", "1.00", ",", "1.00", "]", "green", "=", "[", "0.00", ",", "0.00", ",", "1.00", ",", "1.00", "]", "blue", "=", "[", "0.00", ",", "0.00", ",", "0.00", ",", "0.20", "]", "else", ":", "# default palette, looks cool", "stops", "=", "[", "0.00", ",", "0.34", ",", "0.61", ",", "0.84", ",", "1.00", "]", "red", "=", "[", "0.00", ",", "0.00", ",", "0.87", ",", "1.00", ",", "0.51", "]", "green", "=", "[", "0.00", ",", "0.81", ",", "1.00", ",", "0.20", ",", "0.00", "]", "blue", "=", "[", "0.51", ",", "1.00", ",", "0.12", ",", "0.00", ",", "0.00", "]", "s", "=", "array", ".", "array", "(", "'d'", ",", "stops", ")", "r", "=", "array", ".", "array", "(", "'d'", ",", "red", ")", "g", "=", "array", ".", "array", "(", "'d'", ",", "green", ")", "b", "=", "array", ".", "array", "(", "'d'", ",", "blue", ")", "npoints", "=", "len", "(", "s", ")", "ROOT", ".", "TColor", ".", "CreateGradientColorTable", "(", "npoints", ",", "s", ",", "r", ",", "g", ",", "b", ",", "ncontours", ")", "ROOT", ".", "gStyle", ".", "SetNumberContours", "(", "ncontours", ")" ]

[ "Read", "a", ".", "plist", "file", ".", "pathOrFile", "may", "either", "be", "a", "file", "name", "or", "a", "(", "readable", ")", "file", "object", ".", "Return", "the", "unpacked", "root", "object", "(", "which", "usually", "is", "a", "dictionary", ")", "." ]

[ "def", "readPlist", "(", "pathOrFile", ")", ":", "didOpen", "=", "0", "if", "isinstance", "(", "pathOrFile", ",", "(", "str", ",", "unicode", ")", ")", ":", "pathOrFile", "=", "open", "(", "pathOrFile", ")", "didOpen", "=", "1", "p", "=", "PlistParser", "(", ")", "rootObject", "=", "p", ".", "parse", "(", "pathOrFile", ")", "if", "didOpen", ":", "pathOrFile", ".", "close", "(", ")", "return", "rootObject" ]

[ "Adds", "a", "child", "widget", "to", "the", "container", ".", "This", "makes", "the", "childs", "widgets", "visible", "state", "the", "same", "as", "the", "containers", ".", "i", ".", "e", ".", "if", "the", "containter", "is", "visible", "the", "child", "will", "be", "as", "well", "and", "if", "the", "container", "widget", "is", "hidden", "so", "will", "the", "child", ".", "The", "child", "however", "WILL", "be", "shown", "when", "you", "show", "the", "container", "widget", ".", "If", "you", "want", "the", "child", "to", "be", "hidden", "when", "you", "show", "the", "container", "widget", "you", "must", "call", "child", ".", "hide", "()", "." ]

[ "def", "addChild", "(", "self", ",", "widget", ")", ":", "widget", ".", "parent", "=", "self", "if", "widget", ".", "max_size", "[", "0", "]", ">", "self", ".", "max_size", "[", "0", "]", "or", "widget", ".", "max_size", "[", "1", "]", ">", "self", ".", "max_size", "[", "1", "]", ":", "widget", ".", "max_size", "=", "self", ".", "max_size", "self", ".", "children", ".", "append", "(", "widget", ")", "self", ".", "real_widget", ".", "add", "(", "widget", ".", "real_widget", ")", "# add all to the manager", "def", "_add", "(", "added_widget", ")", ":", "if", "not", "added_widget", ".", "_added", ":", "get_manager", "(", ")", ".", "addWidget", "(", "added_widget", ")", "if", "added_widget", ".", "_top_added", ":", "get_manager", "(", ")", ".", "removeTopWidget", "(", "added_widget", ")", "widget", ".", "deepApply", "(", "_add", ")" ]

[ "Mainly", "internally", "used", "by", "BatchMode", ".", "Provides", "the", "save", "settings", "." ]

[ "def", "set_save", "(", "save_algorithms", ",", "save_as_zero_error_free", ")", ":", "save_command", "=", "NParameterCommand", "(", "command_id", "=", "NParameterCommandId", ".", "SAVE", ",", "values", "=", "[", "save_algorithms", ",", "save_as_zero_error_free", "]", ")", "director", ".", "add_command", "(", "save_command", ")" ]

[ "readlines", "(", "self", "int", "sizehint", "=", "-", "1", ")", "-", ">", "PyObject" ]

[ "def", "readlines", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "InputStream_readlines", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "one_line", "checks", "if", "docstring", "(", "len", "<", "40", ")", "is", "on", "one", "line", ".", "Args", ":", "node", "(", "astroid", ".", "node", ")", ":", "The", "node", "visiting", ".", "Returns", ":", "True", "if", "successful", "otherwise", "False", "." ]

[ "def", "one_line", "(", "self", ",", "node", ")", ":", "doc", "=", "node", ".", "doc", "if", "doc", "is", "None", ":", "return", "True", "if", "len", "(", "doc", ")", ">", "40", ":", "return", "True", "elif", "sum", "(", "doc", ".", "find", "(", "nl", ")", "for", "nl", "in", "(", "'\\n'", ",", "'\\r'", ",", "'\\n\\r'", ")", ")", "==", "-", "3", ":", "return", "True", "else", ":", "self", ".", "add_message", "(", "'W9001'", ",", "node", "=", "node", ",", "line", "=", "node", ".", "fromlineno", ")", "return", "False", "return", "True" ]

[ "Calculate", "planet", "type", "randomly", "for", "a", "potential", "new", "planet", "." ]

[ "def", "calc_planet_type", "(", "star_type", ",", "orbit", ",", "planet_size", ")", ":", "# check specified planet size to determine if we want a planet at all", "if", "planet_size", "in", "planet_sizes", ":", "# if yes, determine planet type based on planet size...", "if", "planet_size", "==", "fo", ".", "planetSize", ".", "gasGiant", ":", "return", "fo", ".", "planetType", ".", "gasGiant", "elif", "planet_size", "==", "fo", ".", "planetSize", ".", "asteroids", ":", "return", "fo", ".", "planetType", ".", "asteroids", "else", ":", "return", "random", ".", "choice", "(", "planet_types_real", ")", "else", ":", "return", "fo", ".", "planetType", ".", "unknown" ]

[ "Initializes", "Command", "from", "names", "and", "helptext", "plus", "optional", "callables", "." ]

[ "def", "__init__", "(", "self", ",", "names", ",", "helptext", ",", "validator", "=", "None", ",", "impl", "=", "None", ")", ":", "self", ".", "names", "=", "names", "self", ".", "validator", "=", "validator", "self", ".", "helptext", "=", "helptext", "self", ".", "impl", "=", "impl", "self", ".", "args", "=", "[", "]", "self", ".", "required_groups", "=", "[", "]", "self", ".", "arg_dict", "=", "{", "}", "self", ".", "positional_args", "=", "[", "]", "self", ".", "cmdline", "=", "None" ]

[ "Sets", "the", "thumbnails", "popup", "menu", "when", "at", "least", "one", "thumbnail", "is", "selected", "." ]

[ "def", "SetPopupMenu", "(", "self", ",", "menu", ")", ":", "self", ".", "_pmenu", "=", "menu" ]

[ "Returns", "the", "dimensions", "of", "an", "image", "tensor", "." ]

[ "def", "_ImageDimensions", "(", "images", ",", "static_only", "=", "True", ")", ":", "# A simple abstraction to provide names for each dimension. This abstraction", "# should make it simpler to switch dimensions in the future (e.g. if we ever", "# want to switch height and width.)", "if", "static_only", "or", "images", ".", "get_shape", "(", ")", ".", "is_fully_defined", "(", ")", ":", "return", "images", ".", "get_shape", "(", ")", ".", "as_list", "(", ")", "else", ":", "return", "array_ops", ".", "unpack", "(", "array_ops", ".", "shape", "(", "images", ")", ")" ]

[ "Gets", "the", "payment", "instruction", "of", "a", "token", "." ]

[ "def", "get_payment_instruction", "(", "self", ",", "action", ",", "response", ",", "*", "*", "kw", ")", ":", "return", "self", ".", "get_object", "(", "action", ",", "kw", ",", "response", ")" ]

[ "This", "method", "is", "called", "whenever", "one", "of", "our", "config", "options", "is", "changed", "." ]

[ "def", "config_notify", "(", "self", ")", "->", "None", ":", "# This is some boilerplate that stores MODULE_OPTIONS in a class", "# member, so that, for instance, the 'emphatic' option is always", "# available as 'self.emphatic'.", "for", "opt", "in", "self", ".", "MODULE_OPTIONS", ":", "setattr", "(", "self", ",", "opt", "[", "'name'", "]", ",", "self", ".", "get_module_option", "(", "opt", "[", "'name'", "]", ")", ")", "self", ".", "log", ".", "debug", "(", "' mgr option %s = %s'", ",", "opt", "[", "'name'", "]", ",", "getattr", "(", "self", ",", "opt", "[", "'name'", "]", ")", ")", "# Do the same for the native options.", "for", "opt", "in", "self", ".", "NATIVE_OPTIONS", ":", "setattr", "(", "self", ",", "opt", ",", "self", ".", "get_ceph_option", "(", "opt", ")", ")", "self", ".", "log", ".", "debug", "(", "' native option %s = %s'", ",", "opt", ",", "getattr", "(", "self", ",", "opt", ")", ")" ]

[ "Look", "for", "the", "next", "sequence", "of", "bytes", "matching", "a", "given", "sequence", ".", "If", "a", "match", "is", "found", "advance", "the", "position", "to", "the", "last", "byte", "of", "the", "match" ]

[ "def", "jumpTo", "(", "self", ",", "bytes", ")", ":", "newPosition", "=", "self", "[", "self", ".", "position", ":", "]", ".", "find", "(", "bytes", ")", "if", "newPosition", ">", "-", "1", ":", "# XXX: This is ugly, but I can't see a nicer way to fix this.", "if", "self", ".", "_position", "==", "-", "1", ":", "self", ".", "_position", "=", "0", "self", ".", "_position", "+=", "(", "newPosition", "+", "len", "(", "bytes", ")", "-", "1", ")", "return", "True", "else", ":", "raise", "StopIteration" ]

[ "GetSplashStyle", "(", "self", ")", "-", ">", "long" ]

[ "def", "GetSplashStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "SplashScreen_GetSplashStyle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Initializes", "a", "plan", "with", "a", "given", "CSpace", "and", "a", "given", "type", ".", "Optionally", "planner", "options", "can", "be", "set", "via", "keyword", "arguments", ".", "Valid", "values", "for", "type", "are", ":" ]

[ "def", "__init__", "(", "self", ",", "space", ",", "type", "=", "None", ",", "*", "*", "options", ")", ":", "if", "space", ".", "cspace", "is", "None", ":", "space", ".", "setup", "(", ")", "if", "type", "!=", "None", ":", "motionplanning", ".", "setPlanType", "(", "type", ")", "if", "len", "(", "options", ")", ">", "0", ":", "MotionPlan", ".", "setOptions", "(", "*", "*", "options", ")", "self", ".", "space", "=", "space", "self", ".", "planOptions", "=", "motionplanning", ".", "getPlanJSONString", "(", ")", "self", ".", "planner", "=", "motionplanning", ".", "PlannerInterface", "(", "space", ".", "cspace", ")", "self", ".", "edgeCost", "=", "None", "self", ".", "terminalCost", "=", "None" ]

[ "Create", "a", "cell", "with", "an", "added", "input", "embedding", "." ]

[ "def", "__init__", "(", "self", ",", "cell", ",", "embedding_classes", ",", "embedding_size", ",", "initializer", "=", "None", ")", ":", "if", "not", "isinstance", "(", "cell", ",", "RNNCell", ")", ":", "raise", "TypeError", "(", "\"The parameter cell is not RNNCell.\"", ")", "if", "embedding_classes", "<=", "0", "or", "embedding_size", "<=", "0", ":", "raise", "ValueError", "(", "\"Both embedding_classes and embedding_size must be > 0: \"", "\"%d, %d.\"", "%", "(", "embedding_classes", ",", "embedding_size", ")", ")", "self", ".", "_cell", "=", "cell", "self", ".", "_embedding_classes", "=", "embedding_classes", "self", ".", "_embedding_size", "=", "embedding_size", "self", ".", "_initializer", "=", "initializer" ]

[ "r", "Initializes", "a", "qubit", "hilbert", "space", "." ]

[ "def", "__init__", "(", "self", ",", "N", ":", "int", "=", "1", ",", "graph", ":", "Optional", "[", "AbstractGraph", "]", "=", "None", ")", ":", "N", "=", "graph_to_N_depwarn", "(", "N", "=", "N", ",", "graph", "=", "graph", ")", "super", "(", ")", ".", "__init__", "(", "[", "0.0", ",", "1.0", "]", ",", "N", ")" ]

[ "helper", "method", "used", "to", "define", "all", "private", "dictionaries", "at", "once", "during", "__init__", "procedure" ]

[ "def", "_init_private_properties", "(", "self", ",", "prop_dict", ")", ":", "class_decor", "=", "'_'", "+", "type", "(", "self", ")", ".", "__name__", "+", "'__'", "for", "key", ",", "val", "in", "prop_dict", ".", "items", "(", ")", ":", "new_key", "=", "class_decor", "+", "key", "object", ".", "__setattr__", "(", "self", ",", "new_key", ",", "val", ")" ]

[ "Find", "the", "operation", "string", "if", "any", "to", "pass", "to", "numexpr", "for", "this", "operation", "." ]

[ "def", "_get_opstr", "(", "op", ",", "cls", ")", ":", "# numexpr is available for non-sparse classes", "subtyp", "=", "getattr", "(", "cls", ",", "'_subtyp'", ",", "''", ")", "use_numexpr", "=", "'sparse'", "not", "in", "subtyp", "if", "not", "use_numexpr", ":", "# if we're not using numexpr, then don't pass a str_rep", "return", "None", "return", "{", "operator", ".", "add", ":", "'+'", ",", "radd", ":", "'+'", ",", "operator", ".", "mul", ":", "'*'", ",", "rmul", ":", "'*'", ",", "operator", ".", "sub", ":", "'-'", ",", "rsub", ":", "'-'", ",", "operator", ".", "truediv", ":", "'/'", ",", "rtruediv", ":", "'/'", ",", "operator", ".", "floordiv", ":", "'//'", ",", "rfloordiv", ":", "'//'", ",", "operator", ".", "mod", ":", "None", ",", "# TODO: Why None for mod but '%' for rmod?", "rmod", ":", "'%'", ",", "operator", ".", "pow", ":", "'**'", ",", "rpow", ":", "'**'", ",", "operator", ".", "eq", ":", "'=='", ",", "operator", ".", "ne", ":", "'!='", ",", "operator", ".", "le", ":", "'<='", ",", "operator", ".", "lt", ":", "'<'", ",", "operator", ".", "ge", ":", "'>='", ",", "operator", ".", "gt", ":", "'>'", ",", "operator", ".", "and_", ":", "'&'", ",", "rand_", ":", "'&'", ",", "operator", ".", "or_", ":", "'|'", ",", "ror_", ":", "'|'", ",", "operator", ".", "xor", ":", "'^'", ",", "rxor", ":", "'^'", ",", "divmod", ":", "None", ",", "rdivmod", ":", "None", "}", "[", "op", "]" ]

[ "Reads", "all", "targets", "from", ".", "ninja_log", "file", "|log_file|", "sorted", "by", "duration", "." ]

[ "def", "ReadTargets", "(", "log", ",", "show_all", ")", ":", "header", "=", "log", ".", "readline", "(", ")", "assert", "header", "==", "'# ninja log v5\\n'", ",", "'unrecognized ninja log version %r'", "%", "header", "targets_dict", "=", "{", "}", "last_end_seen", "=", "0.0", "for", "line", "in", "log", ":", "parts", "=", "line", ".", "strip", "(", ")", ".", "split", "(", "'\\t'", ")", "if", "len", "(", "parts", ")", "!=", "5", ":", "# If ninja.exe is rudely halted then the .ninja_log file may be", "# corrupt. Silently continue.", "continue", "start", ",", "end", ",", "_", ",", "name", ",", "cmdhash", "=", "parts", "# Ignore restat.", "# Convert from integral milliseconds to float seconds.", "start", "=", "int", "(", "start", ")", "/", "1000.0", "end", "=", "int", "(", "end", ")", "/", "1000.0", "if", "not", "show_all", "and", "end", "<", "last_end_seen", ":", "# An earlier time stamp means that this step is the first in a new", "# build, possibly an incremental build. Throw away the previous", "# data so that this new build will be displayed independently.", "# This has to be done by comparing end times because records are", "# written to the .ninja_log file when commands complete, so end", "# times are guaranteed to be in order, but start times are not.", "targets_dict", "=", "{", "}", "target", "=", "None", "if", "cmdhash", "in", "targets_dict", ":", "target", "=", "targets_dict", "[", "cmdhash", "]", "if", "not", "show_all", "and", "(", "target", ".", "start", "!=", "start", "or", "target", ".", "end", "!=", "end", ")", ":", "# If several builds in a row just run one or two build steps then", "# the end times may not go backwards so the last build may not be", "# detected as such. However in many cases there will be a build step", "# repeated in the two builds and the changed start/stop points for", "# that command, identified by the hash, can be used to detect and", "# reset the target dictionary.", "targets_dict", "=", "{", "}", "target", "=", "None", "if", "not", "target", ":", "targets_dict", "[", "cmdhash", "]", "=", "target", "=", "Target", "(", "start", ",", "end", ")", "last_end_seen", "=", "end", "target", ".", "targets", ".", "append", "(", "name", ")", "return", "targets_dict", ".", "values", "(", ")" ]

[ "Process", "indentation", "spaces", "in", "a", "plain", "scalar", "." ]

[ "def", "parse_plain_scalar_indent", "(", "token_class", ")", ":", "def", "callback", "(", "lexer", ",", "match", ",", "context", ")", ":", "text", "=", "match", ".", "group", "(", ")", "if", "len", "(", "text", ")", "<=", "context", ".", "indent", ":", "context", ".", "stack", ".", "pop", "(", ")", "context", ".", "stack", ".", "pop", "(", ")", "return", "if", "text", ":", "yield", "match", ".", "start", "(", ")", ",", "token_class", ",", "text", "context", ".", "pos", "=", "match", ".", "end", "(", ")", "return", "callback" ]

[ "Override", "BaseHTTPServer", ".", "log_error", "." ]

[ "def", "log_error", "(", "self", ",", "*", "args", ")", ":", "# Despite the name, this method is for warnings than for errors.", "# For example, HTTP status code is logged by this method.", "self", ".", "_logger", ".", "warning", "(", "'%s - %s'", ",", "self", ".", "address_string", "(", ")", ",", "args", "[", "0", "]", "%", "args", "[", "1", ":", "]", ")" ]

[ "This", "advances", "the", "cursor", "with", "CRLF", "properties", ".", "The", "cursor", "will", "line", "wrap", "and", "the", "screen", "may", "scroll", "." ]

[ "def", "crlf", "(", "self", ")", ":", "self", ".", "cr", "(", ")", "self", ".", "lf", "(", ")" ]

[ "restore", "saved", "model", ".", "if", "multiprocessing", "on", "gpu", "enable", "dynamic", "memory", "allocation" ]

[ "def", "_restore_model", "(", "self", ")", ":", "tf", ".", "reset_default_graph", "(", ")", "if", "self", ".", "multiGPU", ":", "config", "=", "tf", ".", "ConfigProto", "(", ")", "config", ".", "gpu_options", ".", "allow_growth", "=", "True", "self", ".", "sess", "=", "tf", ".", "Session", "(", "config", "=", "config", ")", "else", ":", "self", ".", "sess", "=", "tf", ".", "Session", "(", ")", "# import graph from file, initialize variables, get variables and operations needed, initialize saver, restore checkpoint", "loader", "=", "tf", ".", "train", ".", "import_meta_graph", "(", "\"./savedmodel/\"", "+", "self", ".", "env_name", "+", "\"/Policy/trained_variables.ckpt.meta\"", ")", "self", ".", "sess", ".", "run", "(", "tf", ".", "global_variables_initializer", "(", ")", ")", "self", ".", "g", "=", "tf", ".", "get_default_graph", "(", ")", "self", ".", "obs_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'obs:0'", ")", "self", ".", "act_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'act:0'", ")", "self", ".", "means", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'means/BiasAdd:0'", ")", "self", ".", "log_vars", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'log_vars:0'", ")", "self", ".", "advantages_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'advantages:0'", ")", "self", ".", "beta_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'beta:0'", ")", "self", ".", "eta_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'eta:0'", ")", "self", ".", "lr_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'lr:0'", ")", "self", ".", "old_log_vars_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'old_log_vars:0'", ")", "self", ".", "old_means_ph", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'old_means:0'", ")", "self", ".", "sampled_act", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'sampledact:0'", ")", "self", ".", "loss", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'loss:0'", ")", "self", ".", "train_op", "=", "self", ".", "g", ".", "get_operation_by_name", "(", "'train_op'", ")", "self", ".", "entropy", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'entropy:0'", ")", "self", ".", "kl", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'kl:0'", ")", "self", ".", "logp", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'logp:0'", ")", "self", ".", "logp_old", "=", "self", ".", "g", ".", "get_tensor_by_name", "(", "'logp_old:0'", ")", "self", ".", "lr", "=", "9e-4", "/", "np", ".", "sqrt", "(", "int", "(", "np", ".", "sqrt", "(", "self", ".", "obs_dim", "*", "10", "*", "self", ".", "act_dim", "*", "10", ")", ")", ")", "self", ".", "saver", "=", "tf", ".", "train", ".", "Saver", "(", ")", "loader", ".", "restore", "(", "self", ".", "sess", ",", "tf", ".", "train", ".", "latest_checkpoint", "(", "\"./savedmodel/\"", "+", "self", ".", "env_name", "+", "\"/Policy\"", ")", ")" ]

[ "Computes", "bandwidth", "averaged", "over", "several", "consecutive", "packets", "." ]

[ "def", "ComputeBandwidth", "(", "self", ")", ":", "start_ms", "=", "self", ".", "data_points", "[", "0", "]", ".", "real_send_time_ms", "stop_ms", "=", "self", ".", "data_points", "[", "-", "1", "]", ".", "real_send_time_ms", "(", "self", ".", "bandwidth_kbps", ",", "_", ")", "=", "numpy", ".", "histogram", "(", "[", "point", ".", "real_send_time_ms", "for", "point", "in", "self", ".", "data_points", "]", ",", "bins", "=", "numpy", ".", "arange", "(", "start_ms", ",", "stop_ms", ",", "RTPStatistics", ".", "PLOT_RESOLUTION_MS", ")", ",", "weights", "=", "[", "point", ".", "size", "*", "8", "/", "RTPStatistics", ".", "PLOT_RESOLUTION_MS", "for", "point", "in", "self", ".", "data_points", "]", ")", "correlate_filter", "=", "(", "numpy", ".", "ones", "(", "RTPStatistics", ".", "BANDWIDTH_SMOOTHING_WINDOW_SIZE", ")", "/", "RTPStatistics", ".", "BANDWIDTH_SMOOTHING_WINDOW_SIZE", ")", "self", ".", "smooth_bw_kbps", "=", "numpy", ".", "correlate", "(", "self", ".", "bandwidth_kbps", ",", "correlate_filter", ")" ]

[ "r", "Compare", "the", "weights", "of", "the", "float", "module", "with", "its", "corresponding", "quantized", "module", ".", "Return", "a", "dict", "with", "key", "corresponding", "to", "module", "names", "and", "each", "entry", "being", "a", "dictionary", "with", "two", "keys", "float", "and", "quantized", "containing", "the", "float", "and", "quantized", "weights", ".", "This", "dict", "can", "be", "used", "to", "compare", "and", "compute", "the", "quantization", "error", "of", "the", "weights", "of", "float", "and", "quantized", "models", "." ]

[ "def", "compare_weights", "(", "float_dict", ":", "Dict", "[", "str", ",", "Any", "]", ",", "quantized_dict", ":", "Dict", "[", "str", ",", "Any", "]", ")", "->", "Dict", "[", "str", ",", "Dict", "[", "str", ",", "torch", ".", "Tensor", "]", "]", ":", "torch", ".", "_C", ".", "_log_api_usage_once", "(", "\"quantization_api._numeric_suite.compare_weights\"", ")", "weight_dict", ":", "Dict", "[", "str", ",", "Dict", "]", "=", "{", "}", "for", "key", "in", "quantized_dict", ":", "match_key", "=", "_find_match", "(", "float_dict", ",", "key", ",", "\"weight\"", ")", "if", "match_key", "is", "not", "None", ":", "weight_dict", "[", "key", "]", "=", "{", "}", "weight_dict", "[", "key", "]", "[", "\"float\"", "]", "=", "float_dict", "[", "match_key", "]", "weight_dict", "[", "key", "]", "[", "\"quantized\"", "]", "=", "quantized_dict", "[", "key", "]", "continue", "# For matching \"fc.weight\" and \"fc._packed_params._packed_params\"", "match_key", "=", "_find_match", "(", "float_dict", ",", "key", ",", "\"_packed_params\"", ")", "if", "match_key", "is", "not", "None", ":", "weight_dict", "[", "key", "]", "=", "{", "}", "weight_dict", "[", "key", "]", "[", "\"float\"", "]", "=", "float_dict", "[", "match_key", "]", "weight_dict", "[", "key", "]", "[", "\"quantized\"", "]", "=", "quantized_dict", "[", "key", "]", "[", "0", "]", "# For LSTM", "split_str", "=", "key", ".", "split", "(", "\".\"", ")", "if", "split_str", "[", "-", "1", "]", "==", "\"param\"", "and", "split_str", "[", "-", "3", "]", "==", "\"_all_weight_values\"", ":", "layer", "=", "split_str", "[", "-", "2", "]", "module_name", "=", "\".\"", ".", "join", "(", "split_str", "[", ":", "-", "3", "]", ")", "float_weight_ih_key", "=", "module_name", "+", "\".weight_ih_l\"", "+", "layer", "float_weight_hh_key", "=", "module_name", "+", "\".weight_hh_l\"", "+", "layer", "if", "float_weight_ih_key", "in", "float_dict", "and", "float_weight_hh_key", "in", "float_dict", ":", "weight_dict", "[", "key", "]", "=", "{", "}", "weight_dict", "[", "key", "]", "[", "\"float\"", "]", "=", "float_dict", "[", "float_weight_ih_key", "]", "weight_dict", "[", "key", "]", "[", "\"quantized\"", "]", "=", "(", "quantized_dict", "[", "key", "]", ".", "__getstate__", "(", ")", "[", "0", "]", "[", "4", "]", "[", "0", "]", ".", "__getstate__", "(", ")", "[", "0", "]", "[", "0", "]", ")", "weight_dict", "[", "key", "]", "[", "\"float\"", "]", "=", "float_dict", "[", "float_weight_hh_key", "]", "weight_dict", "[", "key", "]", "[", "\"quantized\"", "]", "=", "(", "quantized_dict", "[", "key", "]", ".", "__getstate__", "(", ")", "[", "0", "]", "[", "4", "]", "[", "1", "]", ".", "__getstate__", "(", ")", "[", "0", "]", "[", "0", "]", ")", "return", "weight_dict" ]

[ "Returns", "the", "PATH", "variable", "modified", "to", "remove", "the", "path", "to", "this", "program", "." ]

[ "def", "path_without_wrapper", "(", ")", ":", "scriptdir", "=", "get_main_dir", "(", ")", "path", "=", "os", ".", "environ", "[", "'PATH'", "]", "return", "remove_dir_from_path", "(", "path", ",", "scriptdir", ")" ]

[ "GetSelectionBackgroundColour", "(", "self", ")", "-", ">", "Colour" ]

[ "def", "GetSelectionBackgroundColour", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_propgrid", ".", "PropertyGrid_GetSelectionBackgroundColour", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Make", "integer", "x", "into", "an", "IDA", "-", "styled", "offset", "string" ]

[ "def", "MakeOffset", "(", "x", ",", "sign", "=", "True", ")", ":", "if", "sign", "and", "x", "==", "0", ":", "return", "\"\"", "hexstr", "=", "\"%X\"", "%", "x", "if", "hexstr", "[", "0", "]", "in", "(", "'A'", ",", "'B'", ",", "'C'", ",", "'D'", ",", "'E'", ",", "'F'", ")", ":", "hexstr", "=", "'0'", "+", "hexstr", "if", "x", ">", "9", ":", "hexstr", "+=", "'h'", "if", "sign", "and", "x", ">=", "0", ":", "return", "\"+%s\"", "%", "hexstr", "return", "hexstr" ]

[ "Start", "of", "Backup", "Job", ".", "Called", "just", "before", "backup", "job", "really", "start", ".", "Overload", "this", "to", "arrange", "whatever", "you", "have", "to", "do", "at", "this", "time", "." ]

[ "def", "start_backup_job", "(", "self", ")", ":", "return", "bRC_OK" ]

[ "Add", "Builders", "and", "construction", "variables", "for", "gcc", "to", "an", "Environment", "." ]

[ "def", "generate", "(", "env", ")", ":", "cc", ".", "generate", "(", "env", ")", "env", "[", "'CXX'", "]", "=", "'CC'", "env", "[", "'SHOBJSUFFIX'", "]", "=", "'.o'", "env", "[", "'STATIC_AND_SHARED_OBJECTS_ARE_THE_SAME'", "]", "=", "1" ]