Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Sort", "a", "given", "array", "which", "should", "only", "include", "0", "s", "and", "1", "s", "Raise", "a", "value", "error", "on", "the", "first", "value", "which", "is", "not", "0", "or", "1", "otherwise", "returns", "a", "sorted", "array" ]

[ "def", "sortArray", "(", "array", ")", ":", "num_of_ones", "=", "0", "for", "x", "in", "array", ":", "if", "x", "==", "0", ":", "pass", "elif", "x", "==", "1", ":", "num_of_ones", "+=", "1", "else", ":", "raise", "ValueError", "sorted_array", "=", "[", "]", "for", "i", "in", "range", "(", "len", "(", "array", ")", "-", "num_of_ones", ")", ":", "sorted_array", ".", "append", "(", "0", ")", "for", "i", "in", "range", "(", "len", "(", "array", ")", "-", "num_of_ones", ",", "len", "(", "array", ")", ")", ":", "sorted_array", ".", "append", "(", "1", ")", "return", "sorted_array" ]

[ "This", "function", "prints", "info", "on", "screen" ]

[ "def", "KratosPrintInfo", "(", "message", ")", ":", "KM", ".", "Logger", ".", "Print", "(", "\"\"", ",", "message", ")", "KM", ".", "Logger", ".", "Flush", "(", ")" ]

[ "Return", "the", "Unified", "Symbol", "Resultion", "(", "USR", ")", "for", "the", "entity", "referenced", "by", "the", "given", "cursor", "(", "or", "None", ")", "." ]

