Datasets:

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Compute", "the", "dependencies", "of", "a", "gyp", "spec", "." ]

[ "def", "ComputeDeps", "(", "self", ",", "spec", ")", ":", "deps", "=", "[", "]", "link_deps", "=", "[", "]", "if", "'dependencies'", "in", "spec", ":", "deps", ".", "extend", "(", "[", "target_outputs", "[", "dep", "]", "for", "dep", "in", "spec", "[", "'dependencies'", "]", "if", "target_outputs", "[", "dep", "]", "]", ")", "for", "dep", "in", "spec", "[", "'dependencies'", "]", ":", "if", "dep", "in", "target_link_deps", ":", "link_deps", ".", "append", "(", "target_link_deps", "[", "dep", "]", ")", "deps", ".", "extend", "(", "link_deps", ")", "# TODO: It seems we need to transitively link in libraries (e.g. -lfoo)?", "# This hack makes it work:", "# link_deps.extend(spec.get('libraries', []))", "return", "(", "gyp", ".", "common", ".", "uniquer", "(", "deps", ")", ",", "gyp", ".", "common", ".", "uniquer", "(", "link_deps", ")", ")" ]

[ "r", "The", "RooAbsData", "::", "reduce", "()", "function", "is", "pythonized", "with", "the", "command", "argument", "pythonization", ".", "The", "keywords", "must", "correspond", "to", "the", "CmdArgs", "of", "the", "function", "." ]

