Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Run", "a", "Ready", "Print", "Operation" ]

[ "def", "run_print_operation", "(", "self", ",", "print_operation", ",", "parent", ")", ":", "if", "self", ".", "pdf_filepath", ":", "print_operation", ".", "set_export_filename", "(", "self", ".", "pdf_filepath", ")", "print_operation_action", "=", "gtk", ".", "PRINT_OPERATION_ACTION_EXPORT", "if", "self", ".", "pdf_filepath", "else", "gtk", ".", "PRINT_OPERATION_ACTION_PRINT_DIALOG", "try", ":", "res", "=", "print_operation", ".", "run", "(", "print_operation_action", ",", "parent", ")", "except", "gobject", ".", "GError", ",", "ex", ":", "support", ".", "dialog_error", "(", "\"Error printing file:\\n%s (exception caught)\"", "%", "str", "(", "ex", ")", ",", "parent", ")", "else", ":", "if", "res", "==", "gtk", ".", "PRINT_OPERATION_RESULT_ERROR", ":", "support", ".", "dialog_error", "(", "\"Error printing file (bad res)\"", ",", "parent", ")", "elif", "res", "==", "gtk", ".", "PRINT_OPERATION_RESULT_APPLY", ":", "self", ".", "settings", "=", "print_operation", ".", "get_print_settings", "(", ")", "if", "not", "print_operation", ".", "is_finished", "(", ")", ":", "print_operation", ".", "connect", "(", "\"status_changed\"", ",", "self", ".", "on_print_status_changed", ")" ]

[ "Reconstruct", "the", "array", "from", "the", "meta", "-", "information", "and", "the", "z", "-", "file", "." ]

[ "def", "read", "(", "self", ",", "unpickler", ")", ":", "# Here we a simply reproducing the unpickling mechanism for numpy", "# arrays", "filename", "=", "os", ".", "path", ".", "join", "(", "unpickler", ".", "_dirname", ",", "self", ".", "filename", ")", "array", "=", "unpickler", ".", "np", ".", "core", ".", "multiarray", ".", "_reconstruct", "(", "*", "self", ".", "init_args", ")", "with", "open", "(", "filename", ",", "'rb'", ")", "as", "f", ":", "data", "=", "read_zfile", "(", "f", ")", "state", "=", "self", ".", "state", "+", "(", "data", ",", ")", "array", ".", "__setstate__", "(", "state", ")", "return", "array" ]

[ "Construct", "a", "Condition", "." ]

[ "def", "__init__", "(", "self", ",", "file_name", ",", "line", ",", "column", ")", ":", "# type: (str, int, int) -> None", "self", ".", "expr", "=", "None", "# type: str", "self", ".", "constexpr", "=", "None", "# type: str", "self", ".", "preprocessor", "=", "None", "# type: str", "super", "(", "Condition", ",", "self", ")", ".", "__init__", "(", "file_name", ",", "line", ",", "column", ")" ]

[ "Copy", "source", "location", "(", "lineno", "and", "col_offset", "attributes", ")", "from", "*", "old_node", "*", "to", "*", "new_node", "*", "if", "possible", "and", "return", "*", "new_node", "*", "." ]

[ "def", "copy_location", "(", "new_node", ",", "old_node", ")", ":", "for", "attr", "in", "'lineno'", ",", "'col_offset'", ":", "if", "attr", "in", "old_node", ".", "_attributes", "and", "attr", "in", "new_node", ".", "_attributes", "and", "hasattr", "(", "old_node", ",", "attr", ")", ":", "setattr", "(", "new_node", ",", "attr", ",", "getattr", "(", "old_node", ",", "attr", ")", ")", "return", "new_node" ]

[ "SetInitSize", "(", "self", "int", "x", "int", "y", ")" ]

[ "def", "SetInitSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "SizerItem_SetInitSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "\\", "Incremental", "encode", "keep", "track", "of", "digits", "and", "emit", "a", "byte", "when", "a", "pair", "of", "hex", "digits", "is", "found", ".", "The", "space", "is", "optional", "unless", "the", "error", "handling", "is", "defined", "to", "be", "strict", "." ]

[ "def", "encode", "(", "self", ",", "data", ",", "final", "=", "False", ")", ":", "state", "=", "self", ".", "state", "encoded", "=", "[", "]", "for", "c", "in", "data", ".", "upper", "(", ")", ":", "if", "c", "in", "HEXDIGITS", ":", "z", "=", "HEXDIGITS", ".", "index", "(", "c", ")", "if", "state", ":", "encoded", ".", "append", "(", "z", "+", "(", "state", "&", "0xf0", ")", ")", "state", "=", "0", "else", ":", "state", "=", "0x100", "+", "(", "z", "<<", "4", ")", "elif", "c", "==", "' '", ":", "# allow spaces to separate values", "if", "state", "and", "self", ".", "errors", "==", "'strict'", ":", "raise", "UnicodeError", "(", "'odd number of hex digits'", ")", "state", "=", "0", "else", ":", "if", "self", ".", "errors", "==", "'strict'", ":", "raise", "UnicodeError", "(", "'non-hex digit found: {!r}'", ".", "format", "(", "c", ")", ")", "self", ".", "state", "=", "state", "return", "serial", ".", "to_bytes", "(", "encoded", ")" ]

[ ":", "param", "str", "filename", ":", "the", "name", "of", "file", "to", "load", "score", "tracker", "from", "binary", "format" ]

[ "def", "import_score_tracker", "(", "self", ",", "filename", ")", ":", "args", "=", "messages", ".", "ImportScoreTrackerArgs", "(", "file_name", "=", "filename", ")", "result", "=", "self", ".", "_lib", ".", "ArtmImportScoreTracker", "(", "self", ".", "master_id", ",", "args", ")" ]

[ "A", "higher", "-", "level", "interface", "to", "getfirstmatchingheader", "()", "." ]

[ "def", "getrawheader", "(", "self", ",", "name", ")", ":", "lst", "=", "self", ".", "getfirstmatchingheader", "(", "name", ")", "if", "not", "lst", ":", "return", "None", "lst", "[", "0", "]", "=", "lst", "[", "0", "]", "[", "len", "(", "name", ")", "+", "1", ":", "]", "return", "''", ".", "join", "(", "lst", ")" ]

[ "Cleanup", "handles", "when", "find", "/", "replace", "dialog", "is", "closed" ]

[ "def", "OnFindClose", "(", "self", ",", "event", ")", ":", "if", "self", ".", "_findDialog", "!=", "None", ":", "self", ".", "_findDialog", "=", "None", "elif", "self", ".", "_replaceDialog", "!=", "None", ":", "self", ".", "_replaceDialog", "=", "None" ]

[ "Return", "the", "line", "number", "(", "0", "based", ")", "of", "the", "input", "document", "that", "corresponds", "with", "the", "first", "visible", "line", "." ]

[ "def", "first_visible_line", "(", "self", ",", "after_scroll_offset", ":", "bool", "=", "False", ")", "->", "int", ":", "if", "after_scroll_offset", ":", "return", "self", ".", "displayed_lines", "[", "self", ".", "applied_scroll_offsets", ".", "top", "]", "else", ":", "return", "self", ".", "displayed_lines", "[", "0", "]" ]

[ "Serialize", "data", "and", "metadata", "associated", "with", "device", "memory", "." ]

[ "def", "device_serialize", "(", "self", ")", ":", "header", ",", "frames", "=", "self", ".", "serialize", "(", ")", "assert", "all", "(", "(", "type", "(", "f", ")", "in", "[", "cudf", ".", "core", ".", "buffer", ".", "Buffer", ",", "memoryview", "]", ")", "for", "f", "in", "frames", ")", "header", "[", "\"type-serialized\"", "]", "=", "pickle", ".", "dumps", "(", "type", "(", "self", ")", ")", "header", "[", "\"is-cuda\"", "]", "=", "[", "hasattr", "(", "f", ",", "\"__cuda_array_interface__\"", ")", "for", "f", "in", "frames", "]", "header", "[", "\"lengths\"", "]", "=", "[", "f", ".", "nbytes", "for", "f", "in", "frames", "]", "return", "header", ",", "frames" ]

[ "Constructor", "." ]

[ "def", "__new__", "(", "cls", ",", "*", "args", ",", "*", "*", "kwds", ")", ":", "if", "(", "len", "(", "args", ")", "==", "3", "and", "isinstance", "(", "args", "[", "0", "]", ",", "str", ")", "and", "isinstance", "(", "args", "[", "1", "]", ",", "tuple", ")", ")", ":", "# Close enough.", "raise", "TypeError", "(", "f\"Cannot subclass {cls!r}\"", ")", "return", "super", "(", ")", ".", "__new__", "(", "cls", ")" ]

[ "Get", "the", "first", "header", "line", "matching", "name", "." ]

[ "def", "getfirstmatchingheader", "(", "self", ",", "name", ")", ":", "name", "=", "name", ".", "lower", "(", ")", "+", "':'", "n", "=", "len", "(", "name", ")", "lst", "=", "[", "]", "hit", "=", "0", "for", "line", "in", "self", ".", "headers", ":", "if", "hit", ":", "if", "not", "line", "[", ":", "1", "]", ".", "isspace", "(", ")", ":", "break", "elif", "line", "[", ":", "n", "]", ".", "lower", "(", ")", "==", "name", ":", "hit", "=", "1", "if", "hit", ":", "lst", ".", "append", "(", "line", ")", "return", "lst" ]

[ "Cleans", "up", "resources", "after", "a", "Run", "call", ".", "Not", "needed", "for", "Simulate", "." ]

[ "def", "Cleanup", "(", ")", ":", "sr", "(", "'Cleanup'", ")" ]

[ "CreateControlBar", "(", "self", ")" ]

[ "def", "CreateControlBar", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "PreviewFrame_CreateControlBar", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "The", "Glorot", "normal", "initializer", "also", "called", "Xavier", "normal", "initializer", "." ]

[ "def", "glorot_normal_initializer", "(", "seed", "=", "None", ",", "dtype", "=", "dtypes", ".", "float32", ")", ":", "return", "variance_scaling_initializer", "(", "scale", "=", "1.0", ",", "mode", "=", "\"fan_avg\"", ",", "distribution", "=", "\"normal\"", ",", "seed", "=", "seed", ",", "dtype", "=", "dtype", ")" ]

[ "Load", "the", "indexes", "listed", "in", "this", "dataset", "s", "image", "set", "file", "." ]

[ "def", "_load_image_set_index", "(", "self", ")", ":", "# Example path to image set file:", "# self._devkit_path + /VOCdevkit2007/VOC2007/ImageSets/Main/val.txt", "image_set_file", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_data_path", ",", "'ImageSets'", ",", "'Main'", ",", "self", ".", "_image_set", "+", "'.txt'", ")", "assert", "os", ".", "path", ".", "exists", "(", "image_set_file", ")", ",", "'Path does not exist: {}'", ".", "format", "(", "image_set_file", ")", "with", "open", "(", "image_set_file", ")", "as", "f", ":", "image_index", "=", "[", "x", ".", "strip", "(", ")", "for", "x", "in", "f", ".", "readlines", "(", ")", "]", "return", "image_index" ]

[ "File", "base", "name", "-", "text", "after", "the", "final", "slash", "before", "the", "final", "period", "." ]

[ "def", "BaseName", "(", "self", ")", ":", "return", "self", ".", "Split", "(", ")", "[", "1", "]" ]

[ "Load", "data", "and", "go", "through", "each", "file", "to", "determine", "how", "many", "points", "will", "have", "to", "be", "dealt", "with", "." ]