[ "def", "get_usr", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_getCursorUSR", "(", "self", ")" ]

[ "This", "method", "is", "called", "before", "IR", "generation", ".", "This", "method", "sets", "internal_layer_id", "." ]

[ "def", "re_numerate_internal_id_and_get_if_id", "(", "if_node", ")", ":", "then_graph_nodes", "=", "if_node", ".", "then_graph", ".", "nodes", "(", ")", "for", "idx", "in", "range", "(", "len", "(", "if_node", ".", "then_graph", ".", "get_op_nodes", "(", ")", ")", ")", ":", "then_graph_nodes", "[", "idx", "]", "[", "'internal_layer_id'", "]", "=", "idx", "else_graph_nodes", "=", "if_node", ".", "else_graph", ".", "nodes", "(", ")", "for", "idx", "in", "range", "(", "len", "(", "if_node", ".", "else_graph", ".", "get_op_nodes", "(", ")", ")", ")", ":", "else_graph_nodes", "[", "idx", "]", "[", "'internal_layer_id'", "]", "=", "idx", "return", "if_node", ".", "node" ]

[ "Buffer", "size", "in", "bytes", "." ]

[ "def", "bufsize", "(", "self", ")", "->", "int", ":", "return", "self", ".", "_buf", ".", "nbytes" ]

[ "Generates", "a", "string", "of", "the", "location", "string", "up", "to", "a", "given", "scope", ".", "The", "input", "scope", "is", "inclusive", "." ]

[ "def", "location_up_to_scope", "(", "shard", ":", "ShardID", ",", "location_per_scope", ":", "Mapping", "[", "LocationScope", ",", "str", "]", ",", "scope", ":", "LocationScope", ",", ")", "->", "str", ":", "if", "not", "location_per_scope", ":", "return", "\"UNKNOWN\"", "locs", "=", "[", "]", "# Sort scopes from bigger to smaller (ROOT > REGION > CLUSTER > ...)", "for", "loc_scope", "in", "sorted", "(", "location_per_scope", ".", "keys", "(", ")", ",", "key", "=", "lambda", "x", ":", "x", ".", "value", ",", "reverse", "=", "True", ")", ":", "if", "loc_scope", ".", "value", ">=", "scope", ".", "value", ":", "locs", ".", "append", "(", "location_per_scope", "[", "loc_scope", "]", ")", "else", ":", "break", "if", "scope", "==", "LocationScope", ".", "NODE", ":", "locs", ".", "append", "(", "str", "(", "shard", ".", "node", ".", "node_index", ")", ")", "return", "\".\"", ".", "join", "(", "locs", ")" ]

[ "Return", "the", "output", "file", "specified", "by", "this", "command", "or", "None", "if", "not", "specified", "." ]

[ "def", "get_output_file", "(", "args", ")", ":", "grabnext", "=", "False", "for", "arg", "in", "args", ":", "if", "grabnext", ":", "return", "arg", "if", "arg", "==", "'-o'", ":", "# Specified as a separate arg", "grabnext", "=", "True", "elif", "arg", ".", "startswith", "(", "'-o'", ")", ":", "# Specified conjoined with -o", "return", "arg", "[", "2", ":", "]", "assert", "grabnext", "==", "False", "return", "None" ]

[ "Set", "the", "value", "to", "return", "when", "this", "method", "is", "called", "." ]

[ "def", "AndReturn", "(", "self", ",", "return_value", ")", ":", "self", ".", "_return_value", "=", "return_value", "return", "return_value" ]

[]

[ "def", "dist_is_editable", "(", "dist", ")", ":", "# type: (Distribution) -> bool", "for", "path_item", "in", "sys", ".", "path", ":", "egg_link", "=", "os", ".", "path", ".", "join", "(", "path_item", ",", "dist", ".", "project_name", "+", "'.egg-link'", ")", "if", "os", ".", "path", ".", "isfile", "(", "egg_link", ")", ":", "return", "True", "return", "False" ]

[ "A", "factory", "method", "which", "allows", "subclasses", "to", "define", "the", "precise", "type", "of", "socket", "they", "want", "." ]

[ "def", "makeSocket", "(", "self", ",", "timeout", "=", "1", ")", ":", "if", "self", ".", "port", "is", "not", "None", ":", "result", "=", "socket", ".", "create_connection", "(", "self", ".", "address", ",", "timeout", "=", "timeout", ")", "else", ":", "result", "=", "socket", ".", "socket", "(", "socket", ".", "AF_UNIX", ",", "socket", ".", "SOCK_STREAM", ")", "result", ".", "settimeout", "(", "timeout", ")", "try", ":", "result", ".", "connect", "(", "self", ".", "address", ")", "except", "OSError", ":", "result", ".", "close", "(", ")", "# Issue 19182", "raise", "return", "result" ]

[ "r", "Function", "to", "calculate", "only", "the", "edges", "of", "the", "bins", "used", "by", "the", "histogram", "function", "." ]

[ "def", "histogram_bin_edges", "(", "a", ",", "bins", "=", "10", ",", "range", "=", "None", ",", "weights", "=", "None", ")", ":", "a", ",", "weights", "=", "_ravel_and_check_weights", "(", "a", ",", "weights", ")", "bin_edges", ",", "_", "=", "_get_bin_edges", "(", "a", ",", "bins", ",", "range", ",", "weights", ")", "return", "bin_edges" ]

[ "Calculate", "the", "relative", "extrema", "of", "data", "." ]

[ "def", "_boolrelextrema", "(", "data", ",", "comparator", ",", "axis", "=", "0", ",", "order", "=", "1", ",", "mode", "=", "'clip'", ")", ":", "if", "(", "(", "int", "(", "order", ")", "!=", "order", ")", "or", "(", "order", "<", "1", ")", ")", ":", "raise", "ValueError", "(", "'Order must be an int >= 1'", ")", "datalen", "=", "data", ".", "shape", "[", "axis", "]", "locs", "=", "np", ".", "arange", "(", "0", ",", "datalen", ")", "results", "=", "np", ".", "ones", "(", "data", ".", "shape", ",", "dtype", "=", "bool", ")", "main", "=", "data", ".", "take", "(", "locs", ",", "axis", "=", "axis", ",", "mode", "=", "mode", ")", "for", "shift", "in", "xrange", "(", "1", ",", "order", "+", "1", ")", ":", "plus", "=", "data", ".", "take", "(", "locs", "+", "shift", ",", "axis", "=", "axis", ",", "mode", "=", "mode", ")", "minus", "=", "data", ".", "take", "(", "locs", "-", "shift", ",", "axis", "=", "axis", ",", "mode", "=", "mode", ")", "results", "&=", "comparator", "(", "main", ",", "plus", ")", "results", "&=", "comparator", "(", "main", ",", "minus", ")", "if", "(", "~", "results", ".", "any", "(", ")", ")", ":", "return", "results", "return", "results" ]

[ "Encoding", "iterator", "." ]

[ "def", "iterencode", "(", "iterator", ",", "encoding", ",", "errors", "=", "'strict'", ",", "*", "*", "kwargs", ")", ":", "encoder", "=", "getincrementalencoder", "(", "encoding", ")", "(", "errors", ",", "*", "*", "kwargs", ")", "for", "input", "in", "iterator", ":", "output", "=", "encoder", ".", "encode", "(", "input", ")", "if", "output", ":", "yield", "output", "output", "=", "encoder", ".", "encode", "(", "\"\"", ",", "True", ")", "if", "output", ":", "yield", "output" ]

[ "Checks", "the", "TSan", "suppressions", "files", "for", "bad", "suppressions", "." ]

[ "def", "CheckChange", "(", "input_api", ",", "output_api", ")", ":", "# Add the path to the Chrome valgrind dir to the import path:", "tools_vg_path", "=", "os", ".", "path", ".", "join", "(", "input_api", ".", "PresubmitLocalPath", "(", ")", ",", "'..'", ",", "'..'", ",", "'valgrind'", ")", "sys", ".", "path", ".", "append", "(", "tools_vg_path", ")", "import", "suppressions", "return", "suppressions", ".", "PresubmitCheck", "(", "input_api", ",", "output_api", ")" ]

[ "Compute", "the", "top_k", "classification", "accuracy", "for", "the", "given", "network", "and", "images", "." ]

[ "def", "validate", "(", "net", ",", "model_path", ",", "image_producer", ",", "top_k", "=", "5", ")", ":", "# Get the data specifications for given network", "spec", "=", "models", ".", "get_data_spec", "(", "model_instance", "=", "net", ")", "# Get the input node for feeding in the images", "input_node", "=", "net", ".", "inputs", "[", "'data'", "]", "# Create a placeholder for the ground truth labels", "label_node", "=", "tf", ".", "placeholder", "(", "tf", ".", "int32", ")", "# Get the output of the network (class probabilities)", "probs", "=", "net", ".", "get_output", "(", ")", "# Create a top_k accuracy node", "top_k_op", "=", "tf", ".", "nn", ".", "in_top_k", "(", "probs", ",", "label_node", ",", "top_k", ")", "# The number of images processed", "count", "=", "0", "# The number of correctly classified images", "correct", "=", "0", "# The total number of images", "total", "=", "len", "(", "image_producer", ")", "with", "tf", ".", "Session", "(", ")", "as", "sesh", ":", "coordinator", "=", "tf", ".", "train", ".", "Coordinator", "(", ")", "# Load the converted parameters", "net", ".", "load", "(", "data_path", "=", "model_path", ",", "session", "=", "sesh", ")", "# Start the image processing workers", "threads", "=", "image_producer", ".", "start", "(", "session", "=", "sesh", ",", "coordinator", "=", "coordinator", ")", "# Iterate over and classify mini-batches", "for", "(", "labels", ",", "images", ")", "in", "image_producer", ".", "batches", "(", "sesh", ")", ":", "correct", "+=", "np", ".", "sum", "(", "sesh", ".", "run", "(", "top_k_op", ",", "feed_dict", "=", "{", "input_node", ":", "images", ",", "label_node", ":", "labels", "}", ")", ")", "count", "+=", "len", "(", "labels", ")", "cur_accuracy", "=", "float", "(", "correct", ")", "*", "100", "/", "count", "print", "(", "'{:>6}/{:<6} {:>6.2f}%'", ".", "format", "(", "count", ",", "total", ",", "cur_accuracy", ")", ")", "# Stop the worker threads", "coordinator", ".", "request_stop", "(", ")", "coordinator", ".", "join", "(", "threads", ",", "stop_grace_period_secs", "=", "2", ")", "print", "(", "'Top {} Accuracy: {}'", ".", "format", "(", "top_k", ",", "float", "(", "correct", ")", "/", "total", ")", ")" ]

[ "Validator", "to", "check", "if", "Path", "is", "a", "file" ]

[ "def", "PathIsFile", "(", "self", ",", "key", ",", "val", ",", "env", ")", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "val", ")", ":", "if", "os", ".", "path", ".", "isdir", "(", "val", ")", ":", "m", "=", "'File path for option %s is a directory: %s'", "else", ":", "m", "=", "'File path for option %s does not exist: %s'", "raise", "SCons", ".", "Errors", ".", "UserError", "(", "m", "%", "(", "key", ",", "val", ")", ")" ]

[ "Adds", "a", "tool", "file", "to", "the", "project", "." ]

[ "def", "AddToolFile", "(", "self", ",", "path", ")", ":", "self", ".", "tool_files_section", ".", "append", "(", "[", "\"ToolFile\"", ",", "{", "\"RelativePath\"", ":", "path", "}", "]", ")" ]

[ "Initialize", "data", "attributes", "and", "bind", "event", "methods", "." ]

[ "def", "__init__", "(", "self", ",", "text", ")", ":", "self", ".", "text", "=", "text", "self", ".", "history", "=", "[", "]", "self", ".", "prefix", "=", "None", "self", ".", "pointer", "=", "None", "self", ".", "cyclic", "=", "idleConf", ".", "GetOption", "(", "\"main\"", ",", "\"History\"", ",", "\"cyclic\"", ",", "1", ",", "\"bool\"", ")", "text", ".", "bind", "(", "\"<<history-previous>>\"", ",", "self", ".", "history_prev", ")", "text", ".", "bind", "(", "\"<<history-next>>\"", ",", "self", ".", "history_next", ")" ]

[ "r", "Logs", "an", "error", "if", "we", "see", "certain", "non", "-", "ANSI", "constructs", "ignored", "by", "gcc", "-", "2", "." ]

[ "def", "CheckForNonStandardConstructs", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "# Remove comments from the line, but leave in strings for now.", "line", "=", "clean_lines", ".", "lines", "[", "linenum", "]", "if", "Search", "(", "r'printf\\s*\\(.*\".*%[-+ ]?\\d*q'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf_format'", ",", "3", ",", "'%q in format strings is deprecated. Use %ll instead.'", ")", "if", "Search", "(", "r'printf\\s*\\(.*\".*%\\d+\\$'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf_format'", ",", "2", ",", "'%N$ formats are unconventional. Try rewriting to avoid them.'", ")", "# Remove escaped backslashes before looking for undefined escapes.", "line", "=", "line", ".", "replace", "(", "'\\\\\\\\'", ",", "''", ")", "if", "Search", "(", "r'(\"|\\').*\\\\(%|\\[|\\(|{)'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/printf_format'", ",", "3", ",", "'%, [, (, and { are undefined character escapes. Unescape them.'", ")", "# For the rest, work with both comments and strings removed.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "Search", "(", "r'\\b(const|volatile|void|char|short|int|long'", "r'|float|double|signed|unsigned'", "r'|schar|u?int8|u?int16|u?int32|u?int64)'", "r'\\s+(register|static|extern|typedef)\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/storage_class'", ",", "5", ",", "'Storage-class specifier (static, extern, typedef, etc) should be '", "'at the beginning of the declaration.'", ")", "if", "Match", "(", "r'\\s*#\\s*endif\\s*[^/\\s]+'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/endif_comment'", ",", "5", ",", "'Uncommented text after #endif is non-standard. Use a comment.'", ")", "if", "Match", "(", "r'\\s*class\\s+(\\w+\\s*::\\s*)+\\w+\\s*;'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/forward_decl'", ",", "5", ",", "'Inner-style forward declarations are invalid. Remove this line.'", ")", "if", "Search", "(", "r'(\\w+|[+-]?\\d+(\\.\\d*)?)\\s*(<|>)\\?=?\\s*(\\w+|[+-]?\\d+)(\\.\\d*)?'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/deprecated'", ",", "3", ",", "'>? and <? (max and min) operators are non-standard and deprecated.'", ")", "if", "Search", "(", "r'^\\s*const\\s*string\\s*&\\s*\\w+\\s*;'", ",", "line", ")", ":", "# TODO(unknown): Could it be expanded safely to arbitrary references,", "# without triggering too many false positives? The first", "# attempt triggered 5 warnings for mostly benign code in the regtest, hence", "# the restriction.", "# Here's the original regexp, for the reference:", "# type_name = r'\\w+((\\s*::\\s*\\w+)|(\\s*<\\s*\\w+?\\s*>))?'", "# r'\\s*const\\s*' + type_name + '\\s*&\\s*\\w+\\s*;'", "error", "(", "filename", ",", "linenum", ",", "'runtime/member_string_references'", ",", "2", ",", "'const string& members are dangerous. It is much better to use '", "'alternatives, such as pointers or simple constants.'", ")", "# Everything else in this function operates on class declarations.", "# Return early if the top of the nesting stack is not a class, or if", "# the class head is not completed yet.", "classinfo", "=", "nesting_state", ".", "InnermostClass", "(", ")", "if", "not", "classinfo", "or", "not", "classinfo", ".", "seen_open_brace", ":", "return", "# The class may have been declared with namespace or classname qualifiers.", "# The constructor and destructor will not have those qualifiers.", "base_classname", "=", "classinfo", ".", "name", ".", "split", "(", "'::'", ")", "[", "-", "1", "]", "# Look for single-argument constructors that aren't marked explicit.", "# Technically a valid construct, but against style.", "explicit_constructor_match", "=", "Match", "(", "r'\\s+(?:(?:inline|constexpr)\\s+)*(explicit\\s+)?'", "r'(?:(?:inline|constexpr)\\s+)*%s\\s*'", "r'\\(((?:[^()]|\\([^()]*\\))*)\\)'", "%", "re", ".", "escape", "(", "base_classname", ")", ",", "line", ")", "if", "explicit_constructor_match", ":", "is_marked_explicit", "=", "explicit_constructor_match", ".", "group", "(", "1", ")", "if", "not", "explicit_constructor_match", ".", "group", "(", "2", ")", ":", "constructor_args", "=", "[", "]", "else", ":", "constructor_args", "=", "explicit_constructor_match", ".", "group", "(", "2", ")", ".", "split", "(", "','", ")", "# collapse arguments so that commas in template parameter lists and function", "# argument parameter lists don't split arguments in two", "i", "=", "0", "while", "i", "<", "len", "(", "constructor_args", ")", ":", "constructor_arg", "=", "constructor_args", "[", "i", "]", "while", "(", "constructor_arg", ".", "count", "(", "'<'", ")", ">", "constructor_arg", ".", "count", "(", "'>'", ")", "or", "constructor_arg", ".", "count", "(", "'('", ")", ">", "constructor_arg", ".", "count", "(", "')'", ")", ")", ":", "constructor_arg", "+=", "','", "+", "constructor_args", "[", "i", "+", "1", "]", "del", "constructor_args", "[", "i", "+", "1", "]", "constructor_args", "[", "i", "]", "=", "constructor_arg", "i", "+=", "1", "variadic_args", "=", "[", "arg", "for", "arg", "in", "constructor_args", "if", "'&&...'", "in", "arg", "]", "defaulted_args", "=", "[", "arg", "for", "arg", "in", "constructor_args", "if", "'='", "in", "arg", "]", "noarg_constructor", "=", "(", "not", "constructor_args", "# empty arg list", "# 'void' arg specifier", "or", "(", "len", "(", "constructor_args", ")", "==", "1", "and", "constructor_args", "[", "0", "]", ".", "strip", "(", ")", "==", "'void'", ")", ")", "onearg_constructor", "=", "(", "(", "len", "(", "constructor_args", ")", "==", "1", "# exactly one arg", "and", "not", "noarg_constructor", ")", "# all but at most one arg defaulted", "or", "(", "len", "(", "constructor_args", ")", ">=", "1", "and", "not", "noarg_constructor", "and", "len", "(", "defaulted_args", ")", ">=", "len", "(", "constructor_args", ")", "-", "1", ")", "# variadic arguments with zero or one argument", "or", "(", "len", "(", "constructor_args", ")", "<=", "2", "and", "len", "(", "variadic_args", ")", ">=", "1", ")", ")", "initializer_list_constructor", "=", "bool", "(", "onearg_constructor", "and", "Search", "(", "r'\\bstd\\s*::\\s*initializer_list\\b'", ",", "constructor_args", "[", "0", "]", ")", ")", "copy_constructor", "=", "bool", "(", "onearg_constructor", "and", "Match", "(", "r'(const\\s+)?%s(\\s*<[^>]*>)?(\\s+const)?\\s*(?:<\\w+>\\s*)?&'", "%", "re", ".", "escape", "(", "base_classname", ")", ",", "constructor_args", "[", "0", "]", ".", "strip", "(", ")", ")", ")", "if", "(", "not", "is_marked_explicit", "and", "onearg_constructor", "and", "not", "initializer_list_constructor", "and", "not", "copy_constructor", ")", ":", "if", "defaulted_args", "or", "variadic_args", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "5", ",", "'Constructors callable with one argument '", "'should be marked explicit.'", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "5", ",", "'Single-parameter constructors should be marked explicit.'", ")", "elif", "is_marked_explicit", "and", "not", "onearg_constructor", ":", "if", "noarg_constructor", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "5", ",", "'Zero-parameter constructors should not be marked explicit.'", ")" ]

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

[ "def", "SetValue", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "Gauge_SetValue", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Like", "SimpleDecoder", "but", "additionally", "invokes", "modify_value", "on", "every", "value", "before", "storing", "it", ".", "Usually", "modify_value", "is", "ZigZagDecode", "." ]

[ "def", "_ModifiedDecoder", "(", "wire_type", ",", "decode_value", ",", "modify_value", ")", ":", "# Reusing _SimpleDecoder is slightly slower than copying a bunch of code, but", "# not enough to make a significant difference.", "def", "InnerDecode", "(", "buffer", ",", "pos", ")", ":", "(", "result", ",", "new_pos", ")", "=", "decode_value", "(", "buffer", ",", "pos", ")", "return", "(", "modify_value", "(", "result", ")", ",", "new_pos", ")", "return", "_SimpleDecoder", "(", "wire_type", ",", "InnerDecode", ")" ]

[ "__getslice__", "(", "OrderComboLegList", "self", "std", "::", "vector<", "shared_ptr<", "OrderComboLeg", ">", ">", "::", "difference_type", "i", "std", "::", "vector<", "shared_ptr<", "OrderComboLeg", ">", ">", "::", "difference_type", "j", ")", "-", ">", "OrderComboLegList" ]

[ "def", "__getslice__", "(", "self", ",", "i", ",", "j", ")", ":", "return", "_swigibpy", ".", "OrderComboLegList___getslice__", "(", "self", ",", "i", ",", "j", ")" ]

[ "Get", "all", "dict", "entries", "indexed", "by", "name", "that", "apply", "to", "full_name", "or", "name", "." ]

[ "def", "_get_applicable_dict", "(", "self", ",", "transformer_field", ",", "full_name", ",", "name", ")", ":", "# Transformers are indexed to full name, name, or no name", "# as a performance optimization.", "function_transformers", "=", "getattr", "(", "self", ".", "_api_change_spec", ",", "transformer_field", ",", "{", "}", ")", "glob_name", "=", "\"*.\"", "+", "name", "if", "name", "else", "None", "transformers", "=", "function_transformers", ".", "get", "(", "\"*\"", ",", "{", "}", ")", ".", "copy", "(", ")", "transformers", ".", "update", "(", "function_transformers", ".", "get", "(", "glob_name", ",", "{", "}", ")", ")", "transformers", ".", "update", "(", "function_transformers", ".", "get", "(", "full_name", ",", "{", "}", ")", ")", "return", "transformers" ]

[ "GetBitmap", "(", "String", "id", "String", "client", "=", "ART_OTHER", "Size", "size", "=", "DefaultSize", ")", "-", ">", "Bitmap" ]

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

[ "Old", "command", "for", "backward", "compatibility" ]

[ "def", "SaveIqAscii", "(", "reducer", "=", "None", ",", "process", "=", "''", ")", ":", "msg", "=", "\"SaveIqAscii is not longer used:\\n \"", "msg", "+=", "\"Please use 'SaveIq' instead\\n \"", "Logger", "(", "\"CommandInterface\"", ")", ".", "warning", "(", "msg", ")", "ReductionSingleton", "(", ")", ".", "reduction_properties", "[", "\"ProcessInfo\"", "]", "=", "str", "(", "process", ")" ]

[ "All", "the", "packages", "found", "in", "where", "that", "pass", "the", "include", "filter", "but", "not", "the", "exclude", "filter", "." ]

[ "def", "_find_packages_iter", "(", "cls", ",", "where", ",", "exclude", ",", "include", ")", ":", "for", "root", ",", "dirs", ",", "files", "in", "os", ".", "walk", "(", "where", ",", "followlinks", "=", "True", ")", ":", "# Copy dirs to iterate over it, then empty dirs.", "all_dirs", "=", "dirs", "[", ":", "]", "dirs", "[", ":", "]", "=", "[", "]", "for", "dir", "in", "all_dirs", ":", "full_path", "=", "os", ".", "path", ".", "join", "(", "root", ",", "dir", ")", "rel_path", "=", "os", ".", "path", ".", "relpath", "(", "full_path", ",", "where", ")", "package", "=", "rel_path", ".", "replace", "(", "os", ".", "path", ".", "sep", ",", "'.'", ")", "# Skip directory trees that are not valid packages", "if", "(", "'.'", "in", "dir", "or", "not", "cls", ".", "_looks_like_package", "(", "full_path", ")", ")", ":", "continue", "# Should this package be included?", "if", "include", "(", "package", ")", "and", "not", "exclude", "(", "package", ")", ":", "yield", "package", "# Keep searching subdirectories, as there may be more packages", "# down there, even if the parent was excluded.", "dirs", ".", "append", "(", "dir", ")" ]

[ "Return", "a", "new", "time", "with", "new", "values", "for", "the", "specified", "fields", "." ]

[ "def", "replace", "(", "self", ",", "hour", "=", "None", ",", "minute", "=", "None", ",", "second", "=", "None", ",", "microsecond", "=", "None", ",", "tzinfo", "=", "True", ",", "*", ",", "fold", "=", "None", ")", ":", "if", "hour", "is", "None", ":", "hour", "=", "self", ".", "hour", "if", "minute", "is", "None", ":", "minute", "=", "self", ".", "minute", "if", "second", "is", "None", ":", "second", "=", "self", ".", "second", "if", "microsecond", "is", "None", ":", "microsecond", "=", "self", ".", "microsecond", "if", "tzinfo", "is", "True", ":", "tzinfo", "=", "self", ".", "tzinfo", "if", "fold", "is", "None", ":", "fold", "=", "self", ".", "_fold", "return", "type", "(", "self", ")", "(", "hour", ",", "minute", ",", "second", ",", "microsecond", ",", "tzinfo", ",", "fold", "=", "fold", ")" ]

[ "Add", "test", "here", "later", "." ]

[ "def", "test_SegmentEditor1", "(", "self", ")", ":", "self", ".", "delayDisplay", "(", "\"Starting the test\"", ")", "self", ".", "delayDisplay", "(", "'Test passed!'", ")" ]

[ "Generate", "docstring", "cache", "for", "given", "module", "." ]

[ "def", "_lookfor_generate_cache", "(", "module", ",", "import_modules", ",", "regenerate", ")", ":", "# Local import to speed up numpy's import time.", "import", "inspect", "from", "io", "import", "StringIO", "if", "module", "is", "None", ":", "module", "=", "\"numpy\"", "if", "isinstance", "(", "module", ",", "str", ")", ":", "try", ":", "__import__", "(", "module", ")", "except", "ImportError", ":", "return", "{", "}", "module", "=", "sys", ".", "modules", "[", "module", "]", "elif", "isinstance", "(", "module", ",", "list", ")", "or", "isinstance", "(", "module", ",", "tuple", ")", ":", "cache", "=", "{", "}", "for", "mod", "in", "module", ":", "cache", ".", "update", "(", "_lookfor_generate_cache", "(", "mod", ",", "import_modules", ",", "regenerate", ")", ")", "return", "cache", "if", "id", "(", "module", ")", "in", "_lookfor_caches", "and", "not", "regenerate", ":", "return", "_lookfor_caches", "[", "id", "(", "module", ")", "]", "# walk items and collect docstrings", "cache", "=", "{", "}", "_lookfor_caches", "[", "id", "(", "module", ")", "]", "=", "cache", "seen", "=", "{", "}", "index", "=", "0", "stack", "=", "[", "(", "module", ".", "__name__", ",", "module", ")", "]", "while", "stack", ":", "name", ",", "item", "=", "stack", ".", "pop", "(", "0", ")", "if", "id", "(", "item", ")", "in", "seen", ":", "continue", "seen", "[", "id", "(", "item", ")", "]", "=", "True", "index", "+=", "1", "kind", "=", "\"object\"", "if", "inspect", ".", "ismodule", "(", "item", ")", ":", "kind", "=", "\"module\"", "try", ":", "_all", "=", "item", ".", "__all__", "except", "AttributeError", ":", "_all", "=", "None", "# import sub-packages", "if", "import_modules", "and", "hasattr", "(", "item", ",", "'__path__'", ")", ":", "for", "pth", "in", "item", ".", "__path__", ":", "for", "mod_path", "in", "os", ".", "listdir", "(", "pth", ")", ":", "this_py", "=", "os", ".", "path", ".", "join", "(", "pth", ",", "mod_path", ")", "init_py", "=", "os", ".", "path", ".", "join", "(", "pth", ",", "mod_path", ",", "'__init__.py'", ")", "if", "(", "os", ".", "path", ".", "isfile", "(", "this_py", ")", "and", "mod_path", ".", "endswith", "(", "'.py'", ")", ")", ":", "to_import", "=", "mod_path", "[", ":", "-", "3", "]", "elif", "os", ".", "path", ".", "isfile", "(", "init_py", ")", ":", "to_import", "=", "mod_path", "else", ":", "continue", "if", "to_import", "==", "'__init__'", ":", "continue", "try", ":", "old_stdout", "=", "sys", ".", "stdout", "old_stderr", "=", "sys", ".", "stderr", "try", ":", "sys", ".", "stdout", "=", "StringIO", "(", ")", "sys", ".", "stderr", "=", "StringIO", "(", ")", "__import__", "(", "\"%s.%s\"", "%", "(", "name", ",", "to_import", ")", ")", "finally", ":", "sys", ".", "stdout", "=", "old_stdout", "sys", ".", "stderr", "=", "old_stderr", "# Catch SystemExit, too", "except", "BaseException", ":", "continue", "for", "n", ",", "v", "in", "_getmembers", "(", "item", ")", ":", "try", ":", "item_name", "=", "getattr", "(", "v", ",", "'__name__'", ",", "\"%s.%s\"", "%", "(", "name", ",", "n", ")", ")", "mod_name", "=", "getattr", "(", "v", ",", "'__module__'", ",", "None", ")", "except", "NameError", ":", "# ref. SWIG's global cvars", "# NameError: Unknown C global variable", "item_name", "=", "\"%s.%s\"", "%", "(", "name", ",", "n", ")", "mod_name", "=", "None", "if", "'.'", "not", "in", "item_name", "and", "mod_name", ":", "item_name", "=", "\"%s.%s\"", "%", "(", "mod_name", ",", "item_name", ")", "if", "not", "item_name", ".", "startswith", "(", "name", "+", "'.'", ")", ":", "# don't crawl \"foreign\" objects", "if", "isinstance", "(", "v", ",", "ufunc", ")", ":", "# ... unless they are ufuncs", "pass", "else", ":", "continue", "elif", "not", "(", "inspect", ".", "ismodule", "(", "v", ")", "or", "_all", "is", "None", "or", "n", "in", "_all", ")", ":", "continue", "stack", ".", "append", "(", "(", "\"%s.%s\"", "%", "(", "name", ",", "n", ")", ",", "v", ")", ")", "elif", "inspect", ".", "isclass", "(", "item", ")", ":", "kind", "=", "\"class\"", "for", "n", ",", "v", "in", "_getmembers", "(", "item", ")", ":", "stack", ".", "append", "(", "(", "\"%s.%s\"", "%", "(", "name", ",", "n", ")", ",", "v", ")", ")", "elif", "hasattr", "(", "item", ",", "\"__call__\"", ")", ":", "kind", "=", "\"func\"", "try", ":", "doc", "=", "inspect", ".", "getdoc", "(", "item", ")", "except", "NameError", ":", "# ref SWIG's NameError: Unknown C global variable", "doc", "=", "None", "if", "doc", "is", "not", "None", ":", "cache", "[", "name", "]", "=", "(", "doc", ",", "kind", ",", "index", ")", "return", "cache" ]

[ "Return", "the", "sum", "along", "diagonals", "of", "the", "array", "." ]

[ "def", "trace", "(", "a", ",", "offset", "=", "0", ",", "axis1", "=", "0", ",", "axis2", "=", "1", ",", "dtype", "=", "None", ",", "out", "=", "None", ")", ":", "if", "isinstance", "(", "a", ",", "np", ".", "matrix", ")", ":", "# Get trace of matrix via an array to preserve backward compatibility.", "return", "asarray", "(", "a", ")", ".", "trace", "(", "offset", "=", "offset", ",", "axis1", "=", "axis1", ",", "axis2", "=", "axis2", ",", "dtype", "=", "dtype", ",", "out", "=", "out", ")", "else", ":", "return", "asanyarray", "(", "a", ")", ".", "trace", "(", "offset", "=", "offset", ",", "axis1", "=", "axis1", ",", "axis2", "=", "axis2", ",", "dtype", "=", "dtype", ",", "out", "=", "out", ")" ]

[ "Return", "text", "to", "be", "prefixed", "to", "addin", "function", "names", "." ]

[ "def", "prefix", "(", "self", ")", ":", "return", "self", ".", "prefix_" ]

[ "Returns", "the", "number", "of", "lines", "represented", "." ]

[ "def", "NumLines", "(", "self", ")", ":", "return", "self", ".", "num_lines" ]

[ "Unit", "vector", "pointing", "to", "the", "pixel", "viewing", "direction", "." ]

[ "def", "pixel_bearing", "(", "self", ",", "pixel", ")", ":", "point", "=", "np", ".", "asarray", "(", "pixel", ")", ".", "reshape", "(", "(", "1", ",", "1", ",", "2", ")", ")", "distortion", "=", "np", ".", "array", "(", "[", "self", ".", "k1", ",", "self", ".", "k2", ",", "0.", ",", "0.", "]", ")", "x", ",", "y", "=", "cv2", ".", "fisheye", ".", "undistortPoints", "(", "point", ",", "self", ".", "get_K", "(", ")", ",", "distortion", ")", ".", "flat", "l", "=", "np", ".", "sqrt", "(", "x", "*", "x", "+", "y", "*", "y", "+", "1.0", ")", "return", "np", ".", "array", "(", "[", "x", "/", "l", ",", "y", "/", "l", ",", "1.0", "/", "l", "]", ")" ]

[ "Factory", "method", "to", "construct", "an", "OrtValue", "(", "which", "holds", "a", "Tensor", ")", "from", "given", "shape", "and", "element_type" ]

[ "def", "ortvalue_from_shape_and_type", "(", "shape", "=", "None", ",", "element_type", "=", "None", ",", "device_type", "=", "'cpu'", ",", "device_id", "=", "0", ")", ":", "if", "shape", "is", "None", "or", "element_type", "is", "None", ":", "raise", "ValueError", "(", "\"`element_type` and `shape` are to be provided if pre-allocated memory is provided\"", ")", "return", "OrtValue", "(", "C", ".", "OrtValue", ".", "ortvalue_from_shape_and_type", "(", "shape", ",", "element_type", ",", "C", ".", "OrtDevice", "(", "get_ort_device_type", "(", "device_type", ")", ",", "C", ".", "OrtDevice", ".", "default_memory", "(", ")", ",", "device_id", ")", ")", ")" ]

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

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

[ "Return", "the", "serialized", "response", "object", "from", "a", "dict", "." ]

[ "def", "form_response", "(", "self", ",", "response_dict", ")", ":", "self", ".", "_create_moe_log_line", "(", "type", "=", "'response'", ",", "content", "=", "response_dict", ",", ")", "return", "self", ".", "response_schema", ".", "serialize", "(", "response_dict", ")" ]

[ "Produce", "random", "actions", "and", "empty", "summaries", "." ]

[ "def", "__init__", "(", "self", ",", "envs", ")", ":", "self", ".", "_envs", "=", "envs" ]

[ "Creates", "the", "function", "definition", "if", "it", "s", "not", "created", "yet", "." ]

[ "def", "_create_definition_if_needed", "(", "self", ")", ":", "if", "self", ".", "_definition", "is", "not", "None", ":", "return", "# Create the func_def object.", "temp_graph", "=", "_FuncGraph", "(", ")", "with", "temp_graph", ".", "as_default", "(", ")", ":", "# List of placeholders for the function_def.", "inputs", "=", "[", "]", "for", "(", "argname", ",", "argtype", ")", "in", "self", ".", "_args", ":", "argholder", "=", "array_ops", ".", "placeholder", "(", "argtype", ",", "name", "=", "argname", ")", "inputs", ".", "append", "(", "argholder", ")", "# Call func and gather the output tensors.", "with", "vs", ".", "variable_scope", "(", "\"\"", ",", "custom_getter", "=", "temp_graph", ".", "getvar", ")", ":", "outputs", "=", "self", ".", "_func", "(", "*", "inputs", ")", "# If func only returned one value, make it a tuple.", "if", "not", "isinstance", "(", "outputs", ",", "(", "list", ",", "tuple", ")", ")", ":", "outputs", "=", "(", "outputs", ",", ")", "if", "any", "(", "[", "_", "is", "None", "for", "_", "in", "outputs", "]", ")", ":", "raise", "ValueError", "(", "\"Function can not return None.\"", ")", "# Ensures each output is a Tensor.", "outputs", "=", "[", "ops", ".", "convert_to_tensor", "(", "_", ")", "for", "_", "in", "outputs", "]", "self", ".", "_extra_inputs", "=", "temp_graph", ".", "extra_inputs", "inputs", ".", "extend", "(", "temp_graph", ".", "extra_args", ")", "# pylint: disable=protected-access", "self", ".", "_sub_functions", "=", "temp_graph", ".", "_functions", "# pylint: enable=protected-access", "# Build the FunctionDef", "self", ".", "_definition", "=", "_graph_to_function_def", "(", "temp_graph", ",", "temp_graph", ".", "get_operations", "(", ")", ",", "inputs", ",", "outputs", ",", "out_names", "=", "self", ".", "_out_names", ")", "# Extra kwargs are treated as attrs on the function def.", "sig_pre_func_name", "=", "self", ".", "_func_name", "or", "_get_func_name", "(", "self", ".", "_func", ")", "kwargs_attr", "=", "_parse_kwargs_as_attrs", "(", "sig_pre_func_name", ",", "*", "*", "self", ".", "_extra_kwargs", ")", "for", "k", "in", "kwargs_attr", ":", "self", ".", "_definition", ".", "attr", "[", "k", "]", ".", "CopyFrom", "(", "kwargs_attr", "[", "k", "]", ")", "# Hash the definition and its dependencies.", "self", ".", "_hash_str", "=", "self", ".", "_create_hash_str", "(", "self", ".", "_definition", ".", "signature", ".", "input_arg", ",", "self", ".", "_definition", ".", "signature", ".", "output_arg", ",", "self", ".", "_definition", ".", "node_def", ")", "# Finally, we decide the function name to use. If not specified,", "# make up something which is almost certainly unique (but deterministic).", "if", "not", "self", ".", "_func_name", ":", "self", ".", "_func_name", "=", "\"_\"", ".", "join", "(", "[", "_get_func_name", "(", "self", ".", "_func", ")", ",", "self", ".", "_hash_str", "]", ")", "self", ".", "_definition", ".", "signature", ".", "name", "=", "self", ".", "_func_name", "if", "self", ".", "_func", ".", "__doc__", ":", "self", ".", "_definition", ".", "signature", ".", "description", "=", "self", ".", "_func", ".", "__doc__" ]

[ "First", "discrete", "difference", "of", "element", "." ]

[ "def", "diff", "(", "self", ",", "periods", "=", "1", ",", "axis", "=", "0", ")", "->", "\"DataFrame\"", ":", "bm_axis", "=", "self", ".", "_get_block_manager_axis", "(", "axis", ")", "new_data", "=", "self", ".", "_data", ".", "diff", "(", "n", "=", "periods", ",", "axis", "=", "bm_axis", ")", "return", "self", ".", "_constructor", "(", "new_data", ")" ]

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

[ "def", "predict_proba", "(", "self", ",", "X", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_fitted'", ")", "or", "not", "self", ".", "_fitted", ":", "raise", "NotFittedError", "(", "NOT_FITTED_ERROR_DESC", ")", "X", "=", "check_array", "(", "X", ",", "accept_sparse", "=", "True", ")", "self", ".", "_check_n_features", "(", "X", ".", "shape", "[", "1", "]", ")", "if", "self", ".", "_n_classes", "==", "2", ":", "y", "=", "self", ".", "_estimators", "[", "0", "]", ".", "predict", "(", "X", ")", "y", "=", "sigmoid", "(", "y", ")", "y", "=", "np", ".", "c_", "[", "y", ",", "1", "-", "y", "]", "else", ":", "y", "=", "np", ".", "zeros", "(", "(", "X", ".", "shape", "[", "0", "]", ",", "self", ".", "_n_classes", ")", ")", "for", "i", ",", "clf", "in", "enumerate", "(", "self", ".", "_estimators", ")", ":", "class_proba", "=", "clf", ".", "predict", "(", "X", ")", "y", "[", ":", ",", "i", "]", "=", "class_proba", "if", "self", ".", "calc_prob", "==", "\"sigmoid\"", ":", "y", "=", "sigmoid", "(", "y", ")", "normalizer", "=", "np", ".", "sum", "(", "y", ",", "axis", "=", "1", ")", "[", ":", ",", "np", ".", "newaxis", "]", "normalizer", "[", "normalizer", "==", "0.0", "]", "=", "1.0", "y", "/=", "normalizer", "else", ":", "y", "=", "softmax", "(", "y", ")", "return", "y" ]

[ "Produce", "HTML", "documentation", "for", "a", "data", "object", "." ]

[ "def", "docother", "(", "self", ",", "object", ",", "name", "=", "None", ",", "mod", "=", "None", ",", "*", "ignored", ")", ":", "lhs", "=", "name", "and", "'<strong>%s</strong> = '", "%", "name", "or", "''", "return", "lhs", "+", "self", ".", "repr", "(", "object", ")" ]

[ "Retrieve", "the", "Type", "of", "elements", "within", "this", "Type", "." ]

[ "def", "element_type", "(", "self", ")", ":", "result", "=", "conf", ".", "lib", ".", "clang_getElementType", "(", "self", ")", "if", "result", ".", "kind", "==", "TypeKind", ".", "INVALID", ":", "raise", "Exception", "(", "'Element type not available on this type.'", ")", "return", "result" ]

[ "Find", "the", "beginning", "marker", "for", "a", "multiline", "comment", "." ]

[ "def", "FindNextMultiLineCommentStart", "(", "lines", ",", "lineix", ")", ":", "while", "lineix", "<", "len", "(", "lines", ")", ":", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "startswith", "(", "'/*'", ")", ":", "# Only return this marker if the comment goes beyond this line", "if", "lines", "[", "lineix", "]", ".", "strip", "(", ")", ".", "find", "(", "'*/'", ",", "2", ")", "<", "0", ":", "return", "lineix", "lineix", "+=", "1", "return", "len", "(", "lines", ")" ]

[ "Return", "true", "if", "the", "widget", "and", "all", "its", "higher", "ancestors", "are", "mapped", "." ]

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

[ "Set", "the", "mean", "to", "subtract", "for", "centering", "the", "data", "." ]

[ "def", "set_mean", "(", "self", ",", "in_", ",", "mean", ")", ":", "self", ".", "__check_input", "(", "in_", ")", "ms", "=", "mean", ".", "shape", "if", "mean", ".", "ndim", "==", "1", ":", "# broadcast channels", "if", "ms", "[", "0", "]", "!=", "self", ".", "inputs", "[", "in_", "]", "[", "1", "]", ":", "raise", "ValueError", "(", "'Mean channels incompatible with input.'", ")", "mean", "=", "mean", "[", ":", ",", "np", ".", "newaxis", ",", "np", ".", "newaxis", "]", "else", ":", "# elementwise mean", "if", "len", "(", "ms", ")", "==", "2", ":", "ms", "=", "(", "1", ",", ")", "+", "ms", "if", "len", "(", "ms", ")", "!=", "3", ":", "raise", "ValueError", "(", "'Mean shape invalid'", ")", "if", "ms", "!=", "self", ".", "inputs", "[", "in_", "]", "[", "1", ":", "]", ":", "raise", "ValueError", "(", "'Mean shape incompatible with input shape.'", ")", "self", ".", "mean", "[", "in_", "]", "=", "mean" ]

[ "Test", "if", "this", "is", "an", "invalid", "kind", "." ]

[ "def", "is_invalid", "(", "self", ")", ":", "return", "conf", ".", "lib", ".", "clang_isInvalid", "(", "self", ")" ]

[ "Create", "a", "fresh", "SHA", "-", "224", "hash", "object", "." ]

[ "def", "new", "(", "self", ",", "data", "=", "None", ")", ":", "return", "SHA224Hash", "(", "data", ")" ]

[ "Installs", "libjpeg", "-", "turbo", "dependency", "." ]

[ "def", "install", "(", "self", ")", ":", "url", "=", "'https://github.com/libjpeg-turbo/libjpeg-turbo/archive/2.0.2.zip'", "extra_args", "=", "[", "'-DCMAKE_POSITION_INDEPENDENT_CODE=1'", "]", "path", "=", "os", ".", "path", ".", "join", "(", "cfg", ".", "src_dir", ",", "'jpg.zip'", ")", "force", "=", "self", ".", "forced", "(", ")", "dl_dir", "=", "download_archive", "(", "url", ",", "path", ",", "force", ")", "with", "cwd", "(", "dl_dir", ")", ":", "run_cmake", "(", "force", ",", "extra_args", ")" ]

[ "Return", "the", "linkage", "of", "this", "cursor", "." ]

[ "def", "linkage", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_linkage'", ")", ":", "self", ".", "_linkage", "=", "conf", ".", "lib", ".", "clang_getCursorLinkage", "(", "self", ")", "return", "LinkageKind", ".", "from_id", "(", "self", ".", "_linkage", ")" ]

[ "DocLineFromVisible", "(", "self", "int", "lineDisplay", ")", "-", ">", "int" ]

[ "def", "DocLineFromVisible", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_DocLineFromVisible", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Reset", "internal", "quantities", "so", "the", "object", "is", "prepared", "to", "deal", "with", "transition", "to", "state", "with", "symmetry", "given" ]

[ "def", "reset_for_state_symm", "(", "self", ",", "symmetry", ")", ":", "self", ".", "G_es", "=", "symmetry", "self", ".", "_build_prec", "(", ")", "self", ".", "product_cache", ".", "reset", "(", ")" ]

[ "Install", "or", "remove", "random", "pg_upmap_items", "entries", "in", "OSDMap" ]

[ "def", "thrash_pg_upmap_items", "(", "self", ")", ":", "from", "random", "import", "shuffle", "out", "=", "self", ".", "ceph_manager", ".", "raw_cluster_cmd", "(", "'osd'", ",", "'dump'", ",", "'-f'", ",", "'json-pretty'", ")", "j", "=", "json", ".", "loads", "(", "out", ")", "self", ".", "log", "(", "'j is %s'", "%", "j", ")", "try", ":", "if", "random", ".", "random", "(", ")", ">=", ".3", ":", "pgs", "=", "self", ".", "ceph_manager", ".", "get_pg_stats", "(", ")", "if", "not", "pgs", ":", "return", "pg", "=", "random", ".", "choice", "(", "pgs", ")", "pgid", "=", "str", "(", "pg", "[", "'pgid'", "]", ")", "poolid", "=", "int", "(", "pgid", ".", "split", "(", "'.'", ")", "[", "0", "]", ")", "sizes", "=", "[", "x", "[", "'size'", "]", "for", "x", "in", "j", "[", "'pools'", "]", "if", "x", "[", "'pool'", "]", "==", "poolid", "]", "if", "len", "(", "sizes", ")", "==", "0", ":", "return", "n", "=", "sizes", "[", "0", "]", "osds", "=", "self", ".", "in_osds", "+", "self", ".", "out_osds", "shuffle", "(", "osds", ")", "osds", "=", "osds", "[", "0", ":", "n", "*", "2", "]", "self", ".", "log", "(", "'Setting %s to %s'", "%", "(", "pgid", ",", "osds", ")", ")", "cmd", "=", "[", "'osd'", ",", "'pg-upmap-items'", ",", "pgid", "]", "+", "[", "str", "(", "x", ")", "for", "x", "in", "osds", "]", "self", ".", "log", "(", "'cmd %s'", "%", "cmd", ")", "self", ".", "ceph_manager", ".", "raw_cluster_cmd", "(", "*", "cmd", ")", "else", ":", "m", "=", "j", "[", "'pg_upmap_items'", "]", "if", "len", "(", "m", ")", ">", "0", ":", "shuffle", "(", "m", ")", "pg", "=", "m", "[", "0", "]", "[", "'pgid'", "]", "self", ".", "log", "(", "'Clearing pg_upmap on %s'", "%", "pg", ")", "self", ".", "ceph_manager", ".", "raw_cluster_cmd", "(", "'osd'", ",", "'rm-pg-upmap-items'", ",", "pg", ")", "else", ":", "self", ".", "log", "(", "'No pg_upmap entries; doing nothing'", ")", "except", "CommandFailedError", ":", "self", ".", "log", "(", "'Failed to rm-pg-upmap-items, ignoring'", ")" ]

[ "Find", "the", "most", "recent", "distribution", "which", "matches", "the", "given", "requirement", "." ]

[ "def", "locate", "(", "self", ",", "requirement", ",", "prereleases", "=", "False", ")", ":", "result", "=", "None", "scheme", "=", "get_scheme", "(", "self", ".", "scheme", ")", "r", "=", "parse_requirement", "(", "requirement", ")", "if", "r", "is", "None", ":", "raise", "DistlibException", "(", "'Not a valid requirement: %r'", "%", "requirement", ")", "if", "r", ".", "extras", ":", "# lose the extras part of the requirement", "requirement", "=", "r", ".", "requirement", "matcher", "=", "scheme", ".", "matcher", "(", "requirement", ")", "vcls", "=", "matcher", ".", "version_class", "logger", ".", "debug", "(", "'matcher: %s (%s)'", ",", "matcher", ",", "type", "(", "matcher", ")", ".", "__name__", ")", "versions", "=", "self", ".", "get_project", "(", "matcher", ".", "name", ")", "if", "versions", ":", "# sometimes, versions are invalid", "slist", "=", "[", "]", "for", "k", "in", "versions", ":", "try", ":", "if", "not", "matcher", ".", "match", "(", "k", ")", ":", "logger", ".", "debug", "(", "'%s did not match %r'", ",", "matcher", ",", "k", ")", "else", ":", "if", "prereleases", "or", "not", "vcls", "(", "k", ")", ".", "is_prerelease", ":", "slist", ".", "append", "(", "k", ")", "else", ":", "logger", ".", "debug", "(", "'skipping pre-release version %s'", ",", "k", ")", "except", "Exception", ":", "logger", ".", "warning", "(", "'error matching %s with %r'", ",", "matcher", ",", "k", ")", "pass", "# slist.append(k)", "if", "len", "(", "slist", ")", ">", "1", ":", "slist", "=", "sorted", "(", "slist", ",", "key", "=", "scheme", ".", "key", ")", "if", "slist", ":", "logger", ".", "debug", "(", "'sorted list: %s'", ",", "slist", ")", "result", "=", "versions", "[", "slist", "[", "-", "1", "]", "]", "if", "result", "and", "r", ".", "extras", ":", "result", ".", "extras", "=", "r", ".", "extras", "return", "result" ]

[ "Dumps", "a", "flamegraph", "file" ]

[ "def", "dump_flamegraph", "(", "data", ",", "metric", ",", "file", "=", "None", ",", "echo_dart", "=", "False", ")", ":", "from", "timemory", ".", "common", "import", "(", "popen", ",", "get_bin_script", ",", "dart_measurement_file", ",", ")", "_files", "=", "dump_entity", "(", "data", ",", "lambda", "x", ":", "x", ".", "to_flamegraph", "(", "_get_metric", "(", "x", ",", "metric", ")", ")", ",", "file", ",", "\".flamegraph.txt\"", ",", ")", "for", "itr", "in", "_files", ":", "flamegrapher", "=", "get_bin_script", "(", "\"flamegraph.pl\"", ")", "if", "itr", "is", "not", "None", ":", "if", "flamegrapher", "is", "None", ":", "if", "echo_dart", "is", "True", ":", "# write_ctest_notes(itr)", "dart_measurement_file", "(", "os", ".", "path", ".", "basename", "(", "itr", ")", ",", "itr", ",", "format", "=", "\"string\"", ",", "type", "=", "\"text\"", ")", "else", ":", "(", "retc", ",", "outs", ",", "errs", ")", "=", "popen", "(", "[", "flamegrapher", ",", "\"--hash\"", ",", "\"--inverted\"", ",", "\"--bgcolors\"", ",", "\"'#FFFFFF'\"", ",", "itr", ",", "]", ",", "shell", "=", "True", ",", ")", "if", "outs", "is", "not", "None", ":", "lbl", "=", "_get_label", "(", "itr", ")", "sitr", "=", "_get_filename", "(", "itr", ",", "\".svg\"", ")", "pitr", "=", "_get_filename", "(", "itr", ",", "\".png\"", ")", "# write the SVG file", "print", "(", "f\"[{lbl}]|0> Outputting '{sitr}'...\"", ")", "_create_directory", "(", "sitr", ")", "with", "open", "(", "sitr", ",", "\"w\"", ")", "as", "fout", ":", "fout", ".", "write", "(", "f\"{outs}\\n\"", ")", "# generate png", "pfile", "=", "_svg_to_png", "(", "pitr", ",", "svg_code", "=", "outs", ")", "# echo svg and png", "if", "echo_dart", ":", "# write_ctest_notes(sitr)", "dart_measurement_file", "(", "os", ".", "path", ".", "basename", "(", "itr", ")", ",", "itr", ",", "format", "=", "\"string\"", ",", "type", "=", "\"text\"", ",", ")", "dart_measurement_file", "(", "os", ".", "path", ".", "basename", "(", "sitr", ")", ",", "sitr", ",", "\"svg\"", ")", "if", "pfile", "is", "not", "None", ":", "dart_measurement_file", "(", "os", ".", "path", ".", "basename", "(", "pitr", ")", ",", "pitr", ",", "\"png\"", ")", "else", ":", "pass" ]

[ "Describes", "the", "Function", "and", "its", "signature", "as", "a", "string", "." ]

[ "def", "__str__", "(", "self", ")", ":", "f_name", "=", "self", ".", "name", "op_name", "=", "self", ".", "op_name", "if", "self", ".", "is_composite", ":", "if", "self", ".", "root_function", "and", "all", "(", "i", ".", "uid", "==", "ri", ".", "uid", "for", "i", ",", "ri", "in", "zip", "(", "self", ".", "inputs", ",", "self", ".", "root_function", ".", "inputs", ")", ")", ":", "op_name", "=", "self", ".", "root_function", ".", "op_name", "else", ":", "op_name", "=", "'Composite'", "# (real op_name is CompositeFunctionOpName)", "else", ":", "op_name", "=", "self", ".", "op_name", "args", "=", "self", ".", "signature", "def", "format_arg_spec", "(", "v", ",", "is_output", "=", "False", ")", ":", "s", "=", "v", ".", "name", "+", "': '", "if", "not", "is_output", "and", "v", ".", "name", "else", "''", "# (suppress output names, since they duplicate the function name)", "return", "s", "+", "str", "(", "v", ".", "_type", ")", "outputs", "=", "self", ".", "outputs", "if", "len", "(", "outputs", ")", ">", "1", ":", "output_signature", "=", "'Tuple['", "+", "', '", ".", "join", "(", "format_arg_spec", "(", "output", ",", "True", ")", "for", "output", "in", "outputs", ")", "+", "']'", "else", ":", "output_signature", "=", "format_arg_spec", "(", "outputs", "[", "0", "]", ",", "True", ")", "if", "self", ".", "name", ":", "f_name", "+=", "\": \"", "return", "f_name", "+", "op_name", "+", "'('", "+", "\", \"", ".", "join", "(", "[", "format_arg_spec", "(", "param", ")", "for", "param", "in", "args", "]", ")", "+", "') -> '", "+", "output_signature" ]

[ "Returns", "a", "list", "of", "shell", "commands", "that", "contain", "the", "shell", "commands", "to", "run", "as", "postbuilds", "for", "this", "target", "before", "the", "actual", "postbuilds", "." ]

[ "def", "_GetTargetPostbuilds", "(", "self", ",", "configname", ",", "output", ",", "output_binary", ",", "quiet", "=", "False", ")", ":", "# dSYMs need to build before stripping happens.", "return", "(", "self", ".", "_GetDebugInfoPostbuilds", "(", "configname", ",", "output", ",", "output_binary", ",", "quiet", ")", "+", "self", ".", "_GetStripPostbuilds", "(", "configname", ",", "output_binary", ",", "quiet", ")", ")" ]

[ "Run", "net", "forward", "+", "backward", "in", "batches", "." ]

[ "def", "_Net_forward_backward_all", "(", "self", ",", "blobs", "=", "None", ",", "diffs", "=", "None", ",", "*", "*", "kwargs", ")", ":", "# Batch blobs and diffs.", "all_outs", "=", "{", "out", ":", "[", "]", "for", "out", "in", "set", "(", "self", ".", "outputs", "+", "(", "blobs", "or", "[", "]", ")", ")", "}", "all_diffs", "=", "{", "diff", ":", "[", "]", "for", "diff", "in", "set", "(", "self", ".", "inputs", "+", "(", "diffs", "or", "[", "]", ")", ")", "}", "forward_batches", "=", "self", ".", "_batch", "(", "{", "in_", ":", "kwargs", "[", "in_", "]", "for", "in_", "in", "self", ".", "inputs", "if", "in_", "in", "kwargs", "}", ")", "backward_batches", "=", "self", ".", "_batch", "(", "{", "out", ":", "kwargs", "[", "out", "]", "for", "out", "in", "self", ".", "outputs", "if", "out", "in", "kwargs", "}", ")", "# Collect outputs from batches (and heed lack of forward/backward batches).", "for", "fb", ",", "bb", "in", "izip_longest", "(", "forward_batches", ",", "backward_batches", ",", "fillvalue", "=", "{", "}", ")", ":", "batch_blobs", "=", "self", ".", "forward", "(", "blobs", "=", "blobs", ",", "*", "*", "fb", ")", "batch_diffs", "=", "self", ".", "backward", "(", "diffs", "=", "diffs", ",", "*", "*", "bb", ")", "for", "out", ",", "out_blobs", "in", "batch_blobs", ".", "iteritems", "(", ")", ":", "all_outs", "[", "out", "]", ".", "extend", "(", "out_blobs", ".", "copy", "(", ")", ")", "for", "diff", ",", "out_diffs", "in", "batch_diffs", ".", "iteritems", "(", ")", ":", "all_diffs", "[", "diff", "]", ".", "extend", "(", "out_diffs", ".", "copy", "(", ")", ")", "# Package in ndarray.", "for", "out", ",", "diff", "in", "zip", "(", "all_outs", ",", "all_diffs", ")", ":", "all_outs", "[", "out", "]", "=", "np", ".", "asarray", "(", "all_outs", "[", "out", "]", ")", "all_diffs", "[", "diff", "]", "=", "np", ".", "asarray", "(", "all_diffs", "[", "diff", "]", ")", "# Discard padding at the end and package in ndarray.", "pad", "=", "len", "(", "all_outs", ".", "itervalues", "(", ")", ".", "next", "(", ")", ")", "-", "len", "(", "kwargs", ".", "itervalues", "(", ")", ".", "next", "(", ")", ")", "if", "pad", ":", "for", "out", ",", "diff", "in", "zip", "(", "all_outs", ",", "all_diffs", ")", ":", "all_outs", "[", "out", "]", "=", "all_outs", "[", "out", "]", "[", ":", "-", "pad", "]", "all_diffs", "[", "diff", "]", "=", "all_diffs", "[", "diff", "]", "[", ":", "-", "pad", "]", "return", "all_outs", ",", "all_diffs" ]

[ "Set", "a", "local", "configuration", "parameter", "." ]

[ "def", "configure", "(", "self", ",", "parameter", ",", "value", ")", ":", "return", "self", ".", "_callgito", "(", "\"config\"", ",", "[", "\"--local\"", ",", "parameter", ",", "value", "]", ")" ]

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

[ "def", "balancedStringSplit", "(", "self", ",", "s", ")", ":", "result", ",", "count", "=", "0", ",", "0", "for", "c", "in", "s", ":", "count", "+=", "1", "if", "c", "==", "'L'", "else", "-", "1", "if", "count", "==", "0", ":", "result", "+=", "1", "return", "result" ]

[ "Set", "Nodes", "of", "the", "given", "Layer", "." ]

[ "def", "set_layer_nodes", "(", "self", ",", "layer_id", ",", "nodes", ")", ":", "layer_id", "-=", "1", "if", "isinstance", "(", "self", ".", "layers", ",", "list", ")", "and", "layer_id", "<", "len", "(", "self", ".", "layers", ")", ":", "if", "isinstance", "(", "self", ".", "layers", "[", "layer_id", "]", ",", "Layer", ")", ":", "self", ".", "layers", "[", "layer_id", "]", ".", "set_nodes", "(", "nodes", ")", "else", ":", "raise", "ValueError", "(", "\"layer {} is not a SingleLayer\"", ".", "format", "(", "layer_id", ")", ")", "else", ":", "raise", "ValueError", "(", "\"layer id beyond the layers length.\"", ")" ]

[ "Decode", "and", "return", "the", "source", "string", "." ]

[ "def", "read", "(", "self", ")", ":", "return", "self", ".", "decode", "(", "self", ".", "source", ")" ]

[ "Evaluate", "a", "2", "-", "D", "polynomial", "on", "the", "Cartesian", "product", "of", "x", "and", "y", "." ]

[ "def", "polygrid2d", "(", "x", ",", "y", ",", "c", ")", ":", "return", "pu", ".", "_gridnd", "(", "polyval", ",", "c", ",", "x", ",", "y", ")" ]

[ "Run", "the", "given", "command", "and", "return", "the", "exit", "code" ]

[ "def", "run", "(", "cmd", ")", ":", "log", ".", "debug", "(", "'Running %s'", "%", "command_string", "(", "cmd", ")", ")", "try", ":", "proc", "=", "subprocess", ".", "Popen", "(", "cmd", ")", "rc", "=", "proc", ".", "wait", "(", ")", "except", "OSError", "as", "e", ":", "printf", "(", "'error: %s: %s\\n'", ",", "cmd", "[", "0", "]", ",", "e", ".", "strerror", ",", "file", "=", "sys", ".", "stderr", ")", "sys", ".", "exit", "(", "e", ".", "errno", ")", "if", "rc", "!=", "0", ":", "sys", ".", "exit", "(", "rc", ")", "return", "rc" ]

[ "Reload", "a", "ConfigObj", "from", "file", ".", "This", "method", "raises", "a", "ReloadError", "if", "the", "ConfigObj", "doesn", "t", "have", "a", "filename", "attribute", "pointing", "to", "a", "file", "." ]

[ "def", "reload", "(", "self", ")", ":", "if", "not", "isinstance", "(", "self", ".", "filename", ",", "basestring", ")", ":", "raise", "ReloadError", "(", ")", "filename", "=", "self", ".", "filename", "current_options", "=", "{", "}", "for", "entry", "in", "OPTION_DEFAULTS", ":", "if", "entry", "==", "'configspec'", ":", "continue", "current_options", "[", "entry", "]", "=", "getattr", "(", "self", ",", "entry", ")", "configspec", "=", "self", ".", "_original_configspec", "current_options", "[", "'configspec'", "]", "=", "configspec", "self", ".", "clear", "(", ")", "self", ".", "_initialise", "(", "current_options", ")", "self", ".", "_load", "(", "filename", ",", "configspec", ")" ]

[ "Fused", "multiply", "-", "add", "." ]

[ "def", "fma", "(", "self", ",", "other", ",", "third", ",", "context", "=", "None", ")", ":", "other", "=", "_convert_other", "(", "other", ",", "raiseit", "=", "True", ")", "# compute product; raise InvalidOperation if either operand is", "# a signaling NaN or if the product is zero times infinity.", "if", "self", ".", "_is_special", "or", "other", ".", "_is_special", ":", "if", "context", "is", "None", ":", "context", "=", "getcontext", "(", ")", "if", "self", ".", "_exp", "==", "'N'", ":", "return", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'sNaN'", ",", "self", ")", "if", "other", ".", "_exp", "==", "'N'", ":", "return", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'sNaN'", ",", "other", ")", "if", "self", ".", "_exp", "==", "'n'", ":", "product", "=", "self", "elif", "other", ".", "_exp", "==", "'n'", ":", "product", "=", "other", "elif", "self", ".", "_exp", "==", "'F'", ":", "if", "not", "other", ":", "return", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'INF * 0 in fma'", ")", "product", "=", "_SignedInfinity", "[", "self", ".", "_sign", "^", "other", ".", "_sign", "]", "elif", "other", ".", "_exp", "==", "'F'", ":", "if", "not", "self", ":", "return", "context", ".", "_raise_error", "(", "InvalidOperation", ",", "'0 * INF in fma'", ")", "product", "=", "_SignedInfinity", "[", "self", ".", "_sign", "^", "other", ".", "_sign", "]", "else", ":", "product", "=", "_dec_from_triple", "(", "self", ".", "_sign", "^", "other", ".", "_sign", ",", "str", "(", "int", "(", "self", ".", "_int", ")", "*", "int", "(", "other", ".", "_int", ")", ")", ",", "self", ".", "_exp", "+", "other", ".", "_exp", ")", "third", "=", "_convert_other", "(", "third", ",", "raiseit", "=", "True", ")", "return", "product", ".", "__add__", "(", "third", ",", "context", ")" ]

[ "Return", "whether", "the", "task", "is", "the", "chief", "worker", "." ]

[ "def", "_is_chief", "(", "self", ")", ":", "if", "(", "not", "self", ".", "_cluster_spec", "or", "self", ".", "_task_type", "in", "[", "_TaskType", ".", "CHIEF", ",", "_TaskType", ".", "EVALUATOR", ",", "None", "]", ")", ":", "return", "True", "# If not local and chief not in the cluster_spec, use the first worker as", "# chief.", "if", "(", "_TaskType", ".", "CHIEF", "not", "in", "self", ".", "_cluster_spec", ".", "jobs", "and", "self", ".", "_task_type", "==", "_TaskType", ".", "WORKER", "and", "self", ".", "_task_id", "==", "0", ")", ":", "return", "True", "return", "False" ]

[ "Show", "the", "route", "to", "a", "specific", "IP" ]

[ "def", "_ip", "(", "cli_opts", ",", "ip", ",", "vrf", ")", ":", "route", ".", "RouteIpCmd", "(", "cli_opts", ")", ".", "run", "(", "ip", ",", "vrf", ")" ]

[ "Generate", "config", ".", "py", "file", "containing", "system_info", "information", "used", "during", "building", "the", "package", "." ]

[ "def", "generate_config_py", "(", "target", ")", ":", "from", "numpy", ".", "distutils", ".", "system_info", "import", "system_info", "from", "distutils", ".", "dir_util", "import", "mkpath", "mkpath", "(", "os", ".", "path", ".", "dirname", "(", "target", ")", ")", "with", "open", "(", "target", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "'# This file is generated by numpy\\'s %s\\n'", "%", "(", "os", ".", "path", ".", "basename", "(", "sys", ".", "argv", "[", "0", "]", ")", ")", ")", "f", ".", "write", "(", "'# It contains system_info results at the time of building this package.\\n'", ")", "f", ".", "write", "(", "'__all__ = [\"get_info\",\"show\"]\\n\\n'", ")", "# For gfortran+msvc combination, extra shared libraries may exist", "f", ".", "write", "(", "textwrap", ".", "dedent", "(", "\"\"\"\n import os\n import sys\n\n extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs')\n\n if sys.platform == 'win32' and os.path.isdir(extra_dll_dir):\n if sys.version_info >= (3, 8):\n os.add_dll_directory(extra_dll_dir)\n else:\n os.environ.setdefault('PATH', '')\n os.environ['PATH'] += os.pathsep + extra_dll_dir\n\n \"\"\"", ")", ")", "for", "k", ",", "i", "in", "system_info", ".", "saved_results", ".", "items", "(", ")", ":", "f", ".", "write", "(", "'%s=%r\\n'", "%", "(", "k", ",", "i", ")", ")", "f", ".", "write", "(", "textwrap", ".", "dedent", "(", "r'''\n def get_info(name):\n g = globals()\n return g.get(name, g.get(name + \"_info\", {}))\n\n def show():\n for name,info_dict in globals().items():\n if name[0] == \"_\" or type(info_dict) is not type({}): continue\n print(name + \":\")\n if not info_dict:\n print(\" NOT AVAILABLE\")\n for k,v in info_dict.items():\n v = str(v)\n if k == \"sources\" and len(v) > 200:\n v = v[:60] + \" ...\\n... \" + v[-60:]\n print(\" %s = %s\" % (k,v))\n '''", ")", ")", "return", "target" ]

[ "Call", "this", "as", "a", "WSGI", "application", "or", "with", "a", "request" ]

[ "def", "__call__", "(", "self", ",", "req", ",", "*", "args", ",", "*", "*", "kw", ")", ":", "func", "=", "self", ".", "func", "if", "func", "is", "None", ":", "if", "args", "or", "kw", ":", "raise", "TypeError", "(", "\"Unbound %s can only be called with the function it \"", "\"will wrap\"", "%", "self", ".", "__class__", ".", "__name__", ")", "func", "=", "req", "return", "self", ".", "clone", "(", "func", ")", "if", "isinstance", "(", "req", ",", "dict", ")", ":", "if", "len", "(", "args", ")", "!=", "1", "or", "kw", ":", "raise", "TypeError", "(", "\"Calling %r as a WSGI app with the wrong signature\"", ")", "environ", "=", "req", "start_response", "=", "args", "[", "0", "]", "req", "=", "self", ".", "RequestClass", "(", "environ", ")", "req", ".", "response", "=", "req", ".", "ResponseClass", "(", ")", "try", ":", "args", "=", "self", ".", "args", "if", "self", ".", "middleware_wraps", ":", "args", "=", "(", "self", ".", "middleware_wraps", ",", ")", "+", "args", "resp", "=", "self", ".", "call_func", "(", "req", ",", "*", "args", ",", "*", "*", "self", ".", "kwargs", ")", "except", "HTTPException", "as", "exc", ":", "resp", "=", "exc", "if", "resp", "is", "None", ":", "## FIXME: I'm not sure what this should be?", "resp", "=", "req", ".", "response", "if", "isinstance", "(", "resp", ",", "text_type", ")", ":", "resp", "=", "bytes_", "(", "resp", ",", "req", ".", "charset", ")", "if", "isinstance", "(", "resp", ",", "bytes", ")", ":", "body", "=", "resp", "resp", "=", "req", ".", "response", "resp", ".", "write", "(", "body", ")", "if", "resp", "is", "not", "req", ".", "response", ":", "resp", "=", "req", ".", "response", ".", "merge_cookies", "(", "resp", ")", "return", "resp", "(", "environ", ",", "start_response", ")", "else", ":", "if", "self", ".", "middleware_wraps", ":", "args", "=", "(", "self", ".", "middleware_wraps", ",", ")", "+", "args", "return", "self", ".", "func", "(", "req", ",", "*", "args", ",", "*", "*", "kw", ")" ]

[ "Plot", "first", "arrivals", "as", "lines", "." ]

[ "def", "drawFirstPicks", "(", "ax", ",", "data", ",", "tt", "=", "None", ",", "plotva", "=", "False", ",", "*", "*", "kwargs", ")", ":", "px", "=", "pg", ".", "x", "(", "data", ")", "gx", "=", "np", ".", "array", "(", "[", "px", "[", "int", "(", "g", ")", "]", "for", "g", "in", "data", "(", "\"g\"", ")", "]", ")", "sx", "=", "np", ".", "array", "(", "[", "px", "[", "int", "(", "s", ")", "]", "for", "s", "in", "data", "(", "\"s\"", ")", "]", ")", "if", "tt", "is", "None", ":", "tt", "=", "np", ".", "array", "(", "data", "(", "\"t\"", ")", ")", "if", "plotva", ":", "tt", "=", "np", ".", "absolute", "(", "gx", "-", "sx", ")", "/", "tt", "uns", "=", "np", ".", "unique", "(", "sx", ")", "cols", "=", "plt", ".", "cm", ".", "tab10", "(", "np", ".", "arange", "(", "10", ")", ")", "kwargs", ".", "setdefault", "(", "'marker'", ",", "'x'", ")", "kwargs", ".", "setdefault", "(", "'markersize'", ",", "8", ")", "kwargs", ".", "setdefault", "(", "'linestyle'", ",", "'-'", ")", "for", "i", ",", "si", "in", "enumerate", "(", "uns", ")", ":", "ti", "=", "tt", "[", "sx", "==", "si", "]", "gi", "=", "gx", "[", "sx", "==", "si", "]", "ii", "=", "gi", ".", "argsort", "(", ")", "ax", ".", "plot", "(", "gi", "[", "ii", "]", ",", "ti", "[", "ii", "]", ",", "color", "=", "cols", "[", "i", "%", "10", "]", ",", "*", "*", "kwargs", ")", "ax", ".", "plot", "(", "si", ",", "0.", ",", "'s'", ",", "color", "=", "cols", "[", "i", "%", "10", "]", ")", "ax", ".", "grid", "(", "True", ")", "if", "plotva", ":", "ax", ".", "set_ylabel", "(", "\"Apparent velocity (m/s)\"", ")", "else", ":", "ax", ".", "set_ylabel", "(", "\"Traveltime (s)\"", ")", "ax", ".", "set_xlabel", "(", "\"x (m)\"", ")", "ax", ".", "invert_yaxis", "(", ")" ]

[ "Issue", "an", "HTTP", "request", "with", "the", "given", "options", "." ]

[ "def", "_http_request", "(", "body", ",", "method", ",", "url", ",", "options", ",", "content_type", "=", "None", ")", ":", "args", "=", "[", "'curl'", ",", "'--user'", ",", "options", ".", "username", "+", "':'", "+", "options", ".", "password", ",", "# The bodies of HTTP messages must be encoded:", "'--data'", ",", "body", ",", "'--request'", ",", "method", ",", "]", "if", "content_type", "is", "not", "None", ":", "args", ".", "extend", "(", "[", "'--header'", ",", "content_type", ",", "]", ")", "if", "'http_proxy'", "in", "os", ".", "environ", ":", "args", ".", "extend", "(", "[", "'--proxy'", ",", "os", ".", "environ", "[", "'http_proxy'", "]", "]", ")", "# Set how loud cURL should be while running.", "if", "options", ".", "debug", ":", "args", ".", "append", "(", "'--verbose'", ")", "else", ":", "args", ".", "append", "(", "'--silent'", ")", "args", ".", "append", "(", "url", ")", "proc", "=", "subprocess", ".", "Popen", "(", "args", ",", "stdout", "=", "subprocess", ".", "PIPE", ")", "result", "=", "proc", ".", "stdout", ".", "readlines", "(", ")", "result", "=", "[", "x", ".", "decode", "(", ")", "for", "x", "in", "result", "]", "print", "(", "\"Server Response: \"", "+", "str", "(", "result", ")", ")", "return", "result" ]

[ "GetDouble", "(", "SBData", "self", "SBError", "error", "lldb", "::", "offset_t", "offset", ")", "-", ">", "double" ]

[ "def", "GetDouble", "(", "self", ",", "error", ",", "offset", ")", ":", "return", "_lldb", ".", "SBData_GetDouble", "(", "self", ",", "error", ",", "offset", ")" ]

[ "Check", "if", "seek_name", "is", "in", "the", "left", "hand", "side", "lhs", "of", "assignment", "." ]

[ "def", "find_assignments", "(", "lhs", ",", "results", ",", "seek_name", ")", ":", "if", "isinstance", "(", "lhs", ",", "pr", ".", "Array", ")", ":", "return", "assign_tuples", "(", "lhs", ",", "results", ",", "seek_name", ")", "elif", "lhs", ".", "name", ".", "names", "[", "-", "1", "]", "==", "seek_name", ":", "return", "results", "else", ":", "return", "[", "]" ]

[ "Kronecker", "product", "of", "two", "arrays", "." ]

[ "def", "kron", "(", "a", ",", "b", ")", ":", "b", "=", "asanyarray", "(", "b", ")", "a", "=", "array", "(", "a", ",", "copy", "=", "False", ",", "subok", "=", "True", ",", "ndmin", "=", "b", ".", "ndim", ")", "ndb", ",", "nda", "=", "b", ".", "ndim", ",", "a", ".", "ndim", "if", "(", "nda", "==", "0", "or", "ndb", "==", "0", ")", ":", "return", "_nx", ".", "multiply", "(", "a", ",", "b", ")", "as_", "=", "a", ".", "shape", "bs", "=", "b", ".", "shape", "if", "not", "a", ".", "flags", ".", "contiguous", ":", "a", "=", "reshape", "(", "a", ",", "as_", ")", "if", "not", "b", ".", "flags", ".", "contiguous", ":", "b", "=", "reshape", "(", "b", ",", "bs", ")", "nd", "=", "ndb", "if", "(", "ndb", "!=", "nda", ")", ":", "if", "(", "ndb", ">", "nda", ")", ":", "as_", "=", "(", "1", ",", ")", "*", "(", "ndb", "-", "nda", ")", "+", "as_", "else", ":", "bs", "=", "(", "1", ",", ")", "*", "(", "nda", "-", "ndb", ")", "+", "bs", "nd", "=", "nda", "result", "=", "outer", "(", "a", ",", "b", ")", ".", "reshape", "(", "as_", "+", "bs", ")", "axis", "=", "nd", "-", "1", "for", "_", "in", "range", "(", "nd", ")", ":", "result", "=", "concatenate", "(", "result", ",", "axis", "=", "axis", ")", "wrapper", "=", "get_array_prepare", "(", "a", ",", "b", ")", "if", "wrapper", "is", "not", "None", ":", "result", "=", "wrapper", "(", "result", ")", "wrapper", "=", "get_array_wrap", "(", "a", ",", "b", ")", "if", "wrapper", "is", "not", "None", ":", "result", "=", "wrapper", "(", "result", ")", "return", "result" ]

[ "Get", "module", "that", "corresponds", "to", "path", "relative", "to", "relative_to_dir", "." ]

[ "def", "get_module", "(", "dir_path", ",", "relative_to_dir", ")", ":", "dir_path", "=", "dir_path", "[", "len", "(", "relative_to_dir", ")", ":", "]", "# Convert path separators to '/' for easier parsing below.", "dir_path", "=", "dir_path", ".", "replace", "(", "os", ".", "sep", ",", "'/'", ")", "return", "dir_path", ".", "replace", "(", "'/'", ",", "'.'", ")", ".", "strip", "(", "'.'", ")" ]

[ "Constructs", "an", "Estimator", "instance", "." ]

[ "def", "__init__", "(", "self", ",", "model_fn", ",", "model_dir", "=", "None", ",", "config", "=", "None", ",", "params", "=", "None", ")", ":", "Estimator", ".", "_assert_members_are_not_overridden", "(", "self", ")", "if", "config", "is", "None", ":", "self", ".", "_config", "=", "run_config", ".", "RunConfig", "(", ")", "logging", ".", "info", "(", "'Using default config.'", ")", "else", ":", "if", "not", "isinstance", "(", "config", ",", "run_config", ".", "RunConfig", ")", ":", "raise", "ValueError", "(", "'config must be an instance of RunConfig, but provided %s.'", "%", "config", ")", "self", ".", "_config", "=", "config", "# Model directory.", "if", "(", "model_dir", "is", "not", "None", ")", "and", "(", "self", ".", "_config", ".", "model_dir", "is", "not", "None", ")", ":", "if", "model_dir", "!=", "self", ".", "_config", ".", "model_dir", ":", "# TODO(alanyee): remove this suppression after it is no longer needed", "# pylint: disable=g-doc-exception", "raise", "ValueError", "(", "\"model_dir are set both in constructor and RunConfig, but with \"", "\"different values. In constructor: '{}', in RunConfig: \"", "\"'{}' \"", ".", "format", "(", "model_dir", ",", "self", ".", "_config", ".", "model_dir", ")", ")", "# pylint: enable=g-doc-exception", "self", ".", "_model_dir", "=", "model_dir", "or", "self", ".", "_config", ".", "model_dir", "if", "self", ".", "_model_dir", "is", "None", ":", "self", ".", "_model_dir", "=", "tempfile", ".", "mkdtemp", "(", ")", "logging", ".", "warning", "(", "'Using temporary folder as model directory: %s'", ",", "self", ".", "_model_dir", ")", "if", "self", ".", "_config", ".", "model_dir", "is", "None", ":", "self", ".", "_config", "=", "self", ".", "_config", ".", "replace", "(", "model_dir", "=", "self", ".", "_model_dir", ")", "logging", ".", "info", "(", "'Using config: %s'", ",", "str", "(", "vars", "(", "self", ".", "_config", ")", ")", ")", "if", "self", ".", "_config", ".", "session_config", "is", "None", ":", "self", ".", "_session_config", "=", "config_pb2", ".", "ConfigProto", "(", "allow_soft_placement", "=", "True", ")", "else", ":", "self", ".", "_session_config", "=", "self", ".", "_config", ".", "session_config", "self", ".", "_device_fn", "=", "_get_replica_device_setter", "(", "self", ".", "_config", ")", "if", "model_fn", "is", "None", ":", "raise", "ValueError", "(", "'model_fn must be provided to Estimator.'", ")", "_verify_model_fn_args", "(", "model_fn", ",", "params", ")", "self", ".", "_model_fn", "=", "model_fn", "self", ".", "_params", "=", "copy", ".", "deepcopy", "(", "params", "or", "{", "}", ")" ]

[ "SetMultiPaste", "(", "self", "int", "multiPaste", ")" ]

[ "def", "SetMultiPaste", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_stc", ".", "StyledTextCtrl_SetMultiPaste", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Returns", "N", "samples", "from", "the", "prior", "." ]

[ "def", "sample_from_prior", "(", "self", ",", "n_samples", ")", ":", "p0", "=", "np", ".", "random", ".", "normal", "(", "loc", "=", "self", ".", "mean", ",", "scale", "=", "self", ".", "sigma", ",", "size", "=", "n_samples", ")", "return", "p0", "[", ":", ",", "np", ".", "newaxis", "]" ]

[ "Find", "position", "at", "the", "matching", "start", "of", "current", "expression", ".", "This", "is", "almost", "the", "reverse", "of", "FindEndOfExpressionInLine", "but", "note", "that", "the", "input", "position", "and", "returned", "position", "differs", "by", "1", ".", "Args", ":", "line", ":", "a", "CleansedLines", "line", ".", "endpos", ":", "start", "searching", "at", "this", "position", ".", "stack", ":", "nesting", "stack", "at", "endpos", ".", "Returns", ":", "On", "finding", "matching", "start", ":", "(", "index", "at", "matching", "start", "None", ")", "On", "finding", "an", "unclosed", "expression", ":", "(", "-", "1", "None", ")", "Otherwise", ":", "(", "-", "1", "new", "stack", "at", "beginning", "of", "this", "line", ")" ]

[ "def", "FindStartOfExpressionInLine", "(", "line", ",", "endpos", ",", "stack", ")", ":", "i", "=", "endpos", "while", "i", ">=", "0", ":", "char", "=", "line", "[", "i", "]", "if", "char", "in", "')]}'", ":", "# Found end of expression, push to expression stack", "stack", ".", "append", "(", "char", ")", "elif", "char", "==", "'>'", ":", "# Found potential end of template argument list.", "#", "# Ignore it if it's a \"->\" or \">=\" or \"operator>\"", "if", "(", "i", ">", "0", "and", "(", "line", "[", "i", "-", "1", "]", "==", "'-'", "or", "Match", "(", "r'\\s>=\\s'", ",", "line", "[", "i", "-", "1", ":", "]", ")", "or", "Search", "(", "r'\\boperator\\s*$'", ",", "line", "[", "0", ":", "i", "]", ")", ")", ")", ":", "i", "-=", "1", "else", ":", "stack", ".", "append", "(", "'>'", ")", "elif", "char", "==", "'<'", ":", "# Found potential start of template argument list", "if", "i", ">", "0", "and", "line", "[", "i", "-", "1", "]", "==", "'<'", ":", "# Left shift operator", "i", "-=", "1", "else", ":", "# If there is a matching '>', we can pop the expression stack.", "# Otherwise, ignore this '<' since it must be an operator.", "if", "stack", "and", "stack", "[", "-", "1", "]", "==", "'>'", ":", "stack", ".", "pop", "(", ")", "if", "not", "stack", ":", "return", "(", "i", ",", "None", ")", "elif", "char", "in", "'([{'", ":", "# Found start of expression.", "#", "# If there are any unmatched '>' on the stack, they must be", "# operators. Remove those.", "while", "stack", "and", "stack", "[", "-", "1", "]", "==", "'>'", ":", "stack", ".", "pop", "(", ")", "if", "not", "stack", ":", "return", "(", "-", "1", ",", "None", ")", "if", "(", "(", "char", "==", "'('", "and", "stack", "[", "-", "1", "]", "==", "')'", ")", "or", "(", "char", "==", "'['", "and", "stack", "[", "-", "1", "]", "==", "']'", ")", "or", "(", "char", "==", "'{'", "and", "stack", "[", "-", "1", "]", "==", "'}'", ")", ")", ":", "stack", ".", "pop", "(", ")", "if", "not", "stack", ":", "return", "(", "i", ",", "None", ")", "else", ":", "# Mismatched parentheses", "return", "(", "-", "1", ",", "None", ")", "elif", "char", "==", "';'", ":", "# Found something that look like end of statements. If we are currently", "# expecting a '<', the matching '>' must have been an operator, since", "# template argument list should not contain statements.", "while", "stack", "and", "stack", "[", "-", "1", "]", "==", "'>'", ":", "stack", ".", "pop", "(", ")", "if", "not", "stack", ":", "return", "(", "-", "1", ",", "None", ")", "i", "-=", "1", "return", "(", "-", "1", ",", "stack", ")" ]

[ "FullName", "after", "removing", "the", "local", "path", "to", "the", "repository", "." ]

[ "def", "RepositoryName", "(", "self", ")", ":", "fullname", "=", "self", ".", "FullName", "(", ")", "if", "os", ".", "path", ".", "exists", "(", "fullname", ")", ":", "project_dir", "=", "os", ".", "path", ".", "dirname", "(", "fullname", ")", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "project_dir", ",", "\".svn\"", ")", ")", ":", "# If there's a .svn file in the current directory, we recursively look", "# up the directory tree for the top of the SVN checkout", "root_dir", "=", "project_dir", "one_up_dir", "=", "os", ".", "path", ".", "dirname", "(", "root_dir", ")", "while", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "one_up_dir", ",", "\".svn\"", ")", ")", ":", "root_dir", "=", "os", ".", "path", ".", "dirname", "(", "root_dir", ")", "one_up_dir", "=", "os", ".", "path", ".", "dirname", "(", "one_up_dir", ")", "prefix", "=", "os", ".", "path", ".", "commonprefix", "(", "[", "root_dir", ",", "project_dir", "]", ")", "return", "fullname", "[", "len", "(", "prefix", ")", "+", "1", ":", "]", "# Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by", "# searching up from the current path.", "root_dir", "=", "os", ".", "path", ".", "dirname", "(", "fullname", ")", "while", "(", "root_dir", "!=", "os", ".", "path", ".", "dirname", "(", "root_dir", ")", "and", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "root_dir", ",", "\".git\"", ")", ")", "and", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "root_dir", ",", "\".hg\"", ")", ")", "and", "not", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "root_dir", ",", "\".svn\"", ")", ")", ")", ":", "root_dir", "=", "os", ".", "path", ".", "dirname", "(", "root_dir", ")", "if", "(", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "root_dir", ",", "\".git\"", ")", ")", "or", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "root_dir", ",", "\".hg\"", ")", ")", "or", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "root_dir", ",", "\".svn\"", ")", ")", ")", ":", "prefix", "=", "os", ".", "path", ".", "commonprefix", "(", "[", "root_dir", ",", "project_dir", "]", ")", "return", "fullname", "[", "len", "(", "prefix", ")", "+", "1", ":", "]", "# Don't know what to do; header guard warnings may be wrong...", "return", "fullname" ]

[ "Read", "the", "Amber", "parameter", "/", "topology", "(", ".", "top", ")", "file" ]

[ "def", "Read_TOP", "(", "self", ",", "Basename", ")", ":", "Item_list", "=", "self", ".", "Read_data", "(", "Basename", "+", "'.top'", ")", "if", "Item_list", "==", "None", ":", "return", "elif", "len", "(", "Item_list", ")", "<", "31", ":", "print", "'(error: File too short!)'", "return", "# Parse the data", "if", "self", ".", "__dict__", ".", "has_key", "(", "'ITITL'", ")", ":", "if", "Pop", "(", "Item_list", ",", "0", ")", "!=", "self", ".", "ITITL", ":", "print", "'(warning: ITITL differs!)'", "else", ":", "self", ".", "ITITL", "=", "Pop", "(", "Item_list", ",", "0", ")", "print", "self", ".", "ITITL", "# Printing Self Title", "if", "self", ".", "__dict__", ".", "has_key", "(", "'NATOM'", ")", ":", "if", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "!=", "self", ".", "NATOM", ":", "print", "'(error: NATOM differs!)'", "return", "else", ":", "self", ".", "NATOM", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "self", ".", "NATOM", "# Printing total number of atoms just to make sure that thing are going right", "self", ".", "NTYPES", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NBONH", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "MBONA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NTHETH", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "MTHETA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NPHIH", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "MPHIA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NHPARM", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NPARM", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NEXT", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NRES", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NBONA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NTHETA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NPHIA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NUMBND", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NUMANG", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NPTRA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NATYP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NPHB", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "IFPERT", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NBPER", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NGPER", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NDPER", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "MBPER", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "MGPER", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "MDPER", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "IFBOX", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "NMXRS", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "IFCAP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "#....................................................", "if", "len", "(", "Item_list", ")", "<", "5", "*", "self", ".", "NATOM", "+", "self", ".", "NTYPES", "**", "2", "+", "2", "*", "(", "self", ".", "NRES", "+", "self", ".", "NUMBND", "+", "self", ".", "NUMANG", ")", "+", "3", "*", "self", ".", "NPTRA", "+", "self", ".", "NATYP", ":", "print", "'(error: File too short!)'", "return", "-", "1", "self", ".", "IGRAPH", "=", "[", "]", "Pop", "(", "Item_list", ",", "0", ")", "# A little kludge is needed here, since the IGRAPH strings are", "# not separated by spaces if 4 characters in length.", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "if", "len", "(", "Item_list", "[", "0", "]", ")", ">", "4", ":", "Item_list", ".", "insert", "(", "1", ",", "Item_list", "[", "0", "]", "[", "4", ":", "]", ")", "Item_list", ".", "insert", "(", "1", ",", "Item_list", "[", "0", "]", "[", "0", ":", "4", "]", ")", "del", "Item_list", "[", "0", "]", "self", ".", "IGRAPH", ".", "append", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "# Vikas' Modification : In the following section, I am printing out each quantity which is currently being read from the topology file.", "print", "'Reading Charges...'", "self", ".", "CHRG", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "CHRG", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Atomic Number...'", "self", ".", "ANUMBER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ANUMBER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Atomic Masses...'", "self", ".", "AMASS", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "AMASS", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Atom Types...'", "self", ".", "IAC", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "IAC", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Excluded Atoms...'", "self", ".", "NUMEX", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "NUMEX", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Non-bonded Parameter Index...'", "self", ".", "ICO", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NTYPES", "**", "2", ")", ":", "self", ".", "ICO", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Residue Labels...'", "self", ".", "LABRES", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NRES", ")", ":", "self", ".", "LABRES", ".", "append", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "'Reading Residues Starting Pointers...'", "self", ".", "IPRES", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NRES", ")", ":", "self", ".", "IPRES", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Bond Force Constants...'", "self", ".", "RK", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NUMBND", ")", ":", "self", ".", "RK", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Equilibrium Bond Values...'", "self", ".", "REQ", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NUMBND", ")", ":", "self", ".", "REQ", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Angle Force Constants...'", "self", ".", "TK", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NUMANG", ")", ":", "self", ".", "TK", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Equilibrium Angle Values...'", "self", ".", "TEQ", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NUMANG", ")", ":", "self", ".", "TEQ", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Dihedral Force Constants...'", "self", ".", "PK", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPTRA", ")", ":", "self", ".", "PK", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Dihedral Periodicity...'", "self", ".", "PN", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPTRA", ")", ":", "self", ".", "PN", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Dihedral Phase...'", "self", ".", "PHASE", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPTRA", ")", ":", "self", ".", "PHASE", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading 1-4 Electrostatic Scaling Factor...'", "self", ".", "SCEEFAC", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPTRA", ")", ":", "self", ".", "SCEEFAC", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading 1-4 Van der Waals Scaling Factor...'", "self", ".", "SCNBFAC", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPTRA", ")", ":", "self", ".", "SCNBFAC", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Solty...'", "#I think this is currently not used in AMBER. Check it out, though", "self", ".", "SOLTY", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATYP", ")", ":", "self", ".", "SOLTY", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "if", "len", "(", "Item_list", ")", "<", "2", "*", "self", ".", "NTYPES", "*", "(", "self", ".", "NTYPES", "+", "1", ")", "/", "2", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading LJ A Coefficient...'", "self", ".", "CN1", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NTYPES", "*", "(", "self", ".", "NTYPES", "+", "1", ")", "/", "2", ")", ":", "self", ".", "CN1", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading LJ B Coefficient...'", "self", ".", "CN2", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NTYPES", "*", "(", "self", ".", "NTYPES", "+", "1", ")", "/", "2", ")", ":", "self", ".", "CN2", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "if", "len", "(", "Item_list", ")", "<", "3", "*", "(", "self", ".", "NBONH", "+", "self", ".", "NBONA", ")", "+", "4", "*", "(", "self", ".", "NTHETH", "+", "self", ".", "NTHETA", ")", "+", "5", "*", "(", "self", ".", "NPHIH", "+", "self", ".", "NPHIA", ")", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading Bonds which include hydrogen...'", "self", ".", "IBH", "=", "[", "]", "self", ".", "JBH", "=", "[", "]", "self", ".", "ICBH", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NBONH", ")", ":", "self", ".", "IBH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JBH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICBH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Bonds which dont include hydrogen...'", "self", ".", "IB", "=", "[", "]", "self", ".", "JB", "=", "[", "]", "self", ".", "ICB", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NBONA", ")", ":", "self", ".", "IB", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JB", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICB", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Angles which include hydrogen...'", "self", ".", "ITH", "=", "[", "]", "self", ".", "JTH", "=", "[", "]", "self", ".", "KTH", "=", "[", "]", "self", ".", "ICTH", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NTHETH", ")", ":", "self", ".", "ITH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JTH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "KTH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICTH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Angles which dont include hydrogen...'", "self", ".", "IT", "=", "[", "]", "self", ".", "JT", "=", "[", "]", "self", ".", "KT", "=", "[", "]", "self", ".", "ICT", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NTHETA", ")", ":", "self", ".", "IT", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JT", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "KT", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICT", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Dihedrals which include hydrogen...'", "self", ".", "IPH", "=", "[", "]", "self", ".", "JPH", "=", "[", "]", "self", ".", "KPH", "=", "[", "]", "self", ".", "LPH", "=", "[", "]", "self", ".", "ICPH", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPHIH", ")", ":", "self", ".", "IPH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JPH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "KPH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "LPH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICPH", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Dihedrals which dont include hydrogen...'", "self", ".", "IP", "=", "[", "]", "self", ".", "JP", "=", "[", "]", "self", ".", "KP", "=", "[", "]", "self", ".", "LP", "=", "[", "]", "self", ".", "ICP", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPHIA", ")", ":", "self", ".", "IP", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JP", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "KP", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "LP", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICP", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "if", "len", "(", "Item_list", ")", "<", "self", ".", "NEXT", "+", "3", "*", "self", ".", "NPHB", "+", "4", "*", "self", ".", "NATOM", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading Excluded Atom List...'", "self", ".", "NATEX", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NEXT", ")", ":", "self", ".", "NATEX", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading H-Bond A Coefficient, corresponding to r**12 term for all possible types...'", "self", ".", "ASOL", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPHB", ")", ":", "self", ".", "ASOL", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading H-Bond B Coefficient, corresponding to r**10 term for all possible types...'", "self", ".", "BSOL", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPHB", ")", ":", "self", ".", "BSOL", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading H-Bond Cut...'", "# I think it is not being used nowadays", "self", ".", "HBCUT", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NPHB", ")", ":", "self", ".", "HBCUT", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading Amber Atom Types for each atom...'", "self", ".", "ISYMBL", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ISYMBL", ".", "append", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "'Reading Tree Chain Classification...'", "self", ".", "ITREE", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ITREE", ".", "append", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "'Reading Join Array: Tree joining information'", "# Currently unused in Sander, an AMBER module", "self", ".", "JOIN", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "JOIN", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "print", "'Reading IRotate...'", "# Currently unused in Sander and Gibbs", "self", ".", "IROTAT", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "IROTAT", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "if", "self", ".", "IFBOX", ">", "0", ":", "if", "len", "(", "Item_list", ")", "<", "3", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading final residue which is part of solute...'", "self", ".", "IPTRES", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "'Reading total number of molecules...'", "self", ".", "NSPM", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "'Reading first solvent moleule index...'", "self", ".", "NSPSOL", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "if", "len", "(", "Item_list", ")", "<", "self", ".", "NSPM", "+", "4", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading atom per molecule...'", "self", ".", "NSP", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NSPM", ")", ":", "self", ".", "NSP", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "BETA", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "print", "'Reading Box Dimensions...'", "if", "self", ".", "__dict__", ".", "has_key", "(", "'BOX'", ")", ":", "BOX", "=", "[", "]", "for", "i", "in", "range", "(", "3", ")", ":", "BOX", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "for", "i", "in", "range", "(", "3", ")", ":", "if", "BOX", "[", "i", "]", "!=", "self", ".", "BOX", "[", "i", "]", ":", "print", "'(warning: BOX differs!)'", ",", "break", "del", "BOX", "else", ":", "self", ".", "BOX", "=", "[", "]", "for", "i", "in", "range", "(", "3", ")", ":", "self", ".", "BOX", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "if", "self", ".", "IFCAP", ">", "0", ":", "if", "len", "(", "Item_list", ")", "<", "5", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading ICAP variables::: For details, refer to online AMBER format manual'", "self", ".", "NATCAP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "CUTCAP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "XCAP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "YCAP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "self", ".", "ZCAP", "=", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "#....................................................", "if", "self", ".", "IFPERT", ">", "0", ":", "if", "len", "(", "Item_list", ")", "<", "4", "*", "self", ".", "NBPER", "+", "5", "*", "self", ".", "NGPER", "+", "6", "*", "self", ".", "NDPER", "+", "self", ".", "NRES", "+", "6", "*", "self", ".", "NATOM", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading perturb variables, 1. Bond, 2. Angles, 3. Dihedrals, etc etc.::: For details, refer to online AMBER format manual'", "self", ".", "IBPER", "=", "[", "]", "self", ".", "JBPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NBPER", ")", ":", "self", ".", "IBPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JBPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICBPER", "=", "[", "]", "for", "i", "in", "range", "(", "2", "*", "self", ".", "NBPER", ")", ":", "self", ".", "ICBPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ITPER", "=", "[", "]", "self", ".", "JTPER", "=", "[", "]", "self", ".", "KTPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NGPER", ")", ":", "self", ".", "ITPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JTPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "KTPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICTPER", "=", "[", "]", "for", "i", "in", "range", "(", "2", "*", "self", ".", "NGPER", ")", ":", "self", ".", "ICTPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "IPPER", "=", "[", "]", "self", ".", "JPPER", "=", "[", "]", "self", ".", "KPPER", "=", "[", "]", "self", ".", "LPPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NDPER", ")", ":", "self", ".", "IPPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "JPPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "KPPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "LPPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ICPPER", "=", "[", "]", "for", "i", "in", "range", "(", "2", "*", "self", ".", "NDPER", ")", ":", "self", ".", "ICPPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "LABRES", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NRES", ")", ":", "LABRES", ".", "append", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", "for", "i", "in", "range", "(", "self", ".", "NRES", ")", ":", "if", "LABRES", "[", "i", "]", "!=", "self", ".", "LABRES", "[", "i", "]", ":", "print", "'(warning: BOX differs!)'", ",", "break", "self", ".", "IGRPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "IGRPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ISMPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ISMPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "ALMPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ALMPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "IAPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "IAPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "IACPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "IACPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "self", ".", "CGPER", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "CGPER", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "self", ".", "IPOL", "=", "0", "if", "self", ".", "IPOL", "==", "1", ":", "if", "len", "(", "Item_list", ")", "<", "self", ".", "NATOM", ":", "print", "'(error: File too short!)'", "return", "-", "1", "print", "'Reading Polarizability Data. For details, refer to online AMBER format manual'", "self", ".", "ATPOL", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ATPOL", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "if", "self", ".", "IFPERT", "==", "1", ":", "if", "len", "(", "Item_list", ")", "<", "self", ".", "NATOM", ":", "print", "'(error: File too short!)'", "return", "-", "1", "self", ".", "ATPOL1", "=", "[", "]", "for", "i", "in", "range", "(", "self", ".", "NATOM", ")", ":", "self", ".", "ATPOL1", ".", "append", "(", "eval", "(", "Pop", "(", "Item_list", ",", "0", ")", ")", ")", "#....................................................", "if", "len", "(", "Item_list", ")", ":", "print", "'(warning: File too large!)'", ",", "print", "'done.'", "self", ".", "TOP_is_read", "=", "1" ]

[ "Pcap", "examples", "runner", "." ]

[ "def", "main", "(", ")", ":", "examples", "=", "{", "\"open3d-one-scan\"", ":", "pcap_3d_one_scan", ",", "\"plot-xyz-points\"", ":", "pcap_display_xyz_points", ",", "\"pcap-to-csv\"", ":", "pcap_to_csv", ",", "\"pcap-to-las\"", ":", "pcap_to_las", ",", "\"pcap-to-pcd\"", ":", "pcap_to_pcd", ",", "\"query-scan\"", ":", "pcap_query_scan", ",", "\"read-packets\"", ":", "pcap_read_packets", ",", "}", "description", "=", "\"Ouster Python SDK Pcap examples. The EXAMPLE must be one of:\\n \"", "+", "str", ".", "join", "(", "'\\n '", ",", "examples", ".", "keys", "(", ")", ")", "parser", "=", "argparse", ".", "ArgumentParser", "(", "description", "=", "description", ",", "formatter_class", "=", "argparse", ".", "RawTextHelpFormatter", ")", "parser", ".", "add_argument", "(", "'pcap_path'", ",", "metavar", "=", "'PCAP'", ",", "help", "=", "'path to pcap file'", ")", "parser", ".", "add_argument", "(", "'metadata_path'", ",", "metavar", "=", "'METADATA'", ",", "help", "=", "'path to metadata json'", ")", "parser", ".", "add_argument", "(", "'example'", ",", "metavar", "=", "'EXAMPLE'", ",", "choices", "=", "examples", ".", "keys", "(", ")", ",", "help", "=", "'name of the example to run'", ")", "parser", ".", "add_argument", "(", "'--scan-num'", ",", "type", "=", "int", ",", "default", "=", "1", ",", "help", "=", "'index of scan to use'", ")", "args", "=", "parser", ".", "parse_args", "(", ")", "try", ":", "example", "=", "examples", "[", "args", ".", "example", "]", "except", "KeyError", ":", "print", "(", "f\"No such example: {args.example}\"", ")", "print", "(", "description", ")", "exit", "(", "1", ")", "if", "not", "args", ".", "metadata_path", "or", "not", "os", ".", "path", ".", "exists", "(", "args", ".", "metadata_path", ")", ":", "print", "(", "f\"Metadata file does not exist: {args.metadata_path}\"", ")", "exit", "(", "1", ")", "print", "(", "f'example: {args.example}'", ")", "with", "open", "(", "args", ".", "metadata_path", ",", "'r'", ")", "as", "f", ":", "metadata", "=", "client", ".", "SensorInfo", "(", "f", ".", "read", "(", ")", ")", "source", "=", "pcap", ".", "Pcap", "(", "args", ".", "pcap_path", ",", "metadata", ")", "with", "closing", "(", "source", ")", ":", "example", "(", "source", ",", "metadata", ",", "args", ".", "scan_num", ")" ]

[ "r", "Logs", "an", "error", "if", "we", "see", "certain", "non", "-", "ANSI", "constructs", "ignored", "by", "gcc", "-", "2", "." ]

[ "def", "CheckForNonStandardConstructs", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "nesting_state", ",", "error", ")", ":", "# Remove comments from the line, but leave in strings for now.", "line", "=", "clean_lines", ".", "lines", "[", "linenum", "]", "if", "Search", "(", "r'printf\\s*\\(.*\".*%[-+ ]?\\d*q'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf_format'", ",", "3", ",", "'%q in format strings is deprecated. Use %ll instead.'", ")", "if", "Search", "(", "r'printf\\s*\\(.*\".*%\\d+\\$'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/printf_format'", ",", "2", ",", "'%N$ formats are unconventional. Try rewriting to avoid them.'", ")", "# Remove escaped backslashes before looking for undefined escapes.", "line", "=", "line", ".", "replace", "(", "'\\\\\\\\'", ",", "''", ")", "if", "Search", "(", "r'(\"|\\').*\\\\(%|\\[|\\(|{)'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/printf_format'", ",", "3", ",", "'%, [, (, and { are undefined character escapes. Unescape them.'", ")", "# For the rest, work with both comments and strings removed.", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "if", "Search", "(", "r'\\b(const|volatile|void|char|short|int|long'", "r'|float|double|signed|unsigned'", "r'|schar|u?int8|u?int16|u?int32|u?int64)'", "r'\\s+(register|static|extern|typedef)\\b'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/storage_class'", ",", "5", ",", "'Storage class (static, extern, typedef, etc) should be first.'", ")", "if", "Match", "(", "r'\\s*#\\s*endif\\s*[^/\\s]+'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/endif_comment'", ",", "5", ",", "'Uncommented text after #endif is non-standard. Use a comment.'", ")", "if", "Match", "(", "r'\\s*class\\s+(\\w+\\s*::\\s*)+\\w+\\s*;'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/forward_decl'", ",", "5", ",", "'Inner-style forward declarations are invalid. Remove this line.'", ")", "if", "Search", "(", "r'(\\w+|[+-]?\\d+(\\.\\d*)?)\\s*(<|>)\\?=?\\s*(\\w+|[+-]?\\d+)(\\.\\d*)?'", ",", "line", ")", ":", "error", "(", "filename", ",", "linenum", ",", "'build/deprecated'", ",", "3", ",", "'>? and <? (max and min) operators are non-standard and deprecated.'", ")", "if", "Search", "(", "r'^\\s*const\\s*string\\s*&\\s*\\w+\\s*;'", ",", "line", ")", ":", "# TODO(unknown): Could it be expanded safely to arbitrary references,", "# without triggering too many false positives? The first", "# attempt triggered 5 warnings for mostly benign code in the regtest, hence", "# the restriction.", "# Here's the original regexp, for the reference:", "# type_name = r'\\w+((\\s*::\\s*\\w+)|(\\s*<\\s*\\w+?\\s*>))?'", "# r'\\s*const\\s*' + type_name + '\\s*&\\s*\\w+\\s*;'", "error", "(", "filename", ",", "linenum", ",", "'runtime/member_string_references'", ",", "2", ",", "'const string& members are dangerous. It is much better to use '", "'alternatives, such as pointers or simple constants.'", ")", "# Everything else in this function operates on class declarations.", "# Return early if the top of the nesting stack is not a class, or if", "# the class head is not completed yet.", "classinfo", "=", "nesting_state", ".", "InnermostClass", "(", ")", "if", "not", "classinfo", "or", "not", "classinfo", ".", "seen_open_brace", ":", "return", "# The class may have been declared with namespace or classname qualifiers.", "# The constructor and destructor will not have those qualifiers.", "base_classname", "=", "classinfo", ".", "name", ".", "split", "(", "'::'", ")", "[", "-", "1", "]", "# Look for single-argument constructors that aren't marked explicit.", "# Technically a valid construct, but against style. Also look for", "# non-single-argument constructors which are also technically valid, but", "# strongly suggest something is wrong.", "explicit_constructor_match", "=", "Match", "(", "r'\\s+(?:inline\\s+)?(explicit\\s+)?(?:inline\\s+)?%s\\s*'", "r'\\(((?:[^()]|\\([^()]*\\))*)\\)'", "%", "re", ".", "escape", "(", "base_classname", ")", ",", "line", ")", "if", "explicit_constructor_match", ":", "is_marked_explicit", "=", "explicit_constructor_match", ".", "group", "(", "1", ")", "if", "not", "explicit_constructor_match", ".", "group", "(", "2", ")", ":", "constructor_args", "=", "[", "]", "else", ":", "constructor_args", "=", "explicit_constructor_match", ".", "group", "(", "2", ")", ".", "split", "(", "','", ")", "# collapse arguments so that commas in template parameter lists and function", "# argument parameter lists don't split arguments in two", "i", "=", "0", "while", "i", "<", "len", "(", "constructor_args", ")", ":", "constructor_arg", "=", "constructor_args", "[", "i", "]", "while", "(", "constructor_arg", ".", "count", "(", "'<'", ")", ">", "constructor_arg", ".", "count", "(", "'>'", ")", "or", "constructor_arg", ".", "count", "(", "'('", ")", ">", "constructor_arg", ".", "count", "(", "')'", ")", ")", ":", "constructor_arg", "+=", "','", "+", "constructor_args", "[", "i", "+", "1", "]", "del", "constructor_args", "[", "i", "+", "1", "]", "constructor_args", "[", "i", "]", "=", "constructor_arg", "i", "+=", "1", "defaulted_args", "=", "[", "arg", "for", "arg", "in", "constructor_args", "if", "'='", "in", "arg", "]", "noarg_constructor", "=", "(", "not", "constructor_args", "or", "# empty arg list", "# 'void' arg specifier", "(", "len", "(", "constructor_args", ")", "==", "1", "and", "constructor_args", "[", "0", "]", ".", "strip", "(", ")", "==", "'void'", ")", ")", "onearg_constructor", "=", "(", "(", "len", "(", "constructor_args", ")", "==", "1", "and", "# exactly one arg", "not", "noarg_constructor", ")", "or", "# all but at most one arg defaulted", "(", "len", "(", "constructor_args", ")", ">=", "1", "and", "not", "noarg_constructor", "and", "len", "(", "defaulted_args", ")", ">=", "len", "(", "constructor_args", ")", "-", "1", ")", ")", "initializer_list_constructor", "=", "bool", "(", "onearg_constructor", "and", "Search", "(", "r'\\bstd\\s*::\\s*initializer_list\\b'", ",", "constructor_args", "[", "0", "]", ")", ")", "copy_constructor", "=", "bool", "(", "onearg_constructor", "and", "Match", "(", "r'(const\\s+)?%s(\\s*<[^>]*>)?(\\s+const)?\\s*(?:<\\w+>\\s*)?&'", "%", "re", ".", "escape", "(", "base_classname", ")", ",", "constructor_args", "[", "0", "]", ".", "strip", "(", ")", ")", ")", "if", "(", "not", "is_marked_explicit", "and", "onearg_constructor", "and", "not", "initializer_list_constructor", "and", "not", "copy_constructor", ")", ":", "if", "defaulted_args", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "5", ",", "'Constructors callable with one argument '", "'should be marked explicit.'", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "5", ",", "'Single-parameter constructors should be marked explicit.'", ")", "elif", "is_marked_explicit", "and", "not", "onearg_constructor", ":", "if", "noarg_constructor", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "5", ",", "'Zero-parameter constructors should not be marked explicit.'", ")", "else", ":", "error", "(", "filename", ",", "linenum", ",", "'runtime/explicit'", ",", "0", ",", "'Constructors that require multiple arguments '", "'should not be marked explicit.'", ")" ]

[ "Return", "a", "copy", "of", "the", "current", "ZerosPolesGain", "system", "." ]

[ "def", "to_zpk", "(", "self", ")", ":", "return", "copy", ".", "deepcopy", "(", "self", ")" ]

[ "Get", "the", "keras", "layer", "name", "from", "the", "activation", "name", "." ]

[ "def", "_get_elementwise_name_from_keras_layer", "(", "keras_layer", ")", ":", "mode", "=", "keras_layer", ".", "mode", "if", "mode", "==", "\"sum\"", ":", "return", "\"ADD\"", "elif", "mode", "==", "\"mul\"", ":", "return", "\"MULTIPLY\"", "elif", "mode", "==", "\"concat\"", ":", "if", "len", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", "==", "3", "and", "(", "keras_layer", ".", "concat_axis", "==", "1", "or", "keras_layer", ".", "concat_axis", "==", "-", "2", ")", ":", "return", "\"SEQUENCE_CONCAT\"", "elif", "len", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", "==", "4", "and", "(", "keras_layer", ".", "concat_axis", "==", "3", "or", "keras_layer", ".", "concat_axis", "==", "-", "1", ")", ":", "return", "\"CONCAT\"", "elif", "len", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", "==", "2", "and", "(", "keras_layer", ".", "concat_axis", "==", "1", "or", "keras_layer", ".", "concat_axis", "==", "-", "1", ")", ":", "return", "\"CONCAT\"", "else", ":", "option", "=", "\"input_shape = %s concat_axis = %s\"", "%", "(", "str", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", ",", "str", "(", "keras_layer", ".", "concat_axis", ")", ",", ")", "_utils", ".", "raise_error_unsupported_option", "(", "option", ",", "mode", ",", "keras_layer", ".", "name", ")", "elif", "mode", "==", "\"cos\"", ":", "if", "len", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", "==", "2", ":", "return", "\"COS\"", "else", ":", "option", "=", "\"input_shape = %s\"", "%", "(", "str", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", ")", "_utils", ".", "raise_error_unsupported_option", "(", "option", ",", "mode", ",", "keras_layer", ".", "name", ")", "elif", "mode", "==", "\"dot\"", ":", "if", "len", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", "==", "2", ":", "return", "\"DOT\"", "else", ":", "option", "=", "\"input_shape = %s\"", "%", "(", "str", "(", "keras_layer", ".", "input_shape", "[", "0", "]", ")", ")", "_utils", ".", "raise_error_unsupported_option", "(", "option", ",", "mode", ",", "keras_layer", ".", "name", ")", "elif", "mode", "==", "\"max\"", ":", "return", "\"MAX\"", "elif", "mode", "==", "\"ave\"", ":", "return", "\"AVE\"", "else", ":", "_utils", ".", "raise_error_unsupported_categorical_option", "(", "\"mode\"", ",", "mode", ",", "\"Merge\"", ",", "keras_layer", ".", "name", ")" ]

[ "Return", "true", "if", "the", "first", "sequence", "is", "a", "rotation", "of", "the", "second", "sequence", "." ]

[ "def", "is_rotated", "(", "seq1", ",", "seq2", ")", ":", "# Do a sanity check.", "if", "len", "(", "seq1", ")", "!=", "len", "(", "seq2", ")", ":", "return", "False", "# Look for occurrences of second sequence head item in first sequence.", "start_indexes", "=", "[", "]", "head_item", "=", "seq2", "[", "0", "]", "for", "index1", "in", "range", "(", "len", "(", "seq1", ")", ")", ":", "if", "seq1", "[", "index1", "]", "==", "head_item", ":", "start_indexes", ".", "append", "(", "index1", ")", "# Check that wrapped sequence matches.", "double_seq1", "=", "seq1", "+", "seq1", "for", "index1", "in", "start_indexes", ":", "if", "double_seq1", "[", "index1", ":", "index1", "+", "len", "(", "seq1", ")", "]", "==", "seq2", ":", "return", "True", "return", "False" ]

[ "yield", "platform", "-", "specific", "path", "patterns", "(", "suitable", "for", "glob", "or", "fn_match", ")", "from", "a", "glob", "-", "based", "spec", "(", "such", "as", "self", ".", "package_data", "or", "self", ".", "exclude_package_data", ")", "matching", "package", "in", "src_dir", "." ]

[ "def", "_get_platform_patterns", "(", "spec", ",", "package", ",", "src_dir", ")", ":", "raw_patterns", "=", "itertools", ".", "chain", "(", "spec", ".", "get", "(", "''", ",", "[", "]", ")", ",", "spec", ".", "get", "(", "package", ",", "[", "]", ")", ",", ")", "return", "(", "# Each pattern has to be converted to a platform-specific path", "os", ".", "path", ".", "join", "(", "src_dir", ",", "convert_path", "(", "pattern", ")", ")", "for", "pattern", "in", "raw_patterns", ")" ]

[ "Is", "the", "atom", "log", "-", "log", "convex?" ]

[ "def", "is_atom_log_log_convex", "(", "self", ")", "->", "bool", ":", "return", "False" ]

[ "root", "node", "of", "T" ]

[ "def", "root", "(", "self", ")", ":", "return", "self", ".", "_root" ]

[ "InsertItem", "(", "self", "DataViewItem", "parent", "DataViewItem", "previous", "String", "text", "int", "icon", "=", "-", "1", "wxClientData", "data", "=", "None", ")", "-", ">", "DataViewItem" ]

[ "def", "InsertItem", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewTreeCtrl_InsertItem", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Sets", "the", "Z", "coordinate", "of", "the", "LAS", "point", "to", "an", "integer", "value", "value", "." ]

[ "def", "set_raw_z", "(", "self", ",", "value", ")", ":", "return", "core", ".", "las", ".", "LASPoint_SetRawZ", "(", "self", ".", "handle", ",", "value", ")" ]

[ "Return", "the", "indices", "of", "the", "elements", "that", "are", "non", "-", "zero", "." ]

[ "def", "nonzero", "(", "a", ")", ":", "return", "_wrapfunc", "(", "a", ",", "'nonzero'", ")" ]

[ "r", "Returns", "the", "average", "length", "of", "each", "faces", "in", "a", "mesh", "." ]

[ "def", "average_edge_length", "(", "vertices", ",", "faces", ")", ":", "batch_size", "=", "vertices", ".", "shape", "[", "0", "]", "p1", "=", "torch", ".", "index_select", "(", "vertices", ",", "1", ",", "faces", "[", ":", ",", "0", "]", ")", "p2", "=", "torch", ".", "index_select", "(", "vertices", ",", "1", ",", "faces", "[", ":", ",", "1", "]", ")", "p3", "=", "torch", ".", "index_select", "(", "vertices", ",", "1", ",", "faces", "[", ":", ",", "2", "]", ")", "# get edge lentgh", "e1", "=", "p2", "-", "p1", "e2", "=", "p3", "-", "p1", "e3", "=", "p2", "-", "p3", "el1", "=", "torch", ".", "sqrt", "(", "(", "torch", ".", "sum", "(", "e1", "**", "2", ",", "dim", "=", "2", ")", ")", ")", "el2", "=", "torch", ".", "sqrt", "(", "(", "torch", ".", "sum", "(", "e2", "**", "2", ",", "dim", "=", "2", ")", ")", ")", "el3", "=", "torch", ".", "sqrt", "(", "(", "torch", ".", "sum", "(", "e3", "**", "2", ",", "dim", "=", "2", ")", ")", ")", "edge_length", "=", "(", "el1", "+", "el2", "+", "el3", ")", "/", "3.", "return", "edge_length" ]

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

[ "def", "__init__", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "_aui", ".", "AuiTabContainer_swiginit", "(", "self", ",", "_aui", ".", "new_AuiTabContainer", "(", "*", "args", ",", "*", "*", "kwargs", ")", ")" ]

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

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

[ "Generate", "bprop", "for", "Addcmul" ]

[ "def", "get_bprop_index_addcmul", "(", "self", ")", ":", "mul_op", "=", "P", ".", "Mul", "(", ")", "def", "bprop", "(", "input_data", ",", "x1", ",", "x2", ",", "value", ",", "out", ",", "dout", ")", ":", "dx1", "=", "mul_op", "(", "dout", ",", "mul_op", "(", "value", ",", "x2", ")", ")", "dx2", "=", "mul_op", "(", "dout", ",", "mul_op", "(", "value", ",", "x1", ")", ")", "dvalue", "=", "mul_op", "(", "dout", ",", "mul_op", "(", "x1", ",", "x2", ")", ")", "return", "dout", ",", "dx1", ",", "dx2", ",", "dvalue", "return", "bprop" ]

[ "SetIcon", "(", "self", "String", "iconFile", "int", "iconIndex", "=", "0", ")" ]

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

[ "Setup", "basic", "logging", "Args", ":", "level", "(", "int", ")", ":", "minimum", "log", "level", "for", "emitting", "messages" ]

[ "def", "setup_logging", "(", "level", ")", ":", "format", "=", "\"[%(asctime)s] %(levelname)s:%(name)s:%(message)s\"", "logging", ".", "basicConfig", "(", "level", "=", "level", ",", "stream", "=", "sys", ".", "stdout", ",", "format", "=", "format", ",", "datefmt", "=", "\"%Y-%m-%d %H:%M:%S\"", ")" ]

[ "Loads", "NetworkX", "model", "into", "InferenceEngine", "and", "stores", "it", "in", "Engine", "class", ":", "param", "model", ":", "CompressedModel", "instance" ]

[ "def", "set_model", "(", "self", ",", "model", ")", ":", "# save graph to IR and use it to initialize IE Network", "self", ".", "_model", "=", "self", ".", "_set_model", "(", "model", ")", "self", ".", "_output_layers", "=", "{", "}", "stage_names", "=", "[", "'pnet'", ",", "'rnet'", ",", "'onet'", "]", "for", "stage", ",", "model_dict", "in", "enumerate", "(", "model", ".", "models", ")", ":", "self", ".", "_output_layers", "[", "stage_names", "[", "stage", "]", "]", "=", "{", "'probabilities'", ":", "model_dict", "[", "'name'", "]", "+", "'_'", "+", "self", ".", "config", "[", "'outputs'", "]", "[", "'probabilities'", "]", "[", "stage", "]", ",", "'regions'", ":", "model_dict", "[", "'name'", "]", "+", "'_'", "+", "self", ".", "config", "[", "'outputs'", "]", "[", "'regions'", "]", "[", "stage", "]", ",", "}" ]

[ "Fit", "the", "hierarchical", "clustering", "on", "the", "data" ]

[ "def", "fit", "(", "self", ",", "X", ",", "y", "=", "None", ",", "*", "*", "params", ")", ":", "X", "=", "check_array", "(", "X", ",", "accept_sparse", "=", "[", "'csr'", ",", "'csc'", ",", "'coo'", "]", ",", "ensure_min_features", "=", "2", ",", "estimator", "=", "self", ")", "return", "AgglomerativeClustering", ".", "fit", "(", "self", ",", "X", ".", "T", ",", "*", "*", "params", ")" ]