[ "def", "reduce", "(", "self", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "# Redefinition of `RooAbsData.reduce` for keyword arguments.", "args", ",", "kwargs", "=", "_kwargs_to_roocmdargs", "(", "*", "args", ",", "*", "*", "kwargs", ")", "return", "self", ".", "_reduce", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

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

[ "def", "GetAlignment", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewRenderer_GetAlignment", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Return", "the", "message", "for", "this", "LogRecord", "." ]

[ "def", "getMessage", "(", "self", ")", ":", "if", "not", "_unicode", ":", "#if no unicode support...", "msg", "=", "str", "(", "self", ".", "msg", ")", "else", ":", "msg", "=", "self", ".", "msg", "if", "not", "isinstance", "(", "msg", ",", "basestring", ")", ":", "try", ":", "msg", "=", "str", "(", "self", ".", "msg", ")", "except", "UnicodeError", ":", "msg", "=", "self", ".", "msg", "#Defer encoding till later", "if", "self", ".", "args", ":", "msg", "=", "msg", "%", "self", ".", "args", "return", "msg" ]

[ "Returns", "an", "initializer", "performing", "Xavier", "initialization", "for", "weights", "." ]

[ "def", "xavier_initializer", "(", "uniform", "=", "True", ",", "seed", "=", "None", ",", "dtype", "=", "dtypes", ".", "float32", ")", ":", "return", "variance_scaling_initializer", "(", "factor", "=", "1.0", ",", "mode", "=", "'FAN_AVG'", ",", "uniform", "=", "uniform", ",", "seed", "=", "seed", ",", "dtype", "=", "dtype", ")" ]

[ "Constructs", "the", "object", "and", "sets", "the", "default", "settings", "of", "the", "object", "." ]

[ "def", "__init__", "(", "self", ")", ":", "Component", ".", "__init__", "(", "self", ")", "mixins", ".", "ReaderObject", ".", "__init__", "(", "self", ")", "# Check return type of default settings", "defaults", "=", "self", ".", "defaultSettings", "(", ")", "if", "not", "isinstance", "(", "defaults", ",", "dict", ")", ":", "msg", "=", "\"The component '{}' must return a dict from the defaultSettings static method.\"", "raise", "exceptions", ".", "MooseDocsException", "(", "msg", ",", "self", ")" ]

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

[ "def", "GetHandle", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_gdi_", ".", "Cursor_GetHandle", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "The", "gradient", "loop", "state", "." ]

[ "def", "grad_state", "(", "self", ")", ":", "return", "self", ".", "_grad_state" ]

[ "Get", "the", "base", "id", "of", "the", "given", "child" ]

[ "def", "_child_base_id", "(", "self", ",", "child_index", "=", "None", ")", ":", "p", ",", "i", "=", "self", ".", "_parent", "pos", "=", "0", "if", "child_index", "is", "None", "else", "self", ".", "_field_offsets", "[", "child_index", "]", "if", "p", ":", "pos", "+=", "p", ".", "_child_base_id", "(", "i", ")", "return", "pos" ]

[ "Recursively", "copy", "a", "directory", "tree", "using", "copy2", "()", "." ]

[ "def", "copytree", "(", "src", ",", "dst", ",", "symlinks", "=", "False", ",", "ignore", "=", "None", ")", ":", "names", "=", "os", ".", "listdir", "(", "src", ")", "if", "ignore", "is", "not", "None", ":", "ignored_names", "=", "ignore", "(", "src", ",", "names", ")", "else", ":", "ignored_names", "=", "set", "(", ")", "os", ".", "makedirs", "(", "dst", ")", "errors", "=", "[", "]", "for", "name", "in", "names", ":", "if", "name", "in", "ignored_names", ":", "continue", "srcname", "=", "os", ".", "path", ".", "join", "(", "src", ",", "name", ")", "dstname", "=", "os", ".", "path", ".", "join", "(", "dst", ",", "name", ")", "try", ":", "if", "symlinks", "and", "os", ".", "path", ".", "islink", "(", "srcname", ")", ":", "linkto", "=", "os", ".", "readlink", "(", "srcname", ")", "os", ".", "symlink", "(", "linkto", ",", "dstname", ")", "elif", "os", ".", "path", ".", "isdir", "(", "srcname", ")", ":", "copytree", "(", "srcname", ",", "dstname", ",", "symlinks", ",", "ignore", ")", "else", ":", "# Will raise a SpecialFileError for unsupported file types", "copy2", "(", "srcname", ",", "dstname", ")", "# catch the Error from the recursive copytree so that we can", "# continue with other files", "except", "Error", ",", "err", ":", "errors", ".", "extend", "(", "err", ".", "args", "[", "0", "]", ")", "except", "EnvironmentError", ",", "why", ":", "errors", ".", "append", "(", "(", "srcname", ",", "dstname", ",", "str", "(", "why", ")", ")", ")", "try", ":", "copystat", "(", "src", ",", "dst", ")", "except", "OSError", ",", "why", ":", "if", "WindowsError", "is", "not", "None", "and", "isinstance", "(", "why", ",", "WindowsError", ")", ":", "# Copying file access times may fail on Windows", "pass", "else", ":", "errors", ".", "append", "(", "(", "src", ",", "dst", ",", "str", "(", "why", ")", ")", ")", "if", "errors", ":", "raise", "Error", ",", "errors" ]

[ "Unsets", "a", "cookie", "by", "name", "by", "default", "over", "all", "domains", "and", "paths", "." ]

[ "def", "remove_cookie_by_name", "(", "cookiejar", ",", "name", ",", "domain", "=", "None", ",", "path", "=", "None", ")", ":", "clearables", "=", "[", "]", "for", "cookie", "in", "cookiejar", ":", "if", "cookie", ".", "name", "==", "name", ":", "if", "domain", "is", "None", "or", "domain", "==", "cookie", ".", "domain", ":", "if", "path", "is", "None", "or", "path", "==", "cookie", ".", "path", ":", "clearables", ".", "append", "(", "(", "cookie", ".", "domain", ",", "cookie", ".", "path", ",", "cookie", ".", "name", ")", ")", "for", "domain", ",", "path", ",", "name", "in", "clearables", ":", "cookiejar", ".", "clear", "(", "domain", ",", "path", ",", "name", ")" ]

[ "Check", "if", "user", "site", "directory", "is", "safe", "for", "inclusion" ]

[ "def", "check_enableusersite", "(", ")", ":", "if", "sys", ".", "flags", ".", "no_user_site", ":", "return", "False", "if", "hasattr", "(", "os", ",", "\"getuid\"", ")", "and", "hasattr", "(", "os", ",", "\"geteuid\"", ")", ":", "# check process uid == effective uid", "if", "os", ".", "geteuid", "(", ")", "!=", "os", ".", "getuid", "(", ")", ":", "return", "None", "if", "hasattr", "(", "os", ",", "\"getgid\"", ")", "and", "hasattr", "(", "os", ",", "\"getegid\"", ")", ":", "# check process gid == effective gid", "if", "os", ".", "getegid", "(", ")", "!=", "os", ".", "getgid", "(", ")", ":", "return", "None", "return", "True" ]

[ "Classify", "the", "file", "named", "by", "filename", "and", "return", "the", "classification", ".", "If", "the", "file", "is", "classified", "as", "IT_Invalid", "print", "an", "error", "message", "and", "exit", "the", "program", "." ]

[ "def", "check_input_file", "(", "filename", ")", ":", "ftype", ",", "msg", "=", "classify_input_file", "(", "filename", ")", "if", "ftype", "==", "IT_Invalid", ":", "print", "(", "\"Invalid input file: %s\"", "%", "msg", ")", "sys", ".", "exit", "(", "1", ")", "return", "ftype" ]

[ "Split", "arrays", "into", "train", "and", "validation", "subsets", "in", "deterministic", "order", "." ]

[ "def", "train_validation_split", "(", "arrays", ",", "validation_split", ")", ":", "def", "_can_split", "(", "t", ")", ":", "tensor_types", "=", "_get_tensor_types", "(", ")", "return", "isinstance", "(", "t", ",", "tensor_types", ")", "or", "t", "is", "None", "flat_arrays", "=", "nest", ".", "flatten", "(", "arrays", ")", "unsplitable", "=", "[", "type", "(", "t", ")", "for", "t", "in", "flat_arrays", "if", "not", "_can_split", "(", "t", ")", "]", "if", "unsplitable", ":", "raise", "ValueError", "(", "\"`validation_split` is only supported for Tensors or NumPy \"", "\"arrays, found following types in the input: {}\"", ".", "format", "(", "unsplitable", ")", ")", "if", "all", "(", "t", "is", "None", "for", "t", "in", "flat_arrays", ")", ":", "return", "arrays", ",", "arrays", "first_non_none", "=", "None", "for", "t", "in", "flat_arrays", ":", "if", "t", "is", "not", "None", ":", "first_non_none", "=", "t", "break", "# Assumes all arrays have the same batch shape or are `None`.", "batch_dim", "=", "int", "(", "first_non_none", ".", "shape", "[", "0", "]", ")", "split_at", "=", "int", "(", "math", ".", "floor", "(", "batch_dim", "*", "(", "1.", "-", "validation_split", ")", ")", ")", "if", "split_at", "==", "0", "or", "split_at", "==", "batch_dim", ":", "raise", "ValueError", "(", "\"Training data contains {batch_dim} samples, which is not sufficient \"", "\"to split it into a validation and training set as specified by \"", "\"`validation_split={validation_split}`. Either provide more data, or a \"", "\"different value for the `validation_split` argument.\"", ".", "format", "(", "batch_dim", "=", "batch_dim", ",", "validation_split", "=", "validation_split", ")", ")", "def", "_split", "(", "t", ",", "start", ",", "end", ")", ":", "if", "t", "is", "None", ":", "return", "t", "return", "t", "[", "start", ":", "end", "]", "train_arrays", "=", "nest", ".", "map_structure", "(", "functools", ".", "partial", "(", "_split", ",", "start", "=", "0", ",", "end", "=", "split_at", ")", ",", "arrays", ")", "val_arrays", "=", "nest", ".", "map_structure", "(", "functools", ".", "partial", "(", "_split", ",", "start", "=", "split_at", ",", "end", "=", "batch_dim", ")", ",", "arrays", ")", "return", "train_arrays", ",", "val_arrays" ]

[ "Return", "logical", "not", "operation", "result", "of", "x", ".", "Args", ":", "x", "(", "Tensor", ")", ":", "Tensor", ".", "Returns", ":", "Tensor", "Return", "logical", "not", "operation", "result", "of", "x", "." ]

[ "def", "_logical_not_tensor", "(", "x", ")", ":", "if", "F", ".", "isconstant", "(", "x", ")", ":", "return", "F", ".", "bool_not", "(", "x", ".", "__bool__", "(", ")", ")", "return", "F", ".", "logical_not", "(", "x", ".", "__bool__", "(", ")", ")" ]

[ "Two", "siamese", "branches", "each", "embedding", "a", "statement", "." ]

[ "def", "cnn_2x_siamese", "(", "voc_size", ",", "max_len", ",", "dropout", "=", "0.5", ")", ":", "pivot_input", "=", "layers", ".", "Input", "(", "shape", "=", "(", "max_len", ",", ")", ",", "dtype", "=", "'int32'", ")", "statement_input", "=", "layers", ".", "Input", "(", "shape", "=", "(", "max_len", ",", ")", ",", "dtype", "=", "'int32'", ")", "x", "=", "layers", ".", "Embedding", "(", "output_dim", "=", "256", ",", "input_dim", "=", "voc_size", ",", "input_length", "=", "max_len", ")", "(", "pivot_input", ")", "x", "=", "layers", ".", "Convolution1D", "(", "256", ",", "7", ",", "activation", "=", "'relu'", ")", "(", "x", ")", "x", "=", "layers", ".", "MaxPooling1D", "(", "3", ")", "(", "x", ")", "x", "=", "layers", ".", "Convolution1D", "(", "256", ",", "7", ",", "activation", "=", "'relu'", ")", "(", "x", ")", "embedded_pivot", "=", "layers", ".", "GlobalMaxPooling1D", "(", ")", "(", "x", ")", "encoder_model", "=", "Model", "(", "pivot_input", ",", "embedded_pivot", ")", "embedded_statement", "=", "encoder_model", "(", "statement_input", ")", "concat", "=", "layers", ".", "merge", "(", "[", "embedded_pivot", ",", "embedded_statement", "]", ",", "mode", "=", "'concat'", ")", "x", "=", "layers", ".", "Dense", "(", "256", ",", "activation", "=", "'relu'", ")", "(", "concat", ")", "x", "=", "layers", ".", "Dropout", "(", "dropout", ")", "(", "x", ")", "prediction", "=", "layers", ".", "Dense", "(", "1", ",", "activation", "=", "'sigmoid'", ")", "(", "x", ")", "model", "=", "Model", "(", "[", "pivot_input", ",", "statement_input", "]", ",", "prediction", ")", "return", "model" ]

[ "Return", "LD_DYLIB_INSTALL_NAME", "for", "this", "target", "." ]

[ "def", "GetInstallName", "(", "self", ")", ":", "# Xcode sets this for shared_libraries, and for nonbundled loadable_modules.", "if", "(", "self", ".", "spec", "[", "'type'", "]", "!=", "'shared_library'", "and", "(", "self", ".", "spec", "[", "'type'", "]", "!=", "'loadable_module'", "or", "self", ".", "_IsBundle", "(", ")", ")", ")", ":", "return", "None", "default_install_name", "=", "'$(DYLIB_INSTALL_NAME_BASE:standardizepath)/$(EXECUTABLE_PATH)'", "install_name", "=", "self", ".", "GetPerTargetSetting", "(", "'LD_DYLIB_INSTALL_NAME'", ",", "default", "=", "default_install_name", ")", "# Hardcode support for the variables used in chromium for now, to", "# unblock people using the make build.", "if", "'$'", "in", "install_name", ":", "assert", "install_name", "in", "(", "'$(DYLIB_INSTALL_NAME_BASE:standardizepath)/'", "'$(WRAPPER_NAME)/$(PRODUCT_NAME)'", ",", "default_install_name", ")", ",", "(", "'Variables in LD_DYLIB_INSTALL_NAME are not generally supported '", "'yet in target \\'%s\\' (got \\'%s\\')'", "%", "(", "self", ".", "spec", "[", "'target_name'", "]", ",", "install_name", ")", ")", "install_name", "=", "install_name", ".", "replace", "(", "'$(DYLIB_INSTALL_NAME_BASE:standardizepath)'", ",", "self", ".", "_StandardizePath", "(", "self", ".", "GetInstallNameBase", "(", ")", ")", ")", "if", "self", ".", "_IsBundle", "(", ")", ":", "# These are only valid for bundles, hence the |if|.", "install_name", "=", "install_name", ".", "replace", "(", "'$(WRAPPER_NAME)'", ",", "self", ".", "GetWrapperName", "(", ")", ")", "install_name", "=", "install_name", ".", "replace", "(", "'$(PRODUCT_NAME)'", ",", "self", ".", "GetProductName", "(", ")", ")", "else", ":", "assert", "'$(WRAPPER_NAME)'", "not", "in", "install_name", "assert", "'$(PRODUCT_NAME)'", "not", "in", "install_name", "install_name", "=", "install_name", ".", "replace", "(", "'$(EXECUTABLE_PATH)'", ",", "self", ".", "GetExecutablePath", "(", ")", ")", "return", "install_name" ]

[ "This", "function", "configures", "the", "full", "cms", ".", "PSet", "for", "a", "VID", "ID", "and", "returns", "it", ".", "The", "inputs", ":", "first", "object", "is", "of", "the", "type", "WorkingPoint_V2", "second", "object", "is", "of", "the", "type", "WorkingPoint_V1", "containing", "the", "cuts", "for", "the", "Barrel", "(", "EB", ")", "and", "the", "other", "one", "for", "the", "Endcap", "(", "EE", ")", ".", "The", "third", "argument", "contains", "data", "for", "isolation", "calculation", "." ]

[ "def", "configureVIDCutBasedPhoID_V2", "(", "wpEB", ",", "wpEE", ",", "isoInputs", ")", ":", "# print \"VID: Configuring cut set %s\" % wpEB.idName", "parameterSet", "=", "cms", ".", "PSet", "(", "#", "idName", "=", "cms", ".", "string", "(", "wpEB", ".", "idName", ")", ",", "# same name stored in the _EB and _EE objects", "cutFlow", "=", "cms", ".", "VPSet", "(", "psetMinPtCut", "(", ")", ",", "# pt cut", "psetPhoSCEtaMultiRangeCut", "(", ")", ",", "# eta cut", "psetPhoHcalOverEcalBcCut", "(", "wpEB", ",", "wpEE", ")", ",", "# H/E cut", "psetPhoFull5x5SigmaIEtaIEtaValueMapCut", "(", "wpEB", ",", "wpEE", ")", ",", "# full 5x5 sigmaIEtaIEta cut", "psetChHadIsoWithEALinScalingCut", "(", "wpEB", ",", "wpEE", ",", "isoInputs", ")", ",", "# charged hadron isolation cut", "psetNeuHadIsoWithEAExpoScalingEBCut", "(", "wpEB", ",", "wpEE", ",", "isoInputs", ")", ",", "# neutral hadron isolation cut", "psetPhoIsoWithEALinScalingCut", "(", "wpEB", ",", "wpEE", ",", "isoInputs", ")", "# photon isolation cut", ")", ")", "#", "return", "parameterSet" ]

[ "Create", "collection", "space", "with", "specified", "pagesize", "." ]

[ "def", "create_collection_space", "(", "self", ",", "cs_name", ",", "options", "=", "0", ")", ":", "ops", "=", "{", "}", "if", "not", "isinstance", "(", "cs_name", ",", "str_type", ")", ":", "raise", "SDBTypeError", "(", "\"name of collection space must be an instance of str_type\"", ")", "if", "isinstance", "(", "options", ",", "int", ")", ":", "if", "options", "not", "in", "[", "0", ",", "4096", ",", "8192", ",", "16384", ",", "32768", ",", "65536", "]", ":", "raise", "SDBTypeError", "(", "\"page size is invalid\"", ")", "ops", "[", "\"PageSize\"", "]", "=", "options", "elif", "isinstance", "(", "options", ",", "dict", ")", ":", "ops", "=", "options", "else", ":", "raise", "SDBTypeError", "(", "\"options must be an instance of int\"", ")", "bson_options", "=", "bson", ".", "BSON", ".", "encode", "(", "ops", ")", "cs", "=", "collectionspace", "(", ")", "try", ":", "rc", "=", "sdb", ".", "sdb_create_collection_space", "(", "self", ".", "_client", ",", "cs_name", ",", "bson_options", ",", "cs", ".", "_cs", ")", "raise_if_error", "(", "rc", ",", "\"Failed to create collection space: %s\"", "%", "cs_name", ")", "except", "SDBBaseError", ":", "del", "cs", "raise", "return", "cs" ]

[ "Constructs", "a", "new", "PauliStrings", "operator", "given", "a", "set", "of", "Pauli", "operators", ".", "This", "class", "has", "two", "possible", "forms", "for", "initialization", ":", "PauliStrings", "(", "hilbert", "operators", "...", ")", "or", "PauliStrings", "(", "operators", "...", ")", ".", "When", "no", "hilbert", "argument", "is", "passed", "the", "hilbert", "defaults", "to", "Qubit", "where", "the", "number", "of", "qubits", "is", "automatically", "deduced", "from", "the", "operators", "." ]

[ "def", "__init__", "(", "self", ",", "hilbert", ":", "AbstractHilbert", ",", "operators", ":", "List", "[", "str", "]", "=", "None", ",", "weights", ":", "List", "[", "Union", "[", "float", ",", "complex", "]", "]", "=", "None", ",", "*", ",", "cutoff", ":", "float", "=", "1.0e-10", ",", "dtype", ":", "DType", "=", "complex", ",", ")", ":", "if", "hilbert", "is", "None", ":", "raise", "ValueError", "(", "\"None-valued hilbert passed.\"", ")", "if", "not", "isinstance", "(", "hilbert", ",", "AbstractHilbert", ")", ":", "# if first argument is not Hilbert, then shift all arguments by one", "hilbert", ",", "operators", ",", "weights", "=", "None", ",", "hilbert", ",", "operators", "if", "operators", "is", "None", ":", "raise", "ValueError", "(", "\"None valued operators passed. (Might arised when passing None valued hilbert explicitly)\"", ")", "if", "len", "(", "operators", ")", "==", "0", ":", "raise", "ValueError", "(", "\"No Pauli operators passed.\"", ")", "if", "weights", "is", "None", ":", "# default weight is 1", "weights", "=", "[", "True", "for", "i", "in", "operators", "]", "if", "len", "(", "weights", ")", "!=", "len", "(", "operators", ")", ":", "raise", "ValueError", "(", "\"weights should have the same length as operators.\"", ")", "if", "not", "np", ".", "isscalar", "(", "cutoff", ")", "or", "cutoff", "<", "0", ":", "raise", "ValueError", "(", "\"invalid cutoff in PauliStrings.\"", ")", "_hilb_size", "=", "len", "(", "operators", "[", "0", "]", ")", "consistent", "=", "all", "(", "len", "(", "op", ")", "==", "_hilb_size", "for", "op", "in", "operators", ")", "if", "not", "consistent", ":", "raise", "ValueError", "(", "\"Pauli strings have inhomogeneous lengths.\"", ")", "consistent", "=", "all", "(", "bool", "(", "valid_pauli_regex", ".", "search", "(", "op", ")", ")", "for", "op", "in", "operators", ")", "if", "not", "consistent", ":", "raise", "ValueError", "(", "\"\"\"Operators in string must be one of\n the Pauli operators X,Y,Z, or the identity I\"\"\"", ")", "if", "hilbert", "is", "None", ":", "hilbert", "=", "Qubit", "(", "_hilb_size", ")", "super", "(", ")", ".", "__init__", "(", "hilbert", ")", "if", "self", ".", "hilbert", ".", "local_size", "!=", "2", ":", "raise", "ValueError", "(", "\"PauliStrings only work for local hilbert size 2 where PauliMatrices are defined\"", ")", "self", ".", "_cutoff", "=", "cutoff", "b_weights", "=", "np", ".", "asarray", "(", "weights", ",", "dtype", "=", "dtype", ")", "self", ".", "_is_hermitian", "=", "np", ".", "allclose", "(", "b_weights", ".", "imag", ",", "0.0", ")", "self", ".", "_orig_operators", "=", "np", ".", "array", "(", "operators", ",", "dtype", "=", "str", ")", "self", ".", "_orig_weights", "=", "np", ".", "array", "(", "weights", ",", "dtype", "=", "dtype", ")", "self", ".", "_dtype", "=", "dtype", "self", ".", "_initialized", "=", "False" ]

[ "Append", "sharding", "information", "to", "a", "filename", "." ]

[ "def", "sharded_filename", "(", "self", ",", "filename_tensor", ",", "shard", ",", "num_shards", ")", ":", "return", "gen_io_ops", ".", "sharded_filename", "(", "filename_tensor", ",", "shard", ",", "num_shards", ")" ]

[ "Acquire", "a", "lock", "blocking", "or", "non", "-", "blocking", "." ]

[ "def", "acquire", "(", "self", ",", "blocking", "=", "True", ",", "timeout", "=", "-", "1", ")", ":", "me", "=", "get_ident", "(", ")", "if", "self", ".", "_owner", "==", "me", ":", "self", ".", "_count", "+=", "1", "return", "1", "rc", "=", "self", ".", "_block", ".", "acquire", "(", "blocking", ",", "timeout", ")", "if", "rc", ":", "self", ".", "_owner", "=", "me", "self", ".", "_count", "=", "1", "return", "rc" ]

[ "IsContainer", "(", "self", "DataViewItem", "item", ")", "-", ">", "bool" ]

[ "def", "IsContainer", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewTreeCtrl_IsContainer", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Specifies", "if", "the", "calculations", "should", "be", "reset", "on", "each", "run", "." ]

[ "def", "reset", "(", "self", ",", "reset", ")", ":", "self", ".", "_internal", ".", "set_reset", "(", "bool", "(", "reset", ")", ")" ]

[ "Compute", "a", "multidimensional", "binned", "statistic", "for", "a", "set", "of", "data", "." ]

[ "def", "binned_statistic_dd", "(", "sample", ",", "values", ",", "statistic", "=", "'mean'", ",", "bins", "=", "10", ",", "range", "=", "None", ",", "expand_binnumbers", "=", "False", ")", ":", "known_stats", "=", "[", "'mean'", ",", "'median'", ",", "'count'", ",", "'sum'", ",", "'std'", ",", "'min'", ",", "'max'", "]", "if", "not", "callable", "(", "statistic", ")", "and", "statistic", "not", "in", "known_stats", ":", "raise", "ValueError", "(", "'invalid statistic %r'", "%", "(", "statistic", ",", ")", ")", "# `Ndim` is the number of dimensions (e.g. `2` for `binned_statistic_2d`)", "# `Dlen` is the length of elements along each dimension.", "# This code is based on np.histogramdd", "try", ":", "# `sample` is an ND-array.", "Dlen", ",", "Ndim", "=", "sample", ".", "shape", "except", "(", "AttributeError", ",", "ValueError", ")", ":", "# `sample` is a sequence of 1D arrays.", "sample", "=", "np", ".", "atleast_2d", "(", "sample", ")", ".", "T", "Dlen", ",", "Ndim", "=", "sample", ".", "shape", "# Store initial shape of `values` to preserve it in the output", "values", "=", "np", ".", "asarray", "(", "values", ")", "input_shape", "=", "list", "(", "values", ".", "shape", ")", "# Make sure that `values` is 2D to iterate over rows", "values", "=", "np", ".", "atleast_2d", "(", "values", ")", "Vdim", ",", "Vlen", "=", "values", ".", "shape", "# Make sure `values` match `sample`", "if", "(", "statistic", "!=", "'count'", "and", "Vlen", "!=", "Dlen", ")", ":", "raise", "AttributeError", "(", "'The number of `values` elements must match the '", "'length of each `sample` dimension.'", ")", "nbin", "=", "np", ".", "empty", "(", "Ndim", ",", "int", ")", "# Number of bins in each dimension", "edges", "=", "Ndim", "*", "[", "None", "]", "# Bin edges for each dim (will be 2D array)", "dedges", "=", "Ndim", "*", "[", "None", "]", "# Spacing between edges (will be 2D array)", "try", ":", "M", "=", "len", "(", "bins", ")", "if", "M", "!=", "Ndim", ":", "raise", "AttributeError", "(", "'The dimension of bins must be equal '", "'to the dimension of the sample x.'", ")", "except", "TypeError", ":", "bins", "=", "Ndim", "*", "[", "bins", "]", "# Select range for each dimension", "# Used only if number of bins is given.", "if", "range", "is", "None", ":", "smin", "=", "np", ".", "atleast_1d", "(", "np", ".", "array", "(", "sample", ".", "min", "(", "axis", "=", "0", ")", ",", "float", ")", ")", "smax", "=", "np", ".", "atleast_1d", "(", "np", ".", "array", "(", "sample", ".", "max", "(", "axis", "=", "0", ")", ",", "float", ")", ")", "else", ":", "smin", "=", "np", ".", "zeros", "(", "Ndim", ")", "smax", "=", "np", ".", "zeros", "(", "Ndim", ")", "for", "i", "in", "xrange", "(", "Ndim", ")", ":", "smin", "[", "i", "]", ",", "smax", "[", "i", "]", "=", "range", "[", "i", "]", "# Make sure the bins have a finite width.", "for", "i", "in", "xrange", "(", "len", "(", "smin", ")", ")", ":", "if", "smin", "[", "i", "]", "==", "smax", "[", "i", "]", ":", "smin", "[", "i", "]", "=", "smin", "[", "i", "]", "-", ".5", "smax", "[", "i", "]", "=", "smax", "[", "i", "]", "+", ".5", "# Create edge arrays", "for", "i", "in", "xrange", "(", "Ndim", ")", ":", "if", "np", ".", "isscalar", "(", "bins", "[", "i", "]", ")", ":", "nbin", "[", "i", "]", "=", "bins", "[", "i", "]", "+", "2", "# +2 for outlier bins", "edges", "[", "i", "]", "=", "np", ".", "linspace", "(", "smin", "[", "i", "]", ",", "smax", "[", "i", "]", ",", "nbin", "[", "i", "]", "-", "1", ")", "else", ":", "edges", "[", "i", "]", "=", "np", ".", "asarray", "(", "bins", "[", "i", "]", ",", "float", ")", "nbin", "[", "i", "]", "=", "len", "(", "edges", "[", "i", "]", ")", "+", "1", "# +1 for outlier bins", "dedges", "[", "i", "]", "=", "np", ".", "diff", "(", "edges", "[", "i", "]", ")", "nbin", "=", "np", ".", "asarray", "(", "nbin", ")", "# Compute the bin number each sample falls into, in each dimension", "sampBin", "=", "[", "np", ".", "digitize", "(", "sample", "[", ":", ",", "i", "]", ",", "edges", "[", "i", "]", ")", "for", "i", "in", "xrange", "(", "Ndim", ")", "]", "# Using `digitize`, values that fall on an edge are put in the right bin.", "# For the rightmost bin, we want values equal to the right", "# edge to be counted in the last bin, and not as an outlier.", "for", "i", "in", "xrange", "(", "Ndim", ")", ":", "# Find the rounding precision", "decimal", "=", "int", "(", "-", "np", ".", "log10", "(", "dedges", "[", "i", "]", ".", "min", "(", ")", ")", ")", "+", "6", "# Find which points are on the rightmost edge.", "on_edge", "=", "np", ".", "where", "(", "np", ".", "around", "(", "sample", "[", ":", ",", "i", "]", ",", "decimal", ")", "==", "np", ".", "around", "(", "edges", "[", "i", "]", "[", "-", "1", "]", ",", "decimal", ")", ")", "[", "0", "]", "# Shift these points one bin to the left.", "sampBin", "[", "i", "]", "[", "on_edge", "]", "-=", "1", "# Compute the sample indices in the flattened statistic matrix.", "binnumbers", "=", "np", ".", "ravel_multi_index", "(", "sampBin", ",", "nbin", ")", "result", "=", "np", ".", "empty", "(", "[", "Vdim", ",", "nbin", ".", "prod", "(", ")", "]", ",", "float", ")", "if", "statistic", "==", "'mean'", ":", "result", ".", "fill", "(", "np", ".", "nan", ")", "flatcount", "=", "np", ".", "bincount", "(", "binnumbers", ",", "None", ")", "a", "=", "flatcount", ".", "nonzero", "(", ")", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "flatsum", "=", "np", ".", "bincount", "(", "binnumbers", ",", "values", "[", "vv", "]", ")", "result", "[", "vv", ",", "a", "]", "=", "flatsum", "[", "a", "]", "/", "flatcount", "[", "a", "]", "elif", "statistic", "==", "'std'", ":", "result", ".", "fill", "(", "0", ")", "flatcount", "=", "np", ".", "bincount", "(", "binnumbers", ",", "None", ")", "a", "=", "flatcount", ".", "nonzero", "(", ")", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "flatsum", "=", "np", ".", "bincount", "(", "binnumbers", ",", "values", "[", "vv", "]", ")", "flatsum2", "=", "np", ".", "bincount", "(", "binnumbers", ",", "values", "[", "vv", "]", "**", "2", ")", "result", "[", "vv", ",", "a", "]", "=", "np", ".", "sqrt", "(", "flatsum2", "[", "a", "]", "/", "flatcount", "[", "a", "]", "-", "(", "flatsum", "[", "a", "]", "/", "flatcount", "[", "a", "]", ")", "**", "2", ")", "elif", "statistic", "==", "'count'", ":", "result", ".", "fill", "(", "0", ")", "flatcount", "=", "np", ".", "bincount", "(", "binnumbers", ",", "None", ")", "a", "=", "np", ".", "arange", "(", "len", "(", "flatcount", ")", ")", "result", "[", ":", ",", "a", "]", "=", "flatcount", "[", "np", ".", "newaxis", ",", ":", "]", "elif", "statistic", "==", "'sum'", ":", "result", ".", "fill", "(", "0", ")", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "flatsum", "=", "np", ".", "bincount", "(", "binnumbers", ",", "values", "[", "vv", "]", ")", "a", "=", "np", ".", "arange", "(", "len", "(", "flatsum", ")", ")", "result", "[", "vv", ",", "a", "]", "=", "flatsum", "elif", "statistic", "==", "'median'", ":", "result", ".", "fill", "(", "np", ".", "nan", ")", "for", "i", "in", "np", ".", "unique", "(", "binnumbers", ")", ":", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "result", "[", "vv", ",", "i", "]", "=", "np", ".", "median", "(", "values", "[", "vv", ",", "binnumbers", "==", "i", "]", ")", "elif", "statistic", "==", "'min'", ":", "result", ".", "fill", "(", "np", ".", "nan", ")", "for", "i", "in", "np", ".", "unique", "(", "binnumbers", ")", ":", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "result", "[", "vv", ",", "i", "]", "=", "np", ".", "min", "(", "values", "[", "vv", ",", "binnumbers", "==", "i", "]", ")", "elif", "statistic", "==", "'max'", ":", "result", ".", "fill", "(", "np", ".", "nan", ")", "for", "i", "in", "np", ".", "unique", "(", "binnumbers", ")", ":", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "result", "[", "vv", ",", "i", "]", "=", "np", ".", "max", "(", "values", "[", "vv", ",", "binnumbers", "==", "i", "]", ")", "elif", "callable", "(", "statistic", ")", ":", "with", "np", ".", "errstate", "(", "invalid", "=", "'ignore'", ")", ",", "suppress_warnings", "(", ")", "as", "sup", ":", "sup", ".", "filter", "(", "RuntimeWarning", ")", "try", ":", "null", "=", "statistic", "(", "[", "]", ")", "except", "Exception", ":", "null", "=", "np", ".", "nan", "result", ".", "fill", "(", "null", ")", "for", "i", "in", "np", ".", "unique", "(", "binnumbers", ")", ":", "for", "vv", "in", "xrange", "(", "Vdim", ")", ":", "result", "[", "vv", ",", "i", "]", "=", "statistic", "(", "values", "[", "vv", ",", "binnumbers", "==", "i", "]", ")", "# Shape into a proper matrix", "result", "=", "result", ".", "reshape", "(", "np", ".", "append", "(", "Vdim", ",", "nbin", ")", ")", "# Remove outliers (indices 0 and -1 for each bin-dimension).", "core", "=", "tuple", "(", "[", "slice", "(", "None", ")", "]", "+", "Ndim", "*", "[", "slice", "(", "1", ",", "-", "1", ")", "]", ")", "result", "=", "result", "[", "core", "]", "# Unravel binnumbers into an ndarray, each row the bins for each dimension", "if", "(", "expand_binnumbers", "and", "Ndim", ">", "1", ")", ":", "binnumbers", "=", "np", ".", "asarray", "(", "np", ".", "unravel_index", "(", "binnumbers", ",", "nbin", ")", ")", "if", "np", ".", "any", "(", "result", ".", "shape", "[", "1", ":", "]", "!=", "nbin", "-", "2", ")", ":", "raise", "RuntimeError", "(", "'Internal Shape Error'", ")", "# Reshape to have output (`reulst`) match input (`values`) shape", "result", "=", "result", ".", "reshape", "(", "input_shape", "[", ":", "-", "1", "]", "+", "list", "(", "nbin", "-", "2", ")", ")", "return", "BinnedStatisticddResult", "(", "result", ",", "edges", ",", "binnumbers", ")" ]

[ "Return", "dict", "where", "keys", "are", "lines", "in", "the", "line", "number", "table", "." ]

[ "def", "find_lines_from_code", "(", "code", ",", "strs", ")", ":", "linenos", "=", "{", "}", "for", "_", ",", "lineno", "in", "dis", ".", "findlinestarts", "(", "code", ")", ":", "if", "lineno", "not", "in", "strs", ":", "linenos", "[", "lineno", "]", "=", "1", "return", "linenos" ]

[ "Create", "a", "Defun", "decorator", "." ]

[ "def", "__init__", "(", "self", ",", "*", "input_types", ",", "*", "*", "kwargs", ")", ":", "self", ".", "_input_types", "=", "input_types", "self", ".", "_func_name", "=", "kwargs", ".", "pop", "(", "\"func_name\"", ",", "None", ")", "self", ".", "_grad_func", "=", "kwargs", ".", "pop", "(", "\"grad_func\"", ",", "None", ")", "self", ".", "_python_grad_func", "=", "kwargs", ".", "pop", "(", "\"python_grad_func\"", ",", "None", ")", "self", ".", "_extra_kwargs", "=", "kwargs" ]

[ "Scalar", "version", "of", "self", ".", "_binopt", "for", "cases", "in", "which", "no", "new", "nonzeros", "are", "added", ".", "Produces", "a", "new", "spmatrix", "in", "canonical", "form", "." ]

[ "def", "_scalar_binopt", "(", "self", ",", "other", ",", "op", ")", ":", "self", ".", "sum_duplicates", "(", ")", "res", "=", "self", ".", "_with_data", "(", "op", "(", "self", ".", "data", ",", "other", ")", ",", "copy", "=", "True", ")", "res", ".", "eliminate_zeros", "(", ")", "return", "res" ]

[ "Shard", "some", "targets", "apart", "to", "work", "around", "the", "linkers", "limits", "." ]

[ "def", "ShardTargets", "(", "target_list", ",", "target_dicts", ")", ":", "# Gather the targets to shard, and how many pieces.", "targets_to_shard", "=", "{", "}", "for", "t", "in", "target_dicts", ":", "shards", "=", "int", "(", "target_dicts", "[", "t", "]", ".", "get", "(", "'msvs_shard'", ",", "0", ")", ")", "if", "shards", ":", "targets_to_shard", "[", "t", "]", "=", "shards", "# Shard target_list.", "new_target_list", "=", "[", "]", "for", "t", "in", "target_list", ":", "if", "t", "in", "targets_to_shard", ":", "for", "i", "in", "range", "(", "targets_to_shard", "[", "t", "]", ")", ":", "new_target_list", ".", "append", "(", "_ShardName", "(", "t", ",", "i", ")", ")", "else", ":", "new_target_list", ".", "append", "(", "t", ")", "# Shard target_dict.", "new_target_dicts", "=", "{", "}", "for", "t", "in", "target_dicts", ":", "if", "t", "in", "targets_to_shard", ":", "for", "i", "in", "range", "(", "targets_to_shard", "[", "t", "]", ")", ":", "name", "=", "_ShardName", "(", "t", ",", "i", ")", "new_target_dicts", "[", "name", "]", "=", "copy", ".", "copy", "(", "target_dicts", "[", "t", "]", ")", "new_target_dicts", "[", "name", "]", "[", "'target_name'", "]", "=", "_ShardName", "(", "new_target_dicts", "[", "name", "]", "[", "'target_name'", "]", ",", "i", ")", "sources", "=", "new_target_dicts", "[", "name", "]", ".", "get", "(", "'sources'", ",", "[", "]", ")", "new_sources", "=", "[", "]", "for", "pos", "in", "range", "(", "i", ",", "len", "(", "sources", ")", ",", "targets_to_shard", "[", "t", "]", ")", ":", "new_sources", ".", "append", "(", "sources", "[", "pos", "]", ")", "new_target_dicts", "[", "name", "]", "[", "'sources'", "]", "=", "new_sources", "else", ":", "new_target_dicts", "[", "t", "]", "=", "target_dicts", "[", "t", "]", "# Shard dependencies.", "for", "t", "in", "new_target_dicts", ":", "for", "deptype", "in", "(", "'dependencies'", ",", "'dependencies_original'", ")", ":", "dependencies", "=", "copy", ".", "copy", "(", "new_target_dicts", "[", "t", "]", ".", "get", "(", "deptype", ",", "[", "]", ")", ")", "new_dependencies", "=", "[", "]", "for", "d", "in", "dependencies", ":", "if", "d", "in", "targets_to_shard", ":", "for", "i", "in", "range", "(", "targets_to_shard", "[", "d", "]", ")", ":", "new_dependencies", ".", "append", "(", "_ShardName", "(", "d", ",", "i", ")", ")", "else", ":", "new_dependencies", ".", "append", "(", "d", ")", "new_target_dicts", "[", "t", "]", "[", "deptype", "]", "=", "new_dependencies", "return", "(", "new_target_list", ",", "new_target_dicts", ")" ]

[ "Constructor", "." ]

[ "def", "__init__", "(", "self", ",", "name", ",", "package", ",", "options", "=", "None", ",", "serialized_pb", "=", "None", ",", "dependencies", "=", "None", ",", "public_dependencies", "=", "None", ",", "syntax", "=", "None", ",", "pool", "=", "None", ")", ":", "super", "(", "FileDescriptor", ",", "self", ")", ".", "__init__", "(", "options", ",", "'FileOptions'", ")", "if", "pool", "is", "None", ":", "from", "google", ".", "protobuf", "import", "descriptor_pool", "pool", "=", "descriptor_pool", ".", "Default", "(", ")", "self", ".", "pool", "=", "pool", "self", ".", "message_types_by_name", "=", "{", "}", "self", ".", "name", "=", "name", "self", ".", "package", "=", "package", "self", ".", "syntax", "=", "syntax", "or", "\"proto2\"", "self", ".", "serialized_pb", "=", "serialized_pb", "self", ".", "enum_types_by_name", "=", "{", "}", "self", ".", "extensions_by_name", "=", "{", "}", "self", ".", "services_by_name", "=", "{", "}", "self", ".", "dependencies", "=", "(", "dependencies", "or", "[", "]", ")", "self", ".", "public_dependencies", "=", "(", "public_dependencies", "or", "[", "]", ")", "if", "(", "api_implementation", ".", "Type", "(", ")", "==", "'cpp'", "and", "self", ".", "serialized_pb", "is", "not", "None", ")", ":", "_message", ".", "default_pool", ".", "AddSerializedFile", "(", "self", ".", "serialized_pb", ")" ]

[ "Returns", "a", "Review", "Board", "API", "URL", "given", "a", "review", "ID", "." ]

[ "def", "review_api_url", "(", "review_id", ")", ":", "# Reviewboard REST API expects '/' at the end of the URL.", "return", "'{base}/{review}/'", ".", "format", "(", "base", "=", "REVIEWBOARD_API_URL", ",", "review", "=", "review_id", ")" ]

[ "Rewrites", "a", "syntax", "error", "to", "please", "traceback", "systems", "." ]

[ "def", "translate_syntax_error", "(", "error", ",", "source", "=", "None", ")", ":", "error", ".", "source", "=", "source", "error", ".", "translated", "=", "True", "exc_info", "=", "(", "error", ".", "__class__", ",", "error", ",", "None", ")", "filename", "=", "error", ".", "filename", "if", "filename", "is", "None", ":", "filename", "=", "'<unknown>'", "return", "fake_exc_info", "(", "exc_info", ",", "filename", ",", "error", ".", "lineno", ")" ]

[ "Get", "a", "tree", "node", "at", "an", "absolute", "index", "i", ";", "0", "..", "n", "-", "1", ".", "If", "you", "don", "t", "want", "to", "buffer", "up", "nodes", "then", "this", "method", "makes", "no", "sense", "for", "you", "." ]

[ "def", "get", "(", "self", ",", "i", ")", ":", "raise", "NotImplementedError" ]

[ "main" ]

[ "def", "main", "(", "args", ")", ":", "# 定义一个检测器类", "detection", "=", "CaffeDetection", "(", "args", ".", "gpu_id", ",", "args", ".", "model_def", ",", "args", ".", "model_weights", ",", "args", ".", "image_resize", ",", "args", ".", "labelmap_file", ")", "# 检测并获取结果", "result", "=", "detection", ".", "detect", "(", "args", ".", "image_file", ")", "# 打印结果", "print", "result", "#结果显示", "img", "=", "Image", ".", "open", "(", "args", ".", "image_file", ")", "#打开图像", "draw", "=", "ImageDraw", ".", "Draw", "(", "img", ")", "#显示", "width", ",", "height", "=", "img", ".", "size", "#原来图像大小", "print", "width", ",", "height", "for", "item", "in", "result", ":", "# 获取坐标实际整数值", "xmin", "=", "int", "(", "round", "(", "item", "[", "0", "]", "*", "width", ")", ")", "ymin", "=", "int", "(", "round", "(", "item", "[", "1", "]", "*", "height", ")", ")", "xmax", "=", "int", "(", "round", "(", "item", "[", "2", "]", "*", "width", ")", ")", "ymax", "=", "int", "(", "round", "(", "item", "[", "3", "]", "*", "height", ")", ")", "draw", ".", "rectangle", "(", "[", "xmin", ",", "ymin", ",", "xmax", ",", "ymax", "]", ",", "outline", "=", "(", "255", ",", "0", ",", "0", ")", ")", "#红色框", "# [6] label_name [5] score ", "draw", ".", "text", "(", "[", "xmin", ",", "ymin", "]", ",", "item", "[", "-", "1", "]", "+", "str", "(", "item", "[", "-", "2", "]", ")", ",", "(", "0", ",", "0", ",", "255", ")", ")", "#显示文本标签 绿色", "print", "item", "print", "[", "xmin", ",", "ymin", ",", "xmax", ",", "ymax", "]", "print", "[", "xmin", ",", "ymin", "]", ",", "item", "[", "-", "1", "]", "img", ".", "save", "(", "'detect_result.jpg'", ")" ]

[ "Initialize", "a", "parse", "error", "at", "the", "given", "token", "with", "an", "optional", "message", "." ]

[ "def", "__init__", "(", "self", ",", "token", ",", "message", "=", "None", ")", ":", "Exception", ".", "__init__", "(", "self", ",", "message", ")", "self", ".", "token", "=", "token" ]

[ "Do", "constant", "folding", "." ]

[ "def", "fold", "(", "self", ",", "node", ")", ":", "node", "=", "self", ".", "generic_visit", "(", "node", ")", "try", ":", "return", "nodes", ".", "Const", ".", "from_untrusted", "(", "node", ".", "as_const", "(", ")", ",", "lineno", "=", "node", ".", "lineno", ",", "environment", "=", "self", ".", "environment", ")", "except", "nodes", ".", "Impossible", ":", "return", "node" ]

[ "GetIcon", "(", "self", ")", "-", ">", "Icon" ]

[ "def", "GetIcon", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_dataview", ".", "DataViewIconText_GetIcon", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Print", "the", "application", "description", "." ]

[ "def", "print_description", "(", "self", ")", ":", "print", "(", "'\\n'", ".", "join", "(", "self", ".", "emit_description", "(", ")", ")", ")" ]

[ "Unset", "the", "given", "string", "flag", "(", "s", ")", "without", "changing", "others", "." ]

[ "def", "remove_flag", "(", "self", ",", "flag", ")", ":", "if", "'Status'", "in", "self", "or", "'X-Status'", "in", "self", ":", "self", ".", "set_flags", "(", "''", ".", "join", "(", "set", "(", "self", ".", "get_flags", "(", ")", ")", "-", "set", "(", "flag", ")", ")", ")" ]

[ "Adds", "a", "_ArrayToList", "node", "in", "the", "func", "for", "op", ".", "outputs", "[", "start", ":", "limit", "]", "." ]

[ "def", "_add_output_list", "(", "op", ",", "start", ",", "limit", ",", "dtype_lst", ",", "func", ")", ":", "ret_name", "=", "op", ".", "name", "+", "\"_Lst_\"", "+", "str", "(", "start", ")", "+", "\"_\"", "+", "str", "(", "limit", ")", "num", "=", "limit", "-", "start", "assert", "len", "(", "dtype_lst", ")", "==", "num", "# Adds an identity node for each element in the array N*T so that", "# uses of each element can be added easily later. These Identity", "# will be eliminated before graph execution.", "for", "i", "in", "xrange", "(", "num", ")", ":", "node", "=", "function_pb2", ".", "FunctionDef", ".", "Node", "(", ")", "node", ".", "op", "=", "\"Identity\"", "node", ".", "arg", ".", "append", "(", "ret_name", "+", "\":\"", "+", "str", "(", "i", ")", ")", "node", ".", "ret", ".", "append", "(", "_make_argname_from_tensor_name", "(", "op", ".", "outputs", "[", "i", "]", ".", "name", ")", ")", "node", ".", "attr", "[", "\"T\"", "]", ".", "CopyFrom", "(", "attr_value_pb2", ".", "AttrValue", "(", "type", "=", "dtype_lst", "[", "i", "]", ")", ")", "func", ".", "node", ".", "extend", "(", "[", "node", "]", ")", "return", "ret_name" ]

[ "Generate", "the", "next", "value", "when", "not", "given", "." ]

[ "def", "_generate_next_value_", "(", "name", ",", "start", ",", "count", ",", "last_values", ")", ":", "if", "not", "count", ":", "return", "start", "if", "start", "is", "not", "None", "else", "1", "for", "last_value", "in", "reversed", "(", "last_values", ")", ":", "try", ":", "high_bit", "=", "_high_bit", "(", "last_value", ")", "break", "except", "Exception", ":", "raise", "TypeError", "(", "'Invalid Flag value: %r'", "%", "last_value", ")", "from", "None", "return", "2", "**", "(", "high_bit", "+", "1", ")" ]

[ "Create", "a", "tree", "of", "files", "for", "processing", "." ]

[ "def", "get_content", "(", "items", ",", "in_ext", ")", ":", "if", "not", "isinstance", "(", "items", ",", "list", ")", "or", "any", "(", "not", "isinstance", "(", "x", ",", "dict", ")", "for", "x", "in", "items", ")", ":", "LOG", ".", "error", "(", "'The supplied items must be a list of dict items, each with a \"root_dir\" and '", "'optionally a \"content\" entry.'", ")", "return", "None", "roots", "=", "set", "(", ")", "nodes", "=", "dict", "(", ")", "for", "root", ",", "filename", ",", "external", "in", "get_files", "(", "items", ",", "in_ext", ")", ":", "roots", ".", "add", "(", "root", ")", "key", "=", "filename", ".", "replace", "(", "root", ",", "''", ")", ".", "strip", "(", "'/'", ")", "parts", "=", "key", ".", "split", "(", "'/'", ")", "# Create directory nodes if they don't exist", "for", "i", "in", "range", "(", "1", ",", "len", "(", "parts", ")", ")", ":", "dir_key", "=", "os", ".", "path", ".", "join", "(", "*", "parts", "[", ":", "i", "]", ")", "if", "dir_key", "not", "in", "nodes", ":", "nodes", "[", "dir_key", "]", "=", "pages", ".", "Directory", "(", "dir_key", ",", "external", "=", "external", ",", "source", "=", "os", ".", "path", ".", "join", "(", "root", ",", "dir_key", ")", ")", "# Create the file node, if it doesn't already exist. This enforces that the first", "# item in the supplied content lists is the page that is rendered.", "if", "key", "not", "in", "nodes", ":", "nodes", "[", "key", "]", "=", "create_file_page", "(", "key", ",", "filename", ",", "in_ext", ")", "nodes", "[", "key", "]", ".", "external", "=", "external", "# Update the project files", "for", "root", "in", "roots", ":", "if", "mooseutils", ".", "git_is_repo", "(", "root", ")", ":", "MooseDocs", ".", "PROJECT_FILES", ".", "update", "(", "mooseutils", ".", "git_ls_files", "(", "mooseutils", ".", "git_root_dir", "(", "root", ")", ")", ")", "else", ":", "MooseDocs", ".", "PROJECT_FILES", ".", "update", "(", "mooseutils", ".", "list_files", "(", "root", ")", ")", "return", "list", "(", "nodes", ".", "values", "(", ")", ")" ]

[ "Register", "function", "prototypes", "with", "a", "libclang", "library", "instance", "." ]

[ "def", "register_functions", "(", "lib", ",", "ignore_errors", ")", ":", "def", "register", "(", "item", ")", ":", "return", "register_function", "(", "lib", ",", "item", ",", "ignore_errors", ")", "for", "f", "in", "functionList", ":", "register", "(", "f", ")" ]

[ "Pass", "the", "interface", "data", "to", "the", "scripter", "and", "reduce" ]

[ "def", "reduce", "(", "self", ")", ":", "try", ":", "self", ".", "scripter", ".", "update", "(", ")", "except", ":", "print", "(", "\"Error in the user interface\\n %s\"", "%", "str", "(", "traceback", ".", "format_exc", "(", ")", ")", ")", "self", ".", "scripter", ".", "push_state", "(", ")", "return", "# Save the last reduction for later", "try", ":", "red_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "ERROR_REPORT_DIR", ",", "self", ".", "LAST_REDUCTION_NAME", ")", "self", ".", "save_file", "(", "red_path", ")", "except", ":", "print", "(", "\"Could not save last reduction\\n %s\"", "%", "str", "(", "traceback", ".", "format_exc", "(", ")", ")", ")", "try", ":", "self", ".", "set_running", "(", "True", ")", "if", "self", ".", "live_button_is_checked", "(", ")", ":", "# Intercept and redirect if live data requested", "self", ".", "scripter", ".", "apply_live", "(", ")", "else", ":", "# Otherwise take the 'normal' path", "self", ".", "scripter", ".", "apply", "(", ")", "self", ".", "set_running", "(", "False", ")", "except", "RuntimeError", ":", "if", "self", ".", "_settings", ".", "debug", ":", "msg", "=", "\"Reduction could not be executed:\\n\\n%s\"", "%", "unicode", "(", "traceback", ".", "format_exc", "(", ")", ")", "else", ":", "msg", "=", "\"Reduction could not be executed:\\n\\n%s\"", "%", "sys", ".", "exc_info", "(", ")", "[", "1", "]", "log_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "ERROR_REPORT_DIR", ",", "self", ".", "ERROR_REPORT_NAME", ")", "msg", "+=", "\"\\n\\nWhen contacting the Mantid Team, please send this file:\\n%s\\n\"", "%", "log_path", "self", ".", "_warning", "(", "\"Reduction failed\"", ",", "msg", ")", "self", ".", "_error_report", "(", "traceback", ".", "format_exc", "(", ")", ")", "except", ":", "msg", "=", "\"Reduction could not be executed:\\n\\n%s\"", "%", "sys", ".", "exc_info", "(", ")", "[", "1", "]", "msg", "+=", "\"\\n\\nPlease check your reduction parameters\\n\"", "log_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "ERROR_REPORT_DIR", ",", "self", ".", "ERROR_REPORT_NAME", ")", "msg", "+=", "\"\\n\\nWhen contacting the Mantid Team, please send this file:\\n%s\\n\"", "%", "log_path", "self", ".", "_warning", "(", "\"Reduction failed\"", ",", "msg", ")", "self", ".", "_error_report", "(", "traceback", ".", "format_exc", "(", ")", ")", "# Update widgets", "self", ".", "scripter", ".", "push_state", "(", ")" ]