[ "def", "_load_data", "(", "self", ")", ":", "# Load the empty run", "empty_run", "=", "self", ".", "getProperty", "(", "\"EmptyRun\"", ")", ".", "value", "Load", "(", "Filename", "=", "'USANS_%s'", "%", "empty_run", ",", "LoadMonitors", "=", "True", ",", "OutputWorkspace", "=", "'__empty'", ")", "# A simple Load doesn't load the instrument properties correctly with our test file", "# Reload the instrument for now", "LoadInstrument", "(", "Workspace", "=", "'__empty'", ",", "InstrumentName", "=", "'USANS'", ",", "RewriteSpectraMap", "=", "False", ")", "# For testing, we may have to load the monitors by hand", "if", "not", "mtd", ".", "doesExist", "(", "'__empty_monitors'", ")", ":", "Load", "(", "Filename", "=", "self", ".", "_find_monitors", "(", "empty_run", ")", ",", "OutputWorkspace", "=", "'__empty_monitors'", ")", "# Get the wavelength peak positions", "wl_cfg_str", "=", "mtd", "[", "'__empty'", "]", ".", "getInstrument", "(", ")", ".", "getStringParameter", "(", "\"wavelength_config\"", ")", "[", "0", "]", "self", ".", "wl_list", "=", "json", ".", "loads", "(", "wl_cfg_str", ")", "# Get the runs to reduce", "run_list", "=", "self", ".", "getProperty", "(", "\"RunNumbers\"", ")", ".", "value", "# Total number of measurements per wavelength peak", "total_points", "=", "0", "# Load all files so we can determine how many points we have", "self", ".", "data_files", "=", "[", "]", "for", "item", "in", "run_list", ":", "ws_name", "=", "'__sample_%s'", "%", "item", "Load", "(", "Filename", "=", "'USANS_%s'", "%", "item", ",", "LoadMonitors", "=", "True", ",", "OutputWorkspace", "=", "ws_name", ")", "# For testing, we may have to load the monitors by hand", "if", "not", "mtd", ".", "doesExist", "(", "ws_name", "+", "'_monitors'", ")", ":", "Load", "(", "Filename", "=", "self", ".", "_find_monitors", "(", "empty_run", ")", ",", "OutputWorkspace", "=", "ws_name", "+", "'_monitors'", ")", "# Determine whether we are putting together multiple files or whether", "# we will be looking for scan_index markers.", "is_scan", "=", "False", "max_index", "=", "1", "if", "mtd", "[", "ws_name", "]", ".", "getRun", "(", ")", ".", "hasProperty", "(", "'scan_index'", ")", ":", "scan_index", "=", "mtd", "[", "ws_name", "]", ".", "getRun", "(", ")", ".", "getProperty", "(", "\"scan_index\"", ")", ".", "value", "if", "len", "(", "scan_index", ")", ">", "0", ":", "_max_index", "=", "scan_index", ".", "getStatistics", "(", ")", ".", "maximum", "if", "_max_index", ">", "0", ":", "max_index", "=", "_max_index", "is_scan", "=", "True", "# Append the info for when we do the reduction", "self", ".", "data_files", ".", "append", "(", "self", ".", "DataFile", "(", "workspace", "=", "ws_name", ",", "monitor", "=", "ws_name", "+", "'_monitors'", ",", "empty", "=", "'__empty'", ",", "empty_monitor", "=", "'__empty_monitors'", ",", "is_scan", "=", "is_scan", ",", "max_index", "=", "max_index", ")", ")", "total_points", "+=", "max_index", "return", "total_points" ]

[ "Fixes", "files", "used", "as", "input", "when", "pre", "-", "processing", "MPL", "-", "containers", "in", "their", "numbered", "form", "." ]

[ "def", "fix_input_files_for_numbered_seq", "(", "sourceDir", ",", "suffix", ",", "timestamp", ",", "containers", ")", ":", "# Fix input files for each MPL-container type.", "for", "container", "in", "containers", ":", "files", "=", "glob", ".", "glob", "(", "os", ".", "path", ".", "join", "(", "sourceDir", ",", "container", ",", "container", "+", "'*'", "+", "suffix", ")", ")", "for", "currentFile", "in", "sorted", "(", "files", ")", ":", "fix_header_comment", "(", "currentFile", ",", "timestamp", ")" ]

[ "SetTriple", "(", "self", "str", "triple", ")" ]

[ "def", "SetTriple", "(", "self", ",", "*", "args", ")", ":", "return", "_lldb", ".", "SBModuleSpec_SetTriple", "(", "self", ",", "*", "args", ")" ]

[ "Given", "a", "list", "of", "regions", "(", "returned", "by", "a", "call", "to", "get_regions", ")", "remove", "any", "overlapping", "bounding", "boxes", "for", "the", "same", "object", "." ]

[ "def", "non_max_suppression", "(", "regions", ",", "overlap_threshold", ",", "categories", ")", ":", "if", "not", "regions", ":", "# If list of regions is empty, return an empty list", "return", "[", "]", "final_regions", "=", "[", "]", "for", "c", "in", "categories", ":", "# Only look at regions that have found the same object", "filtered_regions", "=", "[", "region", "for", "region", "in", "regions", "if", "region", ".", "category", "==", "c", "]", "if", "len", "(", "filtered_regions", ")", "<", "2", ":", "continue", "# Get all the boxes that represent the object in question", "boxes", "=", "np", ".", "array", "(", "[", "region", ".", "location", "for", "region", "in", "filtered_regions", "]", ")", "# Calculate the areas once", "areas", "=", "boxes", "[", ":", ",", "2", "]", "*", "boxes", "[", ":", ",", "3", "]", "# `argsort` returns the indices in ascending order", "# We want the regions with the highest probability to be considered", "# the \"main\" regions", "sorted_indices", "=", "np", ".", "argsort", "(", "[", "r", ".", "probability", "for", "r", "in", "filtered_regions", "]", ")", "pick", "=", "[", "]", "while", "len", "(", "sorted_indices", ")", ":", "last", "=", "len", "(", "sorted_indices", ")", "-", "1", "i", "=", "sorted_indices", "[", "last", "]", "pick", ".", "append", "(", "i", ")", "suppress", "=", "[", "last", "]", "for", "pos", "in", "range", "(", "last", ")", ":", "j", "=", "sorted_indices", "[", "pos", "]", "intersection", "=", "filtered_regions", "[", "i", "]", ".", "intersect", "(", "filtered_regions", "[", "j", "]", ")", "overlap_width", "=", "intersection", "[", "2", "]", "overlap_height", "=", "intersection", "[", "3", "]", "# If either `overlap_width` or `overlap_height` are `<= 0`", "# then that means there's no overlap", "if", "overlap_width", ">", "0", "and", "overlap_height", ">", "0", ":", "overlap1", "=", "overlap_width", "*", "overlap_height", "/", "areas", "[", "j", "]", "overlap2", "=", "overlap_width", "*", "overlap_height", "/", "areas", "[", "i", "]", "# If there's enough overlap, we want to remove this box", "if", "overlap1", ">", "overlap_threshold", "and", "overlap2", ">", "overlap_threshold", ":", "suppress", ".", "append", "(", "pos", ")", "# Remove all the values that are at the list of indices of", "# `suppress` and return the resultant array", "sorted_indices", "=", "np", ".", "delete", "(", "sorted_indices", ",", "suppress", ")", "# Append to `final_regions` the main bounding boxes", "final_regions", "+=", "[", "filtered_regions", "[", "i", "]", "for", "i", "in", "pick", "]", "return", "final_regions" ]

[ "DrawEllipse", "(", "self", "Double", "x", "Double", "y", "Double", "w", "Double", "h", ")" ]

[ "def", "DrawEllipse", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "GraphicsContext_DrawEllipse", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "types", "of", "properties", "supported", "." ]

[ "def", "Types", "(", ")", ":", "return", "[", "t", "for", "t", "in", "_EditorFactory", "]" ]

[ "Provide", "custom", "logic", "for", "mocking", "classes", "that", "are", "callable", "." ]

[ "def", "__call__", "(", "self", ",", "*", "params", ",", "*", "*", "named_params", ")", ":", "# Verify the class we are mocking is callable", "callable", "=", "self", ".", "_class_to_mock", ".", "__dict__", ".", "get", "(", "'__call__'", ",", "None", ")", "if", "callable", "is", "None", ":", "raise", "TypeError", "(", "'Not callable'", ")", "# Because the call is happening directly on this object instead of a method,", "# the call on the mock method is made right here", "mock_method", "=", "self", ".", "_CreateMockMethod", "(", "'__call__'", ")", "return", "mock_method", "(", "*", "params", ",", "*", "*", "named_params", ")" ]

[ "Get", "recipient", "of", "the", "given", "node", "s", "output", "according", "to", "partition", "graphs", "." ]

[ "def", "node_recipients", "(", "self", ",", "node_name", ",", "is_control", "=", "False", ",", "device_name", "=", "None", ")", ":", "if", "not", "self", ".", "_debug_graphs", ":", "raise", "LookupError", "(", "\"Node recipients are not loaded from partition graphs yet.\"", ")", "device_name", "=", "self", ".", "_infer_device_name", "(", "device_name", ",", "node_name", ")", "debug_graph", "=", "self", ".", "_debug_graphs", "[", "device_name", "]", "if", "is_control", ":", "return", "debug_graph", ".", "node_ctrl_recipients", "[", "node_name", "]", "else", ":", "return", "debug_graph", ".", "node_recipients", "[", "node_name", "]" ]

[ "Cancels", "the", "Search", "Query", "@param", "evt", ":", "SearchCtrl", "event" ]

[ "def", "OnCancel", "(", "self", ",", "evt", ")", ":", "self", ".", "SetValue", "(", "u\"\"", ")", "self", ".", "ShowCancelButton", "(", "False", ")", "evt", ".", "Skip", "(", ")" ]

[ "Args", ":", "topics", ":", "A", "tf", ".", "string", "tensor", "containing", "topic", "names", "in", "[", "topic", "]", "format", ".", "For", "example", ":", "[", "topic1", "]", "group_id", ":", "The", "id", "of", "the", "consumer", "group", ".", "For", "example", ":", "cgstream", "servers", ":", "An", "optional", "list", "of", "bootstrap", "servers", ".", "For", "example", ":", "localhost", ":", "9092", ".", "stream_timeout", ":", "An", "optional", "timeout", "value", "(", "in", "milliseconds", ")", "to", "wait", "for", "the", "new", "messages", "from", "kafka", "to", "be", "retrieved", "by", "the", "consumers", ".", "By", "default", "it", "is", "set", "to", "-", "1", "to", "block", "indefinitely", ".", "message_poll_timeout", ":", "An", "optional", "timeout", "duration", "(", "in", "milliseconds", ")", "after", "which", "the", "kafka", "consumer", "throws", "a", "timeout", "error", "while", "fetching", "a", "single", "message", ".", "This", "value", "also", "represents", "the", "intervals", "at", "which", "the", "kafka", "topic", "(", "s", ")", "are", "polled", "for", "new", "messages", "while", "using", "the", "stream_timeout", ".", "configuration", ":", "An", "optional", "tf", ".", "string", "tensor", "containing", "configurations", "in", "[", "Key", "=", "Value", "]", "format", ".", "Global", "configuration", ":", "please", "refer", "to", "Global", "configuration", "properties", "in", "librdkafka", "doc", ".", "Examples", "include", "[", "enable", ".", "auto", ".", "commit", "=", "false", "heartbeat", ".", "interval", ".", "ms", "=", "2000", "]", "Topic", "configuration", ":", "please", "refer", "to", "Topic", "configuration", "properties", "in", "librdkafka", "doc", ".", "Note", "all", "topic", "configurations", "should", "be", "prefixed", "with", "conf", ".", "topic", ".", ".", "Examples", "include", "[", "conf", ".", "topic", ".", "auto", ".", "offset", ".", "reset", "=", "earliest", "]", "Reference", ":", "https", ":", "//", "github", ".", "com", "/", "edenhill", "/", "librdkafka", "/", "blob", "/", "master", "/", "CONFIGURATION", ".", "md", "internal", ":", "Whether", "the", "dataset", "is", "being", "created", "from", "within", "the", "named", "scope", ".", "Default", ":", "True" ]

