Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Adds", "a", "__slots__", "entry", "to", "dictionary", "containing", "the", "names", "of", "all", "valid", "attributes", "for", "this", "message", "type", "." ]

[ "def", "_AddSlots", "(", "message_descriptor", ",", "dictionary", ")", ":", "dictionary", "[", "'__slots__'", "]", "=", "[", "'_cached_byte_size'", ",", "'_cached_byte_size_dirty'", ",", "'_fields'", ",", "'_unknown_fields'", ",", "'_is_present_in_parent'", ",", "'_listener'", ",", "'_listener_for_children'", ",", "'__weakref__'", "]" ]

[ "Check", "(", "self", "unsigned", "int", "index", "int", "check", "=", "True", ")" ]

[ "def", "Check", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "CheckListBox_Check", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Encrypts", "data", "on", "the", "server", "side", "with", "a", "new", "customer", "master", "key", "without", "exposing", "the", "plaintext", "of", "the", "data", "on", "the", "client", "side", ".", "The", "data", "is", "first", "decrypted", "and", "then", "encrypted", ".", "This", "operation", "can", "also", "be", "used", "to", "change", "the", "encryption", "context", "of", "a", "ciphertext", "." ]

[ "def", "re_encrypt", "(", "self", ",", "ciphertext_blob", ",", "destination_key_id", ",", "source_encryption_context", "=", "None", ",", "destination_encryption_context", "=", "None", ",", "grant_tokens", "=", "None", ")", ":", "if", "not", "isinstance", "(", "ciphertext_blob", ",", "six", ".", "binary_type", ")", ":", "raise", "TypeError", "(", "\"Value of argument ``ciphertext_blob`` \"", "\"must be of type %s.\"", "%", "six", ".", "binary_type", ")", "ciphertext_blob", "=", "base64", ".", "b64encode", "(", "ciphertext_blob", ")", "params", "=", "{", "'CiphertextBlob'", ":", "ciphertext_blob", ",", "'DestinationKeyId'", ":", "destination_key_id", ",", "}", "if", "source_encryption_context", "is", "not", "None", ":", "params", "[", "'SourceEncryptionContext'", "]", "=", "source_encryption_context", "if", "destination_encryption_context", "is", "not", "None", ":", "params", "[", "'DestinationEncryptionContext'", "]", "=", "destination_encryption_context", "if", "grant_tokens", "is", "not", "None", ":", "params", "[", "'GrantTokens'", "]", "=", "grant_tokens", "response", "=", "self", ".", "make_request", "(", "action", "=", "'ReEncrypt'", ",", "body", "=", "json", ".", "dumps", "(", "params", ")", ")", "if", "response", ".", "get", "(", "'CiphertextBlob'", ")", "is", "not", "None", ":", "response", "[", "'CiphertextBlob'", "]", "=", "base64", ".", "b64decode", "(", "response", "[", "'CiphertextBlob'", "]", ".", "encode", "(", "'utf-8'", ")", ")", "return", "response" ]

[ "Checks", "that", "all", "classes", "and", "namespaces", "have", "been", "completely", "parsed", "." ]

[ "def", "CheckCompletedBlocks", "(", "self", ",", "filename", ",", "error", ")", ":", "# Note: This test can result in false positives if #ifdef constructs", "# get in the way of brace matching. See the testBuildClass test in", "# cpplint_unittest.py for an example of this.", "for", "obj", "in", "self", ".", "stack", ":", "if", "isinstance", "(", "obj", ",", "_ClassInfo", ")", ":", "error", "(", "filename", ",", "obj", ".", "starting_linenum", ",", "'build/class'", ",", "5", ",", "'Failed to find complete declaration of class %s'", "%", "obj", ".", "name", ")", "elif", "isinstance", "(", "obj", ",", "_NamespaceInfo", ")", ":", "error", "(", "filename", ",", "obj", ".", "starting_linenum", ",", "'build/namespaces'", ",", "5", ",", "'Failed to find complete declaration of namespace %s'", "%", "obj", ".", "name", ")" ]

[]

[ "def", "connectivityInfoList", "(", "self", ")", ":", "return", "list", "(", "self", ".", "_connectivity_info_dict", ".", "values", "(", ")", ")" ]

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

[ "def", "GetTopMargin", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_richtext", ".", "RichTextObject_GetTopMargin", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Define", "a", "Crop", "layer", "to", "crop", "a", "top", "(", "from", ")", "to", "another", "top", "(", "to", ")", "by", "determining", "the", "coordinate", "mapping", "between", "the", "two", "and", "net", "spec", "ing", "the", "axis", "and", "shift", "parameters", "of", "the", "crop", "." ]

[ "def", "crop", "(", "top_from", ",", "top_to", ")", ":", "ax", ",", "a", ",", "b", "=", "coord_map_from_to", "(", "top_from", ",", "top_to", ")", "assert", "(", "a", "==", "1", ")", ".", "all", "(", ")", ",", "'scale mismatch on crop (a = {})'", ".", "format", "(", "a", ")", "assert", "(", "b", "<=", "0", ")", ".", "all", "(", ")", ",", "'cannot crop negative offset (b = {})'", ".", "format", "(", "b", ")", "assert", "(", "np", ".", "round", "(", "b", ")", "==", "b", ")", ".", "all", "(", ")", ",", "'cannot crop noninteger offset '", "'(b = {})'", ".", "format", "(", "b", ")", "return", "L", ".", "Crop", "(", "top_from", ",", "top_to", ",", "crop_param", "=", "dict", "(", "axis", "=", "ax", "+", "1", ",", "# +1 for first cropping dim.", "offset", "=", "list", "(", "-", "np", ".", "round", "(", "b", ")", ".", "astype", "(", "int", ")", ")", ")", ")" ]

[ "Get", "the", "set", "of", "VTK", "headers", "in", "a", "user", "s", "file", "or", "files", "with", "a", "common", "name", "in", "the", "path", ".", ":", "param", "path", ":", "The", "file", "name", "or", "the", "file", "name", "without", "the", "extension", ".", ":", "return", ":", "headers", "as", "the", "key", "and", "the", "corresponding", "filenames", "as", "the", "value", "." ]

[ "def", "get_users_file_headers", "(", "path", ")", ":", "c", "=", "Constants", "(", ")", "headers", "=", "collections", ".", "defaultdict", "(", "set", ")", "name", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "path", ")", "if", "ext", ":", "if", "ext", "in", "c", ".", "valid_ext", ":", "if", "not", "os", ".", "path", ".", "isfile", "(", "path", ")", ":", "raise", "Exception", "(", "'No such file: '", "+", "path", ")", "with", "open", "(", "path", ")", "as", "data", ":", "# Read the file looking for includes.", "for", "line", "in", "data", ":", "m", "=", "c", ".", "header_pattern", ".", "match", "(", "line", ".", "strip", "(", ")", ")", "if", "m", ":", "# We have a header name, split it from its path (if the path exists).", "header_parts", "=", "os", ".", "path", ".", "split", "(", "m", ".", "group", "(", "1", ")", ")", "m", "=", "c", ".", "vtk_include_pattern", ".", "match", "(", "header_parts", "[", "1", "]", ")", "if", "m", ":", "headers", "[", "m", ".", "group", "(", "1", ")", "]", ".", "add", "(", "os", ".", "path", ".", "split", "(", "path", ")", "[", "1", "]", ")", "else", ":", "raise", "Exception", "(", "'Unrecognised extension:'", "+", "path", ")", "else", ":", "for", "ext", "in", "c", ".", "valid_ext", ":", "fn", "=", "name", "+", "ext", "if", "os", ".", "path", ".", "isfile", "(", "fn", ")", ":", "with", "open", "(", "fn", ")", "as", "data", ":", "# Read the file looking for includes.", "for", "line", "in", "data", ":", "m", "=", "c", ".", "header_pattern", ".", "match", "(", "line", ".", "strip", "(", ")", ")", "if", "m", ":", "# We have a header name, split it from its path (if the path exists).", "header_parts", "=", "os", ".", "path", ".", "split", "(", "m", ".", "group", "(", "1", ")", ")", "m", "=", "c", ".", "vtk_include_pattern", ".", "match", "(", "header_parts", "[", "1", "]", ")", "if", "m", ":", "headers", "[", "m", ".", "group", "(", "1", ")", "]", ".", "add", "(", "os", ".", "path", ".", "split", "(", "path", ")", "[", "1", "]", ")", "return", "headers" ]

[ "Return", "the", "most", "recent", "non", "-", "blank", "line", "and", "its", "line", "number", "." ]

[ "def", "GetPreviousNonBlankLine", "(", "clean_lines", ",", "linenum", ")", ":", "prevlinenum", "=", "linenum", "-", "1", "while", "prevlinenum", ">=", "0", ":", "prevline", "=", "clean_lines", ".", "elided", "[", "prevlinenum", "]", "if", "not", "IsBlankLine", "(", "prevline", ")", ":", "# if not a blank line...", "return", "(", "prevline", ",", "prevlinenum", ")", "prevlinenum", "-=", "1", "return", "(", "''", ",", "-", "1", ")" ]

[ "Parses", "a", "URI", "using", "the", "regex", "given", "in", "Appendix", "B", "of", "RFC", "3986", "." ]

[ "def", "parse_uri", "(", "uri", ")", ":", "groups", "=", "URI", ".", "match", "(", "uri", ")", ".", "groups", "(", ")", "return", "(", "groups", "[", "1", "]", ",", "groups", "[", "3", "]", ",", "groups", "[", "4", "]", ",", "groups", "[", "6", "]", ",", "groups", "[", "8", "]", ")" ]

[ "Initialize", "role_maker", "in", "Fleet", "." ]

[ "def", "init", "(", "self", ",", "role_maker", "=", "None", ",", "is_collective", "=", "False", ",", "strategy", "=", "None", ")", ":", "if", "strategy", "is", "None", ":", "strategy", "=", "DistributedStrategy", "(", ")", "self", ".", "_user_defined_strategy", "=", "copy", ".", "deepcopy", "(", "strategy", ")", "if", "role_maker", "is", "None", ":", "if", "isinstance", "(", "is_collective", ",", "bool", ")", ":", "self", ".", "_is_collective", "=", "is_collective", "self", ".", "_role_maker", "=", "PaddleCloudRoleMaker", "(", "is_collective", "=", "self", ".", "_is_collective", ")", "else", ":", "raise", "ValueError", "(", "\"`is_collective` should be instance of `bool`, but got {}\"", ".", "format", "(", "type", "(", "is_collective", ")", ")", ")", "else", ":", "if", "isinstance", "(", "role_maker", ",", "RoleMakerBase", ")", ":", "self", ".", "_role_maker", "=", "role_maker", "self", ".", "_is_collective", "=", "role_maker", ".", "_is_collective", "else", ":", "raise", "ValueError", "(", "\"`role_maker` should be subclass of `RoleMakerBase`, but got {}\"", ".", "format", "(", "type", "(", "role_maker", ")", ")", ")", "self", ".", "_role_maker", ".", "_generate_role", "(", ")", "import", "paddle", ".", "distributed", ".", "fleet", "as", "fleet", "fleet", ".", "util", ".", "_set_role_maker", "(", "self", ".", "_role_maker", ")", "self", ".", "strategy_compiler", "=", "StrategyCompiler", "(", ")", "if", "self", ".", "_role_maker", ".", "_is_non_distributed", "(", ")", "and", "self", ".", "_is_collective", ":", "if", "paddle", ".", "fluid", ".", "core", ".", "is_compiled_with_cuda", "(", ")", ":", "gpus_num", "=", "paddle", ".", "fluid", ".", "core", ".", "get_cuda_device_count", "(", ")", "if", "gpus_num", "!=", "1", ":", "raise", "ValueError", "(", "\"CUDA_VISIBLE_DEVICES shoule be set only 1 card if you use `python` to launch fleet program.\"", ")", "if", "paddle", ".", "fluid", ".", "framework", ".", "in_dygraph_mode", "(", ")", ":", "if", "self", ".", "worker_num", "(", ")", "==", "1", ":", "# if worker_num is 1, should construct default topology & hcg", "self", ".", "_topology", "=", "tp", ".", "CommunicateTopology", "(", ")", "self", ".", "_hcg", "=", "tp", ".", "HybridCommunicateGroup", "(", "self", ".", "_topology", ")", "return", "if", "parallel_helper", ".", "_is_parallel_ctx_initialized", "(", ")", ":", "warnings", ".", "warn", "(", "\"The dygraph parallel environment has been initialized.\"", ")", "else", ":", "# FLAGS_nccl_nrings is used for dynamic graph multi-stream communication", "if", "\"FLAGS_nccl_nrings\"", "in", "os", ".", "environ", ":", "warnings", ".", "warn", "(", "\"You have set the environment variable FLAGS_nccl_nrings \"", "\"outside the program, so the nccl_comm_num in \"", "\"DistributedStrategy will not take effect here.\"", ")", "else", ":", "os", ".", "environ", "[", "\"FLAGS_nccl_nrings\"", "]", "=", "str", "(", "self", ".", "_user_defined_strategy", ".", "nccl_comm_num", ")", "paddle", ".", "distributed", ".", "init_parallel_env", "(", ")", "# hybrid parallel not support for npu/xpu", "if", "self", ".", "_user_defined_strategy", ".", "heter_ccl_mode", "==", "False", ":", "# init hybrid parallel environment in dygraph", "if", "tp", ".", "_HYBRID_PARALLEL_GROUP", "is", "None", ":", "self", ".", "_init_hybrid_parallel_env", "(", ")", "else", ":", "warnings", ".", "warn", "(", "\"The dygraph hybrid parallel environment has been initialized.\"", ")", "elif", "self", ".", "_is_collective", ":", "use_sharding", "=", "self", ".", "_user_defined_strategy", ".", "sharding", "# global group", "global_rank", "=", "self", ".", "worker_index", "(", ")", "global_world_size", "=", "self", ".", "worker_num", "(", ")", "# NOTE(wangxi): see sharding_optimizer", "global_ring_id", "=", "3", "if", "use_sharding", "else", "0", "global_ranks", "=", "list", "(", "range", "(", "global_world_size", ")", ")", "if", "tp", ".", "_HYBRID_PARALLEL_GROUP", "is", "None", ":", "tp", ".", "_CommunicateGroup", "(", ")", "cg", "=", "tp", ".", "_HYBRID_PARALLEL_GROUP", "self", ".", "_hcg", "=", "cg", "cg", ".", "set_comm_group", "(", "'global'", ",", "global_rank", ",", "global_world_size", ",", "global_ring_id", ",", "global_ranks", ")", "use_tensor_parallel", "=", "self", ".", "_user_defined_strategy", ".", "tensor_parallel", "use_mp", "=", "use_sharding", "or", "use_tensor_parallel", "# hybrid group", "if", "use_mp", "is", "False", ":", "return", "mp_degree_sharding", "=", "1", "mp_degree_tensor_parallel", "=", "1", "if", "use_sharding", ":", "sharding_configs", "=", "self", ".", "_user_defined_strategy", ".", "sharding_configs", "mp_degree_sharding", "=", "int", "(", "sharding_configs", "[", "'mp_degree'", "]", ")", "if", "use_tensor_parallel", ":", "tensor_parallel_configs", "=", "self", ".", "_user_defined_strategy", ".", "tensor_parallel_configs", "mp_degree_tensor_parallel", "=", "int", "(", "tensor_parallel_configs", "[", "'tensor_parallel_degree'", "]", ")", "if", "use_sharding", "and", "use_tensor_parallel", ":", "assert", "mp_degree_sharding", "==", "mp_degree_tensor_parallel", "mp_degree", "=", "mp_degree_sharding", "if", "use_sharding", "else", "mp_degree_tensor_parallel", "if", "mp_degree", ">", "1", ":", "assert", "global_world_size", "%", "mp_degree", "==", "0", "# NOTE(wangxi): mp_ring_id sync with sharding_optimizer.py _build_groups", "mp_ring_id", "=", "0", "mp_rank", "=", "global_rank", "%", "mp_degree", "mp_group_id", "=", "global_rank", "//", "mp_degree", "mp_group_ranks", "=", "[", "idx", "for", "idx", "in", "global_ranks", "if", "idx", "//", "mp_degree", "==", "mp_group_id", "]", "cg", ".", "set_comm_group", "(", "'model'", ",", "mp_rank", ",", "mp_degree", ",", "mp_ring_id", ",", "mp_group_ranks", ")" ]

[ "Calculate", "Bahdanau", "score" ]

[ "def", "forward", "(", "self", ",", "att_query", ",", "att_keys", ",", "normalize_bias", ",", "linear_att", ")", ":", "b", ",", "t_k", ",", "n", "=", "att_keys", ".", "size", "(", ")", "t_q", "=", "att_query", ".", "size", "(", "1", ")", "att_query", "=", "att_query", ".", "unsqueeze", "(", "2", ")", ".", "expand", "(", "b", ",", "t_q", ",", "t_k", ",", "n", ")", "att_keys", "=", "att_keys", ".", "unsqueeze", "(", "1", ")", ".", "expand", "(", "b", ",", "t_q", ",", "t_k", ",", "n", ")", "sum_qk", "=", "att_query", "+", "att_keys", "+", "normalize_bias", "out", "=", "torch", ".", "tanh", "(", "sum_qk", ")", ".", "matmul", "(", "linear_att", ")", "return", "out" ]

[ "r", "Inplace", "version", "of", "erfinv", "API", "the", "output", "Tensor", "will", "be", "inplaced", "with", "input", "x", ".", "Please", "refer", "to", ":", "ref", ":", "api_tensor_erfinv", "." ]

[ "def", "erfinv_", "(", "x", ",", "name", "=", "None", ")", ":", "check_type", "(", "x", ",", "'x'", ",", "(", "paddle", ".", "Tensor", ",", "Variable", ")", ",", "'erfinv'", ")", "return", "_C_ops", ".", "erfinv_", "(", "x", ")" ]

[ "Generate", "generalized", "tube", "(", "i", ".", "e", ".", "cylinder", "with", "an", "axial", "hole", ")", "." ]

[ "def", "generate_tube", "(", "p0", ",", "p1", ",", "r0_out", ",", "r1_out", ",", "r0_in", ",", "r1_in", ",", "num_segments", "=", "16", ",", "with_quad", "=", "False", ")", ":", "assert", "(", "len", "(", "p0", ")", "==", "3", ")", "assert", "(", "len", "(", "p1", ")", "==", "3", ")", "Z", "=", "np", ".", "array", "(", "[", "0", ",", "0", ",", "1", "]", ",", "dtype", "=", "float", ")", "p0", "=", "np", ".", "array", "(", "p0", ",", "dtype", "=", "float", ")", "p1", "=", "np", ".", "array", "(", "p1", ",", "dtype", "=", "float", ")", "axis", "=", "p1", "-", "p0", "l", "=", "norm", "(", "axis", ")", "if", "l", "<=", "1e-12", ":", "axis", "=", "Z", "N", "=", "num_segments", "angles", "=", "[", "2", "*", "math", ".", "pi", "*", "i", "/", "float", "(", "N", ")", "for", "i", "in", "range", "(", "N", ")", "]", "rim", "=", "np", ".", "array", "(", "[", "[", "math", ".", "cos", "(", "theta", ")", ",", "math", ".", "sin", "(", "theta", ")", ",", "0.0", "]", "for", "theta", "in", "angles", "]", ")", "rot", "=", "Quaternion", ".", "fromData", "(", "Z", ",", "axis", ")", ".", "to_matrix", "(", ")", "bottom_outer_rim", "=", "np", ".", "dot", "(", "rot", ",", "rim", ".", "T", ")", ".", "T", "*", "r0_out", "+", "p0", "bottom_inner_rim", "=", "np", ".", "dot", "(", "rot", ",", "rim", ".", "T", ")", ".", "T", "*", "r0_in", "+", "p0", "top_outer_rim", "=", "np", ".", "dot", "(", "rot", ",", "rim", ".", "T", ")", ".", "T", "*", "r1_out", "+", "p1", "top_inner_rim", "=", "np", ".", "dot", "(", "rot", ",", "rim", ".", "T", ")", ".", "T", "*", "r1_in", "+", "p1", "vertices", "=", "np", ".", "vstack", "(", "[", "bottom_outer_rim", ",", "bottom_inner_rim", ",", "top_outer_rim", ",", "top_inner_rim", "]", ")", "if", "with_quad", ":", "top", "=", "np", ".", "array", "(", "[", "[", "2", "*", "N", "+", "i", ",", "2", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "3", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "3", "*", "N", "+", "i", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "bottom", "=", "np", ".", "array", "(", "[", "[", "(", "i", "+", "1", ")", "%", "N", ",", "i", ",", "N", "+", "i", ",", "N", "+", "(", "i", "+", "1", ")", "%", "N", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "inner", "=", "np", ".", "array", "(", "[", "[", "3", "*", "N", "+", "i", ",", "3", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "N", "+", "i", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "outer", "=", "np", ".", "array", "(", "[", "[", "i", ",", "(", "i", "+", "1", ")", "%", "N", ",", "2", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "2", "*", "N", "+", "i", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "faces", "=", "np", ".", "vstack", "(", "[", "top", ",", "bottom", ",", "inner", ",", "outer", "]", ")", "else", ":", "top", "=", "np", ".", "array", "(", "[", "[", "[", "2", "*", "N", "+", "i", ",", "2", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "3", "*", "N", "+", "i", "]", ",", "[", "3", "*", "N", "+", "i", ",", "2", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "3", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", "]", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "bottom", "=", "np", ".", "array", "(", "[", "[", "[", "(", "i", "+", "1", ")", "%", "N", ",", "i", ",", "N", "+", "i", "]", ",", "[", "(", "i", "+", "1", ")", "%", "N", ",", "N", "+", "i", ",", "N", "+", "(", "i", "+", "1", ")", "%", "N", "]", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "inner", "=", "np", ".", "array", "(", "[", "[", "[", "3", "*", "N", "+", "i", ",", "3", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "N", "+", "i", "]", ",", "[", "N", "+", "i", ",", "3", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", ",", "N", "+", "(", "i", "+", "1", ")", "%", "N", "]", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "outer", "=", "np", ".", "array", "(", "[", "[", "[", "i", ",", "(", "i", "+", "1", ")", "%", "N", ",", "2", "*", "N", "+", "i", "]", ",", "[", "2", "*", "N", "+", "i", ",", "(", "i", "+", "1", ")", "%", "N", ",", "2", "*", "N", "+", "(", "i", "+", "1", ")", "%", "N", "]", "]", "for", "i", "in", "range", "(", "N", ")", "]", ")", "faces", "=", "np", ".", "vstack", "(", "[", "top", ".", "reshape", "(", "(", "-", "1", ",", "3", ")", ")", ",", "bottom", ".", "reshape", "(", "(", "-", "1", ",", "3", ")", ")", ",", "inner", ".", "reshape", "(", "(", "-", "1", ",", "3", ")", ")", ",", "outer", ".", "reshape", "(", "(", "-", "1", ",", "3", ")", ")", "]", ")", "return", "form_mesh", "(", "vertices", ",", "faces", ")" ]

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

[ "def", "HasLineSpacing", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_controls_", ".", "TextAttr_HasLineSpacing", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "String", "representation", "of", "this", "HistoricalData", "object", "." ]

[ "def", "__str__", "(", "self", ",", "pretty_print", "=", "True", ")", ":", "if", "pretty_print", ":", "sample_point_list", "=", "self", ".", "to_list_of_sample_points", "(", ")", "return", "pprint", ".", "pformat", "(", "sample_point_list", ")", "else", ":", "out_string", "=", "repr", "(", "self", ".", "_points_sampled", ")", "+", "'\\n'", "out_string", "+=", "repr", "(", "self", ".", "_points_sampled_value", ")", "+", "'\\n'", "out_string", "+=", "repr", "(", "self", ".", "_points_sampled_noise_variance", ")", "return", "out_string" ]

[ "DEPRECATED", ".", "Use", "RunEveryMillis", "instead", "." ]

[ "def", "SetReportNet", "(", "self", ",", "report_net", ",", "report_interval", ")", ":", "self", ".", "_assert_can_mutate", "(", ")", "_add_net_to_dict", "(", "self", ".", "_net_dict", ",", "report_net", ")", "self", ".", "_step", ".", "report_net", "=", "get_net_name", "(", "report_net", ")", "self", ".", "_step", ".", "report_interval", "=", "report_interval" ]

[ "Reset", "the", "counter", "." ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "value", "=", "0" ]

[ "Add", "a", "single", "build", "XML", "output", "file", "to", "our", "data", "." ]

[ "def", "add_input", "(", "self", ",", "input", ")", ":", "events", "=", "xml", ".", "dom", ".", "pulldom", ".", "parse", "(", "input", ")", "context", "=", "[", "]", "for", "(", "event", ",", "node", ")", "in", "events", ":", "if", "event", "==", "xml", ".", "dom", ".", "pulldom", ".", "START_ELEMENT", ":", "context", ".", "append", "(", "node", ")", "if", "node", ".", "nodeType", "==", "xml", ".", "dom", ".", "Node", ".", "ELEMENT_NODE", ":", "x_f", "=", "self", ".", "x_name_", "(", "*", "context", ")", "if", "x_f", ":", "events", ".", "expandNode", "(", "node", ")", "# expanding eats the end element, hence walking us out one level", "context", ".", "pop", "(", ")", "# call handler", "(", "x_f", "[", "1", "]", ")", "(", "node", ")", "elif", "event", "==", "xml", ".", "dom", ".", "pulldom", ".", "END_ELEMENT", ":", "context", ".", "pop", "(", ")" ]

[ "Given", "a", "list", "or", "tuple", "of", "values", "sets", "a", "slice", "of", "values", "[", "min", "max", ")" ]

[ "def", "__setitem__", "(", "self", ",", "idx", ",", "value", ")", ":", "if", "isinstance", "(", "idx", ",", "slice", ")", ":", "indices", "=", "idx", ".", "indices", "(", "len", "(", "self", ")", ")", "for", "i", ",", "j", "in", "zip", "(", "range", "(", "*", "indices", ")", ",", "value", ")", ":", "op", "=", "value", "[", "i", "-", "min", "]", "self", ".", "SMProperty", ".", "SetInputConnection", "(", "i", ",", "op", ".", "SMProxy", ",", "op", ".", "Port", ")", "self", ".", "_UpdateProperty", "(", ")", "elif", "idx", ">=", "len", "(", "self", ")", "or", "idx", "<", "0", ":", "raise", "IndexError", "else", ":", "self", ".", "SMProperty", ".", "SetInputConnection", "(", "idx", ",", "value", ".", "SMProxy", ",", "value", ".", "Port", ")", "self", ".", "_UpdateProperty", "(", ")" ]

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

[ "def", "__init__", "(", "self", ",", "path", ",", "factory", "=", "None", ",", "create", "=", "True", ")", ":", "self", ".", "_path", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "path", ".", "expanduser", "(", "path", ")", ")", "self", ".", "_factory", "=", "factory" ]

[ "SetCache", "(", "self", "int", "from", "int", "to", ")" ]

[ "def", "SetCache", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewEvent_SetCache", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "\\", "search", "all", "/", "dev", "devices", "and", "look", "for", "symlinks", "to", "known", "ports", "already", "listed", "in", "devices", "." ]

[ "def", "list_links", "(", "devices", ")", ":", "links", "=", "[", "]", "for", "device", "in", "glob", ".", "glob", "(", "'/dev/*'", ")", ":", "if", "os", ".", "path", ".", "islink", "(", "device", ")", "and", "os", ".", "path", ".", "realpath", "(", "device", ")", "in", "devices", ":", "links", ".", "append", "(", "device", ")", "return", "links" ]

[ "Given", "a", "summary", "tag", "return", "all", "associated", "histograms", "." ]

[ "def", "Histograms", "(", "self", ",", "tag", ")", ":", "return", "self", ".", "_histograms", ".", "Items", "(", "tag", ")" ]

[ "Needed", "for", "SubObjects", "modifiers", ".", "Implemented", "by", "Dion", "Moult", "during", "0", ".", "19", "dev", "cycle", "(", "works", "only", "with", "Draft", "Wire", ")", "." ]

[ "def", "move_vertex", "(", "object", ",", "vertex_index", ",", "vector", ")", ":", "points", "=", "object", ".", "Points", "points", "[", "vertex_index", "]", "=", "points", "[", "vertex_index", "]", ".", "add", "(", "vector", ")", "object", ".", "Points", "=", "points" ]

[ "Adds", "a", "sample", "data", "point", "." ]

[ "def", "add", "(", "self", ",", "datum", ",", "location_ids", ")", ":", "node_name", "=", "datum", ".", "node_exec_stats", ".", "node_name", "if", "node_name", "in", "self", ".", "_node_name_to_sample", ":", "sample", "=", "self", ".", "_node_name_to_sample", "[", "node_name", "]", "sample", ".", "location_id", ".", "extend", "(", "location_ids", ")", "else", ":", "sample", "=", "profile_pb2", ".", "Sample", "(", ")", "# Sample stores 3 values: count, all_time, op_time", "sample", ".", "value", ".", "extend", "(", "[", "0", ",", "0", ",", "0", "]", ")", "label", "=", "sample", ".", "label", ".", "add", "(", ")", "label", ".", "key", "=", "self", ".", "_string_table", ".", "index_of", "(", "'node_name'", ")", "label", ".", "str", "=", "self", ".", "_string_table", ".", "index_of", "(", "node_name", ")", "label", "=", "sample", ".", "label", ".", "add", "(", ")", "label", ".", "key", "=", "self", ".", "_string_table", ".", "index_of", "(", "'op_type'", ")", "label", ".", "str", "=", "self", ".", "_string_table", ".", "index_of", "(", "datum", ".", "op_type", ")", "self", ".", "_node_name_to_sample", "[", "node_name", "]", "=", "sample", "sample", ".", "value", "[", "0", "]", "+=", "1", "sample", ".", "value", "[", "1", "]", "+=", "datum", ".", "node_exec_stats", ".", "all_end_rel_micros", "sample", ".", "value", "[", "2", "]", "+=", "(", "datum", ".", "node_exec_stats", ".", "op_end_rel_micros", "-", "datum", ".", "node_exec_stats", ".", "op_start_rel_micros", ")" ]

[ "Flattens", "the", "trie", "of", "paths", "prepending", "a", "prefix", "to", "each", "." ]

[ "def", "ConvertTrieToFlatPaths", "(", "trie", ",", "prefix", "=", "None", ")", ":", "result", "=", "{", "}", "for", "name", ",", "data", "in", "trie", ".", "items", "(", ")", ":", "if", "prefix", ":", "name", "=", "prefix", "+", "'/'", "+", "name", "if", "len", "(", "data", ")", "!=", "0", "and", "not", "'results'", "in", "data", ":", "result", ".", "update", "(", "ConvertTrieToFlatPaths", "(", "data", ",", "name", ")", ")", "else", ":", "result", "[", "name", "]", "=", "data", "return", "result" ]

[ "Returns", "the", "current", "item", "check", "image", "." ]

[ "def", "GetCurrentCheckedImage", "(", "self", ")", ":", "if", "self", ".", "_type", "==", "0", ":", "return", "None", "checked", "=", "self", ".", "IsChecked", "(", ")", "if", "checked", ">", "0", ":", "if", "self", ".", "_type", "==", "1", ":", "# Checkbox", "if", "checked", "==", "wx", ".", "CHK_CHECKED", ":", "return", "self", ".", "_checkedimages", "[", "TreeItemIcon_Checked", "]", "else", ":", "return", "self", ".", "_checkedimages", "[", "TreeItemIcon_Undetermined", "]", "else", ":", "# Radiobutton", "return", "self", ".", "_checkedimages", "[", "TreeItemIcon_Flagged", "]", "else", ":", "if", "self", ".", "_type", "==", "1", ":", "# Checkbox", "return", "self", ".", "_checkedimages", "[", "TreeItemIcon_NotChecked", "]", "else", ":", "# Radiobutton", "return", "self", ".", "_checkedimages", "[", "TreeItemIcon_NotFlagged", "]" ]

[ "Display", "a", "piece", "of", "text", "that", "can", "be", "formated", "using", "C", "stdio", "s", "printf", "()", "style", ".", "For", "instance", "if", "you", "want", "to", "display", "text", "mixed", "with", "numbers", "you", "can", "use", ":" ]

[ "def", "printf", "(", "theWhere", ",", "theX", ",", "theY", ",", "theFontScale", ",", "theColor", ",", "theFmt", ")", ":", "print", "(", "'This is wrapper function to help code autocompletion.'", ")" ]

[ "Return", "the", "Objective", "-", "C", "type", "encoding", "as", "a", "str", "." ]

[ "def", "objc_type_encoding", "(", "self", ")", ":", "if", "not", "hasattr", "(", "self", ",", "'_objc_type_encoding'", ")", ":", "self", ".", "_objc_type_encoding", "=", "conf", ".", "lib", ".", "clang_getDeclObjCTypeEncoding", "(", "self", ")", "return", "self", ".", "_objc_type_encoding" ]

[ "Creates", "an", "appropriate", "empty", "response", "for", "the", "type", "that", "is", "expected", "based", "on", "the", "service", "model", "s", "shape", "type", ".", "For", "example", "a", "value", "that", "is", "normally", "a", "list", "would", "then", "return", "an", "empty", "list", ".", "A", "structure", "would", "return", "an", "empty", "dict", "and", "a", "number", "would", "return", "None", "." ]

[ "def", "build_empty_response", "(", "search_path", ",", "operation_name", ",", "service_model", ")", ":", "response", "=", "None", "operation_model", "=", "service_model", ".", "operation_model", "(", "operation_name", ")", "shape", "=", "operation_model", ".", "output_shape", "if", "search_path", ":", "# Walk the search path and find the final shape. For example, given", "# a path of ``foo.bar[0].baz``, we first find the shape for ``foo``,", "# then the shape for ``bar`` (ignoring the indexing), and finally", "# the shape for ``baz``.", "for", "item", "in", "search_path", ".", "split", "(", "'.'", ")", ":", "item", "=", "item", ".", "strip", "(", "'[0123456789]$'", ")", "if", "shape", ".", "type_name", "==", "'structure'", ":", "shape", "=", "shape", ".", "members", "[", "item", "]", "elif", "shape", ".", "type_name", "==", "'list'", ":", "shape", "=", "shape", ".", "member", "else", ":", "raise", "NotImplementedError", "(", "'Search path hits shape type {0} from {1}'", ".", "format", "(", "shape", ".", "type_name", ",", "item", ")", ")", "# Anything not handled here is set to None", "if", "shape", ".", "type_name", "==", "'structure'", ":", "response", "=", "{", "}", "elif", "shape", ".", "type_name", "==", "'list'", ":", "response", "=", "[", "]", "elif", "shape", ".", "type_name", "==", "'map'", ":", "response", "=", "{", "}", "return", "response" ]

[ "Removes", "a", "given", "Credentials", "instance", "from", "the", "chain", "." ]

[ "def", "remove", "(", "self", ",", "name", ")", ":", "available_methods", "=", "[", "p", ".", "METHOD", "for", "p", "in", "self", ".", "providers", "]", "if", "name", "not", "in", "available_methods", ":", "# It's not present. Fail silently.", "return", "offset", "=", "available_methods", ".", "index", "(", "name", ")", "self", ".", "providers", ".", "pop", "(", "offset", ")" ]

[ "Invert", "a", "coord", "map", "by", "de", "-", "scaling", "and", "un", "-", "shifting", ";", "this", "gives", "the", "backward", "mapping", "for", "the", "gradient", "." ]

[ "def", "inverse", "(", "coord_map", ")", ":", "ax", ",", "a", ",", "b", "=", "coord_map", "return", "ax", ",", "1", "/", "a", ",", "-", "b", "/", "a" ]

[ "Dummy", "function", "to", "retrieve", "data", "." ]

[ "def", "fetch", "(", "self", ")", ":", "self", ".", "check", "(", ")", "pass" ]

[ "Validate", "the", "edges", "." ]

[ "def", "validate", "(", "self", ")", ":", "for", "function", "in", "compat_itervalues", "(", "self", ".", "functions", ")", ":", "for", "callee_id", "in", "compat_keys", "(", "function", ".", "calls", ")", ":", "assert", "function", ".", "calls", "[", "callee_id", "]", ".", "callee_id", "==", "callee_id", "if", "callee_id", "not", "in", "self", ".", "functions", ":", "sys", ".", "stderr", ".", "write", "(", "'warning: call to undefined function %s from function %s\\n'", "%", "(", "str", "(", "callee_id", ")", ",", "function", ".", "name", ")", ")", "del", "function", ".", "calls", "[", "callee_id", "]" ]

[ "Internal", ":", "raise", "an", "OSError", "exception", "for", "unsupported", "operations", "." ]

[ "def", "_unsupported", "(", "self", ",", "name", ")", ":", "raise", "UnsupportedOperation", "(", "\"%s.%s() not supported\"", "%", "(", "self", ".", "__class__", ".", "__name__", ",", "name", ")", ")" ]

[ "Return", "an", "undefined", "object", "for", "unsafe", "attributes", "." ]

[ "def", "unsafe_undefined", "(", "self", ",", "obj", ",", "attribute", ")", ":", "return", "self", ".", "undefined", "(", "'access to attribute %r of %r '", "'object is unsafe.'", "%", "(", "attribute", ",", "obj", ".", "__class__", ".", "__name__", ")", ",", "name", "=", "attribute", ",", "obj", "=", "obj", ",", "exc", "=", "SecurityError", ")" ]

[ "Retrieve", "the", "real", "component", "of", "this", "number", "." ]

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

[ "Apply", "mask", "files", "to", "the", "workspace" ]

[ "def", "mask_with_mask_files", "(", "mask_info", ",", "inst_info", ",", "workspace", ")", ":", "mask_files", "=", "mask_info", ".", "mask_files", "if", "mask_files", ":", "idf_path", "=", "inst_info", ".", "idf_path", "# Mask loader", "load_name", "=", "\"LoadMask\"", "load_options", "=", "{", "\"Instrument\"", ":", "idf_path", ",", "\"OutputWorkspace\"", ":", "EMPTY_NAME", "}", "load_alg", "=", "create_unmanaged_algorithm", "(", "load_name", ",", "*", "*", "load_options", ")", "mask_alg", "=", "create_unmanaged_algorithm", "(", "\"MaskDetectors\"", ")", "file_paths", "=", "[", "find_full_file_path", "(", "i", ")", "for", "i", "in", "mask_files", "]", "# Find full file path returns an empty string, so we need to remake it", "missing_file_paths", "=", "[", "mask_files", "[", "i", "]", "for", "i", ",", "path", "in", "enumerate", "(", "file_paths", ")", "if", "not", "path", "]", "if", "missing_file_paths", ":", "err_str", "=", "\"The following mask files are missing:\"", "err_str", "+=", "\"\\n\"", ".", "join", "(", "missing_file_paths", ")", "raise", "FileNotFoundError", "(", "err_str", ")", "# Masker", "for", "mask_file", "in", "file_paths", ":", "# Get the detector ids which need to be masked", "load_alg", ".", "setProperty", "(", "\"InputFile\"", ",", "mask_file", ")", "load_alg", ".", "execute", "(", ")", "masking_workspace", "=", "load_alg", ".", "getProperty", "(", "\"OutputWorkspace\"", ")", ".", "value", "# Could use MaskDetectors directly with masking_workspace but it does not", "# support MPI. Use a two step approach via a and b instead.", "# a) Extract detectors to mask from MaskWorkspace", "det_ids", "=", "masking_workspace", ".", "getMaskedDetectors", "(", ")", "# b) Mask the detector ids on the instrument", "mask_alg", ".", "setProperty", "(", "\"Workspace\"", ",", "workspace", ")", "mask_alg", ".", "setProperty", "(", "\"DetectorList\"", ",", "det_ids", ")", "mask_alg", ".", "execute", "(", ")", "workspace", "=", "mask_alg", ".", "getProperty", "(", "\"Workspace\"", ")", ".", "value", "return", "workspace" ]

[ "Brings", "a", "table", "on", "-", "line", "(", "enables", "it", ")" ]

[ "def", "enableTable", "(", "self", ",", "tableName", ")", ":", "pass" ]

[ "x", "-", "center", "x", "y", "-", "center", "y", "width", "-", "width", "of", "ellipse", "(", "in", "x", "direction", "when", "angle", "=", "0", ")", "height", "-", "height", "of", "ellipse", "(", "in", "y", "direction", "when", "angle", "=", "0", ")", "angle", "-", "angle", "in", "radians", "to", "rotate", "clockwise" ]

[ "def", "path_ellipse", "(", "cr", ",", "x", ",", "y", ",", "width", ",", "height", ",", "angle", "=", "0", ")", ":", "cr", ".", "save", "(", ")", "cr", ".", "translate", "(", "x", ",", "y", ")", "cr", ".", "rotate", "(", "angle", ")", "cr", ".", "scale", "(", "width", "/", "2.0", ",", "height", "/", "2.0", ")", "cr", ".", "arc", "(", "0.0", ",", "0.0", ",", "1.0", ",", "0.0", ",", "2.0", "*", "M_PI", ")", "cr", ".", "restore", "(", ")" ]

[ "Returns", "the", "siblings", "of", "this", "Tag", "that", "match", "the", "given", "criteria", "and", "appear", "before", "this", "Tag", "in", "the", "document", "." ]

[ "def", "findPreviousSiblings", "(", "self", ",", "name", "=", "None", ",", "attrs", "=", "{", "}", ",", "text", "=", "None", ",", "limit", "=", "None", ",", "*", "*", "kwargs", ")", ":", "return", "self", ".", "_findAll", "(", "name", ",", "attrs", ",", "text", ",", "limit", ",", "self", ".", "previousSiblingGenerator", ",", "*", "*", "kwargs", ")" ]

[ "Get", "a", "Python", "class", "for", "a", "CLSID", "Given", "a", "CLSID", "return", "a", "Python", "class", "which", "wraps", "the", "COM", "object", "Returns", "the", "Python", "class", "or", "None", "if", "no", "module", "is", "available", ".", "Params", "clsid", "--", "A", "COM", "CLSID", "(", "or", "string", "repr", "of", "one", ")" ]

[ "def", "GetClassForCLSID", "(", "clsid", ")", ":", "# first, take a short-cut - we may already have generated support ready-to-roll.", "clsid", "=", "str", "(", "clsid", ")", "if", "CLSIDToClass", ".", "HasClass", "(", "clsid", ")", ":", "return", "CLSIDToClass", ".", "GetClass", "(", "clsid", ")", "mod", "=", "GetModuleForCLSID", "(", "clsid", ")", "if", "mod", "is", "None", ":", "return", "None", "try", ":", "return", "CLSIDToClass", ".", "GetClass", "(", "clsid", ")", "except", "KeyError", ":", "return", "None" ]

[ "Add", "Builders", "and", "construction", "variables", "for", "compaq", "visual", "fortran", "to", "an", "Environment", "." ]

[ "def", "generate", "(", "env", ")", ":", "fortran", ".", "generate", "(", "env", ")", "env", "[", "'FORTRAN'", "]", "=", "'f90'", "env", "[", "'FORTRANCOM'", "]", "=", "'$FORTRAN $FORTRANFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'", "env", "[", "'FORTRANPPCOM'", "]", "=", "'$FORTRAN $FORTRANFLAGS $CPPFLAGS $_CPPDEFFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'", "env", "[", "'SHFORTRANCOM'", "]", "=", "'$SHFORTRAN $SHFORTRANFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'", "env", "[", "'SHFORTRANPPCOM'", "]", "=", "'$SHFORTRAN $SHFORTRANFLAGS $CPPFLAGS $_CPPDEFFLAGS $_FORTRANMODFLAG $_FORTRANINCFLAGS /compile_only ${SOURCES.windows} /object:${TARGET.windows}'", "env", "[", "'OBJSUFFIX'", "]", "=", "'.obj'", "env", "[", "'FORTRANMODDIR'", "]", "=", "'${TARGET.dir}'", "env", "[", "'FORTRANMODDIRPREFIX'", "]", "=", "'/module:'", "env", "[", "'FORTRANMODDIRSUFFIX'", "]", "=", "''" ]

[ "adds", "a", "constraint", "from", "a", "symbolic", "Function", "or", "Expression", "(", "see", "symbolic", "module", ")", ".", "This", "will", "be", "smart", "in", "that", "AND", "Expressions", "will", "be", "converted", "to", "multiple", "constraints", "inequalities", "will", "be", "converted", "to", "inequality", "constraints", "and", "bounds", "will", "be", "converted", "to", "bound", "constraints", ".", "All", "other", "constraints", "will", "be", "treated", "as", "feasibility", "constraints" ]

[ "def", "addSymbolicConstraint", "(", "self", ",", "func", ",", "context", ",", "varorder", "=", "None", ",", "blackbox", "=", "False", ")", ":", "if", "varorder", "is", "None", ":", "varorder", "=", "context", ".", "variables", "if", "symbolic", ".", "is_op", "(", "func", ",", "\"and\"", ")", ":", "for", "a", "in", "func", ".", "args", ":", "self", ".", "addSymbolicConstraint", "(", "self", ",", "a", ",", "context", ",", "varorder", ")", "elif", "symbolic", ".", "is_op", "(", "func", ",", "\"le\"", ")", ":", "if", "symbolic", ".", "is_var", "(", "func", ".", "args", "[", "0", "]", ")", "and", "symbolic", ".", "is_const", "(", "func", ".", "args", "[", "1", "]", ")", ":", "#x <= c", "x", "=", "symbolic", ".", "to_var", "(", "func", ".", "args", "[", "0", "]", ")", "xmax", "=", "symbolic", ".", "to_const", "(", "func", ".", "args", "[", "1", "]", ")", "indices", "=", "context", ".", "getFlatVarRanges", "(", "varorder", ")", "xindex", "=", "[", "i", "for", "i", ",", "v", "in", "enumerate", "(", "varorder", ")", "if", "v", ".", "name", "==", "x", ".", "name", "]", "[", "0", "]", "ai", ",", "bi", "=", "indices", "[", "xindex", "]", ",", "indices", "[", "xindex", "+", "1", "]", "n", "=", "indices", "[", "-", "1", "]", "if", "self", ".", "bounds", "is", "None", ":", "self", ".", "bounds", "=", "(", "np", ".", "array", "(", "[", "-", "float", "(", "'inf'", ")", "]", "*", "n", ")", ",", "np", ".", "array", "(", "[", "float", "(", "'inf'", ")", "]", "*", "n", ")", ")", "self", ".", "bounds", "[", "1", "]", "[", "ai", ":", "bi", "]", "=", "np", ".", "minimum", "(", "self", ".", "bounds", "[", "1", "]", "[", "ai", ":", "bi", "]", ",", "xmax", ")", "elif", "symbolic", ".", "is_var", "(", "func", ".", "args", "[", "1", "]", ")", "and", "symbolic", ".", "is_const", "(", "func", ".", "args", "[", "0", "]", ")", ":", "#c <= x", "xmin", "=", "symbolic", ".", "to_const", "(", "func", ".", "args", "[", "0", "]", ")", "x", "=", "symbolic", ".", "to_var", "(", "func", ".", "args", "[", "1", "]", ")", "indices", "=", "context", ".", "getFlatVarRanges", "(", "varorder", ")", "xindex", "=", "[", "i", "for", "i", ",", "v", "in", "enumerate", "(", "varorder", ")", "if", "v", ".", "name", "==", "x", ".", "name", "]", "[", "0", "]", "ai", ",", "bi", "=", "indices", "[", "xindex", "]", ",", "indices", "[", "xindex", "+", "1", "]", "n", "=", "indices", "[", "-", "1", "]", "if", "self", ".", "bounds", "is", "None", ":", "self", ".", "bounds", "=", "(", "np", ".", "array", "(", "[", "-", "float", "(", "'inf'", ")", "]", "*", "n", ")", ",", "np", ".", "array", "(", "[", "float", "(", "'inf'", ")", "]", "*", "n", ")", ")", "self", ".", "bounds", "[", "0", "]", "[", "ai", ":", "bi", "]", "=", "np", ".", "maximum", "(", "self", ".", "bounds", "[", "0", "]", "[", "ai", ":", "bi", "]", ",", "a", ")", "else", ":", "h", "=", "symbolic", ".", "simplify", "(", "func", ".", "args", "[", "0", "]", "-", "func", ".", "args", "[", "1", "]", ")", "if", "func", ".", "args", "[", "0", "]", ".", "returnType", "(", ")", ".", "is_scalar", "(", ")", "and", "func", ".", "args", "[", "1", "]", ".", "returnType", "(", ")", ".", "is_scalar", "(", ")", ":", "#need to convert to a vector", "h", "=", "symbolic", ".", "flatten", "(", "h", ")", "hpy", ",", "varorder", "=", "context", ".", "makeFlatFunction", "(", "h", ",", "varorder", ")", "dhpy", ",", "varorder", "=", "context", ".", "makeFlatFunctionDeriv", "(", "h", ",", "varorder", ")", "self", ".", "addInequality", "(", "hpy", ",", "dhpy", ")", "elif", "symbolic", ".", "is_op", "(", "func", ",", "\"ge\"", ")", ":", "c", "=", "(", "func", ".", "args", "[", "1", "]", "<=", "func", ".", "args", "[", "0", "]", ")", "self", ".", "addSymbolicConstraint", "(", "c", ",", "context", ",", "varorder", ")", "elif", "symbolic", ".", "is_op", "(", "func", ",", "\"eq\"", ")", ":", "g", "=", "symbolic", ".", "simplify", "(", "func", ".", "args", "[", "0", "]", "-", "func", ".", "args", "[", "1", "]", ")", "if", "func", ".", "args", "[", "0", "]", ".", "returnType", "(", ")", ".", "is_scalar", "(", ")", "and", "func", ".", "args", "[", "1", "]", ".", "returnType", "(", ")", ".", "is_scalar", "(", ")", ":", "#need to convert to a vector", "g", "=", "symbolic", ".", "flatten", "(", "g", ")", "gpy", ",", "varorder", "=", "context", ".", "makeFlatFunction", "(", "g", ",", "varorder", ")", "dgpy", ",", "varorder", "=", "context", ".", "makeFlatFunctionDeriv", "(", "g", ",", "varorder", ")", "self", ".", "addEquality", "(", "gpy", ",", "dgpy", ")", "elif", "symbolic", ".", "is_op", "(", "func", ")", ":", "if", "func", ".", "functionInfo", "is", "symbolic_linalg", ".", "bound_contains", "and", "symbolic", ".", "is_const", "(", "func", ".", "args", "[", "0", "]", ")", "and", "symbolic", ".", "is_const", "(", "func", ".", "args", "[", "1", "]", ")", "and", "symbolic", ".", "is_var", "(", "func", ".", "args", "[", "2", "]", ")", ":", "#bound constraint", "xmin", "=", "symbolic", ".", "to_const", "(", "func", ".", "args", "[", "0", "]", ")", "xmax", "=", "symbolic", ".", "to_const", "(", "func", ".", "args", "[", "1", "]", ")", "x", "=", "symbolic", ".", "to_var", "(", "func", ".", "args", "[", "2", "]", ")", "indices", "=", "context", ".", "getFlatVarRanges", "(", "varorder", ")", "xindex", "=", "[", "i", "for", "i", ",", "v", "in", "enumerate", "(", "varorder", ")", "if", "v", ".", "name", "==", "x", ".", "name", "]", "[", "0", "]", "ai", ",", "bi", "=", "indices", "[", "xindex", "]", ",", "indices", "[", "xindex", "+", "1", "]", "n", "=", "indices", "[", "-", "1", "]", "if", "self", ".", "bounds", "is", "None", ":", "self", ".", "bounds", "=", "(", "[", "-", "float", "(", "'inf'", ")", "]", "*", "n", ",", "[", "float", "(", "'inf'", ")", "]", "*", "n", ")", "for", "i", ",", "a", ",", "b", "in", "zip", "(", "range", "(", "ai", ",", "bi", ")", ",", "xmin", ",", "xmax", ")", ":", "self", ".", "bounds", "[", "0", "]", "[", "i", "]", "=", "max", "(", "self", ".", "bounds", "[", "0", "]", "[", "i", "]", ",", "a", ")", "self", ".", "bounds", "[", "1", "]", "[", "i", "]", "=", "min", "(", "self", ".", "bounds", "[", "1", "]", "[", "i", "]", ",", "b", ")", "else", ":", "#it's a generic boolean", "if", "not", "blackbox", ":", "print", "\"OptimizationProblem.addSymbolicConstraint(): Warning, turning function\"", ",", "func", ",", "\"into black box function\"", "fpy", ",", "varorder", "=", "context", ".", "makeFlatFunction", "(", "func", ",", "varorder", ")", "self", ".", "addFeasibilityTest", "(", "fpy", ")", "else", ":", "#it's a generic boolean", "if", "not", "blackbox", ":", "print", "\"OptimizationProblem.addSymbolicConstraint(): Warning, turning function\"", ",", "func", ",", "\"into black box function\"", "fpy", ",", "varorder", "=", "context", ".", "makeFlatFunction", "(", "func", ",", "varorder", ")", "self", ".", "addFeasibilityTest", "(", "fpy", ")" ]

[ "Unpack", "the", "tarfile", "for", "(", "build_os", "arch", "spec", ")", "into", "directory", "where", "." ]

[ "def", "unpack_binaries_into", "(", "build_os", ",", "arch", ",", "spec", ",", "where", ")", ":", "rootdir", "=", "os", ".", "getcwd", "(", ")", "ensure_dir", "(", "where", ")", "# Note: POSIX tar doesn't require support for gtar's \"-C\" option,", "# and Python's tarfile module prior to Python 2.7 doesn't have the", "# features to make this detail easy. So we'll just do the dumb", "# thing and chdir into where and run tar there.", "os", ".", "chdir", "(", "where", ")", "try", ":", "sysassert", "(", "[", "\"tar\"", ",", "\"xvzf\"", ",", "rootdir", "+", "\"/\"", "+", "tarfile", "(", "build_os", ",", "arch", ",", "spec", ")", "]", ")", "release_dir", "=", "glob", "(", "'mongodb-linux-*'", ")", "[", "0", "]", "for", "releasefile", "in", "\"bin\"", ",", "\"LICENSE-Community.txt\"", ",", "\"README\"", ",", "\"THIRD-PARTY-NOTICES\"", ",", "\"MPL-2\"", ":", "print", "(", "\"moving file: %s/%s\"", "%", "(", "release_dir", ",", "releasefile", ")", ")", "os", ".", "rename", "(", "\"%s/%s\"", "%", "(", "release_dir", ",", "releasefile", ")", ",", "releasefile", ")", "os", ".", "rmdir", "(", "release_dir", ")", "except", "Exception", ":", "exc", "=", "sys", ".", "exc_info", "(", ")", "[", "1", "]", "os", ".", "chdir", "(", "rootdir", ")", "raise", "exc", "os", ".", "chdir", "(", "rootdir", ")" ]

[ "True", "if", "an", "atom", "is", "present", "in", "this", "residue" ]

[ "def", "__contains__", "(", "self", ",", "thing", ")", ":", "return", "thing", "in", "self", ".", "atoms" ]

[ "Subscribe", "to", "a", "Topic", "." ]

[ "def", "subscribe", "(", "self", ",", "topic", ",", "protocol", ",", "endpoint", ")", ":", "params", "=", "{", "'TopicArn'", ":", "topic", ",", "'Protocol'", ":", "protocol", ",", "'Endpoint'", ":", "endpoint", "}", "return", "self", ".", "_make_request", "(", "'Subscribe'", ",", "params", ")" ]

[ "Add", "Tensor", "outputs", "tagged", "with", "name", "to", "collections", "." ]

[ "def", "collect_named_outputs", "(", "collections", ",", "name", ",", "outputs", ")", ":", "# Remove ending '/' if present.", "if", "name", "[", "-", "1", "]", "==", "'/'", ":", "name", "=", "name", "[", ":", "-", "1", "]", "if", "collections", ":", "ops", ".", "add_to_collections", "(", "collections", ",", "NamedOutputs", "(", "name", ",", "outputs", ")", ")", "return", "outputs" ]

[ ":", "type", "head", ":", "ListNode", ":", "type", "val", ":", "int", ":", "rtype", ":", "ListNode" ]

[ "def", "removeElements", "(", "self", ",", "head", ",", "val", ")", ":", "new_head", "=", "ListNode", "(", "0", ")", "new_head", ".", "next", "=", "head", "cur", "=", "new_head", "while", "(", "cur", ".", "next", "is", "not", "None", ")", ":", "node", "=", "cur", ".", "next", "if", "node", ".", "val", "!=", "val", ":", "cur", "=", "cur", ".", "next", "continue", "cur", ".", "next", "=", "node", ".", "next", "del", "node", "return", "new_head", ".", "next" ]

[ "Return", "the", "Bartlett", "window", "." ]

[ "def", "bartlett", "(", "M", ")", ":", "if", "M", "<", "1", ":", "return", "array", "(", "[", "]", ")", "if", "M", "==", "1", ":", "return", "ones", "(", "1", ",", "float", ")", "n", "=", "arange", "(", "0", ",", "M", ")", "return", "where", "(", "less_equal", "(", "n", ",", "(", "M", "-", "1", ")", "/", "2.0", ")", ",", "2.0", "*", "n", "/", "(", "M", "-", "1", ")", ",", "2.0", "-", "2.0", "*", "n", "/", "(", "M", "-", "1", ")", ")" ]

[ "Returns", "the", "image", "data", "as", "a", "direct", "representation", "of", "an", "x", "*", "y", "*", "planes", "array", ".", "This", "method", "is", "intended", "to", "remove", "the", "need", "for", "callers", "to", "deal", "with", "palettes", "and", "transparency", "themselves", ".", "Images", "with", "a", "palette", "(", "colour", "type", "3", ")", "are", "converted", "to", "RGB", "or", "RGBA", ";", "images", "with", "transparency", "(", "a", "tRNS", "chunk", ")", "are", "converted", "to", "LA", "or", "RGBA", "as", "appropriate", ".", "When", "returned", "in", "this", "format", "the", "pixel", "values", "represent", "the", "colour", "value", "directly", "without", "needing", "to", "refer", "to", "palettes", "or", "transparency", "information", "." ]

[ "def", "asDirect", "(", "self", ")", ":", "self", ".", "preamble", "(", ")", "# Simple case, no conversion necessary.", "if", "not", "self", ".", "colormap", "and", "not", "self", ".", "trns", "and", "not", "self", ".", "sbit", ":", "return", "self", ".", "read", "(", ")", "x", ",", "y", ",", "pixels", ",", "meta", "=", "self", ".", "read", "(", ")", "if", "self", ".", "colormap", ":", "meta", "[", "'colormap'", "]", "=", "False", "meta", "[", "'alpha'", "]", "=", "bool", "(", "self", ".", "trns", ")", "meta", "[", "'bitdepth'", "]", "=", "8", "meta", "[", "'planes'", "]", "=", "3", "+", "bool", "(", "self", ".", "trns", ")", "plte", "=", "self", ".", "palette", "(", ")", "def", "iterpal", "(", "pixels", ")", ":", "for", "row", "in", "pixels", ":", "row", "=", "map", "(", "plte", ".", "__getitem__", ",", "row", ")", "yield", "array", "(", "'B'", ",", "itertools", ".", "chain", "(", "*", "row", ")", ")", "pixels", "=", "iterpal", "(", "pixels", ")", "elif", "self", ".", "trns", ":", "# It would be nice if there was some reasonable way of doing", "# this without generating a whole load of intermediate tuples.", "# But tuples does seem like the easiest way, with no other way", "# clearly much simpler or much faster. (Actually, the L to LA", "# conversion could perhaps go faster (all those 1-tuples!), but", "# I still wonder whether the code proliferation is worth it)", "it", "=", "self", ".", "transparent", "maxval", "=", "2", "**", "meta", "[", "'bitdepth'", "]", "-", "1", "planes", "=", "meta", "[", "'planes'", "]", "meta", "[", "'alpha'", "]", "=", "True", "meta", "[", "'planes'", "]", "+=", "1", "typecode", "=", "'BH'", "[", "meta", "[", "'bitdepth'", "]", ">", "8", "]", "def", "itertrns", "(", "pixels", ")", ":", "for", "row", "in", "pixels", ":", "# For each row we group it into pixels, then form a", "# characterisation vector that says whether each pixel", "# is opaque or not. Then we convert True/False to", "# 0/maxval (by multiplication), and add it as the extra", "# channel.", "row", "=", "group", "(", "row", ",", "planes", ")", "opa", "=", "map", "(", "it", ".", "__ne__", ",", "row", ")", "opa", "=", "map", "(", "maxval", ".", "__mul__", ",", "opa", ")", "opa", "=", "zip", "(", "opa", ")", "# convert to 1-tuples", "yield", "array", "(", "typecode", ",", "itertools", ".", "chain", "(", "*", "map", "(", "operator", ".", "add", ",", "row", ",", "opa", ")", ")", ")", "pixels", "=", "itertrns", "(", "pixels", ")", "targetbitdepth", "=", "None", "if", "self", ".", "sbit", ":", "sbit", "=", "struct", ".", "unpack", "(", "'%dB'", "%", "len", "(", "self", ".", "sbit", ")", ",", "self", ".", "sbit", ")", "targetbitdepth", "=", "max", "(", "sbit", ")", "if", "targetbitdepth", ">", "meta", "[", "'bitdepth'", "]", ":", "raise", "Error", "(", "'sBIT chunk %r exceeds bitdepth %d'", "%", "(", "sbit", ",", "self", ".", "bitdepth", ")", ")", "if", "min", "(", "sbit", ")", "<=", "0", ":", "raise", "Error", "(", "'sBIT chunk %r has a 0-entry'", "%", "sbit", ")", "if", "targetbitdepth", "==", "meta", "[", "'bitdepth'", "]", ":", "targetbitdepth", "=", "None", "if", "targetbitdepth", ":", "shift", "=", "meta", "[", "'bitdepth'", "]", "-", "targetbitdepth", "meta", "[", "'bitdepth'", "]", "=", "targetbitdepth", "def", "itershift", "(", "pixels", ")", ":", "for", "row", "in", "pixels", ":", "yield", "map", "(", "shift", ".", "__rrshift__", ",", "row", ")", "pixels", "=", "itershift", "(", "pixels", ")", "return", "x", ",", "y", ",", "pixels", ",", "meta" ]

[ "Return", "the", "object", "as", "a", "ustar", "header", "block", ".", "If", "it", "cannot", "be" ]

[ "def", "create_pax_header", "(", "self", ",", "info", ",", "encoding", ")", ":", "info", "[", "\"magic\"", "]", "=", "POSIX_MAGIC", "pax_headers", "=", "self", ".", "pax_headers", ".", "copy", "(", ")", "# Test string fields for values that exceed the field length or cannot", "# be represented in ASCII encoding.", "for", "name", ",", "hname", ",", "length", "in", "(", "(", "\"name\"", ",", "\"path\"", ",", "LENGTH_NAME", ")", ",", "(", "\"linkname\"", ",", "\"linkpath\"", ",", "LENGTH_LINK", ")", ",", "(", "\"uname\"", ",", "\"uname\"", ",", "32", ")", ",", "(", "\"gname\"", ",", "\"gname\"", ",", "32", ")", ")", ":", "if", "hname", "in", "pax_headers", ":", "# The pax header has priority.", "continue", "# Try to encode the string as ASCII.", "try", ":", "info", "[", "name", "]", ".", "encode", "(", "\"ascii\"", ",", "\"strict\"", ")", "except", "UnicodeEncodeError", ":", "pax_headers", "[", "hname", "]", "=", "info", "[", "name", "]", "continue", "if", "len", "(", "info", "[", "name", "]", ")", ">", "length", ":", "pax_headers", "[", "hname", "]", "=", "info", "[", "name", "]", "# Test number fields for values that exceed the field limit or values", "# that like to be stored as float.", "for", "name", ",", "digits", "in", "(", "(", "\"uid\"", ",", "8", ")", ",", "(", "\"gid\"", ",", "8", ")", ",", "(", "\"size\"", ",", "12", ")", ",", "(", "\"mtime\"", ",", "12", ")", ")", ":", "if", "name", "in", "pax_headers", ":", "# The pax header has priority. Avoid overflow.", "info", "[", "name", "]", "=", "0", "continue", "val", "=", "info", "[", "name", "]", "if", "not", "0", "<=", "val", "<", "8", "**", "(", "digits", "-", "1", ")", "or", "isinstance", "(", "val", ",", "float", ")", ":", "pax_headers", "[", "name", "]", "=", "str", "(", "val", ")", "info", "[", "name", "]", "=", "0", "# Create a pax extended header if necessary.", "if", "pax_headers", ":", "buf", "=", "self", ".", "_create_pax_generic_header", "(", "pax_headers", ",", "XHDTYPE", ",", "encoding", ")", "else", ":", "buf", "=", "b\"\"", "return", "buf", "+", "self", ".", "_create_header", "(", "info", ",", "USTAR_FORMAT", ",", "\"ascii\"", ",", "\"replace\"", ")" ]

[ "Check", "if", "an", "item", "exists", "in", "a", "folder", "based", "on", "its", "name", "folderID", "--", "ID", "of", "the", "folder", ".", "itemName", "--", "Name", "of", "the", "item", "to", "check", "for", ".", "token", "--", "Authentication", "token", ".", "communicator", "--", "Midas", "session", "communicator", ".", "Returns", "a", "boolean", "indicating", "if", "the", "item", "exists", "or", "not", "." ]

[ "def", "itemExists", "(", "folderID", ",", "itemName", ",", "token", ",", "communicator", ")", ":", "folderChildren", "=", "communicator", ".", "folder_children", "(", "token", ",", "folderID", ")", "folder_children_items", "=", "folderChildren", "[", "\"items\"", "]", "for", "item", "in", "folder_children_items", ":", "if", "item", "[", "\"name\"", "]", "==", "itemName", ":", "return", "True", "return", "False" ]

[ "Converts", "a", "datum", "to", "an", "array", ".", "Note", "that", "the", "label", "is", "not", "returned", "as", "one", "can", "easily", "get", "it", "by", "calling", "datum", ".", "label", "." ]

[ "def", "datum_to_array", "(", "datum", ")", ":", "if", "len", "(", "datum", ".", "data", ")", ":", "return", "np", ".", "fromstring", "(", "datum", ".", "data", ",", "dtype", "=", "np", ".", "uint8", ")", ".", "reshape", "(", "datum", ".", "channels", ",", "datum", ".", "height", ",", "datum", ".", "width", ")", "else", ":", "return", "np", ".", "array", "(", "datum", ".", "float_data", ")", ".", "astype", "(", "float", ")", ".", "reshape", "(", "datum", ".", "channels", ",", "datum", ".", "height", ",", "datum", ".", "width", ")" ]

[ "Check", "for", "specials", ".", "Note", "that", "this", "type", "of", "test", "is", "processor", "-", "and", "/", "or", "platform", "-", "specific", "so", "do", "tests", "which", "don", "t", "depend", "on", "the", "internals", "." ]

[ "def", "floatstr", "(", "o", ",", "allow_nan", "=", "True", ")", ":", "if", "o", "!=", "o", ":", "text", "=", "'NaN'", "elif", "o", "==", "INFINITY", ":", "text", "=", "'Infinity'", "elif", "o", "==", "-", "INFINITY", ":", "text", "=", "'-Infinity'", "else", ":", "return", "FLOAT_REPR", "(", "o", ")", "if", "not", "allow_nan", ":", "raise", "ValueError", "(", "\"Out of range float values are not JSON compliant: %r\"", "%", "(", "o", ",", ")", ")", "return", "text" ]

[ "Return", "tuple", "of", "decimal", "values", "for", "red", "green", "blue", "for", "COLOR", "in", "this", "widget", "." ]

[ "def", "winfo_rgb", "(", "self", ",", "color", ")", ":", "return", "self", ".", "_getints", "(", "self", ".", "tk", ".", "call", "(", "'winfo'", ",", "'rgb'", ",", "self", ".", "_w", ",", "color", ")", ")" ]

[ "Returns", "<v8_root", ">", "/", "<output_dir", ">", "/", "(", "Release|Debug|<other", ">", ")", "." ]

[ "def", "GetNinjaOutputDirectory", "(", "v8_root", ",", "configuration", "=", "None", ")", ":", "output_dirs", "=", "[", "]", "generator_flags", "=", "os", ".", "getenv", "(", "'GYP_GENERATOR_FLAGS'", ",", "''", ")", ".", "split", "(", "' '", ")", "for", "flag", "in", "generator_flags", ":", "name_value", "=", "flag", ".", "split", "(", "'='", ",", "1", ")", "if", "(", "len", "(", "name_value", ")", "==", "2", "and", "name_value", "[", "0", "]", "==", "'output_dir'", "and", "os", ".", "path", ".", "isdir", "(", "os", ".", "path", ".", "join", "(", "v8_root", ",", "name_value", "[", "1", "]", ")", ")", ")", ":", "output_dirs", "=", "[", "name_value", "[", "1", "]", "]", "if", "configuration", ":", "output_dir", "=", "'out'", "if", "len", "(", "output_dirs", ")", "==", "0", "else", "output_dirs", "[", "-", "1", "]", "return", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "join", "(", "v8_root", ",", "output_dir", ")", ",", "configuration", ")", "if", "not", "output_dirs", ":", "for", "f", "in", "os", ".", "listdir", "(", "v8_root", ")", ":", "if", "re", ".", "match", "(", "r'out(\\b|_)'", ",", "f", ")", ":", "if", "os", ".", "path", ".", "isdir", "(", "os", ".", "path", ".", "join", "(", "v8_root", ",", "f", ")", ")", ":", "output_dirs", ".", "append", "(", "f", ")", "def", "generate_paths", "(", ")", ":", "for", "out_dir", "in", "output_dirs", ":", "out_path", "=", "os", ".", "path", ".", "join", "(", "v8_root", ",", "out_dir", ")", "for", "config", "in", "os", ".", "listdir", "(", "out_path", ")", ":", "path", "=", "os", ".", "path", ".", "join", "(", "out_path", ",", "config", ")", "if", "os", ".", "path", ".", "exists", "(", "os", ".", "path", ".", "join", "(", "path", ",", "'build.ninja'", ")", ")", ":", "yield", "path", "def", "approx_directory_mtime", "(", "path", ")", ":", "# This is a heuristic; don't recurse into subdirectories.", "paths", "=", "[", "path", "]", "+", "[", "os", ".", "path", ".", "join", "(", "path", ",", "f", ")", "for", "f", "in", "os", ".", "listdir", "(", "path", ")", "]", "return", "max", "(", "filter", "(", "None", ",", "[", "safe_mtime", "(", "p", ")", "for", "p", "in", "paths", "]", ")", ")", "def", "safe_mtime", "(", "path", ")", ":", "try", ":", "return", "os", ".", "path", ".", "getmtime", "(", "path", ")", "except", "OSError", ":", "return", "None", "try", ":", "return", "max", "(", "generate_paths", "(", ")", ",", "key", "=", "approx_directory_mtime", ")", "except", "ValueError", ":", "raise", "RuntimeError", "(", "'Unable to find a valid ninja output directory.'", ")" ]

[ "Get", "the", "websocket", "timeout", "(", "second", ")", "." ]

[ "def", "gettimeout", "(", "self", ")", ":", "return", "self", ".", "sock", ".", "gettimeout", "(", ")" ]

[ "Construct", "an", "AST", "node", "of", "type", "ASTType", ".", "Comparison", "." ]

[ "def", "Comparison", "(", "comparison", ":", "int", ",", "left", ":", "AST", ",", "right", ":", "AST", ")", "->", "AST", ":", "p_ast", "=", "_ffi", ".", "new", "(", "'clingo_ast_t**'", ")", "_handle_error", "(", "_lib", ".", "clingo_ast_build", "(", "_lib", ".", "clingo_ast_type_comparison", ",", "p_ast", ",", "_ffi", ".", "cast", "(", "'int'", ",", "comparison", ")", ",", "left", ".", "_rep", ",", "right", ".", "_rep", ")", ")", "return", "AST", "(", "p_ast", "[", "0", "]", ")" ]

[ "Update", "state", "with", "exogenous", "regressors", "." ]

[ "def", "_exogenous_input_step", "(", "self", ",", "current_times", ",", "current_exogenous_regressors", ",", "state", ")", ":", "if", "self", ".", "_configuration", ".", "exogenous_noise_decreases", ":", "state", "=", "self", ".", "_exogenous_noise_decreasing", "(", "current_times", ",", "current_exogenous_regressors", ",", "state", ")", "if", "self", ".", "_configuration", ".", "exogenous_noise_increases", ":", "state", "=", "self", ".", "_exogenous_noise_increasing", "(", "current_times", ",", "current_exogenous_regressors", ",", "state", ")", "return", "state" ]

[ "Get", "a", "useful", "printable", "representation", "of", "the", "object", "." ]

[ "def", "__repr__", "(", "self", ")", ":", "return", "'<{cls} file {filename} for {package} on {device}>'", ".", "format", "(", "cls", "=", "type", "(", "self", ")", ".", "__name__", ",", "filename", "=", "self", ".", "filename", ",", "package", "=", "self", ".", "package", ",", "device", "=", "str", "(", "self", ".", "_device", ")", ")" ]

[ "TpmMarshaller", "method" ]

[ "def", "toTpm", "(", "self", ",", "buf", ")", ":", "buf", ".", "writeByte", "(", "self", ".", "locality", ")" ]

[ "Using", "TopicTreeSpecPrinter", "exports", "the", "topic", "tree", "rooted", "at", "rootTopic", "to", "a", "Python", "module", "(", ".", "py", ")", "file", ".", "This", "module", "will", "define", "module", "-", "level", "classes", "representing", "root", "topics", "nested", "classes", "for", "subtopics", "etc", ".", "Returns", "a", "string", "representing", "the", "contents", "of", "the", "file", ".", "Parameters", ":" ]

[ "def", "exportTopicTreeSpec", "(", "moduleName", "=", "None", ",", "rootTopic", "=", "None", ",", "bak", "=", "'bak'", ",", "moduleDoc", "=", "None", ")", ":", "if", "rootTopic", "is", "None", ":", "from", ".", ".", "import", "pub", "rootTopic", "=", "pub", ".", "getDefaultTopicMgr", "(", ")", ".", "getRootAllTopics", "(", ")", "elif", "py2and3", ".", "isstring", "(", "rootTopic", ")", ":", "from", ".", ".", "import", "pub", "rootTopic", "=", "pub", ".", "getDefaultTopicMgr", "(", ")", ".", "getTopic", "(", "rootTopic", ")", "# create exporter", "if", "moduleName", "is", "None", ":", "capture", "=", "py2and3", ".", "StringIO", "(", ")", "TopicTreeSpecPrinter", "(", "rootTopic", ",", "fileObj", "=", "capture", ",", "treeDoc", "=", "moduleDoc", ")", "return", "capture", ".", "getvalue", "(", ")", "else", ":", "filename", "=", "'%s.py'", "%", "moduleName", "if", "bak", ":", "_backupIfExists", "(", "filename", ",", "bak", ")", "moduleFile", "=", "open", "(", "filename", ",", "'w'", ")", "try", ":", "TopicTreeSpecPrinter", "(", "rootTopic", ",", "fileObj", "=", "moduleFile", ",", "treeDoc", "=", "moduleDoc", ")", "finally", ":", "moduleFile", ".", "close", "(", ")" ]

[ "Return", "text", "block", "string", "of", "comment", "for", "serializable", "class", "." ]

[ "def", "get_comment", "(", "self", ")", ":", "return", "self", ".", "__comment" ]

[ "Set", "the", "focus", "on", "the", "widget", "that", "receives", "the", "key", "signal", "." ]

[ "def", "set_focus", "(", "self", ",", "key", "=", "None", ")", ":", "if", "key", "is", "None", "or", "key", "==", "\"x\"", ":", "self", ".", "form", ".", "input_c_x", ".", "setFocus", "(", ")", "self", ".", "form", ".", "input_c_x", ".", "selectAll", "(", ")", "elif", "key", "==", "\"y\"", ":", "self", ".", "form", ".", "input_c_y", ".", "setFocus", "(", ")", "self", ".", "form", ".", "input_c_y", ".", "selectAll", "(", ")", "elif", "key", "==", "\"z\"", ":", "self", ".", "form", ".", "input_c_z", ".", "setFocus", "(", ")", "self", ".", "form", ".", "input_c_z", ".", "selectAll", "(", ")" ]

[ "Documents", "an", "entire", "service", "." ]

[ "def", "document_service", "(", "self", ")", ":", "doc_structure", "=", "DocumentStructure", "(", "self", ".", "_service_name", ",", "section_names", "=", "self", ".", "sections", ",", "target", "=", "'html'", ")", "self", ".", "title", "(", "doc_structure", ".", "get_section", "(", "'title'", ")", ")", "self", ".", "table_of_contents", "(", "doc_structure", ".", "get_section", "(", "'table-of-contents'", ")", ")", "self", ".", "client_api", "(", "doc_structure", ".", "get_section", "(", "'client'", ")", ")", "self", ".", "paginator_api", "(", "doc_structure", ".", "get_section", "(", "'paginators'", ")", ")", "self", ".", "waiter_api", "(", "doc_structure", ".", "get_section", "(", "'waiters'", ")", ")", "if", "self", ".", "_service_resource", ":", "self", ".", "_document_service_resource", "(", "doc_structure", ".", "get_section", "(", "'service-resource'", ")", ")", "self", ".", "_document_resources", "(", "doc_structure", ".", "get_section", "(", "'resources'", ")", ")", "self", ".", "_document_examples", "(", "doc_structure", ".", "get_section", "(", "'examples'", ")", ")", "return", "doc_structure", ".", "flush_structure", "(", ")" ]

[ "Tbe", "Initialize", ":", "param", "job", ":", ":", "return", ":" ]

[ "def", "tbe_initialize", "(", "job", ":", "TbeJob", ")", ":", "os", ".", "environ", "[", "\"CONTEXT_MODELCOMPILING\"", "]", "=", "\"TRUE\"", "soc_info", "=", "get_soc_info", "(", "job", ".", "content", ")", "res", "=", "te_set_version", "(", "*", "soc_info", ")", "if", "not", "res", ":", "job", ".", "error", "(", "\"Set version failed\"", ")", "res", "=", "_tune_init", "(", "job", ")", "if", "not", "res", ":", "job", ".", "error", "(", "\"Tune init failed\"", ")", "lock_file", "=", "os", ".", "path", ".", "join", "(", "job", ".", "content", "[", "\"SocInfo\"", "]", "[", "\"op_debug_dir\"", "]", ",", "\"kernel_meta\"", ",", "\"file.lock\"", ")", "local_lock", "=", "LocalLock", "(", "lock_file", ")", "try", ":", "local_lock", ".", "lock", "(", ")", "res", "=", "_cann_kb_load", "(", "job", ")", "if", "res", "==", "1", ":", "job", ".", "error", "(", "\"Cann kb load failed\"", ")", "res", "=", "_parallel_compilation_init", "(", "job", ")", "if", "not", "res", ":", "job", ".", "error", "(", "\"Parallel compilation failed\"", ")", "except", "RuntimeError", ":", "job", ".", "error", "(", "\"Initialize failed with RuntimeError\"", ")", "finally", ":", "local_lock", ".", "unlock", "(", ")", "job", ".", "result", "=", "\"Success\"", "return", "res" ]

[ "Load", "Iris", "dataset", "." ]

[ "def", "load_iris", "(", "data_path", "=", "None", ")", ":", "if", "data_path", "is", "None", ":", "module_path", "=", "path", ".", "dirname", "(", "__file__", ")", "data_path", "=", "path", ".", "join", "(", "module_path", ",", "'data'", ",", "'iris.csv'", ")", "return", "load_csv_with_header", "(", "data_path", ",", "target_dtype", "=", "np", ".", "int", ",", "features_dtype", "=", "np", ".", "float", ")" ]

[ "Clears", "system", "caches" ]

[ "def", "clear_system_caches", "(", ")", ":", "try", ":", "os", ".", "system", "(", "'sudo sh -c \"/bin/echo 3 > /proc/sys/vm/drop_caches\"'", ")", "except", "Exception", "as", "e", ":", "errormessage", "=", "\"Clear system caches failed with error: \"", "+", "str", "(", "e", ")", "logging", ".", "error", "(", "errormessage", ")" ]

[ "Return", "a", "set", "of", "package", "names", "which", "depend", "on", "the", "package", "." ]

[ "def", "get_depends_on", "(", "self", ",", "pkg_name", ",", "depend_type", ",", "ignore_pkgs", "=", "None", ")", ":", "ignore_pkgs", "=", "ignore_pkgs", "or", "[", "]", "depends_on", "=", "set", "(", "[", "]", ")", "for", "name", "in", "self", ".", "_distribution_instance", ".", "release_packages", ".", "keys", "(", ")", ":", "if", "name", "in", "ignore_pkgs", ":", "continue", "pkg", "=", "self", ".", "_distribution_instance", ".", "release_packages", "[", "name", "]", "repo", "=", "self", ".", "_distribution_instance", ".", "repositories", "[", "pkg", ".", "repository_name", "]", ".", "release_repository", "if", "repo", "is", "None", "or", "repo", ".", "version", "is", "None", ":", "continue", "deps", "=", "self", ".", "_get_dependencies", "(", "name", ",", "depend_type", ")", "if", "pkg_name", "in", "deps", ":", "depends_on", ".", "add", "(", "name", ")", "return", "depends_on" ]

[ "Return", "the", "prefix", "to", "prepend", "to", "the", "environment", "variable", "NAME", "adding", "any", "path", "in", "NEW_PATHS_STR", "without", "creating", "duplicate", "or", "empty", "items", "." ]

[ "def", "_prefix_env_variable", "(", "environ", ",", "name", ",", "paths", ",", "subfolders", ")", ":", "value", "=", "environ", "[", "name", "]", "if", "name", "in", "environ", "else", "''", "environ_paths", "=", "[", "path", "for", "path", "in", "value", ".", "split", "(", "os", ".", "pathsep", ")", "if", "path", "]", "checked_paths", "=", "[", "]", "for", "path", "in", "paths", ":", "if", "not", "isinstance", "(", "subfolders", ",", "list", ")", ":", "subfolders", "=", "[", "subfolders", "]", "for", "subfolder", "in", "subfolders", ":", "path_tmp", "=", "path", "if", "subfolder", ":", "path_tmp", "=", "os", ".", "path", ".", "join", "(", "path_tmp", ",", "subfolder", ")", "# skip nonexistent paths", "if", "not", "os", ".", "path", ".", "exists", "(", "path_tmp", ")", ":", "continue", "# exclude any path already in env and any path we already added", "if", "path_tmp", "not", "in", "environ_paths", "and", "path_tmp", "not", "in", "checked_paths", ":", "checked_paths", ".", "append", "(", "path_tmp", ")", "prefix_str", "=", "os", ".", "pathsep", ".", "join", "(", "checked_paths", ")", "if", "prefix_str", "!=", "''", "and", "environ_paths", ":", "prefix_str", "+=", "os", ".", "pathsep", "return", "prefix_str" ]

[ "Missing", "DocString" ]

[ "def", "doPost", "(", "self", ")", ":", "post_cmds", "=", "[", "]", "if", "not", "afcommon", ".", "checkBlockFlag", "(", "self", ".", "taskInfo", "[", "'block_flags'", "]", ",", "'skipthumbnails'", ")", ":", "post_cmds", ".", "extend", "(", "self", ".", "generateThumbnail", "(", "False", ")", ")", "# post_cmds.extend(['ls -la > ' + self.taskInfo['store_dir'] + '/afile'])", "return", "post_cmds" ]

[ "sum", "of", "elements", "nums", "[", "i", "..", "j", "]", "inclusive", ".", ":", "type", "i", ":", "int", ":", "type", "j", ":", "int", ":", "rtype", ":", "int" ]

[ "def", "sumRange", "(", "self", ",", "i", ",", "j", ")", ":", "return", "self", ".", "__sum", "(", "j", ")", "-", "self", ".", "__sum", "(", "i", "-", "1", ")" ]

[ "True", "when", "__array_ufunc__", "is", "set", "to", "None", "." ]

[ "def", "_disables_array_ufunc", "(", "obj", ")", ":", "try", ":", "return", "obj", ".", "__array_ufunc__", "is", "None", "except", "AttributeError", ":", "return", "False" ]

[ "Validate", "a", "document", "tree", "in", "memory", "." ]

[ "def", "schemaValidateDoc", "(", "self", ",", "ctxt", ")", ":", "if", "ctxt", "is", "None", ":", "ctxt__o", "=", "None", "else", ":", "ctxt__o", "=", "ctxt", ".", "_o", "ret", "=", "libxml2mod", ".", "xmlSchemaValidateDoc", "(", "ctxt__o", ",", "self", ".", "_o", ")", "return", "ret" ]

[ "Complex", "Morlet", "wavelet", "." ]

[ "def", "morlet", "(", "M", ",", "w", "=", "5.0", ",", "s", "=", "1.0", ",", "complete", "=", "True", ")", ":", "x", "=", "linspace", "(", "-", "s", "*", "2", "*", "pi", ",", "s", "*", "2", "*", "pi", ",", "M", ")", "output", "=", "exp", "(", "1j", "*", "w", "*", "x", ")", "if", "complete", ":", "output", "-=", "exp", "(", "-", "0.5", "*", "(", "w", "**", "2", ")", ")", "output", "*=", "exp", "(", "-", "0.5", "*", "(", "x", "**", "2", ")", ")", "*", "pi", "**", "(", "-", "0.25", ")", "return", "output" ]

[ "For", "validation", "purposes", "mktemp", "()", "s", "return", "values", "are", "stored", "." ]

[ "def", "FakeReturnedMktempValues", "(", "self", ")", ":", "return", "self", ".", "_mktemp_retvals" ]

[ "Generate", "one", "C", "header", "from", "a", "grammar" ]

[ "def", "mk_extinst", "(", "name", ",", "grammar_file", ")", ":", "script", "=", "'../../../tools/buildHeaders/bin/generate_language_headers.py'", "subprocess", ".", "check_call", "(", "[", "'python3'", ",", "script", ",", "'--extinst-name='", "+", "name", ",", "'--extinst-grammar='", "+", "grammar_file", ",", "'--extinst-output-base='", "+", "name", "]", ")", "subprocess", ".", "check_call", "(", "[", "'dos2unix'", ",", "name", "+", "'.h'", "]", ")" ]

[ "Get", "commands", "for", "map", "wokers" ]

[ "def", "get_worker_cmd", "(", "self", ")", ":", "options", "=", "self", ".", "options", "rank", "=", "self", ".", "rank", "map_worker_id", "=", "rank", "task", "=", "options", ".", "all_tasks", "[", "rank", "]", "executable", "=", "'%s/%s %s'", "%", "(", "task", "[", "'tmp_dir'", "]", ",", "options", ".", "remote_executable", ",", "options", ".", "cmd_args", ")", "param", "=", "(", "executable", ",", "task", "[", "'input_path'", "]", ",", "task", "[", "'output_path'", "]", ",", "task", "[", "'log_filebase'", "]", ",", "options", ".", "num_map_worker", ",", "options", ".", "reduce_workers", ",", "map_worker_id", ",", "task", "[", "'class'", "]", ",", "task", "[", "'input_format'", "]", ",", "task", "[", "'output_format'", "]", ")", "cmd_map_worker", "=", "\"\"\" %s\n --mr_input_filepattern=\"%s\"\n --mr_output_files=\"%s\"\n --mr_log_filebase=\"%s\"\n --mr_num_map_workers=%s\n --mr_reduce_workers=%s\n --mr_map_worker_id=%s\n --mr_map_only=true\n --mr_mapper_class=%s\n --mr_input_format=%s\n --mr_output_format=%s\n \"\"\"", "%", "param", "return", "cmd_map_worker" ]

[ "Determines", "libc", "++", "path" ]

[ "def", "getLibCXXPaths", "(", ")", ":", "# determine defaults", "if", "os", ".", "name", "==", "'posix'", ":", "inc_path", "=", "'/usr/include'", "lib_path", "=", "'/usr/lib/libc++.so'", "else", ":", "raise", "ValueError", ",", "'Error: unknown OS. Where is libc++ installed?'", "# override with environement variables", "if", "'LIBCXX_INC_PATH'", "in", "os", ".", "environ", ":", "inc_path", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "environ", "[", "'LIBCXX_INC_PATH'", "]", ")", "if", "'LIBCXX_LIB_PATH'", "in", "os", ".", "environ", ":", "lib_path", "=", "os", ".", "path", ".", "abspath", "(", "os", ".", "environ", "[", "'LIBCXX_LIB_PATH'", "]", ")", "return", "(", "inc_path", ",", "lib_path", ")" ]

[ "Checks", "if", "the", "upper", "HUD", "is", "visible", "by", "looking", "at", "the", "global", "HUD", "visibility", "menu", "as", "well", "as", "the", "Subtree", "Info", "menu" ]

[ "def", "_isHUDVisible", "(", "self", ")", ":", "return", "self", ".", "_dataModel", ".", "viewSettings", ".", "showHUD", "and", "self", ".", "_dataModel", ".", "viewSettings", ".", "showHUD_Info" ]

[ "Initializes", "a", "ValidationMonitor", "." ]

[ "def", "__init__", "(", "self", ",", "x", "=", "None", ",", "y", "=", "None", ",", "input_fn", "=", "None", ",", "batch_size", "=", "None", ",", "eval_steps", "=", "None", ",", "every_n_steps", "=", "100", ",", "metrics", "=", "None", ",", "early_stopping_rounds", "=", "None", ",", "early_stopping_metric", "=", "\"loss\"", ",", "early_stopping_metric_minimize", "=", "True", ",", "name", "=", "None", ")", ":", "super", "(", "ValidationMonitor", ",", "self", ")", ".", "__init__", "(", "every_n_steps", "=", "every_n_steps", ",", "first_n_steps", "=", "-", "1", ")", "# TODO(mdan): Checks like this are already done by evaluate.", "if", "x", "is", "None", "and", "input_fn", "is", "None", ":", "raise", "ValueError", "(", "\"Either x or input_fn should be provided.\"", ")", "self", ".", "x", "=", "x", "self", ".", "y", "=", "y", "self", ".", "input_fn", "=", "input_fn", "self", ".", "batch_size", "=", "batch_size", "self", ".", "eval_steps", "=", "eval_steps", "self", ".", "metrics", "=", "metrics", "self", ".", "early_stopping_rounds", "=", "early_stopping_rounds", "self", ".", "early_stopping_metric", "=", "early_stopping_metric", "self", ".", "early_stopping_metric_minimize", "=", "early_stopping_metric_minimize", "self", ".", "name", "=", "name", "self", ".", "_best_value_step", "=", "None", "self", ".", "_best_value", "=", "None", "self", ".", "_early_stopped", "=", "False", "self", ".", "_latest_path", "=", "None", "self", ".", "_latest_path_step", "=", "None" ]

[ "Determine", "whether", "a", "basic", "CHECK", "can", "be", "replaced", "with", "a", "more", "specific", "one", "." ]

[ "def", "replaceable_check", "(", "operator", ",", "macro", ",", "line", ")", ":", "# This matches decimal and hex integers, strings, and chars (in that order).", "match_constant", "=", "r'([-+]?(\\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|\".*\"|\\'.*\\')'", "# Expression to match two sides of the operator with something that", "# looks like a literal, since CHECK(x == iterator) won't compile.", "# This means we can't catch all the cases where a more specific", "# CHECK is possible, but it's less annoying than dealing with", "# extraneous warnings.", "match_this", "=", "(", "r'\\s*'", "+", "macro", "+", "r'\\((\\s*'", "+", "match_constant", "+", "r'\\s*'", "+", "operator", "+", "r'[^<>].*|'", "r'.*[^<>]'", "+", "operator", "+", "r'\\s*'", "+", "match_constant", "+", "r'\\s*\\))'", ")", "# Don't complain about CHECK(x == NULL) or similar because", "# CHECK_EQ(x, NULL) won't compile (requires a cast).", "# Also, don't complain about more complex boolean expressions", "# involving && or || such as CHECK(a == b || c == d).", "return", "match", "(", "match_this", ",", "line", ")", "and", "not", "search", "(", "r'NULL|&&|\\|\\|'", ",", "line", ")" ]

[ "determine", "which", "of", "a", "set", "of", "vcf", "records", "presumed", "to", "refer", "to", "the", "same", "inversion", "are", "kept", "right", "now", "best", "is", "a", "record", "with", "PASS", "in", "the", "filter", "field", "and", "secondarily", "the", "high", "quality" ]

[ "def", "resolveRec", "(", "recEqualSet", ",", "recList", ")", ":", "if", "not", "recEqualSet", ":", "return", "bestIndex", "=", "0", "bestSS", "=", "0.", "bestPos", "=", "0", "bestIsPass", "=", "False", "for", "(", "index", ",", "rec", ")", "in", "enumerate", "(", "recEqualSet", ")", ":", "assert", "rec", ".", "pos", ">", "0", "isNewPass", "=", "(", "(", "not", "bestIsPass", ")", "and", "rec", ".", "isPass", ")", "isHighQual", "=", "(", "(", "bestIsPass", "==", "rec", ".", "isPass", ")", "and", "(", "rec", ".", "pos", "<", "bestPos", ")", ")", "#(rec.ss > bestSS))", "if", "(", "isNewPass", "or", "isHighQual", ")", ":", "bestIndex", "=", "index", "bestPos", "=", "rec", ".", "pos", "bestIsPass", "=", "rec", ".", "isPass", "# potentially could reward two non-pass inversion calls here:", "# if not bestIsPass and (len(recEqualSet) == 2) :", "# if (recEqualSet[0].isInv3 and reEqualSet[1].isInv5) or", "# recEqualSet[1].isInv3 and reEqualSet[0].isInv5)) :", "recList", ".", "append", "(", "recEqualSet", "[", "bestIndex", "]", ")" ]

[ "Create", "command", "textbox", "on", "screen", "." ]

[ "def", "_screen_create_command_textbox", "(", "self", ",", "existing_command", ")", ":", "# Display the tfdbg prompt.", "self", ".", "_stdscr", ".", "addstr", "(", "self", ".", "_max_y", "-", "self", ".", "_command_textbox_height", ",", "0", ",", "self", ".", "CLI_PROMPT", ",", "curses", ".", "A_BOLD", ")", "self", ".", "_stdscr", ".", "refresh", "(", ")", "self", ".", "_command_window", ".", "clear", "(", ")", "# Command text box.", "self", ".", "_command_textbox", "=", "textpad", ".", "Textbox", "(", "self", ".", "_command_window", ",", "insert_mode", "=", "True", ")", "# Enter existing command.", "self", ".", "_auto_key_in", "(", "existing_command", ")" ]

[ "Generate", "information", "for", "a", "bug", "report", "." ]

[ "def", "info", "(", ")", ":", "try", ":", "platform_info", "=", "{", "'system'", ":", "platform", ".", "system", "(", ")", ",", "'release'", ":", "platform", ".", "release", "(", ")", ",", "}", "except", "IOError", ":", "platform_info", "=", "{", "'system'", ":", "'Unknown'", ",", "'release'", ":", "'Unknown'", ",", "}", "implementation_info", "=", "_implementation", "(", ")", "urllib3_info", "=", "{", "'version'", ":", "urllib3", ".", "__version__", "}", "chardet_info", "=", "{", "'version'", ":", "chardet", ".", "__version__", "}", "pyopenssl_info", "=", "{", "'version'", ":", "None", ",", "'openssl_version'", ":", "''", ",", "}", "if", "OpenSSL", ":", "pyopenssl_info", "=", "{", "'version'", ":", "OpenSSL", ".", "__version__", ",", "'openssl_version'", ":", "'%x'", "%", "OpenSSL", ".", "SSL", ".", "OPENSSL_VERSION_NUMBER", ",", "}", "cryptography_info", "=", "{", "'version'", ":", "getattr", "(", "cryptography", ",", "'__version__'", ",", "''", ")", ",", "}", "idna_info", "=", "{", "'version'", ":", "getattr", "(", "idna", ",", "'__version__'", ",", "''", ")", ",", "}", "system_ssl", "=", "ssl", ".", "OPENSSL_VERSION_NUMBER", "system_ssl_info", "=", "{", "'version'", ":", "'%x'", "%", "system_ssl", "if", "system_ssl", "is", "not", "None", "else", "''", "}", "return", "{", "'platform'", ":", "platform_info", ",", "'implementation'", ":", "implementation_info", ",", "'system_ssl'", ":", "system_ssl_info", ",", "'using_pyopenssl'", ":", "pyopenssl", "is", "not", "None", ",", "'pyOpenSSL'", ":", "pyopenssl_info", ",", "'urllib3'", ":", "urllib3_info", ",", "'chardet'", ":", "chardet_info", ",", "'cryptography'", ":", "cryptography_info", ",", "'idna'", ":", "idna_info", ",", "'requests'", ":", "{", "'version'", ":", "requests_version", ",", "}", ",", "}" ]

[ "write", "in", "a", "format", "that", "we", "can", "search", "later", "on", "(", "but", "cannot", "append", "to", ")", ":", "write", "out", "the", "indices", "and", "the", "values", "using", "_write_array", "(", "e", ".", "g", ".", "a", "CArray", ")", "create", "an", "indexing", "table", "so", "that", "we", "can", "search" ]

[ "def", "write", "(", "self", ",", "*", "*", "kwargs", ")", ":", "raise", "NotImplementedError", "(", "\"WORKTable needs to implement write\"", ")" ]

[ "SetPopupAnchor", "(", "self", "int", "anchorSide", ")" ]

[ "def", "SetPopupAnchor", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_combo", ".", "ComboCtrl_SetPopupAnchor", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ ":", "type", "tot", ":", "int", ":", "rtype", ":", "int" ]

[ "def", "count", "(", "self", ",", "tot", ")", ":", "return", "sum", "(", "cnt", "*", "self", ".", "__count2", "[", "tot", "-", "x", "]", "for", "x", ",", "cnt", "in", "self", ".", "__count1", ".", "iteritems", "(", ")", ")" ]

[ "Creates", "an", "array", "from", "any", "object", "exposing", "the", "array", "interface", "." ]

[ "def", "array", "(", "source_array", ",", "ctx", "=", "None", ",", "dtype", "=", "None", ")", ":", "if", "spsp", "is", "not", "None", "and", "isinstance", "(", "source_array", ",", "spsp", ".", "csr", ".", "csr_matrix", ")", ":", "return", "_sparse_array", "(", "source_array", ",", "ctx", "=", "ctx", ",", "dtype", "=", "dtype", ")", "elif", "isinstance", "(", "source_array", ",", "NDArray", ")", "and", "source_array", ".", "stype", "!=", "'default'", ":", "return", "_sparse_array", "(", "source_array", ",", "ctx", "=", "ctx", ",", "dtype", "=", "dtype", ")", "else", ":", "return", "_array", "(", "source_array", ",", "ctx", "=", "ctx", ",", "dtype", "=", "dtype", ")" ]

[ "Returns", "the", "PRODUCT_TYPE", "of", "this", "target", "." ]

[ "def", "GetProductType", "(", "self", ")", ":", "if", "self", ".", "_IsBundle", "(", ")", ":", "return", "{", "'executable'", ":", "'com.apple.product-type.application'", ",", "'loadable_module'", ":", "'com.apple.product-type.bundle'", ",", "'shared_library'", ":", "'com.apple.product-type.framework'", ",", "}", "[", "self", ".", "spec", "[", "'type'", "]", "]", "else", ":", "return", "{", "'executable'", ":", "'com.apple.product-type.tool'", ",", "'loadable_module'", ":", "'com.apple.product-type.library.dynamic'", ",", "'shared_library'", ":", "'com.apple.product-type.library.dynamic'", ",", "'static_library'", ":", "'com.apple.product-type.library.static'", ",", "}", "[", "self", ".", "spec", "[", "'type'", "]", "]" ]

[ "Initialize", "settings", "for", "context", "block", "." ]

[ "def", "__init__", "(", "self", ",", "editwin", ")", ":", "self", ".", "editwin", "=", "editwin", "self", ".", "text", "=", "editwin", ".", "text", "self", ".", "_reset", "(", ")" ]

[ "Highlight", "will", "remain", "until", "user", "input", "turns", "it", "off", "or", "the", "insert", "has", "moved" ]

[ "def", "set_timeout_none", "(", "self", ")", ":", "# After CHECK_DELAY, call a function which disables the \"paren\" tag", "# if the event is for the most recent timer and the insert has changed,", "# or schedules another call for itself.", "self", ".", "counter", "+=", "1", "def", "callme", "(", "callme", ",", "self", "=", "self", ",", "c", "=", "self", ".", "counter", ",", "index", "=", "self", ".", "text", ".", "index", "(", "\"insert\"", ")", ")", ":", "if", "index", "!=", "self", ".", "text", ".", "index", "(", "\"insert\"", ")", ":", "self", ".", "handle_restore_timer", "(", "c", ")", "else", ":", "self", ".", "editwin", ".", "text_frame", ".", "after", "(", "CHECK_DELAY", ",", "callme", ",", "callme", ")", "self", ".", "editwin", ".", "text_frame", ".", "after", "(", "CHECK_DELAY", ",", "callme", ",", "callme", ")" ]

[ "Get", "the", "Document", "used", "by", "the", "IDE", "and", "the", "in", "-", "memory", "document", "model", "used", "by", "runtime", "engine" ]

[ "def", "GetDocCallback", "(", "filepath", ")", ":", "docMgr", "=", "wx", ".", "GetApp", "(", ")", ".", "GetDocumentManager", "(", ")", "try", ":", "doc", "=", "docMgr", ".", "CreateDocument", "(", "filepath", ",", "docMgr", ".", "GetFlags", "(", ")", "|", "wx", ".", "lib", ".", "docview", ".", "DOC_SILENT", "|", "wx", ".", "lib", ".", "docview", ".", "DOC_OPEN_ONCE", "|", "wx", ".", "lib", ".", "docview", ".", "DOC_NO_VIEW", ")", "if", "doc", ":", "AddProjectMapping", "(", "doc", ")", "else", ":", "# already open", "for", "d", "in", "docMgr", ".", "GetDocuments", "(", ")", ":", "if", "os", ".", "path", ".", "normcase", "(", "d", ".", "GetFilename", "(", ")", ")", "==", "os", ".", "path", ".", "normcase", "(", "filepath", ")", ":", "doc", "=", "d", "break", "except", "Exception", ",", "e", ":", "doc", "=", "None", "aglogging", ".", "reportException", "(", "e", ",", "stacktrace", "=", "True", ")", "if", "doc", "and", "doc", ".", "GetDocumentTemplate", "(", ")", ".", "GetDocumentType", "(", ")", "==", "WsdlAgEditor", ".", "WsdlAgDocument", ":", "# get referenced wsdl doc instead", "if", "doc", ".", "GetModel", "(", ")", ".", "filePath", ":", "if", "os", ".", "path", ".", "isabs", "(", "doc", ".", "GetModel", "(", ")", ".", "filePath", ")", ":", "# if absolute path, leave it alone", "filepath", "=", "doc", ".", "GetModel", "(", ")", ".", "filePath", "else", ":", "filepath", "=", "doc", ".", "GetAppDocMgr", "(", ")", ".", "fullPath", "(", "doc", ".", "GetModel", "(", ")", ".", "filePath", ")", "# check relative to project homeDir", "if", "not", "os", ".", "path", ".", "isfile", "(", "filepath", ")", ":", "filepath", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "join", "(", "os", ".", "path", ".", "dirname", "(", "doc", ".", "GetFilename", "(", ")", ")", ",", "doc", ".", "GetModel", "(", ")", ".", "filePath", ")", ")", "# check relative to wsdlag file", "if", "not", "os", ".", "path", ".", "isfile", "(", "filepath", ")", ":", "filename", "=", "os", ".", "sep", "+", "os", ".", "path", ".", "basename", "(", "doc", ".", "GetModel", "(", ")", ".", "filePath", ")", "# check to see if in project file", "filePaths", "=", "findDocumentMgr", "(", "doc", ")", ".", "filePaths", "for", "fp", "in", "filePaths", ":", "if", "fp", ".", "endswith", "(", "filename", ")", ":", "filepath", "=", "fp", "break", "try", ":", "doc", "=", "docMgr", ".", "CreateDocument", "(", "filepath", ",", "docMgr", ".", "GetFlags", "(", ")", "|", "wx", ".", "lib", ".", "docview", ".", "DOC_SILENT", "|", "wx", ".", "lib", ".", "docview", ".", "DOC_OPEN_ONCE", "|", "wx", ".", "lib", ".", "docview", ".", "DOC_NO_VIEW", ")", "except", "Exception", ",", "e", ":", "doc", "=", "None", "aglogging", ".", "reportException", "(", "e", ",", "stacktrace", "=", "True", ")", "if", "doc", ":", "AddProjectMapping", "(", "doc", ")", "else", ":", "# already open", "for", "d", "in", "docMgr", ".", "GetDocuments", "(", ")", ":", "if", "os", ".", "path", ".", "normcase", "(", "d", ".", "GetFilename", "(", ")", ")", "==", "os", ".", "path", ".", "normcase", "(", "filepath", ")", ":", "doc", "=", "d", "break", "else", ":", "doc", "=", "None", "if", "doc", ":", "docModel", "=", "doc", ".", "GetModel", "(", ")", "else", ":", "docModel", "=", "None", "return", "doc", ",", "docModel" ]

[ "Entry", "point", "." ]

[ "def", "main", "(", "pythonroot", ")", ":", "# Collect all include names in the root. These are the private includes.", "included_names", "=", "[", "]", "for", "fname", "in", "iterfiles", "(", "pythonroot", ",", "'*.h'", ")", ":", "included_names", ".", "extend", "(", "parse_include_names", "(", "fname", ")", ")", "# Discard duplicates and remove Python.h itself.", "included_names", "=", "set", "(", "included_names", ")", "included_names", ".", "remove", "(", "'Python.h'", ")", "# Print mappings from name -> Python.h.", "print", "(", "'['", ")", "print", "(", "',\\n'", ".", "join", "(", "generate_imp_lines", "(", "sorted", "(", "included_names", ")", ")", ")", ")", "print", "(", "']'", ")", "return", "0" ]

[ "Node", "representation", "as", "required" ]

[ "def", "__repr__", "(", "self", ")", ":", "return", "self", ".", "data" ]

[ "Create", "a", "CREATE", "script", "with", "the", "catalog", "objects", ".", "The", "catalog", "must", "have", "been", "previously", "processed", "with", "generateSQLCreateStatements", "()", "so", "that", "the", "objects", "have", "their", "temp_sql", "attributes", "set", "with", "their", "respective", "SQL", "CREATE", "statements", "." ]

[ "def", "createScriptForCatalogObjects", "(", "path", ",", "catalog", ",", "objectCreationParams", ")", ":", "def", "object_heading", "(", "type", ",", "name", ")", ":", "text", "=", "\"\"\"\n-- ----------------------------------------------------------------------------\n-- %s %s\n-- ----------------------------------------------------------------------------\n\"\"\"", "%", "(", "type", ",", "name", ")", "return", "text", "import", "time", "file", "=", "open", "(", "path", ",", "\"w+\"", ")", "file", ".", "write", "(", "\"\"\"-- ----------------------------------------------------------------------------\n-- MySQL Workbench Migration\n-- Migrated Schemata: %s\n-- Source Schemata: %s\n-- Created: %s\n-- Workbench Version: %s\n-- ----------------------------------------------------------------------------\n\n\"\"\"", "%", "(", "\", \"", ".", "join", "(", "[", "s", ".", "name", "for", "s", "in", "catalog", ".", "schemata", "]", ")", ",", "\", \"", ".", "join", "(", "[", "s", ".", "oldName", "for", "s", "in", "catalog", ".", "schemata", "]", ")", ",", "time", ".", "ctime", "(", ")", ",", "Version", ".", "fromgrt", "(", "grt", ".", "root", ".", "wb", ".", "info", ".", "version", ")", ")", ")", "preamble", "=", "catalog", ".", "customData", "[", "\"migration:preamble\"", "]", "if", "preamble", "and", "preamble", ".", "temp_sql", ":", "#file.write(object_heading(\"Preamble script\", \"\"))", "file", ".", "write", "(", "preamble", ".", "temp_sql", "+", "\"\\n\"", ")", "for", "schema", "in", "catalog", ".", "schemata", ":", "file", ".", "write", "(", "object_heading", "(", "\"Schema\"", ",", "schema", ".", "name", ")", ")", "file", ".", "write", "(", "schema", ".", "temp_sql", "+", "\";\\n\"", ")", "for", "table", "in", "schema", ".", "tables", ":", "file", ".", "write", "(", "object_heading", "(", "\"Table\"", ",", "\"%s.%s\"", "%", "(", "schema", ".", "name", ",", "table", ".", "name", ")", ")", ")", "file", ".", "write", "(", "table", ".", "temp_sql", "+", "\";\\n\"", ")", "for", "view", "in", "schema", ".", "views", ":", "file", ".", "write", "(", "object_heading", "(", "\"View\"", ",", "\"%s.%s\"", "%", "(", "schema", ".", "name", ",", "view", ".", "name", ")", ")", ")", "file", ".", "write", "(", "view", ".", "temp_sql", "+", "\";\\n\"", ")", "for", "routine", "in", "schema", ".", "routines", ":", "file", ".", "write", "(", "object_heading", "(", "\"Routine\"", ",", "\"%s.%s\"", "%", "(", "schema", ".", "name", ",", "routine", ".", "name", ")", ")", ")", "file", ".", "write", "(", "routine", ".", "temp_sql", ")", "for", "table", "in", "schema", ".", "tables", ":", "for", "trigger", "in", "table", ".", "triggers", ":", "file", ".", "write", "(", "object_heading", "(", "\"Trigger\"", ",", "\"%s.%s\"", "%", "(", "schema", ".", "name", ",", "trigger", ".", "name", ")", ")", ")", "file", ".", "write", "(", "trigger", ".", "temp_sql", "+", "\";\\n\"", ")", "postamble", "=", "catalog", ".", "customData", "[", "\"migration:postamble\"", "]", "if", "postamble", "and", "postamble", ".", "temp_sql", ":", "#file.write(object_heading(\"Postamble script\", \"\"))", "file", ".", "write", "(", "postamble", ".", "temp_sql", "+", "\"\\n\"", ")", "file", ".", "close", "(", ")", "return", "1" ]

[ "A", "utility", "function", "to", "check", "the", "parameters", "for", "the", "data", "layers", "." ]

[ "def", "check_params", "(", "params", ")", ":", "assert", "'split'", "in", "params", ".", "keys", "(", ")", ",", "'Params must include split (train, val, or test).'", "required", "=", "[", "'batch_size'", ",", "'pascal_root'", ",", "'im_shape'", "]", "for", "r", "in", "required", ":", "assert", "r", "in", "params", ".", "keys", "(", ")", ",", "'Params must include {}'", ".", "format", "(", "r", ")" ]

[ "Attempt", "to", "remove", "file", "or", "directory", "at", "path" ]

[ "def", "rm_file_or_dir", "(", "path", ")", ":", "try", ":", "shutil", ".", "rmtree", "(", "path", ")", "except", "Exception", ":", "pass", "try", ":", "os", ".", "remove", "(", "path", ")", "except", "Exception", ":", "pass" ]