[ "Run", "ops", "using", "a", "step", "function", "." ]

[ "def", "run_step_fn", "(", "self", ",", "step_fn", ")", ":", "step_fn_arguments", "=", "util", ".", "fn_args", "(", "step_fn", ")", "if", "step_fn_arguments", "!=", "(", "'step_context'", ",", ")", "and", "step_fn_arguments", "!=", "(", "'self'", ",", "'step_context'", ",", ")", ":", "raise", "ValueError", "(", "'`step_fn` may either have one `step_context` argument, or'", "' `self` and `step_context` arguments if it\\'s an instance'", "' method. Got {} instead.'", ".", "format", "(", "step_fn_arguments", ")", ")", "try", ":", "return", "step_fn", "(", "_MonitoredSession", ".", "StepContext", "(", "self", ".", "_tf_sess", "(", ")", ",", "self", ".", "run", ")", ")", "except", "StopIteration", ":", "self", ".", "_stop_requested_in_step_fn", "=", "True", "raise" ]

[ "Serialize", "this", "manifest", "to", "a", "file", "or", "file", "object", "." ]

[ "def", "write", "(", "self", ",", "path", "=", "None", ",", "fileobj", "=", "None", ")", ":", "with", "_auto_fileobj", "(", "path", ",", "fileobj", ",", "'wb'", ")", "as", "fh", ":", "fh", ".", "write", "(", "'%d\\n'", "%", "self", ".", "CURRENT_VERSION", ")", "for", "dest", "in", "sorted", "(", "self", ".", "_dests", ")", ":", "entry", "=", "self", ".", "_dests", "[", "dest", "]", "parts", "=", "[", "'%d'", "%", "entry", "[", "0", "]", ",", "dest", "]", "parts", ".", "extend", "(", "entry", "[", "1", ":", "]", ")", "fh", ".", "write", "(", "'%s\\n'", "%", "self", ".", "FIELD_SEPARATOR", ".", "join", "(", "p", ".", "encode", "(", "'utf-8'", ")", "for", "p", "in", "parts", ")", ")" ]