[ "def", "__init__", "(", "self", ",", "topics", ",", "group_id", ",", "servers", ",", "stream_timeout", "=", "-", "1", ",", "message_poll_timeout", "=", "10000", ",", "configuration", "=", "None", ",", "internal", "=", "True", ",", ")", ":", "with", "tf", ".", "name_scope", "(", "\"KafkaBatchIODataset\"", ")", ":", "assert", "internal", "if", "stream_timeout", "==", "-", "1", ":", "stream_timeout", "=", "sys", ".", "maxsize", "elif", "stream_timeout", ">=", "0", ":", "# Taking the max of `stream_timeout` and `message_poll_timeout`", "# to prevent the user from bothering about the underlying polling", "# mechanism.", "stream_timeout", "=", "max", "(", "stream_timeout", ",", "message_poll_timeout", ")", "else", ":", "raise", "ValueError", "(", "\"Invalid stream_timeout value: {} ,set it to -1 to block indefinitely.\"", ".", "format", "(", "stream_timeout", ")", ")", "metadata", "=", "list", "(", "configuration", "or", "[", "]", ")", "if", "group_id", "is", "not", "None", ":", "metadata", ".", "append", "(", "\"group.id=%s\"", "%", "group_id", ")", "if", "servers", "is", "not", "None", ":", "metadata", ".", "append", "(", "\"bootstrap.servers=%s\"", "%", "servers", ")", "resource", "=", "core_ops", ".", "io_kafka_group_readable_init", "(", "topics", "=", "topics", ",", "metadata", "=", "metadata", ")", "self", ".", "_resource", "=", "resource", "dataset", "=", "tf", ".", "data", ".", "experimental", ".", "Counter", "(", ")", "dataset", "=", "dataset", ".", "map", "(", "lambda", "i", ":", "core_ops", ".", "io_kafka_group_readable_next", "(", "input", "=", "self", ".", "_resource", ",", "index", "=", "i", ",", "message_poll_timeout", "=", "message_poll_timeout", ",", "stream_timeout", "=", "stream_timeout", ",", ")", ")", "dataset", "=", "dataset", ".", "apply", "(", "tf", ".", "data", ".", "experimental", ".", "take_while", "(", "lambda", "v", ":", "tf", ".", "greater", "(", "v", ".", "continue_fetch", ",", "0", ")", ")", ")", "dataset", "=", "dataset", ".", "map", "(", "lambda", "v", ":", "tf", ".", "data", ".", "Dataset", ".", "zip", "(", "(", "tf", ".", "data", ".", "Dataset", ".", "from_tensor_slices", "(", "v", ".", "message", ")", ",", "tf", ".", "data", ".", "Dataset", ".", "from_tensor_slices", "(", "v", ".", "key", ")", ",", ")", ")", ")", "self", ".", "_dataset", "=", "dataset", "super", "(", ")", ".", "__init__", "(", "self", ".", "_dataset", ".", "_variant_tensor", ")" ]

[ "__init__", "(", "self", "int", "id", "=", "0", ")", "-", ">", "QueryLayoutInfoEvent" ]

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_windows_", ".", "QueryLayoutInfoEvent_swiginit", "(", "self", ",", "_windows_", ".", "new_QueryLayoutInfoEvent", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

[ "Create", "the", "call", "-", "tip", "widget", "." ]

[ "def", "showcontents", "(", "self", ")", ":", "self", ".", "label", "=", "Label", "(", "self", ".", "tipwindow", ",", "text", "=", "self", ".", "text", ",", "justify", "=", "LEFT", ",", "background", "=", "\"#ffffd0\"", ",", "foreground", "=", "\"black\"", ",", "relief", "=", "SOLID", ",", "borderwidth", "=", "1", ",", "font", "=", "self", ".", "anchor_widget", "[", "'font'", "]", ")", "self", ".", "label", ".", "pack", "(", ")" ]

[ "Like", ":", "meth", ":", "stat", "but", "do", "not", "follow", "symbolic", "links", "." ]

[ "def", "lstat", "(", "self", ")", ":", "return", "os", ".", "lstat", "(", "self", ")" ]

[ "Construct", "python", "script" ]

[ "def", "constructPythonScript", "(", "self", ",", "paramdict", ")", ":", "# 1. Obtain all information", "runsetupdict", "=", "paramdict", "[", "\"RunSetupWidget\"", "]", "advsetupdict", "=", "paramdict", "[", "\"AdvancedSetupWidget\"", "]", "filterdict", "=", "paramdict", "[", "\"FilterSetupWidget\"", "]", "# 2. Obtain some information", "datafilenames", "=", "self", ".", "getDataFileNames", "(", "runsetupdict", ",", "advsetupdict", ")", "if", "len", "(", "datafilenames", ")", "==", "0", ":", "raise", "NotImplementedError", "(", "\"RunNumber cannot be neglected. \"", ")", "dofilter", "=", "self", ".", "doFiltering", "(", "filterdict", ")", "# 3. Header", "script", "=", "\"from mantid.simpleapi import *\\n\"", "script", "+=", "\"config['default.facility']=\\\"%s\\\"\\n\"", "%", "self", ".", "facility_name", "script", "+=", "\"\\n\"", "if", "dofilter", ":", "# a) Construct python script with generating filters", "for", "runtuple", "in", "datafilenames", ":", "runnumber", "=", "runtuple", "[", "0", "]", "datafilename", "=", "runtuple", "[", "1", "]", "# print \"Working on run \", str(runnumber), \" in file \", datafilename", "# i. Load meta data only", "metadatawsname", "=", "str", "(", "datafilename", ".", "split", "(", "\".\"", ")", "[", "0", "]", "+", "\"_meta\"", ")", "splitwsname", "=", "str", "(", "datafilename", ".", "split", "(", "\".\"", ")", "[", "0", "]", "+", "\"_splitters\"", ")", "splitinfowsname", "=", "str", "(", "datafilename", ".", "split", "(", "\".\"", ")", "[", "0", "]", "+", "\"_splitinfo\"", ")", "script", "+=", "\"# Load data's log only\\n\"", "script", "+=", "\"Load(\\n\"", "script", "+=", "\"{}Filename = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "datafilename", ")", "script", "+=", "\"{}OutputWorkspace = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "metadatawsname", ")", "script", "+=", "\"{}MetaDataOnly = True)\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ")", "script", "+=", "\"\\n\"", "# ii. Generate event filters", "script", "+=", "\"# Construct the event filters\\n\"", "script", "+=", "\"GenerateEventsFilter(\\n\"", "script", "+=", "\"{}InputWorkspace = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "metadatawsname", ")", "script", "+=", "\"{}OutputWorkspace = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "splitwsname", ")", "script", "+=", "\"{}InformationWorkspace = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "splitinfowsname", ")", "if", "filterdict", "[", "\"FilterByTimeMin\"", "]", "!=", "\"\"", ":", "script", "+=", "\"{}StartTime = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"FilterByTimeMin\"", "]", ")", "if", "filterdict", "[", "\"FilterByTimeMax\"", "]", "!=", "\"\"", ":", "script", "+=", "\"{}StopTime = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"FilterByTimeMax\"", "]", ")", "if", "filterdict", "[", "\"FilterType\"", "]", "==", "\"ByTime\"", ":", "# Filter by time", "script", "+=", "\"{}TimeInterval = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"LengthOfTimeInterval\"", "]", ")", "script", "+=", "\"{}UnitOfTime = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"UnitOfTime\"", "]", ")", "script", "+=", "\"{}LogName = '',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ")", "# intentionally empty", "elif", "filterdict", "[", "\"FilterType\"", "]", "==", "\"ByLogValue\"", ":", "# Filter by log value", "script", "+=", "\"{}LogName = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"LogName\"", "]", ")", "if", "filterdict", "[", "\"MinimumLogValue\"", "]", "!=", "\"\"", ":", "script", "+=", "\"{}MinimumLogValue = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"MinimumLogValue\"", "]", ")", "if", "filterdict", "[", "\"MaximumLogValue\"", "]", "!=", "\"\"", ":", "script", "+=", "\"{}MaximumLogValue = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"MaximumLogValue\"", "]", ")", "script", "+=", "\"{}FilterLogValueByChangingDirection = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"FilterLogValueByChangingDirection\"", "]", ")", "if", "filterdict", "[", "\"LogValueInterval\"", "]", "!=", "\"\"", ":", "# Filter by log value interval", "script", "+=", "\"{}LogValueInterval = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"LogValueInterval\"", "]", ")", "script", "+=", "\"{}LogBoundary = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"LogBoundary\"", "]", ")", "if", "filterdict", "[", "\"TimeTolerance\"", "]", "!=", "\"\"", ":", "script", "+=", "\"{}TimeTolerance = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"TimeTolerance\"", "]", ")", "if", "filterdict", "[", "\"LogValueTolerance\"", "]", "!=", "\"\"", ":", "script", "+=", "\"{}LogValueTolerance = '{}',\\n\"", ".", "format", "(", "DiffractionReductionScripter", ".", "WIDTH", ",", "filterdict", "[", "\"LogValueTolerance\"", "]", ")", "# ENDIF", "script", "+=", "\")\\n\"", "# iii. Data reduction", "script", "+=", "self", ".", "buildPowderDataReductionScript", "(", "runsetupdict", ",", "advsetupdict", ",", "runnumber", ",", "splitwsname", ",", "splitinfowsname", ")", "# ENDFOR data file names", "else", ":", "# b) Construct python script without generating filters", "script", "+=", "self", ".", "buildPowderDataReductionScript", "(", "runsetupdict", ",", "advsetupdict", ")", "# ENDIF : do filter", "print", "(", "\"Script and Save XML to default.\"", ")", "return", "script" ]

[ "Code", "complete", "in", "this", "translation", "unit", "." ]

[ "def", "codeComplete", "(", "self", ",", "path", ",", "line", ",", "column", ",", "unsaved_files", "=", "None", ",", "include_macros", "=", "False", ",", "include_code_patterns", "=", "False", ",", "include_brief_comments", "=", "False", ")", ":", "options", "=", "0", "if", "include_macros", ":", "options", "+=", "1", "if", "include_code_patterns", ":", "options", "+=", "2", "if", "include_brief_comments", ":", "options", "+=", "4", "if", "unsaved_files", "is", "None", ":", "unsaved_files", "=", "[", "]", "unsaved_files_array", "=", "0", "if", "len", "(", "unsaved_files", ")", ":", "unsaved_files_array", "=", "(", "_CXUnsavedFile", "*", "len", "(", "unsaved_files", ")", ")", "(", ")", "for", "i", ",", "(", "name", ",", "value", ")", "in", "enumerate", "(", "unsaved_files", ")", ":", "if", "not", "isinstance", "(", "value", ",", "str", ")", ":", "# FIXME: It would be great to support an efficient version", "# of this, one day.", "value", "=", "value", ".", "read", "(", ")", "print", "(", "value", ")", "if", "not", "isinstance", "(", "value", ",", "str", ")", ":", "raise", "TypeError", "(", "'Unexpected unsaved file contents.'", ")", "unsaved_files_array", "[", "i", "]", ".", "name", "=", "name", "unsaved_files_array", "[", "i", "]", ".", "contents", "=", "value", "unsaved_files_array", "[", "i", "]", ".", "length", "=", "len", "(", "value", ")", "ptr", "=", "conf", ".", "lib", ".", "clang_codeCompleteAt", "(", "self", ",", "path", ",", "line", ",", "column", ",", "unsaved_files_array", ",", "len", "(", "unsaved_files", ")", ",", "options", ")", "if", "ptr", ":", "return", "CodeCompletionResults", "(", "ptr", ")", "return", "None" ]

[ "Receives", "a", "query", "stored", "in", "a", "log", "file", "and", "prepares", "it", "for", "the", "output", "in", "the", "log", "viewer", "shortening", "to", "256", "characters", "and", "taking", "care", "of", "encoding", "issues" ]

[ "def", "_shorten_query_field", "(", "self", ",", "data", ")", ":", "l", "=", "len", "(", "data", ")", "abbr", "=", "data", "[", ":", "256", "]", "size", "=", "'%d bytes'", "%", "l", "if", "l", "<", "1024", "else", "'%.1f KB'", "%", "(", "l", "/", "1024.0", ")", "return", "data", "if", "l", "<=", "256", "else", "data", "+", "' [truncated, %s total]'", "%", "size" ]

[ "Loads", "the", "model", "currently", "set", "by", "metadata", "." ]

[ "def", "load_model", "(", "self", ")", "->", "None", ":", "# loading text because the setup pauses here during motion load", "logger", ".", "info", "(", "\"Loading...\"", ")", "self", ".", "hide_model", "(", ")", "self", ".", "activity", "=", "Activity", ".", "MOTION_STAGE", "# keeps the model up to date with current data target", "data", "=", "self", ".", "user_metadata", "# add an ArticulatedObject to the world with a fixed base", "self", ".", "model", "=", "self", ".", "art_obj_mgr", ".", "add_articulated_object_from_urdf", "(", "filepath", "=", "data", "[", "\"urdf_path\"", "]", ",", "fixed_base", "=", "True", ")", "assert", "self", ".", "model", ".", "is_alive", "# change motion_type to KINEMATIC", "self", ".", "model", ".", "motion_type", "=", "phy", ".", "MotionType", ".", "KINEMATIC", "self", ".", "model", ".", "translation", "=", "self", ".", "translation_offset", "self", ".", "next_pose", "(", "repeat", "=", "True", ")", "logger", ".", "info", "(", "\"Done Loading.\"", ")" ]