[ "Set", "the", "input", "channel", "order", "for", "e", ".", "g", ".", "RGB", "to", "BGR", "conversion", "as", "needed", "for", "the", "reference", "ImageNet", "model", "." ]

[ "def", "set_transpose", "(", "self", ",", "in_", ",", "order", ")", ":", "self", ".", "__check_input", "(", "in_", ")", "if", "len", "(", "order", ")", "!=", "len", "(", "self", ".", "inputs", "[", "in_", "]", ")", "-", "1", ":", "raise", "Exception", "(", "'Transpose order needs to have the same number of '", "'dimensions as the input.'", ")", "self", ".", "transpose", "[", "in_", "]", "=", "order" ]

[ "Create", "the", "HasDescriptors", "class", "." ]

[ "def", "__new__", "(", "mcls", ",", "name", ",", "bases", ",", "classdict", ")", ":", "for", "k", ",", "v", "in", "classdict", ".", "items", "(", ")", ":", "# ----------------------------------------------------------------", "# Support of deprecated behavior allowing for TraitType types", "# to be used instead of TraitType instances.", "if", "inspect", ".", "isclass", "(", "v", ")", "and", "issubclass", "(", "v", ",", "TraitType", ")", ":", "warn", "(", "\"Traits should be given as instances, not types (for example, `Int()`, not `Int`).\"", "\" Passing types is deprecated in traitlets 4.1.\"", ",", "DeprecationWarning", ",", "stacklevel", "=", "2", ")", "classdict", "[", "k", "]", "=", "v", "(", ")", "# ----------------------------------------------------------------", "return", "super", "(", "MetaHasDescriptors", ",", "mcls", ")", ".", "__new__", "(", "mcls", ",", "name", ",", "bases", ",", "classdict", ")" ]

[ "Given", "a", "Klamp", "t", "rotation", "representation", "produces", "the", "corresponding", "unit", "quaternion", "(", "w", "x", "y", "z", ")", "." ]

[ "def", "quaternion", "(", "R", ")", ":", "tr", "=", "trace", "(", "R", ")", "+", "1.0", "a11", ",", "a21", ",", "a31", ",", "a12", ",", "a22", ",", "a32", ",", "a13", ",", "a23", ",", "a33", "=", "R", "#If the trace is nonzero, it's a nondegenerate rotation", "if", "tr", ">", "1e-5", ":", "s", "=", "math", ".", "sqrt", "(", "tr", ")", "w", "=", "s", "*", "0.5", "s", "=", "0.5", "/", "s", "x", "=", "(", "a32", "-", "a23", ")", "*", "s", "y", "=", "(", "a13", "-", "a31", ")", "*", "s", "z", "=", "(", "a21", "-", "a12", ")", "*", "s", "return", "vectorops", ".", "unit", "(", "(", "w", ",", "x", ",", "y", ",", "z", ")", ")", "else", ":", "#degenerate it's a rotation of 180 degrees", "nxt", "=", "[", "1", ",", "2", ",", "0", "]", "#check for largest diagonal entry", "i", "=", "0", "if", "a22", ">", "a11", ":", "i", "=", "1", "if", "a33", ">", "max", "(", "a11", ",", "a22", ")", ":", "i", "=", "2", "j", "=", "nxt", "[", "i", "]", "k", "=", "nxt", "[", "j", "]", "M", "=", "matrix", "(", "R", ")", "q", "=", "[", "0.0", "]", "*", "4", "s", "=", "math", ".", "sqrt", "(", "(", "M", "[", "i", "]", "[", "i", "]", "-", "(", "M", "[", "j", "]", "[", "j", "]", "+", "M", "[", "k", "]", "[", "k", "]", ")", ")", "+", "1.0", ")", "q", "[", "i", "]", "=", "s", "*", "0.5", "if", "abs", "(", "s", ")", "<", "1e-7", ":", "raise", "ValueError", "(", "\"Could not solve for quaternion... Invalid rotation matrix?\"", ")", "else", ":", "s", "=", "0.5", "/", "s", "q", "[", "3", "]", "=", "(", "M", "[", "k", "]", "[", "j", "]", "-", "M", "[", "j", "]", "[", "k", "]", ")", "*", "s", "q", "[", "j", "]", "=", "(", "M", "[", "i", "]", "[", "j", "]", "+", "M", "[", "j", "]", "[", "i", "]", ")", "*", "s", "q", "[", "k", "]", "=", "(", "M", "[", "i", "]", "[", "k", "]", "+", "M", "[", "i", "]", "[", "k", "]", ")", "*", "s", "w", ",", "x", ",", "y", ",", "z", "=", "q", "[", "3", "]", ",", "q", "[", "0", "]", ",", "q", "[", "1", "]", ",", "q", "[", "2", "]", "return", "vectorops", ".", "unit", "(", "[", "w", ",", "x", ",", "y", ",", "z", "]", ")" ]

[ "Print", "information", "about", "the", "annotation", "file", ".", ":", "return", ":" ]

[ "def", "info", "(", "self", ")", ":", "for", "key", ",", "value", "in", "self", ".", "dataset", "[", "'info'", "]", ".", "items", "(", ")", ":", "print", "(", "'{}: {}'", ".", "format", "(", "key", ",", "value", ")", ")" ]

[ "Triggered", "when", "a", "drop", "event", "is", "received", "in", "the", "list", "widget", ".", "Here", "name", "is", "assumed", "to", "be", "a", "workspace", "name", "." ]

[ "def", "on_drop", "(", "self", ",", "name", ")", ":", "selection", "=", "self", ".", "_view", ".", "get_selection", "(", ")", "self", ".", "_model", ".", "add_workspace", "(", "name", ")", "self", ".", "_update_list", "(", ")", "self", ".", "_view", ".", "set_selection", "(", "selection", ")", "self", ".", "_update_plot", "(", ")" ]

[ "Creates", "a", "DatasetDataProvider", "." ]

[ "def", "__init__", "(", "self", ",", "dataset", ",", "num_readers", "=", "1", ",", "reader_kwargs", "=", "None", ",", "shuffle", "=", "True", ",", "num_epochs", "=", "None", ",", "common_queue_capacity", "=", "256", ",", "common_queue_min", "=", "128", ",", "record_key", "=", "'record_key'", ",", "seed", "=", "None", ",", "scope", "=", "None", ")", ":", "key", ",", "data", "=", "parallel_reader", ".", "parallel_read", "(", "dataset", ".", "data_sources", ",", "reader_class", "=", "dataset", ".", "reader", ",", "num_epochs", "=", "num_epochs", ",", "num_readers", "=", "num_readers", ",", "reader_kwargs", "=", "reader_kwargs", ",", "shuffle", "=", "shuffle", ",", "capacity", "=", "common_queue_capacity", ",", "min_after_dequeue", "=", "common_queue_min", ",", "seed", "=", "seed", ",", "scope", "=", "scope", ")", "items", "=", "dataset", ".", "decoder", ".", "list_items", "(", ")", "tensors", "=", "dataset", ".", "decoder", ".", "decode", "(", "data", ",", "items", ")", "if", "record_key", "in", "items", ":", "raise", "ValueError", "(", "'The item name used for `record_key` cannot also be '", "'used for a dataset item: %s'", ",", "record_key", ")", "items", ".", "append", "(", "record_key", ")", "tensors", ".", "append", "(", "key", ")", "super", "(", "DatasetDataProvider", ",", "self", ")", ".", "__init__", "(", "items_to_tensors", "=", "dict", "(", "zip", "(", "items", ",", "tensors", ")", ")", ",", "num_samples", "=", "dataset", ".", "num_samples", ")" ]

[ "Change", "the", "behavior", "of", "the", "validation", "code", "allowing", "control", "to", "have", "a", "value", "of", "None", "or", "not", "as", "appropriate", ".", "If", "the", "value", "of", "the", "control", "is", "currently", "None", "and", "allow_none", "is", "False", "the", "value", "of", "the", "control", "will", "be", "set", "to", "the", "minimum", "value", "of", "the", "control", "or", "0", "if", "no", "lower", "bound", "is", "set", "." ]

[ "def", "SetAllowNone", "(", "self", ",", "allow_none", ")", ":", "self", ".", "_allowNone", "=", "allow_none", "if", "not", "allow_none", "and", "self", ".", "GetValue", "(", ")", "is", "None", ":", "min", "=", "self", ".", "GetMin", "(", ")", "if", "min", "is", "not", "None", ":", "self", ".", "SetValue", "(", "min", ")", "else", ":", "self", ".", "SetValue", "(", "0", ")" ]

[ "This", "function", "checks", "if", "an", "attribute", "on", "a", "builtin", "mutable", "object", "(", "list", "dict", "set", "or", "deque", ")", "would", "modify", "it", "if", "called", ".", "It", "also", "supports", "the", "user", "-", "versions", "of", "the", "objects", "(", "sets", ".", "Set", "UserDict", ".", "*", "etc", ".", ")", "and", "with", "Python", "2", ".", "6", "onwards", "the", "abstract", "base", "classes", "MutableSet", "MutableMapping", "and", "MutableSequence", "." ]

[ "def", "modifies_known_mutable", "(", "obj", ",", "attr", ")", ":", "for", "typespec", ",", "unsafe", "in", "_mutable_spec", ":", "if", "isinstance", "(", "obj", ",", "typespec", ")", ":", "return", "attr", "in", "unsafe", "return", "False" ]

[ "Creates", "a", "enum", "value", "descriptor", "object", "from", "a", "enum", "value", "proto", "." ]

[ "def", "_MakeEnumValueDescriptor", "(", "self", ",", "value_proto", ",", "index", ")", ":", "return", "descriptor", ".", "EnumValueDescriptor", "(", "name", "=", "value_proto", ".", "name", ",", "index", "=", "index", ",", "number", "=", "value_proto", ".", "number", ",", "options", "=", "value_proto", ".", "options", ",", "type", "=", "None", ")" ]

[ "A", "recursive", "update", "-", "useful", "for", "merging", "config", "files", ".", ">>>", "a", "=", "[", "section1", "]", "...", "option1", "=", "True", "...", "[[", "subsection", "]]", "...", "more_options", "=", "False", "...", "#", "end", "of", "file", ".", "splitlines", "()", ">>>", "b", "=", "#", "File", "is", "user", ".", "ini", "...", "[", "section1", "]", "...", "option1", "=", "False", "...", "#", "end", "of", "file", ".", "splitlines", "()", ">>>", "c1", "=", "ConfigObj", "(", "b", ")", ">>>", "c2", "=", "ConfigObj", "(", "a", ")", ">>>", "c2", ".", "merge", "(", "c1", ")", ">>>", "c2", "{", "section1", ":", "{", "option1", ":", "False", "subsection", ":", "{", "more_options", ":", "False", "}}}" ]

[ "def", "merge", "(", "self", ",", "indict", ")", ":", "for", "key", ",", "val", "in", "indict", ".", "items", "(", ")", ":", "if", "(", "key", "in", "self", "and", "isinstance", "(", "self", "[", "key", "]", ",", "dict", ")", "and", "isinstance", "(", "val", ",", "dict", ")", ")", ":", "self", "[", "key", "]", ".", "merge", "(", "val", ")", "else", ":", "self", "[", "key", "]", "=", "val" ]

[ "Run", "evaluation", "on", "cpu", "." ]