[ "DoGetVirtualSize", "(", "self", ")", "-", ">", "Size" ]

[ "def", "DoGetVirtualSize", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "PyControl_DoGetVirtualSize", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Build", "a", "new", "property", "path", "from", "a", "prim", "path", "and", "a", "property", "name", "." ]

[ "def", "_buildPropPath", "(", "self", ",", "primPath", ",", "propName", ")", ":", "return", "Sdf", ".", "Path", "(", "str", "(", "primPath", ")", "+", "\".\"", "+", "propName", ")" ]

[ "Return", "the", "generated", "output", "." ]

[ "def", "generate", "(", ")", ":", "global", "MESSAGES", "# the keys are sorted in the .mo file", "keys", "=", "sorted", "(", "MESSAGES", ".", "keys", "(", ")", ")", "offsets", "=", "[", "]", "ids", "=", "strs", "=", "b''", "for", "id", "in", "keys", ":", "# For each string, we need size and file offset. Each string is NUL", "# terminated; the NUL does not count into the size.", "offsets", ".", "append", "(", "(", "len", "(", "ids", ")", ",", "len", "(", "id", ")", ",", "len", "(", "strs", ")", ",", "len", "(", "MESSAGES", "[", "id", "]", ")", ")", ")", "ids", "+=", "id", "+", "b'\\0'", "strs", "+=", "MESSAGES", "[", "id", "]", "+", "b'\\0'", "output", "=", "''", "# The header is 7 32-bit unsigned integers. We don't use hash tables, so", "# the keys start right after the index tables.", "# translated string.", "keystart", "=", "7", "*", "4", "+", "16", "*", "len", "(", "keys", ")", "# and the values start after the keys", "valuestart", "=", "keystart", "+", "len", "(", "ids", ")", "koffsets", "=", "[", "]", "voffsets", "=", "[", "]", "# The string table first has the list of keys, then the list of values.", "# Each entry has first the size of the string, then the file offset.", "for", "o1", ",", "l1", ",", "o2", ",", "l2", "in", "offsets", ":", "koffsets", "+=", "[", "l1", ",", "o1", "+", "keystart", "]", "voffsets", "+=", "[", "l2", ",", "o2", "+", "valuestart", "]", "offsets", "=", "koffsets", "+", "voffsets", "output", "=", "struct", ".", "pack", "(", "\"Iiiiiii\"", ",", "0x950412de", ",", "# Magic", "0", ",", "# Version", "len", "(", "keys", ")", ",", "# # of entries", "7", "*", "4", ",", "# start of key index", "7", "*", "4", "+", "len", "(", "keys", ")", "*", "8", ",", "# start of value index", "0", ",", "0", ")", "# size and offset of hash table", "output", "+=", "array", ".", "array", "(", "\"i\"", ",", "offsets", ")", ".", "tobytes", "(", ")", "output", "+=", "ids", "output", "+=", "strs", "return", "output" ]

[ "Extracts", "a", "list", "of", "result", "types", "from", "the", "given", "comment", "." ]

[ "def", "extract_result_types", "(", "comment", ")", ":", "result_types", "=", "[", "]", "m", "=", "re", ".", "search", "(", "r'Usable as: Any Matcher[\\s\\n]*$'", ",", "comment", ",", "re", ".", "S", ")", "if", "m", ":", "return", "[", "'*'", "]", "while", "True", ":", "m", "=", "re", ".", "match", "(", "r'^(.*)Matcher<([^>]+)>\\s*,?[\\s\\n]*$'", ",", "comment", ",", "re", ".", "S", ")", "if", "not", "m", ":", "if", "re", ".", "search", "(", "r'Usable as:\\s*$'", ",", "comment", ")", ":", "return", "result_types", "else", ":", "return", "None", "result_types", "+=", "[", "m", ".", "group", "(", "2", ")", "]", "comment", "=", "m", ".", "group", "(", "1", ")" ]

[ "Return", "the", "information", "exported", "by", "this", "distribution", ".", ":", "return", ":", "A", "dictionary", "of", "exports", "mapping", "an", "export", "category", "to", "a", "dict", "of", ":", "class", ":", "ExportEntry", "instances", "describing", "the", "individual", "export", "entries", "and", "keyed", "by", "name", "." ]

[ "def", "exports", "(", "self", ")", ":", "result", "=", "{", "}", "r", "=", "self", ".", "get_distinfo_resource", "(", "EXPORTS_FILENAME", ")", "if", "r", ":", "result", "=", "self", ".", "read_exports", "(", ")", "return", "result" ]

[ "Recursively", "compares", "two", "messages", "by", "value", "and", "structure", "." ]

[ "def", "__eq__", "(", "self", ",", "other_msg", ")", ":", "raise", "NotImplementedError" ]

[ "node", "initialization" ]

[ "def", "__init__", "(", "self", ")", ":", "self", ".", "_cv_bridge", "=", "CvBridge", "(", ")", "#self._session = tf.Session()", "self", ".", "pspnet", "=", "PSPNet101", "(", "nb_classes", "=", "19", ",", "input_shape", "=", "(", "713", ",", "713", ")", ",", "weights", "=", "'pspnet101_cityscapes'", ")", "#init = tf.global_variables_initializer()", "#self._session.run(init)", "self", ".", "graph", "=", "tf", ".", "get_default_graph", "(", ")", "self", ".", "_sub", "=", "rospy", ".", "Subscriber", "(", "'image'", ",", "Image", ",", "self", ".", "callback", ",", "queue_size", "=", "1000", ")", "self", ".", "_pub", "=", "rospy", ".", "Publisher", "(", "'/result'", ",", "frame", ",", "queue_size", "=", "1", ")" ]

[ "get", "CPU", "cores" ]

[ "def", "get_cpu_cores", "(", "self", ")", ":", "return", "self", ".", "CPUINFO", ".", "count", "(", "'processor'", ")" ]

[ "Initializes", "the", "TFAsymmetryModeSwitcherView", "." ]

[ "def", "__init__", "(", "self", ",", "parent", ":", "QWidget", "=", "None", ")", ":", "super", "(", "TFAsymmetryModeSwitcherView", ",", "self", ")", ".", "__init__", "(", "parent", ")", "self", ".", "setupUi", "(", "self", ")" ]

[ "请求查询报单手续费响应" ]

[ "def", "onRspQryInstrumentOrderCommRate", "(", "self", ",", "InstrumentOrderCommRateField", ",", "RspInfoField", ",", "requestId", ",", "final", ")", ":", "pass" ]

[ "Adds", "implementation", "of", "private", "helper", "methods", "to", "cls", "." ]

[ "def", "_AddPrivateHelperMethods", "(", "message_descriptor", ",", "cls", ")", ":", "def", "Modified", "(", "self", ")", ":", "\"\"\"Sets the _cached_byte_size_dirty bit to true,\n and propagates this to our listener iff this was a state change.\n \"\"\"", "# Note: Some callers check _cached_byte_size_dirty before calling", "# _Modified() as an extra optimization. So, if this method is ever", "# changed such that it does stuff even when _cached_byte_size_dirty is", "# already true, the callers need to be updated.", "if", "not", "self", ".", "_cached_byte_size_dirty", ":", "self", ".", "_cached_byte_size_dirty", "=", "True", "self", ".", "_listener_for_children", ".", "dirty", "=", "True", "self", ".", "_is_present_in_parent", "=", "True", "self", ".", "_listener", ".", "Modified", "(", ")", "def", "_UpdateOneofState", "(", "self", ",", "field", ")", ":", "\"\"\"Sets field as the active field in its containing oneof.\n\n Will also delete currently active field in the oneof, if it is different\n from the argument. Does not mark the message as modified.\n \"\"\"", "other_field", "=", "self", ".", "_oneofs", ".", "setdefault", "(", "field", ".", "containing_oneof", ",", "field", ")", "if", "other_field", "is", "not", "field", ":", "del", "self", ".", "_fields", "[", "other_field", "]", "self", ".", "_oneofs", "[", "field", ".", "containing_oneof", "]", "=", "field", "cls", ".", "_Modified", "=", "Modified", "cls", ".", "SetInParent", "=", "Modified", "cls", ".", "_UpdateOneofState", "=", "_UpdateOneofState" ]

[ "The", "tailweight", "in", ":", "Y", "=", "Sinh", "((", "Arcsinh", "(", "X", ")", "+", "skewness", ")", "*", "tailweight", ")", "." ]

[ "def", "tailweight", "(", "self", ")", ":", "return", "self", ".", "_tailweight" ]

[ "Create", "a", "KeyRanges", "object", "." ]

[ "def", "create_from_list", "(", "cls", ",", "list_of_key_ranges", ")", ":", "return", "_KeyRangesFromList", "(", "list_of_key_ranges", ")" ]

[ "Show", "currently", "configured", "RibPolicy" ]

[ "def", "show", "(", "cli_opts", ")", ":", "# noqa: B902", "decision", ".", "DecisionRibPolicyCmd", "(", "cli_opts", ")", ".", "run", "(", ")" ]

[ "CreateScrolledWindow", "(", "self", "Window", "parent", ")", "-", ">", "ScrolledWindow" ]

[ "def", "CreateScrolledWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_windows_", ".", "StandardDialogLayoutAdapter_CreateScrolledWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Update", "the", "variational", "distributions", "for", "the", "means" ]

[ "def", "_update_means", "(", "self", ",", "X", ",", "z", ")", ":", "n_features", "=", "X", ".", "shape", "[", "1", "]", "for", "k", "in", "range", "(", "self", ".", "n_components", ")", ":", "if", "self", ".", "covariance_type", "in", "[", "'spherical'", ",", "'diag'", "]", ":", "num", "=", "np", ".", "sum", "(", "z", ".", "T", "[", "k", "]", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", "*", "X", ",", "axis", "=", "0", ")", "num", "*=", "self", ".", "precs_", "[", "k", "]", "den", "=", "1.", "+", "self", ".", "precs_", "[", "k", "]", "*", "np", ".", "sum", "(", "z", ".", "T", "[", "k", "]", ")", "self", ".", "means_", "[", "k", "]", "=", "num", "/", "den", "elif", "self", ".", "covariance_type", "in", "[", "'tied'", ",", "'full'", "]", ":", "if", "self", ".", "covariance_type", "==", "'tied'", ":", "cov", "=", "self", ".", "precs_", "else", ":", "cov", "=", "self", ".", "precs_", "[", "k", "]", "den", "=", "np", ".", "identity", "(", "n_features", ")", "+", "cov", "*", "np", ".", "sum", "(", "z", ".", "T", "[", "k", "]", ")", "num", "=", "np", ".", "sum", "(", "z", ".", "T", "[", "k", "]", ".", "reshape", "(", "(", "-", "1", ",", "1", ")", ")", "*", "X", ",", "axis", "=", "0", ")", "num", "=", "np", ".", "dot", "(", "cov", ",", "num", ")", "self", ".", "means_", "[", "k", "]", "=", "linalg", ".", "lstsq", "(", "den", ",", "num", ")", "[", "0", "]" ]

[ "Remove", "the", "keyed", "message", ";", "raise", "KeyError", "if", "it", "doesn", "t", "exist", "." ]

[ "def", "remove", "(", "self", ",", "key", ")", ":", "self", ".", "_lookup", "(", "key", ")", "del", "self", ".", "_toc", "[", "key", "]", "self", ".", "_pending", "=", "True" ]

[ "Calls", "restorecon", "to", "set", "the", "proper", "context", "on", "SELinux", "systems", ".", "Only", "if", "the", "restorecon", "executable", "is", "found", "anywhere", "in", "the", "path", "it", "will", "get", "called", "." ]

[ "def", "set_context", "(", "path", ",", "recursive", "=", "False", ")", ":", "skip", "=", "os", ".", "environ", ".", "get", "(", "'CEPH_VOLUME_SKIP_RESTORECON'", ",", "''", ")", "if", "skip", ".", "lower", "(", ")", "in", "[", "'1'", ",", "'true'", ",", "'yes'", "]", ":", "logger", ".", "info", "(", "'CEPH_VOLUME_SKIP_RESTORECON environ is set, will not call restorecon'", ")", "return", "try", ":", "stdout", ",", "stderr", ",", "code", "=", "process", ".", "call", "(", "[", "'selinuxenabled'", "]", ",", "verbose_on_failure", "=", "False", ")", "except", "FileNotFoundError", ":", "logger", ".", "info", "(", "'No SELinux found, skipping call to restorecon'", ")", "return", "if", "code", "!=", "0", ":", "logger", ".", "info", "(", "'SELinux is not enabled, will not call restorecon'", ")", "return", "# restore selinux context to default policy values", "if", "which", "(", "'restorecon'", ")", ".", "startswith", "(", "'/'", ")", ":", "if", "recursive", ":", "process", ".", "run", "(", "[", "'restorecon'", ",", "'-R'", ",", "path", "]", ")", "else", ":", "process", ".", "run", "(", "[", "'restorecon'", ",", "path", "]", ")" ]

[ "r", "Return", "the", "truncated", "value", "of", "the", "input", "element", "-", "wise", ".", "The", "truncated", "value", "of", "the", "scalar", "x", "is", "the", "nearest", "integer", "i", "which", "is", "closer", "to", "zero", "than", "x", "is", ".", "In", "short", "the", "fractional", "part", "of", "the", "signed", "number", "x", "is", "discarded", "." ]

[ "def", "trunc", "(", "x", ",", "out", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "_mx_nd_np", ".", "trunc", "(", "x", ",", "out", "=", "out", ",", "*", "*", "kwargs", ")" ]

[ "GetClassDefaultAttributes", "(", "int", "variant", "=", "WINDOW_VARIANT_NORMAL", ")", "-", ">", "VisualAttributes" ]

[ "def", "GetClassDefaultAttributes", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ListCtrl_GetClassDefaultAttributes", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "T", "-", "test", "for", "means", "of", "two", "independent", "samples", "from", "descriptive", "statistics", "." ]

[ "def", "ttest_ind_from_stats", "(", "mean1", ",", "std1", ",", "nobs1", ",", "mean2", ",", "std2", ",", "nobs2", ",", "equal_var", "=", "True", ")", ":", "if", "equal_var", ":", "df", ",", "denom", "=", "_equal_var_ttest_denom", "(", "std1", "**", "2", ",", "nobs1", ",", "std2", "**", "2", ",", "nobs2", ")", "else", ":", "df", ",", "denom", "=", "_unequal_var_ttest_denom", "(", "std1", "**", "2", ",", "nobs1", ",", "std2", "**", "2", ",", "nobs2", ")", "res", "=", "_ttest_ind_from_stats", "(", "mean1", ",", "mean2", ",", "denom", ",", "df", ")", "return", "Ttest_indResult", "(", "*", "res", ")" ]

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

[ "def", "GetCaretLineBackAlpha", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_GetCaretLineBackAlpha", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Given", "a", "datetime", "and", "a", "time", "zone", "determine", "whether", "or", "not", "a", "given", "datetime", "is", "ambiguous", "(", "i", ".", "e", "if", "there", "are", "two", "times", "differentiated", "only", "by", "their", "DST", "status", ")", "." ]

[ "def", "datetime_ambiguous", "(", "dt", ",", "tz", "=", "None", ")", ":", "if", "tz", "is", "None", ":", "if", "dt", ".", "tzinfo", "is", "None", ":", "raise", "ValueError", "(", "'Datetime is naive and no time zone provided.'", ")", "tz", "=", "dt", ".", "tzinfo", "# If a time zone defines its own \"is_ambiguous\" function, we'll use that.", "is_ambiguous_fn", "=", "getattr", "(", "tz", ",", "'is_ambiguous'", ",", "None", ")", "if", "is_ambiguous_fn", "is", "not", "None", ":", "try", ":", "return", "tz", ".", "is_ambiguous", "(", "dt", ")", "except", ":", "pass", "# If it doesn't come out and tell us it's ambiguous, we'll just check if", "# the fold attribute has any effect on this particular date and time.", "dt", "=", "dt", ".", "replace", "(", "tzinfo", "=", "tz", ")", "wall_0", "=", "enfold", "(", "dt", ",", "fold", "=", "0", ")", "wall_1", "=", "enfold", "(", "dt", ",", "fold", "=", "1", ")", "same_offset", "=", "wall_0", ".", "utcoffset", "(", ")", "==", "wall_1", ".", "utcoffset", "(", ")", "same_dst", "=", "wall_0", ".", "dst", "(", ")", "==", "wall_1", ".", "dst", "(", ")", "return", "not", "(", "same_offset", "and", "same_dst", ")" ]

[ "Runs", "benchmarks", "with", "the", "given", "context", "and", "precision", "(", "dtype", ")", "for", "all", "the", "binary", "element_wise", "operators", "in", "MXNet", "." ]

[ "def", "run_mx_binary_element_wise_operators_benchmarks", "(", "ctx", "=", "mx", ".", "cpu", "(", ")", ",", "dtype", "=", "'float32'", ",", "warmup", "=", "10", ",", "runs", "=", "50", ")", ":", "# Fetch all Binary Element_wise Operators", "mx_binary_element_wise_ops", "=", "get_all_elemen_wise_binary_operators", "(", ")", "# Run benchmarks", "mx_binary_op_results", "=", "run_op_benchmarks", "(", "mx_binary_element_wise_ops", ",", "dtype", ",", "ctx", ",", "warmup", ",", "runs", ")", "return", "mx_binary_op_results" ]

[ "Outputs", "a", "Summary", "protocol", "buffer", "with", "images", "." ]

[ "def", "image", "(", "name", ",", "tensor", ",", "max_outputs", "=", "3", ",", "collections", "=", "None", ",", "family", "=", "None", ")", ":", "with", "_summary_op_util", ".", "summary_scope", "(", "name", ",", "family", ",", "values", "=", "[", "tensor", "]", ")", "as", "(", "tag", ",", "scope", ")", ":", "# pylint: disable=protected-access", "val", "=", "_gen_logging_ops", ".", "_image_summary", "(", "tag", "=", "tag", ",", "tensor", "=", "tensor", ",", "max_images", "=", "max_outputs", ",", "name", "=", "scope", ")", "_summary_op_util", ".", "collect", "(", "val", ",", "collections", ",", "[", "_ops", ".", "GraphKeys", ".", "SUMMARIES", "]", ")", "return", "val" ]

[ "Execute", "the", "coroutine", "and", "return", "the", "result", "." ]

[ "def", "run", "(", "main", ",", "*", ",", "debug", "=", "False", ")", ":", "if", "events", ".", "_get_running_loop", "(", ")", "is", "not", "None", ":", "raise", "RuntimeError", "(", "\"asyncio.run() cannot be called from a running event loop\"", ")", "if", "not", "coroutines", ".", "iscoroutine", "(", "main", ")", ":", "raise", "ValueError", "(", "\"a coroutine was expected, got {!r}\"", ".", "format", "(", "main", ")", ")", "loop", "=", "events", ".", "new_event_loop", "(", ")", "try", ":", "events", ".", "set_event_loop", "(", "loop", ")", "loop", ".", "set_debug", "(", "debug", ")", "return", "loop", ".", "run_until_complete", "(", "main", ")", "finally", ":", "try", ":", "_cancel_all_tasks", "(", "loop", ")", "loop", ".", "run_until_complete", "(", "loop", ".", "shutdown_asyncgens", "(", ")", ")", "finally", ":", "events", ".", "set_event_loop", "(", "None", ")", "loop", ".", "close", "(", ")" ]

[ "Writes", "data", "in", "xml", "file", "format", "." ]

[ "def", "write", "(", "self", ",", "name", "=", "\"\"", ",", "indent", "=", "\"\"", ")", ":", "return", "Input", ".", "write", "(", "self", ",", "name", "=", "name", ",", "indent", "=", "indent", ",", "text", "=", "write_type", "(", "self", ".", "type", ",", "self", ".", "value", ")", ")" ]

[ "Creates", "a", "cell", "initializer", "object", "." ]

[ "def", "fetch", "(", "self", ")", ":", "mode", "=", "self", ".", "mode", ".", "fetch", "(", ")", "ibase", "=", "super", "(", "InputInitCell", ",", "self", ")", ".", "fetch", "(", ")", "if", "mode", "==", "\"abc\"", "or", "mode", "==", "\"abcABC\"", ":", "h", "=", "io_xml", ".", "read_array", "(", "np", ".", "float", ",", "ibase", ".", "value", ")", "if", "mode", "==", "\"abc\"", ":", "if", "h", ".", "size", "!=", "3", ":", "raise", "ValueError", "(", "\"If you are initializing cell from cell side lengths you must pass the 'cell' tag an array of 3 floats.\"", ")", "else", ":", "h", "=", "mt", ".", "abc2h", "(", "h", "[", "0", "]", ",", "h", "[", "1", "]", ",", "h", "[", "2", "]", ",", "np", ".", "pi", "/", "2", ",", "np", ".", "pi", "/", "2", ",", "np", ".", "pi", "/", "2", ")", "elif", "mode", "==", "\"abcABC\"", ":", "if", "h", ".", "size", "!=", "6", ":", "raise", "ValueError", "(", "\"If you are initializing cell from cell side lengths and angles you must pass the 'cell' tag an array of 6 floats.\"", ")", "else", ":", "h", "=", "mt", ".", "abc2h", "(", "h", "[", "0", "]", ",", "h", "[", "1", "]", ",", "h", "[", "2", "]", ",", "h", "[", "3", "]", "*", "np", ".", "pi", "/", "180.0", ",", "h", "[", "4", "]", "*", "np", ".", "pi", "/", "180.0", ",", "h", "[", "5", "]", "*", "np", ".", "pi", "/", "180.0", ")", "h", ".", "shape", "=", "(", "9", ",", ")", "ibase", ".", "value", "=", "h", "mode", "=", "\"manual\"", "if", "mode", "==", "\"manual\"", ":", "h", "=", "ibase", ".", "value", "if", "h", ".", "size", "!=", "9", ":", "raise", "ValueError", "(", "\"Cell objects must contain a 3x3 matrix describing the cell vectors.\"", ")", "if", "not", "(", "h", "[", "3", "]", "==", "0.0", "and", "h", "[", "6", "]", "==", "0.0", "and", "h", "[", "7", "]", "==", "0.0", ")", ":", "warning", "(", "\"Cell vector matrix must be upper triangular, all elements below the diagonal being set to zero.\"", ",", "verbosity", ".", "low", ")", "h", "[", "3", "]", "=", "h", "[", "6", "]", "=", "h", "[", "7", "]", "=", "0", "ibase", ".", "value", "=", "h", "return", "self", ".", "_initclass", "(", "value", "=", "ibase", ".", "value", ",", "mode", "=", "mode", ",", "units", "=", "self", ".", "units", ".", "fetch", "(", ")", ")" ]

[ "Changes", "the", "overall", "style" ]

[ "def", "style", "(", "self", ",", "*", "*", "attr", ")", ":", "self", ".", "attr", "=", "attr" ]

[ "Load", "the", "edges", "map", "from", "the", "dump", "file", "and", "filter", "it", "to", "only", "show", "targets", "in", "|targets|", "and", "their", "depedendents", "." ]

[ "def", "LoadEdges", "(", "filename", ",", "targets", ")", ":", "file", "=", "open", "(", "'dump.json'", ")", "edges", "=", "json", ".", "load", "(", "file", ")", "file", ".", "close", "(", ")", "# Copy out only the edges we're interested in from the full edge list.", "target_edges", "=", "{", "}", "to_visit", "=", "targets", "[", ":", "]", "while", "to_visit", ":", "src", "=", "to_visit", ".", "pop", "(", ")", "if", "src", "in", "target_edges", ":", "continue", "target_edges", "[", "src", "]", "=", "edges", "[", "src", "]", "to_visit", ".", "extend", "(", "edges", "[", "src", "]", ")", "return", "target_edges" ]

[ "Microsoft", "Visual", "C", "++", "for", "Python", "registry", "key", "." ]

[ "def", "vc_for_python", "(", "self", ")", ":", "return", "r'DevDiv\\VCForPython'" ]

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

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

[ "Bind", "this", "set", "of", "event", "types", "to", "target", "." ]

[ "def", "Bind", "(", "self", ",", "target", ",", "id1", ",", "id2", ",", "function", ")", ":", "for", "et", "in", "self", ".", "evtType", ":", "target", ".", "Connect", "(", "id1", ",", "id2", ",", "et", ",", "function", ")" ]

[ "Execute", "the", "call", "behavior", "." ]

[ "def", "__call__", "(", "self", ",", "x", ")", ":", "return", "umath", ".", "less", "(", "umath", ".", "absolute", "(", "umath", ".", "cos", "(", "x", ")", ")", ",", "self", ".", "eps", ")" ]

[ "Calculate", "manipulator", "Jacobian", ".", "Takes", "numpy", "array", "of", "joint", "angles", "in", "radians", ".", "Returns", "the", "manipulator", "Jacobian", "of", "differential", "twists", ".", "When", "multiplied", "with", "a", "vector", "of", "joint", "velocities", "will", "yield", "a", "single", "differential", "twist", "which", "is", "the", "spatial", "velocity", "d", "(", "sTt", ")", "/", "dt", "*", "inv", "(", "sTt", ")", "of", "the", "end", "-", "effector", "pose", ".", "Just", "like", "always", "differential", "twists", "can", "be", "hatted", "and", "multiplied", "with", "spatial", "coordinates", "of", "a", "point", "to", "give", "the", "spatial", "velocity", "of", "the", "point", "." ]

[ "def", "manipulator_jacobian", "(", "self", ",", "q", ")", ":", "l1Zl1", "=", "Pose2", ".", "Expmap", "(", "self", ".", "xi1", "*", "q", "[", "0", "]", ")", "l2Zl2", "=", "Pose2", ".", "Expmap", "(", "self", ".", "xi2", "*", "q", "[", "1", "]", ")", "# l3Zl3 = Pose2.Expmap(self.xi3 * q[2])", "p1", "=", "self", ".", "xi1", "# p1 = Pose2().Adjoint(self.xi1)", "sTl1", "=", "l1Zl1", "p2", "=", "sTl1", ".", "Adjoint", "(", "self", ".", "xi2", ")", "sTl2", "=", "compose", "(", "l1Zl1", ",", "l2Zl2", ")", "p3", "=", "sTl2", ".", "Adjoint", "(", "self", ".", "xi3", ")", "differential_twists", "=", "[", "p1", ",", "p2", ",", "p3", "]", "return", "np", ".", "stack", "(", "differential_twists", ",", "axis", "=", "1", ")" ]

[ "Creates", "effects", "that", "are", "used", "for", "repairing", "(", "unit", "command", ":", "106", ")" ]

[ "def", "get_repair_effects", "(", "line", ",", "location_ref", ")", ":", "dataset", "=", "line", ".", "data", "api_objects", "=", "dataset", ".", "nyan_api_objects", "name_lookup_dict", "=", "internal_name_lookups", ".", "get_entity_lookups", "(", "dataset", ".", "game_version", ")", "effects", "=", "[", "]", "effect_parent", "=", "\"engine.effect.continuous.flat_attribute_change.FlatAttributeChange\"", "repair_parent", "=", "\"engine.effect.continuous.flat_attribute_change.type.FlatAttributeChangeIncrease\"", "repairable_lines", "=", "[", "]", "repairable_lines", ".", "extend", "(", "dataset", ".", "building_lines", ".", "values", "(", ")", ")", "for", "unit_line", "in", "dataset", ".", "unit_lines", ".", "values", "(", ")", ":", "if", "unit_line", ".", "is_repairable", "(", ")", ":", "repairable_lines", ".", "append", "(", "unit_line", ")", "for", "repairable_line", "in", "repairable_lines", ":", "game_entity_name", "=", "name_lookup_dict", "[", "repairable_line", ".", "get_head_unit_id", "(", ")", "]", "[", "0", "]", "repair_name", "=", "f\"{game_entity_name}RepairEffect\"", "repair_ref", "=", "f\"{location_ref}.{repair_name}\"", "repair_raw_api_object", "=", "RawAPIObject", "(", "repair_ref", ",", "repair_name", ",", "dataset", ".", "nyan_api_objects", ")", "repair_raw_api_object", ".", "add_raw_parent", "(", "repair_parent", ")", "repair_location", "=", "ForwardRef", "(", "line", ",", "location_ref", ")", "repair_raw_api_object", ".", "set_location", "(", "repair_location", ")", "line", ".", "add_raw_api_object", "(", "repair_raw_api_object", ")", "# Type", "type_ref", "=", "f\"util.attribute_change_type.types.{game_entity_name}Repair\"", "change_type", "=", "dataset", ".", "pregen_nyan_objects", "[", "type_ref", "]", ".", "get_nyan_object", "(", ")", "repair_raw_api_object", ".", "add_raw_member", "(", "\"type\"", ",", "change_type", ",", "effect_parent", ")", "# Min value (optional; not added because buildings don't block repairing)", "# Max value (optional; not added because there is none in AoE2)", "# Change rate", "# =================================================================================", "rate_name", "=", "f\"{location_ref}.{repair_name}.ChangeRate\"", "rate_raw_api_object", "=", "RawAPIObject", "(", "rate_name", ",", "\"ChangeRate\"", ",", "dataset", ".", "nyan_api_objects", ")", "rate_raw_api_object", ".", "add_raw_parent", "(", "\"engine.util.attribute.AttributeRate\"", ")", "rate_location", "=", "ForwardRef", "(", "line", ",", "repair_ref", ")", "rate_raw_api_object", ".", "set_location", "(", "rate_location", ")", "attribute", "=", "dataset", ".", "pregen_nyan_objects", "[", "\"util.attribute.types.Health\"", "]", ".", "get_nyan_object", "(", ")", "rate_raw_api_object", ".", "add_raw_member", "(", "\"type\"", ",", "attribute", ",", "\"engine.util.attribute.AttributeRate\"", ")", "# Hardcoded repair rate:", "# - Buildings: 750 HP/min = 12.5 HP/s", "# - Ships/Siege: 187.5 HP/min = 3.125 HP/s", "if", "isinstance", "(", "repairable_line", ",", "GenieBuildingLineGroup", ")", ":", "repair_rate", "=", "12.5", "else", ":", "repair_rate", "=", "3.125", "rate_raw_api_object", ".", "add_raw_member", "(", "\"rate\"", ",", "repair_rate", ",", "\"engine.util.attribute.AttributeRate\"", ")", "line", ".", "add_raw_api_object", "(", "rate_raw_api_object", ")", "# =================================================================================", "rate_forward_ref", "=", "ForwardRef", "(", "line", ",", "rate_name", ")", "repair_raw_api_object", ".", "add_raw_member", "(", "\"change_rate\"", ",", "rate_forward_ref", ",", "effect_parent", ")", "# Ignore protection", "repair_raw_api_object", ".", "add_raw_member", "(", "\"ignore_protection\"", ",", "[", "]", ",", "effect_parent", ")", "# Repair cost", "property_ref", "=", "f\"{repair_ref}.Cost\"", "property_raw_api_object", "=", "RawAPIObject", "(", "property_ref", ",", "\"Cost\"", ",", "dataset", ".", "nyan_api_objects", ")", "property_raw_api_object", ".", "add_raw_parent", "(", "\"engine.effect.property.type.Cost\"", ")", "property_location", "=", "ForwardRef", "(", "line", ",", "repair_ref", ")", "property_raw_api_object", ".", "set_location", "(", "property_location", ")", "line", ".", "add_raw_api_object", "(", "property_raw_api_object", ")", "cost_ref", "=", "f\"{game_entity_name}.CreatableGameEntity.{game_entity_name}RepairCost\"", "cost_forward_ref", "=", "ForwardRef", "(", "repairable_line", ",", "cost_ref", ")", "property_raw_api_object", ".", "add_raw_member", "(", "\"cost\"", ",", "cost_forward_ref", ",", "\"engine.effect.property.type.Cost\"", ")", "property_forward_ref", "=", "ForwardRef", "(", "line", ",", "property_ref", ")", "properties", "=", "{", "api_objects", "[", "\"engine.effect.property.type.Cost\"", "]", ":", "property_forward_ref", "}", "repair_raw_api_object", ".", "add_raw_member", "(", "\"properties\"", ",", "properties", ",", "\"engine.effect.Effect\"", ")", "repair_forward_ref", "=", "ForwardRef", "(", "line", ",", "repair_ref", ")", "effects", ".", "append", "(", "repair_forward_ref", ")", "return", "effects" ]

[ "Check", "swap", "mode", "." ]

[ "def", "check", "(", "cls", ",", "mode", ")", ":", "if", "mode", "==", "cls", ".", "swap", ":", "return", "True", ",", "True", "elif", "mode", "==", "cls", ".", "b2a", ":", "return", "False", ",", "True", "elif", "mode", "==", "cls", ".", "a2b", ":", "return", "True", ",", "False", "else", ":", "raise", "ValueError", "(", "\"Unknown _RerouteMode: {}\"", ".", "format", "(", "mode", ")", ")" ]

[ "Returns", "a", "sizer", "for", "a", "string", "field", "." ]

[ "def", "StringSizer", "(", "field_number", ",", "is_repeated", ",", "is_packed", ")", ":", "tag_size", "=", "_TagSize", "(", "field_number", ")", "local_VarintSize", "=", "_VarintSize", "local_len", "=", "len", "assert", "not", "is_packed", "if", "is_repeated", ":", "def", "RepeatedFieldSize", "(", "value", ")", ":", "result", "=", "tag_size", "*", "len", "(", "value", ")", "for", "element", "in", "value", ":", "l", "=", "local_len", "(", "element", ".", "encode", "(", "'utf-8'", ")", ")", "result", "+=", "local_VarintSize", "(", "l", ")", "+", "l", "return", "result", "return", "RepeatedFieldSize", "else", ":", "def", "FieldSize", "(", "value", ")", ":", "l", "=", "local_len", "(", "value", ".", "encode", "(", "'utf-8'", ")", ")", "return", "tag_size", "+", "local_VarintSize", "(", "l", ")", "+", "l", "return", "FieldSize" ]

[ "DeleteChildren", "(", "self", "TreeItemId", "item", ")" ]

[ "def", "DeleteChildren", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gizmos", ".", "TreeListCtrl_DeleteChildren", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Removes", "the", "thread", "with", "the", "indicated", "ID", "from", "the", "thread", "list", "." ]

[ "def", "_remove_thread_id", "(", "threadId", ")", ":", "# On interpreter shutdown, Python may set module globals to None.", "if", "_threadsLock", "is", "None", "or", "_threads", "is", "None", ":", "return", "_threadsLock", ".", "acquire", "(", ")", "try", ":", "if", "threadId", "in", "_threads", ":", "thread", ",", "locals", ",", "wrapper", "=", "_threads", "[", "threadId", "]", "assert", "thread", ".", "getPythonIndex", "(", ")", "==", "threadId", "del", "_threads", "[", "threadId", "]", "thread", ".", "setPythonIndex", "(", "-", "1", ")", "finally", ":", "_threadsLock", ".", "release", "(", ")" ]

[ "Return", "line", "number", "information", "associated", "with", "the", "frame", "s", "pc", ".", "If", "symbol", "table", "/", "line", "information", "does", "not", "exist", "or", "if", "this", "frame", "is", "deemed", "to", "be", "a", "special", "case", "return", "None" ]

[ "def", "line", "(", "self", ")", ":", "if", "hasattr", "(", "self", ".", "_base", ",", "\"line\"", ")", ":", "return", "self", ".", "_base", ".", "line", "(", ")", "frame", "=", "self", ".", "inferior_frame", "(", ")", "if", "self", ".", "_is_limited_frame", "(", "frame", ")", ":", "return", "None", "sal", "=", "frame", ".", "find_sal", "(", ")", "if", "(", "sal", ")", ":", "return", "sal", ".", "line", "else", ":", "return", "None" ]

[ "Returns", "flags", "that", "need", "to", "be", "passed", "to", "the", "linker", "." ]

[ "def", "GetLdflags", "(", "self", ",", "configname", ",", "product_dir", ",", "gyp_to_build_path", ")", ":", "self", ".", "configname", "=", "configname", "ldflags", "=", "[", "]", "# The xcode build is relative to a gyp file's directory, and OTHER_LDFLAGS", "# can contain entries that depend on this. Explicitly absolutify these.", "for", "ldflag", "in", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'OTHER_LDFLAGS'", ",", "[", "]", ")", ":", "ldflags", ".", "append", "(", "self", ".", "_MapLinkerFlagFilename", "(", "ldflag", ",", "gyp_to_build_path", ")", ")", "if", "self", ".", "_Test", "(", "'DEAD_CODE_STRIPPING'", ",", "'YES'", ",", "default", "=", "'NO'", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-dead_strip'", ")", "if", "self", ".", "_Test", "(", "'PREBINDING'", ",", "'YES'", ",", "default", "=", "'NO'", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-prebind'", ")", "self", ".", "_Appendf", "(", "ldflags", ",", "'DYLIB_COMPATIBILITY_VERSION'", ",", "'-compatibility_version %s'", ")", "self", ".", "_Appendf", "(", "ldflags", ",", "'DYLIB_CURRENT_VERSION'", ",", "'-current_version %s'", ")", "self", ".", "_Appendf", "(", "ldflags", ",", "'MACOSX_DEPLOYMENT_TARGET'", ",", "'-mmacosx-version-min=%s'", ")", "if", "'SDKROOT'", "in", "self", ".", "_Settings", "(", ")", ":", "ldflags", ".", "append", "(", "'-isysroot '", "+", "self", ".", "_SdkPath", "(", ")", ")", "for", "library_path", "in", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'LIBRARY_SEARCH_PATHS'", ",", "[", "]", ")", ":", "ldflags", ".", "append", "(", "'-L'", "+", "gyp_to_build_path", "(", "library_path", ")", ")", "if", "'ORDER_FILE'", "in", "self", ".", "_Settings", "(", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-order_file '", "+", "'-Wl,'", "+", "gyp_to_build_path", "(", "self", ".", "_Settings", "(", ")", "[", "'ORDER_FILE'", "]", ")", ")", "archs", "=", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'ARCHS'", ",", "[", "'i386'", "]", ")", "if", "len", "(", "archs", ")", "!=", "1", ":", "# TODO: Supporting fat binaries will be annoying.", "self", ".", "_WarnUnimplemented", "(", "'ARCHS'", ")", "archs", "=", "[", "'i386'", "]", "ldflags", ".", "append", "(", "'-arch '", "+", "archs", "[", "0", "]", ")", "# Xcode adds the product directory by default.", "ldflags", ".", "append", "(", "'-L'", "+", "product_dir", ")", "install_name", "=", "self", ".", "GetInstallName", "(", ")", "if", "install_name", ":", "ldflags", ".", "append", "(", "'-install_name '", "+", "install_name", ".", "replace", "(", "' '", ",", "r'\\ '", ")", ")", "for", "rpath", "in", "self", ".", "_Settings", "(", ")", ".", "get", "(", "'LD_RUNPATH_SEARCH_PATHS'", ",", "[", "]", ")", ":", "ldflags", ".", "append", "(", "'-Wl,-rpath,'", "+", "rpath", ")", "config", "=", "self", ".", "spec", "[", "'configurations'", "]", "[", "self", ".", "configname", "]", "framework_dirs", "=", "config", ".", "get", "(", "'mac_framework_dirs'", ",", "[", "]", ")", "for", "directory", "in", "framework_dirs", ":", "ldflags", ".", "append", "(", "'-F'", "+", "directory", ".", "replace", "(", "'$(SDKROOT)'", ",", "self", ".", "_SdkPath", "(", ")", ")", ")", "self", ".", "configname", "=", "None", "return", "ldflags" ]

[ "see", "display_page" ]

[ "def", "do_dp", "(", "self", ",", "address", ")", ":", "return", "self", ".", "do_display_page", "(", "address", ")" ]

[ "Return", "the", "current", "contents", "of", "the", "line", "buffer", "." ]

[ "def", "get_line_buffer", "(", "self", ")", ":", "return", "self", ".", "mode", ".", "l_buffer", ".", "get_line_text", "(", ")" ]

[ "Loads", "a", "JSON", "file", "int", "a", "Python", "object", "and", "return", "this", "object", "." ]

[ "def", "_Load", "(", "filename", ")", ":", "# TODO(beaudoin): When moving to Python 2.7 use object_pairs_hook=OrderedDict.", "with", "open", "(", "filename", ",", "'r'", ")", "as", "handle", ":", "result", "=", "json", ".", "loads", "(", "json_comment_eater", ".", "Nom", "(", "handle", ".", "read", "(", ")", ")", ")", "return", "result" ]

[ "%feature", "(", "docstring", ")", "gr_make_align_on_samplenumbers_ss", "::", "align_state", "Wraps", "the", "C", "++", ":", "gr_align_on_samplenumbers_ss", "::", "align_state", ";" ]

[ "def", "generate_swig_doc_i", "(", "self", ")", ":", "pass" ]

[ "Helper", "method", "for", "fromPy", "." ]

[ "def", "_fromPyHelper", "(", "self", ",", "value", ",", "name", "=", "None", ",", "path", "=", "None", ")", ":", "# Note, the double exception throwing has no good solution in Python 2,", "# but Python 3 has exception chaining that we should use when we can", "activeElement", "=", "self", "def", "getActivePathMessage", "(", "isArrayEntry", "=", "False", ")", ":", "elementType", "=", "\"scalar\"", "if", "activeElement", ".", "isArray", "(", ")", ":", "elementType", "=", "\"array\"", "elif", "activeElement", ".", "isComplexType", "(", ")", ":", "elementType", "=", "\"complex\"", "arrayEntryText", "=", "\"an entry in \"", "if", "isArrayEntry", "else", "\"\"", "return", "\"While operating on {}{} Element `{}`, \"", ".", "format", "(", "arrayEntryText", ",", "elementType", ",", "path", ")", "if", "path", "is", "None", ":", "path", "=", "str", "(", "activeElement", ".", "name", "(", ")", ")", "if", "name", "is", "not", "None", ":", "try", ":", "activeElement", "=", "self", ".", "getElement", "(", "name", ")", "path", "+=", "\"/\"", "+", "str", "(", "activeElement", ".", "name", "(", ")", ")", "except", "Exception", "as", "exc", ":", "errorMsg", "=", "\"encountered error: {}\"", ".", "format", "(", "exc", ")", "raise", "Exception", "(", "getActivePathMessage", "(", ")", "+", "errorMsg", ")", "if", "activeElement", ".", "numElements", "(", ")", "or", "activeElement", ".", "numValues", "(", ")", ":", "errorMsg", "=", "\"this Element has already been formatted\"", "raise", "Exception", "(", "getActivePathMessage", "(", ")", "+", "errorMsg", ")", "if", "isinstance", "(", "value", ",", "Mapping", ")", ":", "if", "not", "activeElement", ".", "isComplexType", "(", ")", ":", "errorMsg", "=", "\"encountered a `Mapping` instance while\"", "\" formatting a non-complex Element\"", "raise", "Exception", "(", "getActivePathMessage", "(", ")", "+", "errorMsg", ")", "complexElement", "=", "activeElement", "for", "subName", "in", "value", ":", "subValue", "=", "value", "[", "subName", "]", "complexElement", ".", "_fromPyHelper", "(", "subValue", ",", "subName", ",", "path", ")", "elif", "isNonScalarSequence", "(", "value", ")", ":", "if", "not", "activeElement", ".", "isArray", "(", ")", ":", "errorMsg", "=", "\"encountered a `Sequence` while formatting a\"", "\" non-array Element\"", "raise", "Exception", "(", "getActivePathMessage", "(", ")", "+", "errorMsg", ")", "arrayElement", "=", "activeElement", "typeDef", "=", "arrayElement", ".", "elementDefinition", "(", ")", ".", "typeDefinition", "(", ")", "arrayValuesAreScalar", "=", "not", "typeDef", ".", "isComplexType", "(", ")", "for", "index", ",", "val", "in", "enumerate", "(", "value", ")", ":", "if", "isinstance", "(", "val", ",", "Mapping", ")", ":", "if", "arrayValuesAreScalar", ":", "path", "+=", "\"[{}]\"", ".", "format", "(", "index", ")", "errorMsg", "=", "\"encountered a `Mapping` where a scalar\"", "\" value was expected.\"", "raise", "Exception", "(", "getActivePathMessage", "(", "isArrayEntry", "=", "True", ")", "+", "errorMsg", ")", "appendedElement", "=", "arrayElement", ".", "appendElement", "(", ")", "arrayEntryPath", "=", "path", "+", "\"[{}]\"", ".", "format", "(", "index", ")", "appendedElement", ".", "_fromPyHelper", "(", "val", ",", "path", "=", "arrayEntryPath", ")", "elif", "isNonScalarSequence", "(", "val", ")", ":", "path", "+=", "\"[{}]\"", ".", "format", "(", "index", ")", "expectedObject", "=", "\"scalar value\"", "if", "arrayValuesAreScalar", "else", "\"`Mapping`\"", "errorMsg", "=", "\"encountered a nested `Sequence` where a {}\"", "\" was expected.\"", ".", "format", "(", "expectedObject", ")", "raise", "Exception", "(", "getActivePathMessage", "(", "isArrayEntry", "=", "True", ")", "+", "errorMsg", ")", "else", ":", "if", "not", "arrayValuesAreScalar", ":", "path", "+=", "\"[{}]\"", ".", "format", "(", "index", ")", "errorMsg", "=", "\"encountered a scalar value where a\"", "\" `Mapping` was expected.\"", "raise", "Exception", "(", "getActivePathMessage", "(", "isArrayEntry", "=", "True", ")", "+", "errorMsg", ")", "try", ":", "arrayElement", ".", "appendValue", "(", "val", ")", "except", "Exception", "as", "exc", ":", "path", "+=", "\"[{}]\"", ".", "format", "(", "index", ")", "errorMsg", "=", "\"encountered error: {}\"", ".", "format", "(", "exc", ")", "raise", "Exception", "(", "getActivePathMessage", "(", "isArrayEntry", "=", "True", ")", "+", "errorMsg", ")", "else", ":", "if", "value", "is", "None", ":", "return", "if", "activeElement", ".", "isComplexType", "(", ")", "or", "activeElement", ".", "isArray", "(", ")", ":", "errorMsg", "=", "\"encountered an incompatible type, {}, for a\"", "\" non-scalar Element\"", ".", "format", "(", "type", "(", "value", ")", ")", "raise", "Exception", "(", "getActivePathMessage", "(", ")", "+", "errorMsg", ")", "try", ":", "activeElement", ".", "setValue", "(", "value", ")", "except", "Exception", "as", "exc", ":", "errorMsg", "=", "\"encountered error: {}\"", ".", "format", "(", "exc", ")", "raise", "Exception", "(", "getActivePathMessage", "(", ")", "+", "errorMsg", ")" ]

[ "Clear", "the", "module", "state", ".", "This", "is", "mainly", "for", "testing", "purposes", "." ]

[ "def", "reset", "(", ")", ":", "global", "__scanners", ",", "__rv_cache", ",", "__scanner_cache", "# Maps registered scanner classes to relevant properties", "__scanners", "=", "{", "}", "# A cache of scanners.", "# The key is: class_name.properties_tag, where properties_tag is the concatenation ", "# of all relevant properties, separated by '-'", "__scanner_cache", "=", "{", "}" ]

[ "Puts", "all", "source", "files", "into", "a", "tar", ".", "gz", "file", "." ]

[ "def", "collectintargz", "(", "target", ",", "source", ",", "env", ")", ":", "# the rpm tool depends on a source package, until this is changed", "# this hack needs to be here that tries to pack all sources in.", "sources", "=", "env", ".", "FindSourceFiles", "(", ")", "# filter out the target we are building the source list for.", "sources", "=", "[", "s", "for", "s", "in", "sources", "if", "s", "not", "in", "target", "]", "# find the .spec file for rpm and add it since it is not necessarily found", "# by the FindSourceFiles function.", "sources", ".", "extend", "(", "[", "s", "for", "s", "in", "source", "if", "str", "(", "s", ")", ".", "rfind", "(", "'.spec'", ")", "!=", "-", "1", "]", ")", "# as the source contains the url of the source package this rpm package", "# is built from, we extract the target name", "tarball", "=", "(", "str", "(", "target", "[", "0", "]", ")", "+", "\".tar.gz\"", ")", ".", "replace", "(", "'.rpm'", ",", "''", ")", "try", ":", "tarball", "=", "env", "[", "'SOURCE_URL'", "]", ".", "split", "(", "'/'", ")", "[", "-", "1", "]", "except", "KeyError", ",", "e", ":", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "\"Missing PackageTag '%s' for RPM packager\"", "%", "e", ".", "args", "[", "0", "]", ")", "tarball", "=", "src_targz", ".", "package", "(", "env", ",", "source", "=", "sources", ",", "target", "=", "tarball", ",", "PACKAGEROOT", "=", "env", "[", "'PACKAGEROOT'", "]", ",", ")", "return", "(", "target", ",", "tarball", ")" ]

[ "Sets", "the", "global", "TensorFlow", "session", "." ]

[ "def", "set_session", "(", "session", ")", ":", "global", "_SESSION", "_SESSION", "=", "session" ]

[ "remove", "effect", "of", "(", "constant", "high", "-", "frequency", ")", "epsilon", "from", "sigma" ]

[ "def", "removeEpsilonEffect", "(", "self", ",", "er", "=", "None", ",", "mode", "=", "0", ")", ":", "sigR", ",", "sigI", "=", "self", ".", "realimag", "(", "cond", "=", "True", ")", "if", "er", "is", "None", ":", "#", "er", "=", "self", ".", "determineEpsilon", "(", "mode", "=", "mode", ",", "sigmaR", "=", "sigR", ",", "sigmaI", "=", "sigI", ")", "print", "(", "\"detected epsilon of \"", ",", "er", ")", "sigI", "-=", "er", "*", "self", ".", "omega", "(", ")", "*", "self", ".", "epsilon0", "self", ".", "phiOrg", "=", "self", ".", "phi", "self", ".", "phi", "=", "np", ".", "arctan", "(", "sigI", "/", "sigR", ")", "self", ".", "ampOrg", "=", "self", ".", "amp", "self", ".", "amp", "=", "1.", "/", "np", ".", "sqrt", "(", "sigR", "**", "2", "+", "sigR", "**", "2", ")", "return", "er" ]

[ "analyze", "a", "simple", "word", "to", "detect", "cross", "-", "references", "and", "styling" ]

[ "def", "make_html_word", "(", "self", ",", "word", ")", ":", "# look for cross-references", "m", "=", "re_crossref", ".", "match", "(", "word", ")", "if", "m", ":", "try", ":", "name", "=", "m", ".", "group", "(", "1", ")", "rest", "=", "m", ".", "group", "(", "2", ")", "block", "=", "self", ".", "identifiers", "[", "name", "]", "url", "=", "self", ".", "make_block_url", "(", "block", ")", "return", "'<a href=\"'", "+", "url", "+", "'\">'", "+", "name", "+", "'</a>'", "+", "rest", "except", ":", "# we detected a cross-reference to an unknown item", "sys", ".", "stderr", ".", "write", "(", "\"WARNING: undefined cross reference '\"", "+", "name", "+", "\"'.\\n\"", ")", "return", "'?'", "+", "name", "+", "'?'", "+", "rest", "# look for italics and bolds", "m", "=", "re_italic", ".", "match", "(", "word", ")", "if", "m", ":", "name", "=", "m", ".", "group", "(", "1", ")", "rest", "=", "m", ".", "group", "(", "3", ")", "return", "'<i>'", "+", "name", "+", "'</i>'", "+", "rest", "m", "=", "re_bold", ".", "match", "(", "word", ")", "if", "m", ":", "name", "=", "m", ".", "group", "(", "1", ")", "rest", "=", "m", ".", "group", "(", "3", ")", "return", "'<b>'", "+", "name", "+", "'</b>'", "+", "rest", "return", "html_quote", "(", "word", ")" ]

[ "Replace", "HTML", "tags", "with", "Kodi", "skin", "tags" ]

[ "def", "_clean_plot", "(", "plot", ")", ":", "# type: (Text) -> Text", "for", "repl", "in", "CLEAN_PLOT_REPLACEMENTS", ":", "plot", "=", "plot", ".", "replace", "(", "repl", "[", "0", "]", ",", "repl", "[", "1", "]", ")", "plot", "=", "TAG_RE", ".", "sub", "(", "''", ",", "plot", ")", "return", "plot" ]

[ "return", "x", "y", "yerr" ]

[ "def", "extract_data", "(", "self", ",", "lines", ")", ":", "data", "=", "defaultdict", "(", "list", ")", "cur_x", "=", "None", "for", "lino", ",", "line", "in", "enumerate", "(", "lines", ")", ":", "tx", "=", "self", ".", "get_x", "(", "line", ")", "if", "tx", "is", "not", "None", ":", "assert", "cur_x", "is", "None", ",", "(", "lino", "+", "1", ",", "line", ")", "cur_x", "=", "tx", "ty", "=", "self", ".", "get_y", "(", "line", ")", "if", "ty", "is", "not", "None", ":", "assert", "cur_x", "is", "not", "None", ",", "(", "lino", "+", "1", ",", "line", ")", "data", "[", "cur_x", "]", ".", "append", "(", "ty", ")", "cur_x", "=", "None", "xs", ",", "ys", ",", "yerr", "=", "[", "]", ",", "[", "]", ",", "[", "]", "for", "x", ",", "y", "in", "sorted", "(", "data", ".", "iteritems", "(", ")", ")", ":", "xs", ".", "append", "(", "x", ")", "ys", ".", "append", "(", "np", ".", "mean", "(", "y", ")", ")", "yerr", ".", "append", "(", "np", ".", "std", "(", "y", ")", ")", "return", "xs", ",", "ys", ",", "yerr" ]

[ "parse_args", "(", "args", ":", "[", "string", "]", "=", "sys", ".", "argv", "[", "1", ":", "]", "values", ":", "Values", "=", "None", ")", "-", ">", "(", "values", ":", "Values", "args", ":", "[", "string", "]", ")" ]

[ "def", "parse_args", "(", "self", ",", "args", "=", "None", ",", "values", "=", "None", ")", ":", "rargs", "=", "self", ".", "_get_args", "(", "args", ")", "if", "values", "is", "None", ":", "values", "=", "self", ".", "get_default_values", "(", ")", "# Store the halves of the argument list as attributes for the", "# convenience of callbacks:", "# rargs", "# the rest of the command-line (the \"r\" stands for", "# \"remaining\" or \"right-hand\")", "# largs", "# the leftover arguments -- ie. what's left after removing", "# options and their arguments (the \"l\" stands for \"leftover\"", "# or \"left-hand\")", "self", ".", "rargs", "=", "rargs", "self", ".", "largs", "=", "largs", "=", "[", "]", "self", ".", "values", "=", "values", "try", ":", "stop", "=", "self", ".", "_process_args", "(", "largs", ",", "rargs", ",", "values", ")", "except", "(", "BadOptionError", ",", "OptionValueError", ")", ",", "err", ":", "self", ".", "error", "(", "str", "(", "err", ")", ")", "args", "=", "largs", "+", "rargs", "return", "self", ".", "check_values", "(", "values", ",", "args", ")" ]

[ "Set", "the", "scale", "of", "preprocessed", "inputs", "s", ".", "t", ".", "the", "blob", "=", "blob", "*", "scale", ".", "N", ".", "B", ".", "input_scale", "is", "done", "AFTER", "mean", "subtraction", "and", "other", "preprocessing", "while", "raw_scale", "is", "done", "BEFORE", "." ]

[ "def", "set_input_scale", "(", "self", ",", "in_", ",", "scale", ")", ":", "self", ".", "__check_input", "(", "in_", ")", "self", ".", "input_scale", "[", "in_", "]", "=", "scale" ]

[ ":", "type", "s", ":", "str", ":", "rtype", ":", "str" ]

[ "def", "reverseString", "(", "self", ",", "s", ")", ":", "return", "s", "[", ":", ":", "-", "1", "]" ]

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

[ "def", "IsControl", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "ToolBarToolBase_IsControl", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Creates", "the", "NN", "function", "without", "any", "buffers", "in", "it", "s", "signature" ]

[ "def", "base_declaration", "(", "func", ",", "thnn_function", ",", "backends", ",", "backend_types", ",", "inplace", "=", "False", ")", ":", "name", ",", "params", "=", "re", ".", "match", "(", "NAME_PARAM_REGEX", ",", "func", "[", "'name'", "]", ")", ".", "groups", "(", ")", "if", "inplace", ":", "name", "+=", "'_'", "params", "=", "params", ".", "split", "(", "', '", ")", "arguments", "=", "[", "argument_to_declaration", "(", "a", ",", "func", ")", "for", "a", "in", "params", "]", "if", "not", "inplace", ":", "arguments", "+=", "output_arguments", "(", "thnn_function", ")", "buffers", "=", "[", "argument_to_declaration", "(", "'Tensor '", "+", "buf", ")", "for", "buf", "in", "func", ".", "get", "(", "'buffers'", ",", "[", "]", ")", "]", "return", "function_info", "(", "name", ",", "arguments", ",", "None", ",", "buffers", ",", "backends", ",", "inplace", ",", "func", ".", "get", "(", "'scalar_check'", ")", ",", "backend_types", ")" ]

[ "Walk", "a", "Graph", "and", "capture", "the", "subgraph", "between", "init_tensor", "and", "sources", "." ]

[ "def", "map_subgraph", "(", "init_tensor", ",", "sources", ",", "disallowed_placeholders", ",", "visited_ops", ",", "op_outputs", ",", "add_sources", ")", ":", "ops_to_visit", "=", "[", "_as_operation", "(", "init_tensor", ")", "]", "extra_sources", "=", "object_identity", ".", "ObjectIdentitySet", "(", ")", "while", "ops_to_visit", ":", "op", "=", "ops_to_visit", ".", "pop", "(", ")", "if", "op", "in", "visited_ops", ":", "continue", "visited_ops", ".", "add", "(", "op", ")", "should_raise", "=", "False", "if", "disallowed_placeholders", "is", "not", "None", "and", "op", "in", "disallowed_placeholders", ":", "should_raise", "=", "True", "elif", "op", ".", "type", "==", "\"Placeholder\"", ":", "if", "disallowed_placeholders", "is", "None", "and", "not", "add_sources", ":", "should_raise", "=", "True", "extra_sources", ".", "update", "(", "op", ".", "outputs", ")", "if", "should_raise", ":", "raise", "UnliftableError", "(", "\"Unable to lift tensor %s because it depends transitively on \"", "\"placeholder %s via at least one path, e.g.: %s\"", "%", "(", "repr", "(", "init_tensor", ")", ",", "repr", "(", "op", ")", ",", "_path_from", "(", "op", ",", "init_tensor", ",", "sources", ")", ")", ")", "for", "inp", "in", "graph_inputs", "(", "op", ")", ":", "op_outputs", "[", "inp", "]", ".", "add", "(", "op", ")", "if", "inp", "not", "in", "visited_ops", "and", "inp", "not", "in", "(", "sources", "or", "extra_sources", ")", ":", "ops_to_visit", ".", "append", "(", "inp", ")", "return", "extra_sources" ]

[ "GetPasswordFromUser", "(", "String", "message", "String", "caption", "=", "EmptyString", "String", "default_value", "=", "EmptyString", "Window", "parent", "=", "None", ")", "-", ">", "String" ]

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

[ "TpmUnion", "method" ]

[ "def", "GetUnionSelector", "(", "self", ")", ":", "# TPM_ALG_ID", "return", "TPM_ALG_ID", ".", "NULL" ]

[ "Attempts", "to", "find", "an", "executable", "in", "the", "path" ]

[ "def", "find_in_path", "(", "file", ",", "path", "=", "None", ")", ":", "if", "platform", ".", "system", "(", ")", "==", "'Windows'", ":", "file", "+=", "'.exe'", "if", "path", "is", "None", ":", "path", "=", "os", ".", "environ", ".", "get", "(", "'PATH'", ",", "''", ")", "if", "type", "(", "path", ")", "is", "type", "(", "''", ")", ":", "path", "=", "path", ".", "split", "(", "os", ".", "pathsep", ")", "return", "list", "(", "filter", "(", "os", ".", "path", ".", "exists", ",", "map", "(", "lambda", "dir", ",", "file", "=", "file", ":", "os", ".", "path", ".", "join", "(", "dir", ",", "file", ")", ",", "path", ")", ")", ")" ]

[ "Add", "a", "param", "to", "the", ".", "params", "file" ]

[ "def", "add_param", "(", "self", ",", "param_name", ",", "layer_index", ",", "blob_index", ")", ":", "blobs", "=", "self", ".", "layers", "[", "layer_index", "]", ".", "blobs", "self", ".", "dict_param", "[", "param_name", "]", "=", "mx", ".", "nd", ".", "array", "(", "caffe", ".", "io", ".", "blobproto_to_array", "(", "blobs", "[", "blob_index", "]", ")", ")" ]

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

[ "def", "GetOverflowVisible", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_aui", ".", "AuiToolBar_GetOverflowVisible", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]