[ "def", "evaluate", "(", "mod", ",", "data_iter", ",", "epoch", ",", "log_interval", ")", ":", "start", "=", "time", ".", "time", "(", ")", "total_L", "=", "0.0", "nbatch", "=", "0", "density", "=", "0", "mod", ".", "set_states", "(", "value", "=", "0", ")", "for", "batch", "in", "data_iter", ":", "mod", ".", "forward", "(", "batch", ",", "is_train", "=", "False", ")", "outputs", "=", "mod", ".", "get_outputs", "(", "merge_multi_context", "=", "False", ")", "states", "=", "outputs", "[", ":", "-", "1", "]", "total_L", "+=", "outputs", "[", "-", "1", "]", "[", "0", "]", "mod", ".", "set_states", "(", "states", "=", "states", ")", "nbatch", "+=", "1", "# don't include padding data in the test perplexity", "density", "+=", "batch", ".", "data", "[", "1", "]", ".", "mean", "(", ")", "if", "(", "nbatch", "+", "1", ")", "%", "log_interval", "==", "0", ":", "logging", ".", "info", "(", "\"Eval batch %d loss : %.7f\"", "%", "(", "nbatch", ",", "(", "total_L", "/", "density", ")", ".", "asscalar", "(", ")", ")", ")", "data_iter", ".", "reset", "(", ")", "loss", "=", "(", "total_L", "/", "density", ")", ".", "asscalar", "(", ")", "ppl", "=", "math", ".", "exp", "(", "loss", ")", "if", "loss", "<", "100", "else", "1e37", "end", "=", "time", ".", "time", "(", ")", "logging", ".", "info", "(", "'Iter[%d]\\t\\t CE loss %.7f, ppl %.7f. Eval duration = %.2f seconds '", "%", "(", "epoch", ",", "loss", ",", "ppl", ",", "end", "-", "start", ")", ")", "return", "loss" ]

[ "Read", "data", "from", "child", "workers", "and", "yield", "batches", "of", "raw", "tensors" ]

[ "def", "parse", "(", "self", ")", ":", "gen", "=", "self", ".", "v2_gen", "(", ")", "# read from workers", "gen", "=", "self", ".", "tuple_gen", "(", "gen", ")", "# convert v2->tuple", "gen", "=", "self", ".", "batch_gen", "(", "gen", ")", "# assemble into batches", "for", "b", "in", "gen", ":", "yield", "b" ]

[ "Checks", "whether", "all", "Comparators", "are", "equal", "to", "rhs", "." ]

[ "def", "equals", "(", "self", ",", "rhs", ")", ":", "for", "comparator", "in", "self", ".", "_comparators", ":", "if", "not", "comparator", ".", "equals", "(", "rhs", ")", ":", "return", "False", "return", "True" ]

[ "Render", "text", "documentation", "given", "an", "object", "or", "a", "path", "to", "an", "object", "." ]

[ "def", "render_doc", "(", "thing", ",", "title", "=", "'Python Library Documentation: %s'", ",", "forceload", "=", "0", ",", "renderer", "=", "None", ")", ":", "if", "renderer", "is", "None", ":", "renderer", "=", "text", "object", ",", "name", "=", "resolve", "(", "thing", ",", "forceload", ")", "desc", "=", "describe", "(", "object", ")", "module", "=", "inspect", ".", "getmodule", "(", "object", ")", "if", "name", "and", "'.'", "in", "name", ":", "desc", "+=", "' in '", "+", "name", "[", ":", "name", ".", "rfind", "(", "'.'", ")", "]", "elif", "module", "and", "module", "is", "not", "object", ":", "desc", "+=", "' in module '", "+", "module", ".", "__name__", "if", "not", "(", "inspect", ".", "ismodule", "(", "object", ")", "or", "inspect", ".", "isclass", "(", "object", ")", "or", "inspect", ".", "isroutine", "(", "object", ")", "or", "inspect", ".", "isgetsetdescriptor", "(", "object", ")", "or", "inspect", ".", "ismemberdescriptor", "(", "object", ")", "or", "isinstance", "(", "object", ",", "property", ")", ")", ":", "# If the passed object is a piece of data or an instance,", "# document its available methods instead of its value.", "object", "=", "type", "(", "object", ")", "desc", "+=", "' object'", "return", "title", "%", "desc", "+", "'\\n\\n'", "+", "renderer", ".", "document", "(", "object", ",", "name", ")" ]

[ "Evaluate", "a", "3", "-", "D", "Laguerre", "series", "on", "the", "Cartesian", "product", "of", "x", "y", "and", "z", "." ]

[ "def", "laggrid3d", "(", "x", ",", "y", ",", "z", ",", "c", ")", ":", "c", "=", "lagval", "(", "x", ",", "c", ")", "c", "=", "lagval", "(", "y", ",", "c", ")", "c", "=", "lagval", "(", "z", ",", "c", ")", "return", "c" ]

[ "Displays", "a", "table", "containing", "data", "from", "items", "formatted", "as", "defined", "by", "specs", "." ]

[ "def", "__output_table", "(", "self", ",", "items", ",", "specs", ",", "sort_column_count", "=", "1", ",", "indent", "=", "False", ",", "first_sort_column", "=", "0", ")", ":", "def", "default_formatter", "(", "v", ")", ":", "return", "str", "(", "v", ")", "if", "v", "is", "not", "None", "else", "''", "def", "get_formatted_value", "(", "item", ",", "spec", ")", ":", "field", "=", "spec", "[", "'Field'", "]", "formatter", "=", "spec", ".", "get", "(", "'Formatter'", ",", "default_formatter", ")", "default", "=", "spec", ".", "get", "(", "'Default'", ",", "None", ")", "return", "formatter", "(", "item", ".", "get", "(", "field", ",", "default", ")", ")", "# For simplicity we generate the formatted value multiple times. If this", "# ends up being used to display large tables this may need to be changed.", "# We sort working up to the first column and python guarantees that a", "# stable sort is used, so things work out how we want.", "for", "sort_column", "in", "range", "(", "(", "sort_column_count", "+", "first_sort_column", ")", "-", "1", ",", "first_sort_column", "-", "1", ",", "-", "1", ")", ":", "items", "=", "sorted", "(", "items", ",", "key", "=", "lambda", "item", ":", "get_formatted_value", "(", "item", ",", "specs", "[", "sort_column", "]", ")", ")", "# determine width of each column", "lengths", "=", "{", "}", "for", "item", "in", "items", ":", "for", "spec", "in", "specs", ":", "field", "=", "spec", "[", "'Field'", "]", "lengths", "[", "field", "]", "=", "max", "(", "lengths", ".", "get", "(", "field", ",", "0", ")", ",", "len", "(", "get_formatted_value", "(", "item", ",", "spec", ")", ")", ")", "def", "is_hidden", "(", "spec", ")", ":", "return", "spec", ".", "get", "(", "'Hidden'", ",", "False", ")", "or", "(", "spec", ".", "get", "(", "'HideWhenEmpty'", ",", "False", ")", "and", "lengths", ".", "get", "(", "spec", "[", "'Field'", "]", ",", "0", ")", "==", "0", ")", "specs", "=", "[", "spec", "for", "spec", "in", "specs", "if", "not", "is_hidden", "(", "spec", ")", "]", "for", "spec", "in", "specs", ":", "field", "=", "spec", "[", "'Field'", "]", "lengths", "[", "field", "]", "=", "max", "(", "lengths", ".", "get", "(", "field", ",", "0", ")", ",", "len", "(", "spec", "[", "'Heading'", "]", ")", ")", "# determine the prefix for each line", "if", "indent", ":", "prefix", "=", "' '", "else", ":", "prefix", "=", "''", "# show the headings", "heading", "=", "'\\n'", "heading", "+=", "prefix", "for", "spec", "in", "specs", ":", "heading", "+=", "'{0:{1}} '", ".", "format", "(", "spec", "[", "'Heading'", "]", ",", "lengths", "[", "spec", "[", "'Field'", "]", "]", ")", "self", ".", "_output_message", "(", "heading", ")", "# show a dividing line under the headings", "divider", "=", "prefix", "for", "spec", "in", "specs", ":", "divider", "+=", "(", "'-'", "*", "lengths", "[", "spec", "[", "'Field'", "]", "]", ")", "+", "' '", "self", ".", "_output_message", "(", "divider", ")", "# show the items", "for", "item", "in", "items", ":", "line", "=", "prefix", "for", "spec", "in", "specs", ":", "formatted_value", "=", "get_formatted_value", "(", "item", ",", "spec", ")", "line", "+=", "'{0:{1}} '", ".", "format", "(", "formatted_value", ",", "lengths", "[", "spec", "[", "'Field'", "]", "]", ")", "self", ".", "_output_message", "(", "line", ")" ]

[ "get", "extra", "setting", "for", "a", "label", "by", "name" ]

[ "def", "get_extra_bylabel", "(", "label", ",", "name", ",", "default", "=", "None", ")", ":", "p", "=", "bylabel", ".", "get", "(", "label", ")", "if", "p", "is", "None", ":", "return", "default", "return", "p", ".", "extra_value", "(", "name", ",", "type", "=", "str", ",", "default", "=", "default", ")" ]

[ "Returns", "dict", "of", "{", "metric", "-", ">", "count", "}", "where", "|count|", "is", "sum", "(", "metric", ")", "." ]

[ "def", "GetTotalCounts", "(", "self", ")", ":", "ret", "=", "{", "}", "for", "metric", "in", "(", "'fields'", ",", "'methods'", ",", "'strings'", ",", "'types'", ")", ":", "ret", "[", "metric", "]", "=", "sum", "(", "x", "[", "metric", "]", "for", "x", "in", "self", ".", "_counts_by_label", ".", "values", "(", ")", ")", "return", "ret" ]

[ "Returns", "number", "of", "tracks", "containing", "this", "hit", "." ]

[ "def", "ntracks", "(", "self", ")", ":", "self", ".", "_checkIsValid", "(", ")", "return", "getattr", "(", "self", ".", "_tree", ",", "self", ".", "_prefix", "+", "\"_trkIdx\"", ")", "[", "self", ".", "_index", "]", ".", "size", "(", ")" ]

[ "Return", "a", "file", "handle", "of", "the", "base64", "-", "decoded", "sample", "in", "a", "zip", "file", "." ]

[ "def", "zfh", "(", "self", ")", ":", "if", "self", ".", "get", "(", "m", ".", "SAMPLE", ")", "is", "None", ":", "self", ".", "details", "(", ")", "zfh", "=", "io", ".", "BytesIO", "(", ")", "zfh", ".", "write", "(", "base64", ".", "b64decode", "(", "self", ".", "get", "(", "m", ".", "SAMPLE", ")", ")", ")", "zfh", ".", "seek", "(", "0", ")", "return", "zfh" ]

[ "Train", "a", "model", "." ]

[ "def", "train", "(", "graph", ",", "output_dir", ",", "train_op", ",", "loss_op", ",", "global_step_tensor", "=", "None", ",", "init_op", "=", "None", ",", "init_feed_dict", "=", "None", ",", "init_fn", "=", "None", ",", "log_every_steps", "=", "10", ",", "supervisor_is_chief", "=", "True", ",", "supervisor_master", "=", "''", ",", "supervisor_save_model_secs", "=", "600", ",", "keep_checkpoint_max", "=", "5", ",", "supervisor_save_summaries_steps", "=", "100", ",", "feed_fn", "=", "None", ",", "steps", "=", "None", ",", "fail_on_nan_loss", "=", "True", ",", "monitors", "=", "None", ",", "max_steps", "=", "None", ")", ":", "while", "True", ":", "try", ":", "return", "_train_internal", "(", "graph", ",", "output_dir", ",", "train_op", ",", "loss_op", ",", "global_step_tensor", ",", "init_op", ",", "init_feed_dict", ",", "init_fn", ",", "log_every_steps", ",", "supervisor_is_chief", ",", "supervisor_master", ",", "supervisor_save_model_secs", ",", "keep_checkpoint_max", ",", "supervisor_save_summaries_steps", ",", "feed_fn", ",", "steps", ",", "fail_on_nan_loss", ",", "monitors", ",", "max_steps", ")", "except", "errors", ".", "AbortedError", ":", "# Happens when PS restarts, keep training.", "logging", ".", "warning", "(", "'Training got Aborted error. Keep training.'", ")" ]

[ "Given", "a", "list", "of", "filenames", "return", "them", "in", "descending", "order", "by", "version", "number", "." ]

[ "def", "_by_version_descending", "(", "names", ")", ":", "def", "_by_version", "(", "name", ")", ":", "\"\"\"\n Parse each component of the filename\n \"\"\"", "name", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "name", ")", "parts", "=", "itertools", ".", "chain", "(", "name", ".", "split", "(", "'-'", ")", ",", "[", "ext", "]", ")", "return", "[", "packaging", ".", "version", ".", "parse", "(", "part", ")", "for", "part", "in", "parts", "]", "return", "sorted", "(", "names", ",", "key", "=", "_by_version", ",", "reverse", "=", "True", ")" ]

[ "Ask", "for", "a", "color" ]

[ "def", "askcolor", "(", "color", "=", "None", ",", "*", "*", "options", ")", ":", "global", "_chooser", "if", "not", "_chooser", ":", "_chooser", "=", "apply", "(", "Chooser", ",", "(", ")", ",", "options", ")", "return", "_chooser", ".", "show", "(", "color", ",", "options", ")" ]

[ "If", "Failed", "is", "true", "returns", "a", "human", "-", "readable", "description", "of", "the", "error", "." ]

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

[ "exo", ".", "put_node_set_dist_fact", "(", "node_set_id", "ns_dist_facts", ")" ]

[ "def", "put_node_set_dist_fact", "(", "self", ",", "id", ",", "nodeSetDistFact", ")", ":", "self", ".", "__ex_put_node_set_dist_fact", "(", "id", ",", "nodeSetDistFact", ")" ]

[ "Calls", "the", "given", "function", "for", "every", "token", "in", "the", "given", "token", "stream", "." ]

[ "def", "_ExecutePass", "(", "self", ",", "token", ",", "pass_function", ",", "parse_error", "=", "None", ",", "debug_tokens", "=", "False", ")", ":", "self", ".", "_state_tracker", ".", "Reset", "(", ")", "while", "token", ":", "if", "debug_tokens", ":", "print", "token", "if", "parse_error", "and", "parse_error", ".", "token", "==", "token", ":", "message", "=", "(", "'Error parsing file at token \"%s\". Unable to '", "'check the rest of file.'", "%", "token", ".", "string", ")", "self", ".", "HandleError", "(", "errors", ".", "FILE_DOES_NOT_PARSE", ",", "message", ",", "token", ")", "self", ".", "_error_handler", ".", "FinishFile", "(", ")", "return", "try", ":", "self", ".", "_state_tracker", ".", "HandleToken", "(", "token", ",", "self", ".", "_state_tracker", ".", "GetLastNonSpaceToken", "(", ")", ")", "pass_function", "(", "token", ")", "self", ".", "_state_tracker", ".", "HandleAfterToken", "(", "token", ")", "except", ":", "if", "FLAGS", ".", "error_trace", ":", "raise", "else", ":", "self", ".", "HandleError", "(", "errors", ".", "FILE_DOES_NOT_PARSE", ",", "(", "'Error parsing file at token \"%s\". Unable to '", "'check the rest of file.'", "%", "token", ".", "string", ")", ",", "token", ")", "self", ".", "_error_handler", ".", "FinishFile", "(", ")", "return", "False", "token", "=", "token", ".", "next", "return", "True" ]

[ "Arguments", ":", "proposal_matcher", "(", "Matcher", ")", "fg_bg_sampler", "(", "BalancedPositiveNegativeSampler", ")", "box_coder", "(", "BoxCoder", ")" ]

[ "def", "__init__", "(", "self", ",", "proposal_matcher", ",", "fg_bg_sampler", ",", "box_coder", ")", ":", "self", ".", "proposal_matcher", "=", "proposal_matcher", "self", ".", "fg_bg_sampler", "=", "fg_bg_sampler", "self", ".", "box_coder", "=", "box_coder" ]

[ "Helper", "method", "for", ":", "func", ":", "exhale", ".", "ExhaleRoot", ".", "reparentAll", ".", "Iterates", "over", "the", "self", ".", "class_like", "list", "and", "adds", "each", "object", "as", "a", "child", "to", "a", "namespace", "if", "the", "class", "or", "struct", "is", "a", "member", "of", "that", "namespace", ".", "Many", "classes", "/", "structs", "will", "be", "reparented", "to", "a", "namespace", "node", "these", "will", "remain", "in", "self", ".", "class_like", ".", "However", "if", "a", "class", "or", "struct", "is", "reparented", "to", "a", "different", "class", "or", "struct", "(", "it", "is", "a", "nested", "class", "/", "struct", ")", "it", "*", "will", "*", "be", "removed", "from", "so", "that", "the", "class", "view", "hierarchy", "is", "generated", "correctly", "." ]

[ "def", "reparentClassLike", "(", "self", ")", ":", "removals", "=", "[", "]", "for", "cl", "in", "self", ".", "class_like", ":", "parts", "=", "cl", ".", "name", ".", "split", "(", "\"::\"", ")", "if", "len", "(", "parts", ")", ">", "1", ":", "# first try and reparent to namespaces", "namespace_name", "=", "\"::\"", ".", "join", "(", "parts", "[", ":", "-", "1", "]", ")", "parent_found", "=", "False", "for", "n", "in", "self", ".", "namespaces", ":", "if", "n", ".", "name", "==", "namespace_name", ":", "n", ".", "children", ".", "append", "(", "cl", ")", "cl", ".", "parent", "=", "n", "parent_found", "=", "True", "break", "# if a namespace parent wasn not found, try and reparent to a class", "if", "not", "parent_found", ":", "# parent class name would be namespace_name", "for", "p_cls", "in", "self", ".", "class_like", ":", "if", "p_cls", ".", "name", "==", "namespace_name", ":", "p_cls", ".", "children", ".", "append", "(", "cl", ")", "cl", ".", "parent", "=", "p_cls", "removals", ".", "append", "(", "cl", ")", "break", "for", "rm", "in", "removals", ":", "if", "rm", "in", "self", ".", "class_like", ":", "self", ".", "class_like", ".", "remove", "(", "rm", ")" ]

[ "Outputs", "a", "file", "to", "standard", "out", "with", "the", "globe", "name", "replaced", "." ]

[ "def", "OutputFile", "(", "file_name", ",", "replace_params", ")", ":", "fp", "=", "open", "(", "file_name", ")", "text", "=", "fp", ".", "read", "(", ")", "fp", ".", "close", "(", ")", "print", "ReplaceParams", "(", "text", ",", "replace_params", ")" ]

[ "AppendCols", "(", "self", "size_t", "numCols", "=", "1", ")", "-", ">", "bool" ]

[ "def", "AppendCols", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_grid", ".", "GridTableBase_AppendCols", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Searches", "the", "string", "for", "the", "pattern", "caching", "the", "compiled", "regexp", "." ]

[ "def", "Search", "(", "pattern", ",", "s", ")", ":", "if", "pattern", "not", "in", "_regexp_compile_cache", ":", "_regexp_compile_cache", "[", "pattern", "]", "=", "sre_compile", ".", "compile", "(", "pattern", ")", "return", "_regexp_compile_cache", "[", "pattern", "]", ".", "search", "(", "s", ")" ]

[ "a", "**", "b" ]

[ "def", "power", "(", "a", ",", "b", ",", "third", "=", "None", ")", ":", "if", "third", "is", "not", "None", ":", "raise", "MAError", "(", "\"3-argument power not supported.\"", ")", "ma", "=", "getmask", "(", "a", ")", "mb", "=", "getmask", "(", "b", ")", "m", "=", "mask_or", "(", "ma", ",", "mb", ")", "fa", "=", "filled", "(", "a", ",", "1", ")", "fb", "=", "filled", "(", "b", ",", "1", ")", "if", "fb", ".", "dtype", ".", "char", "in", "typecodes", "[", "\"Integer\"", "]", ":", "return", "masked_array", "(", "umath", ".", "power", "(", "fa", ",", "fb", ")", ",", "m", ")", "md", "=", "make_mask", "(", "umath", ".", "less", "(", "fa", ",", "0", ")", ",", "flag", "=", "1", ")", "m", "=", "mask_or", "(", "m", ",", "md", ")", "if", "m", "is", "nomask", ":", "return", "masked_array", "(", "umath", ".", "power", "(", "fa", ",", "fb", ")", ")", "else", ":", "fa", "=", "numeric", ".", "where", "(", "m", ",", "1", ",", "fa", ")", "return", "masked_array", "(", "umath", ".", "power", "(", "fa", ",", "fb", ")", ",", "m", ")" ]

[ "Saves", "a", "model", "as", "a", "TensorFlow", "SavedModel", "or", "HDF5", "file", "." ]

[ "def", "save_model", "(", "model", ",", "filepath", ",", "overwrite", "=", "True", ",", "include_optimizer", "=", "True", ",", "save_format", "=", "None", ",", "signatures", "=", "None", ",", "options", "=", "None", ",", "save_traces", "=", "True", ")", ":", "# pylint: disable=line-too-long", "# pylint: enable=line-too-long", "from", "tensorflow", ".", "python", ".", "keras", ".", "engine", "import", "sequential", "# pylint: disable=g-import-not-at-top", "default_format", "=", "'tf'", "if", "tf2", ".", "enabled", "(", ")", "else", "'h5'", "save_format", "=", "save_format", "or", "default_format", "filepath", "=", "path_to_string", "(", "filepath", ")", "# If the user has not already called fit or built the underlying metrics, we", "# should do that before saving to ensure the metric names have all", "# appropriate name transformations applied.", "saving_utils", ".", "try_build_compiled_arguments", "(", "model", ")", "if", "(", "save_format", "==", "'h5'", "or", "(", "h5py", "is", "not", "None", "and", "isinstance", "(", "filepath", ",", "h5py", ".", "File", ")", ")", "or", "saving_utils", ".", "is_hdf5_filepath", "(", "filepath", ")", ")", ":", "# TODO(b/130258301): add utility method for detecting model type.", "if", "(", "not", "model", ".", "_is_graph_network", "and", "# pylint:disable=protected-access", "not", "isinstance", "(", "model", ",", "sequential", ".", "Sequential", ")", ")", ":", "raise", "NotImplementedError", "(", "'Saving the model to HDF5 format requires the model to be a '", "'Functional model or a Sequential model. It does not work for '", "'subclassed models, because such models are defined via the body of '", "'a Python method, which isn\\'t safely serializable. Consider saving '", "'to the Tensorflow SavedModel format (by setting save_format=\"tf\") '", "'or using `save_weights`.'", ")", "hdf5_format", ".", "save_model_to_hdf5", "(", "model", ",", "filepath", ",", "overwrite", ",", "include_optimizer", ")", "else", ":", "with", "generic_utils", ".", "SharedObjectSavingScope", "(", ")", ":", "saved_model_save", ".", "save", "(", "model", ",", "filepath", ",", "overwrite", ",", "include_optimizer", ",", "signatures", ",", "options", ",", "save_traces", ")" ]

[ "Gets", "the", "value", "of", "a", "property", "that", "is", "the", "part", "following", "the", "grist", "if", "any", "." ]

[ "def", "get_value", "(", "property", ")", ":", "return", "replace_grist", "(", "property", ",", "''", ")" ]

[ "请求查询预埋撤单响应" ]

[ "def", "onRspQryParkedOrderAction", "(", "self", ",", "ParkedOrderActionField", ",", "RspInfoField", ",", "requestId", ",", "final", ")", ":", "pass" ]

[ "Overridden", "from", "Argument", "." ]

[ "def", "WriteValidationCode", "(", "self", ",", "file", ",", "func", ")", ":", "file", ".", "Write", "(", "\" if (%s == NULL) {\\n\"", "%", "self", ".", "name", ")", "file", ".", "Write", "(", "\" return error::kOutOfBounds;\\n\"", ")", "file", ".", "Write", "(", "\" }\\n\"", ")" ]

[ "Internal", "function", ".", "It", "reads", "BASENAME", ".", "tcl", "and", "CLASSNAME", ".", "tcl", "into", "the", "Tcl", "Interpreter", "and", "calls", "execfile", "on", "BASENAME", ".", "py", "and", "CLASSNAME", ".", "py", "if", "such", "a", "file", "exists", "in", "the", "home", "directory", "." ]

[ "def", "readprofile", "(", "self", ",", "baseName", ",", "className", ")", ":", "import", "os", "if", "'HOME'", "in", "os", ".", "environ", ":", "home", "=", "os", ".", "environ", "[", "'HOME'", "]", "else", ":", "home", "=", "os", ".", "curdir", "class_tcl", "=", "os", ".", "path", ".", "join", "(", "home", ",", "'.%s.tcl'", "%", "className", ")", "class_py", "=", "os", ".", "path", ".", "join", "(", "home", ",", "'.%s.py'", "%", "className", ")", "base_tcl", "=", "os", ".", "path", ".", "join", "(", "home", ",", "'.%s.tcl'", "%", "baseName", ")", "base_py", "=", "os", ".", "path", ".", "join", "(", "home", ",", "'.%s.py'", "%", "baseName", ")", "dir", "=", "{", "'self'", ":", "self", "}", "exec", "'from Tkinter import *'", "in", "dir", "if", "os", ".", "path", ".", "isfile", "(", "class_tcl", ")", ":", "self", ".", "tk", ".", "call", "(", "'source'", ",", "class_tcl", ")", "if", "os", ".", "path", ".", "isfile", "(", "class_py", ")", ":", "execfile", "(", "class_py", ",", "dir", ")", "if", "os", ".", "path", ".", "isfile", "(", "base_tcl", ")", ":", "self", ".", "tk", ".", "call", "(", "'source'", ",", "base_tcl", ")", "if", "os", ".", "path", ".", "isfile", "(", "base_py", ")", ":", "execfile", "(", "base_py", ",", "dir", ")" ]

[ "Connect", "the", "slot", "for", "the", "start", "x", "option", "." ]

[ "def", "set_slot_for_plot_guess_start_x_updated", "(", "self", ",", "slot", ")", "->", "None", ":", "self", ".", "plot_guess_start_x_line_edit", ".", "editingFinished", ".", "connect", "(", "slot", ")" ]

[ "Returns", "the", "weight", "tensor", "from", "the", "given", "transformed", "input_tensor", "." ]

[ "def", "weight_tensor", "(", "self", ",", "input_tensor", ")", ":", "return", "None" ]

[ "This", "event", "occurs", "when", "a", "call", "transfer", "status", "changes", "." ]

[ "def", "CallTransferStatusChanged", "(", "self", ",", "Call", ",", "Status", ")", ":" ]

[ "Handles", "when", "Exclude", "Range", "is", "ticked", "or", "unticked", "." ]

[ "def", "handle_exclude_range_state_changed", "(", "self", ")", "->", "None", ":", "self", ".", "model", ".", "exclude_range", "=", "self", ".", "view", ".", "exclude_range", "self", ".", "view", ".", "set_exclude_start_and_end_x_visible", "(", "self", ".", "model", ".", "exclude_range", ")" ]

[ "Get", "peak", "index", "(", "HKL", ")", "from", "survey", "table", "(", "i", ".", "e", ".", "SPICE", "file", ")", ":", "param", "row_index", ":", ":", "return", ":" ]

[ "def", "get_hkl", "(", "self", ",", "row_index", ")", ":", "index_h", "=", "self", ".", "get_cell_value", "(", "row_index", ",", "self", ".", "_colIndexH", ")", "index_k", "=", "self", ".", "get_cell_value", "(", "row_index", ",", "self", ".", "_colIndexK", ")", "index_l", "=", "self", ".", "get_cell_value", "(", "row_index", ",", "self", ".", "_colIndexL", ")", "return", "index_h", ",", "index_k", ",", "index_l" ]

[ "Register", "a", "hook", "for", "request", "/", "response", "tweaking", "." ]

[ "def", "register_compliance_hook", "(", "self", ",", "hook_type", ",", "hook", ")", ":", "if", "hook_type", "not", "in", "self", ".", "compliance_hook", ":", "raise", "ValueError", "(", "'Hook type %s is not in %s.'", ",", "hook_type", ",", "self", ".", "compliance_hook", ")", "self", ".", "compliance_hook", "[", "hook_type", "]", ".", "add", "(", "hook", ")" ]

[ "Insert", "AbbrPreprocessor", "before", "ReferencePreprocessor", "." ]

[ "def", "extendMarkdown", "(", "self", ",", "md", ",", "md_globals", ")", ":", "md", ".", "preprocessors", ".", "add", "(", "'abbr'", ",", "AbbrPreprocessor", "(", "md", ")", ",", "'<reference'", ")" ]

[ "r", "setAxialRotConstraint", "(", "IKObjective", "self", "double", "const", "[", "3", "]", "alocal", "double", "const", "[", "3", "]", "aworld", ")" ]

[ "def", "setAxialRotConstraint", "(", "self", ",", "alocal", ":", "\"double const [3]\"", ",", "aworld", ":", "\"double const [3]\"", ")", "->", "\"void\"", ":", "return", "_robotsim", ".", "IKObjective_setAxialRotConstraint", "(", "self", ",", "alocal", ",", "aworld", ")" ]

[ "Prepare", "the", "results", "for", "this", "page", "." ]

[ "def", "Stop", "(", "self", ",", "_", ",", "tab", ")", ":", "if", "not", "self", ".", "_platform", ".", "CanMonitorNetworkData", "(", ")", ":", "return", "data", "=", "self", ".", "_platform", ".", "GetNetworkData", "(", "self", ".", "_browser", ")", "if", "data", "is", "not", "None", ":", "snd", ",", "rcv", "=", "data", "if", "self", ".", "_network_snd", "is", "not", "None", ":", "self", ".", "_network_snd", "=", "snd", "-", "self", ".", "_network_snd", "if", "self", ".", "_network_rcv", "is", "not", "None", ":", "self", ".", "_network_rcv", "=", "rcv", "-", "self", ".", "_network_rcv", "else", ":", "# If end data cannot be found, report none.", "self", ".", "_network_snd", "=", "None", "self", ".", "_network_rcv", "=", "None" ]

[ "Byte", "-", "compile", "all", "module", "on", "sys", ".", "path", "." ]

[ "def", "compile_path", "(", "skip_curdir", "=", "1", ",", "maxlevels", "=", "0", ",", "force", "=", "False", ",", "quiet", "=", "0", ",", "legacy", "=", "False", ",", "optimize", "=", "-", "1", ",", "invalidation_mode", "=", "None", ")", ":", "success", "=", "True", "for", "dir", "in", "sys", ".", "path", ":", "if", "(", "not", "dir", "or", "dir", "==", "os", ".", "curdir", ")", "and", "skip_curdir", ":", "if", "quiet", "<", "2", ":", "print", "(", "'Skipping current directory'", ")", "else", ":", "success", "=", "success", "and", "compile_dir", "(", "dir", ",", "maxlevels", ",", "None", ",", "force", ",", "quiet", "=", "quiet", ",", "legacy", "=", "legacy", ",", "optimize", "=", "optimize", ",", "invalidation_mode", "=", "invalidation_mode", ",", ")", "return", "success" ]

[ "Pastes", "src", "to", "trg", "with", "the", "top", "left", "corner", "at", "pos", "." ]

[ "def", "paste_im", "(", "src", ",", "trg", ",", "pos", ")", ":", "assert", "(", "src", ".", "ndim", "==", "trg", ".", "ndim", ")", "# Size of the region to be pasted", "w", "=", "min", "(", "src", ".", "shape", "[", "1", "]", ",", "trg", ".", "shape", "[", "1", "]", "-", "pos", "[", "0", "]", ")", "h", "=", "min", "(", "src", ".", "shape", "[", "0", "]", ",", "trg", ".", "shape", "[", "0", "]", "-", "pos", "[", "1", "]", ")", "if", "src", ".", "ndim", "==", "3", ":", "trg", "[", "pos", "[", "1", "]", ":", "(", "pos", "[", "1", "]", "+", "h", ")", ",", "pos", "[", "0", "]", ":", "(", "pos", "[", "0", "]", "+", "w", ")", ",", ":", "]", "=", "src", "[", ":", "h", ",", ":", "w", ",", ":", "]", "else", ":", "trg", "[", "pos", "[", "1", "]", ":", "(", "pos", "[", "1", "]", "+", "h", ")", ",", "pos", "[", "0", "]", ":", "(", "pos", "[", "0", "]", "+", "w", ")", "]", "=", "src", "[", ":", "h", ",", ":", "w", "]" ]

[ "Customized", "write_stub", "function", "to", "allow", "us", "to", "inject", "generated", "python", "api", "codes", "into", "egg", "python", "file", "." ]

[ "def", "custom_write_stub", "(", "resource", ",", "pyfile", ")", ":", "_stub_template", "=", "textwrap", ".", "dedent", "(", "\"\"\"\n import os\n import sys\n import types\n import paddle\n \n def inject_ext_module(module_name, api_names):\n if module_name in sys.modules:\n return sys.modules[module_name]\n\n new_module = types.ModuleType(module_name)\n for api_name in api_names:\n setattr(new_module, api_name, eval(api_name))\n\n return new_module\n\n def __bootstrap__():\n cur_dir = os.path.dirname(os.path.abspath(__file__))\n so_path = os.path.join(cur_dir, \"{resource}\")\n\n assert os.path.exists(so_path)\n\n # load custom op shared library with abs path\n new_custom_ops = paddle.utils.cpp_extension.load_op_meta_info_and_register_op(so_path)\n m = inject_ext_module(__name__, new_custom_ops)\n \n __bootstrap__()\n\n {custom_api}\n \"\"\"", ")", ".", "lstrip", "(", ")", "# Parse registerring op information", "_", ",", "op_info", "=", "CustomOpInfo", ".", "instance", "(", ")", ".", "last", "(", ")", "so_path", "=", "op_info", ".", "so_path", "new_custom_ops", "=", "load_op_meta_info_and_register_op", "(", "so_path", ")", "assert", "len", "(", "new_custom_ops", ")", ">", "0", ",", "\"Required at least one custom operators, but received len(custom_op) = %d\"", "%", "len", "(", "new_custom_ops", ")", "# NOTE: To avoid importing .so file instead of python file because they have same name,", "# we rename .so shared library to another name, see EasyInstallCommand.", "filename", ",", "ext", "=", "os", ".", "path", ".", "splitext", "(", "resource", ")", "resource", "=", "filename", "+", "\"_pd_\"", "+", "ext", "api_content", "=", "[", "]", "for", "op_name", "in", "new_custom_ops", ":", "api_content", ".", "append", "(", "_custom_api_content", "(", "op_name", ")", ")", "with", "open", "(", "pyfile", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "_stub_template", ".", "format", "(", "resource", "=", "resource", ",", "custom_api", "=", "'\\n\\n'", ".", "join", "(", "api_content", ")", ")", ")" ]

[ "Conversion", "function", "for", "Graph", ".", "as_graph_element", "()", "." ]

[ "def", "_as_graph_element", "(", "self", ")", ":", "return", "self", ".", "_graph_element" ]

[ "Divide", "self", "by", "other", "in", "place", "." ]

[ "def", "__idiv__", "(", "self", ",", "other", ")", ":", "t", "=", "self", ".", "_data", ".", "dtype", ".", "char", "f", "=", "filled", "(", "other", ",", "0", ")", "t1", "=", "f", ".", "dtype", ".", "char", "if", "t", "==", "t1", ":", "pass", "elif", "t", "in", "typecodes", "[", "'Integer'", "]", ":", "if", "t1", "in", "typecodes", "[", "'Integer'", "]", ":", "f", "=", "f", ".", "astype", "(", "t", ")", "else", ":", "raise", "TypeError", "(", "'Incorrect type for in-place operation.'", ")", "elif", "t", "in", "typecodes", "[", "'Float'", "]", ":", "if", "t1", "in", "typecodes", "[", "'Integer'", "]", ":", "f", "=", "f", ".", "astype", "(", "t", ")", "elif", "t1", "in", "typecodes", "[", "'Float'", "]", ":", "f", "=", "f", ".", "astype", "(", "t", ")", "else", ":", "raise", "TypeError", "(", "'Incorrect type for in-place operation.'", ")", "elif", "t", "in", "typecodes", "[", "'Complex'", "]", ":", "if", "t1", "in", "typecodes", "[", "'Integer'", "]", ":", "f", "=", "f", ".", "astype", "(", "t", ")", "elif", "t1", "in", "typecodes", "[", "'Float'", "]", ":", "f", "=", "f", ".", "astype", "(", "t", ")", "elif", "t1", "in", "typecodes", "[", "'Complex'", "]", ":", "f", "=", "f", ".", "astype", "(", "t", ")", "else", ":", "raise", "TypeError", "(", "'Incorrect type for in-place operation.'", ")", "else", ":", "raise", "TypeError", "(", "'Incorrect type for in-place operation.'", ")", "mo", "=", "getmask", "(", "other", ")", "result", "=", "divide", "(", "self", ",", "masked_array", "(", "f", ",", "mask", "=", "mo", ")", ")", "self", ".", "_data", "=", "result", ".", "data", "dm", "=", "result", ".", "raw_mask", "(", ")", "if", "dm", "is", "not", "self", ".", "_mask", ":", "self", ".", "_mask", "=", "dm", "self", ".", "_shared_mask", "=", "1", "return", "self" ]

[ "Return", "a", "file", "-", "like", "representation", "or", "raise", "a", "KeyError", "." ]

[ "def", "get_file", "(", "self", ",", "key", ",", "from_", "=", "False", ")", ":", "start", ",", "stop", "=", "self", ".", "_lookup", "(", "key", ")", "self", ".", "_file", ".", "seek", "(", "start", ")", "if", "not", "from_", ":", "self", ".", "_file", ".", "readline", "(", ")", "return", "_PartialFile", "(", "self", ".", "_file", ",", "self", ".", "_file", ".", "tell", "(", ")", ",", "stop", ")" ]

[ "Helper", "parse", "action", "for", "removing", "quotation", "marks", "from", "parsed", "quoted", "strings", "." ]

[ "def", "removeQuotes", "(", "s", ",", "l", ",", "t", ")", ":", "return", "t", "[", "0", "]", "[", "1", ":", "-", "1", "]" ]

[ "Find", "the", "best", "matching", "lidar", "file", "from", "a", "list", "." ]

[ "def", "findMatchingLidarFileFromList", "(", "imageFile", ",", "lidarFiles", ")", ":", "vals", "=", "parseTimeStamps", "(", "imageFile", ")", "if", "len", "(", "vals", ")", "<", "2", ":", "raise", "Exception", "(", "'Failed to parse the date and time from: '", "+", "imageFile", ")", "useTimeFix", "=", "False", "returnMinAndSecOnly", "=", "False", "imageDateTime", "=", "parseDateTimeStrings", "(", "vals", "[", "0", "]", ",", "vals", "[", "1", "]", ",", "useTimeFix", ",", "returnMinAndSecOnly", ")", "#print 'INPUT = ' + str(imageDateTime)", "# Search for the matching file in the lidar folder.", "# - We are looking for the closest lidar time that starts BEFORE the image time.", "# - It is possible for an image to span lidar files, we will address that if we need to!", "bestTimeDelta", "=", "datetime", ".", "timedelta", ".", "max", "bestLidarFile", "=", "'NA'", "zeroDelta", "=", "datetime", ".", "timedelta", "(", ")", "# First see if we need correction for sometimes seconds going from 1 to 60.", "minMinSec", "=", "60", "maxMinSec", "=", "0", "for", "lidarPath", "in", "lidarFiles", ":", "vals", "=", "parseTimeStamps", "(", "lidarPath", ")", "if", "len", "(", "vals", ")", "<", "2", ":", "continue", "# ignore bad files", "useTimeFix", "=", "False", "returnMinAndSecOnly", "=", "True", "(", "minute", ",", "second", ")", "=", "parseDateTimeStrings", "(", "vals", "[", "0", "]", ",", "vals", "[", "1", "]", ",", "useTimeFix", ",", "returnMinAndSecOnly", ")", "if", "second", "<", "minMinSec", ":", "minMinSec", "=", "second", "if", "second", ">", "maxMinSec", ":", "maxMinSec", "=", "second", "if", "minute", "<", "minMinSec", ":", "minMinSec", "=", "minute", "if", "minute", ">", "maxMinSec", ":", "maxMinSec", "=", "minute", "if", "minMinSec", "<=", "0", "and", "maxMinSec", ">=", "60", ":", "raise", "Exception", "(", "\"The minute/second range goes from \"", "+", "str", "(", "minMinSec", ")", "+", "\" to \"", "+", "str", "(", "maxMinSec", ")", ")", "useTimeFix", "=", "False", "if", "maxMinSec", ">=", "60", ":", "useTimeFix", "=", "True", "#print 'Using lidar time fix!'", "for", "lidarPath", "in", "lidarFiles", ":", "vals", "=", "parseTimeStamps", "(", "lidarPath", ")", "if", "len", "(", "vals", ")", "<", "2", ":", "continue", "# ignore bad files", "try", ":", "returnMinAndSecOnly", "=", "False", "lidarDateTime", "=", "parseDateTimeStrings", "(", "vals", "[", "0", "]", ",", "vals", "[", "1", "]", ",", "useTimeFix", ",", "returnMinAndSecOnly", ")", "#lidarDateTime = lidarDateTime + datetime.timedelta(hours=2, minutes=3, seconds=42) # Manual hack for flights with bad lidar times!", "except", "Exception", "as", "e", ":", "raise", "Exception", "(", "'Failed to parse datetime for lidar file: '", "+", "lidarPath", "+", "'\\n'", "+", "'Error is: '", "+", "str", "(", "e", ")", ")", "#print 'THIS = ' + str(lidarDateTime)", "# Compare time to the image time", "timeDelta", "=", "abs", "(", "imageDateTime", "-", "lidarDateTime", ")", "#print 'DELTA = ' + str(timeDelta)", "# Select the closest lidar time", "# - Since we are using the paired files, the file time is in the middle ", "# of the (large) file so being close to the middle should make sure the DEM", "# is fully covered by LIDAR data.", "if", "timeDelta", "<", "bestTimeDelta", ":", "bestLidarFile", "=", "lidarPath", "bestTimeDelta", "=", "timeDelta", "# Normal spacing seems to be 6.5 minutes but this must vary by flight.", "MAX_DELTA", "=", "datetime", ".", "timedelta", "(", "minutes", "=", "15", ")", "if", "(", "bestLidarFile", "==", "'NA'", ")", "or", "(", "bestTimeDelta", ">", "MAX_DELTA", ")", ":", "errorMessage", "=", "'Failed to find matching lidar file for image '", "+", "imageFile", "if", "bestLidarFile", ":", "errorMessage", "+=", "'\\n--> Nearest lidar file was '", "+", "bestLidarFile", "+", "' with delta '", "+", "str", "(", "bestTimeDelta", ")", "raise", "Exception", "(", "errorMessage", ")", "#print bestLidarFile", "#print bestTimeDelta", "return", "bestLidarFile" ]