Datasets:

---

sia-precision-education

/

pile_cpp

like 1

Follow

Sia Precision Education 5

[ "Returns", "the", "length", "of", "each", "row", "in", "a", "SparseTensor", "." ]

[ "def", "sparse_row_envelope", "(", "sparse_input", ",", "row_axis", "=", "0", ",", "col_axis", "=", "1", ",", "name", "=", "None", ")", ":", "if", "not", "(", "isinstance", "(", "row_axis", ",", "compat", ".", "integral_types", ")", "and", "isinstance", "(", "col_axis", ",", "compat", ".", "integral_types", ")", ")", ":", "raise", "ValueError", "(", "\"`row_axis` and `col_axis` must be integers.\"", ")", "if", "row_axis", "==", "col_axis", ":", "raise", "ValueError", "(", "\"Row and column can not be the same axis.\"", ")", "with", "ops", ".", "name_scope", "(", "name", ",", "\"sparse_row_envelope\"", ",", "[", "sparse_input", "]", ")", ":", "indices", "=", "sparse_input", ".", "indices", "row_indices", "=", "indices", "[", ":", ",", "row_axis", "]", "col_indices", "=", "indices", "[", ":", ",", "col_axis", "]", "num_rows", "=", "math_ops", ".", "cast", "(", "sparse_input", ".", "dense_shape", "[", "row_axis", "]", ",", "dtypes", ".", "int32", ")", "row_envelope", "=", "math_ops", ".", "unsorted_segment_max", "(", "col_indices", "+", "1", ",", "row_indices", ",", "num_rows", ",", "name", "=", "name", ")", "zeros", "=", "array_ops", ".", "zeros_like", "(", "row_envelope", ")", "return", "array_ops", ".", "where", "(", "row_envelope", ">", "zeros", ",", "row_envelope", ",", "zeros", ")" ]

[ ":", "type", "parents", ":", "List", "[", "int", "]", ":", "rtype", ":", "int" ]

[ "def", "countHighestScoreNodes", "(", "self", ",", "parents", ")", ":", "def", "iter_dfs", "(", "adj", ")", ":", "result", "=", "[", "0", "]", "*", "2", "stk", "=", "[", "(", "1", ",", "(", "0", ",", "[", "0", "]", ")", ")", "]", "while", "stk", ":", "step", ",", "args", "=", "stk", ".", "pop", "(", ")", "if", "step", "==", "1", ":", "i", ",", "ret", "=", "args", "cnts", "=", "[", "[", "0", "]", "for", "_", "in", "xrange", "(", "len", "(", "adj", "[", "i", "]", ")", ")", "]", "stk", ".", "append", "(", "(", "2", ",", "(", "cnts", ",", "ret", ")", ")", ")", "for", "j", ",", "child", "in", "enumerate", "(", "adj", "[", "i", "]", ")", ":", "stk", ".", "append", "(", "(", "1", ",", "(", "child", ",", "cnts", "[", "j", "]", ")", ")", ")", "elif", "step", "==", "2", ":", "cnts", ",", "ret", "=", "args", "ret", "[", "0", "]", "=", "sum", "(", "cnt", "[", "0", "]", "for", "cnt", "in", "cnts", ")", "+", "1", "score", "=", "max", "(", "(", "len", "(", "adj", ")", "-", "ret", "[", "0", "]", ")", ",", "1", ")", "*", "reduce", "(", "lambda", "x", ",", "y", ":", "x", "*", "y", "[", "0", "]", ",", "cnts", ",", "1", ")", "if", "score", ">", "result", "[", "0", "]", ":", "result", "[", ":", "]", "=", "[", "score", ",", "1", "]", "elif", "score", "==", "result", "[", "0", "]", ":", "result", "[", "1", "]", "+=", "1", "return", "result", "[", "1", "]", "adj", "=", "[", "[", "]", "for", "_", "in", "xrange", "(", "len", "(", "parents", ")", ")", "]", "# Space: O(n)", "for", "i", "in", "xrange", "(", "1", ",", "len", "(", "parents", ")", ")", ":", "adj", "[", "parents", "[", "i", "]", "]", ".", "append", "(", "i", ")", "return", "iter_dfs", "(", "adj", ")" ]

[ "Pack", "a", "python", "object", "into", "an", "AE", "descriptor" ]

[ "def", "pack", "(", "x", ",", "forcetype", "=", "None", ")", ":", "if", "forcetype", ":", "if", "type", "(", "x", ")", "is", "StringType", ":", "return", "AE", ".", "AECreateDesc", "(", "forcetype", ",", "x", ")", "else", ":", "return", "pack", "(", "x", ")", ".", "AECoerceDesc", "(", "forcetype", ")", "if", "x", "is", "None", ":", "return", "AE", ".", "AECreateDesc", "(", "'null'", ",", "''", ")", "if", "isinstance", "(", "x", ",", "AEDescType", ")", ":", "return", "x", "if", "isinstance", "(", "x", ",", "FSSType", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'fss '", ",", "x", ".", "data", ")", "if", "isinstance", "(", "x", ",", "FSRefType", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'fsrf'", ",", "x", ".", "data", ")", "if", "isinstance", "(", "x", ",", "AliasType", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'alis'", ",", "x", ".", "data", ")", "if", "isinstance", "(", "x", ",", "IntType", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'long'", ",", "struct", ".", "pack", "(", "'l'", ",", "x", ")", ")", "if", "isinstance", "(", "x", ",", "FloatType", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'doub'", ",", "struct", ".", "pack", "(", "'d'", ",", "x", ")", ")", "if", "isinstance", "(", "x", ",", "StringType", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'TEXT'", ",", "x", ")", "if", "isinstance", "(", "x", ",", "UnicodeType", ")", ":", "data", "=", "x", ".", "encode", "(", "'utf16'", ")", "if", "data", "[", ":", "2", "]", "==", "'\\xfe\\xff'", ":", "data", "=", "data", "[", "2", ":", "]", "return", "AE", ".", "AECreateDesc", "(", "'utxt'", ",", "data", ")", "if", "isinstance", "(", "x", ",", "ListType", ")", ":", "list", "=", "AE", ".", "AECreateList", "(", "''", ",", "0", ")", "for", "item", "in", "x", ":", "list", ".", "AEPutDesc", "(", "0", ",", "pack", "(", "item", ")", ")", "return", "list", "if", "isinstance", "(", "x", ",", "DictionaryType", ")", ":", "record", "=", "AE", ".", "AECreateList", "(", "''", ",", "1", ")", "for", "key", ",", "value", "in", "x", ".", "items", "(", ")", ":", "packkey", "(", "record", ",", "key", ",", "value", ")", "#record.AEPutParamDesc(key, pack(value))", "return", "record", "if", "type", "(", "x", ")", "==", "types", ".", "ClassType", "and", "issubclass", "(", "x", ",", "ObjectSpecifier", ")", ":", "# Note: we are getting a class object here, not an instance", "return", "AE", ".", "AECreateDesc", "(", "'type'", ",", "x", ".", "want", ")", "if", "hasattr", "(", "x", ",", "'__aepack__'", ")", ":", "return", "x", ".", "__aepack__", "(", ")", "if", "hasattr", "(", "x", ",", "'which'", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'TEXT'", ",", "x", ".", "which", ")", "if", "hasattr", "(", "x", ",", "'want'", ")", ":", "return", "AE", ".", "AECreateDesc", "(", "'TEXT'", ",", "x", ".", "want", ")", "return", "AE", ".", "AECreateDesc", "(", "'TEXT'", ",", "repr", "(", "x", ")", ")" ]

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

[ "def", "TransferFromWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "Validator_TransferFromWindow", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

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

[ "def", "IsSortKey", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "HeaderColumn_IsSortKey", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Convert", "the", "device", "tree", "to", "DTS", "and", "write", "to", "a", "file", "." ]

[ "def", "writeDtsFile", "(", "self", ",", "filename", ")", ":", "filename", "=", "os", ".", "path", ".", "realpath", "(", "filename", ")", "try", ":", "with", "open", "(", "filename", ",", "'w'", ")", "as", "f", ":", "f", ".", "write", "(", "self", ".", "to_dts", "(", ")", ")", "return", "filename", "except", "IOError", ":", "raise", "RuntimeError", "(", "\"Failed to open DTS output file\"", ")" ]

[ "verify", "(", "M", ":", "string|long", "signature", ":", "tuple", ")", ":", "bool", "Verify", "that", "the", "signature", "is", "valid", "for", "the", "message", "M", ";", "returns", "true", "if", "the", "signature", "checks", "out", "." ]

[ "def", "verify", "(", "self", ",", "M", ",", "signature", ")", ":", "if", "isinstance", "(", "M", ",", "types", ".", "StringType", ")", ":", "M", "=", "bytes_to_long", "(", "M", ")", "return", "self", ".", "_verify", "(", "M", ",", "signature", ")" ]

[ "Returns", "self", "with", "the", "sign", "of", "other", "." ]

[ "def", "copy_sign", "(", "self", ",", "other", ",", "context", "=", "None", ")", ":", "other", "=", "_convert_other", "(", "other", ",", "raiseit", "=", "True", ")", "return", "_dec_from_triple", "(", "other", ".", "_sign", ",", "self", ".", "_int", ",", "self", ".", "_exp", ",", "self", ".", "_is_special", ")" ]

[ "Retrieve", "the", "name", "of", "the", "manager", "daemon", "where", "this", "plugin", "is", "currently", "being", "executed", "(", "i", ".", "e", ".", "the", "active", "manager", ")", "." ]

[ "def", "get_mgr_id", "(", "self", ")", "->", "str", ":", "return", "self", ".", "_ceph_get_mgr_id", "(", ")" ]

[ "Computes", "the", "elementwise", "y", "th", "power", "of", "x", "." ]

[ "def", "pow", "(", "x", ",", "y", ")", ":", "return", "intrinsic", "(", "'pow'", ",", "x", ",", "y", ")" ]

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

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

[ "Defined", "to", "generate", "internal", "includes", "within", "a", "file", ".", "Usually", "used", "for", "data", "type", "includes", "and", "system", "includes", "." ]

[ "def", "includes2Visit", "(", "self", ",", "obj", ")", ":" ]

[ "The", "apparent", "encoding", "provided", "by", "the", "chardet", "library", "." ]

[ "def", "apparent_encoding", "(", "self", ")", ":", "return", "chardet", ".", "detect", "(", "self", ".", "content", ")", "[", "'encoding'", "]" ]

[ "Reads", "in", "a", "set", "of", "5", "html", "tables", "and", "returns", "corresponding", "yield", "data" ]

[ "def", "readtable", "(", "i", ",", "spdat", ")", ":", "parent", "=", "getdata", "(", "i", ",", "spdat", ")", "[", "0", "]", "pfinal", "=", "(", "parent", ".", "split", "(", "'<strong>'", ")", "[", "1", "]", ")", ".", "split", "(", "'</strong>'", ")", "[", "0", "]", "pid", "=", "conv_to_id", "(", "pfinal", ")", "fpdata", "=", "getdata", "(", "i", "+", "1", ",", "spdat", ")", "dt", "=", "np", ".", "dtype", "(", "[", "(", "'from_nuc'", ",", "'i4'", ")", ",", "(", "'to_nuc'", ",", "'i4'", ")", ",", "(", "'yield_thermal'", ",", "float", ")", ",", "(", "'yield_thermal_err'", ",", "float", ")", ",", "(", "'yield_fast'", ",", "float", ")", ",", "(", "'yield_fast_err'", ",", "float", ")", ",", "(", "'yield_14MeV'", ",", "float", ")", ",", "(", "'yield_14MeV_err'", ",", "float", ")", "]", ")", "dfinal", "=", "np", ".", "zeros", "(", "(", "len", "(", "fpdata", ")", ",", ")", ",", "dtype", "=", "dt", ")", "for", "index", ",", "item", "in", "enumerate", "(", "fpdata", ")", ":", "dfinal", "[", "index", "]", "[", "'from_nuc'", "]", "=", "pid", "dfinal", "[", "index", "]", "[", "'to_nuc'", "]", "=", "conv_to_id", "(", "item", ")", "thermaldata", "=", "getdata", "(", "i", "+", "2", ",", "spdat", ")", "for", "index", ",", "item", "in", "enumerate", "(", "thermaldata", ")", ":", "dat", ",", "err", "=", "conv_to_num", "(", "item", ")", "dfinal", "[", "index", "]", "[", "'yield_thermal'", "]", "=", "dat", "dfinal", "[", "index", "]", "[", "'yield_thermal_err'", "]", "=", "err", "fastdata", "=", "getdata", "(", "i", "+", "3", ",", "spdat", ")", "for", "index", ",", "item", "in", "enumerate", "(", "fastdata", ")", ":", "dat", ",", "err", "=", "conv_to_num", "(", "item", ")", "dfinal", "[", "index", "]", "[", "'yield_fast'", "]", "=", "dat", "dfinal", "[", "index", "]", "[", "'yield_fast_err'", "]", "=", "err", "dtdata", "=", "getdata", "(", "i", "+", "4", ",", "spdat", ")", "for", "index", ",", "item", "in", "enumerate", "(", "dtdata", ")", ":", "dat", ",", "err", "=", "conv_to_num", "(", "item", ")", "dfinal", "[", "index", "]", "[", "'yield_14MeV'", "]", "=", "dat", "dfinal", "[", "index", "]", "[", "'yield_14MeV_err'", "]", "=", "err", "return", "dfinal" ]

[ "Pull", "all", "the", "dependencies", "." ]

[ "def", "pull_dependencies", "(", "self", ",", "nodes", ")", ":", "visitor", "=", "DependencyFinderVisitor", "(", ")", "for", "node", "in", "nodes", ":", "visitor", ".", "visit", "(", "node", ")", "for", "dependency", "in", "\"filters\"", ",", "\"tests\"", ":", "mapping", "=", "getattr", "(", "self", ",", "dependency", ")", "for", "name", "in", "getattr", "(", "visitor", ",", "dependency", ")", ":", "if", "name", "not", "in", "mapping", ":", "mapping", "[", "name", "]", "=", "self", ".", "temporary_identifier", "(", ")", "self", ".", "writeline", "(", "\"%s = environment.%s[%r]\"", "%", "(", "mapping", "[", "name", "]", ",", "dependency", ",", "name", ")", ")" ]

[ "Fallback", "to", "the", "HTMLRenderer", "method", "if", "the", "MaterializeRenderer", "method", "is", "not", "located", "." ]

[ "def", "_method", "(", "self", ",", "component", ")", ":", "if", "hasattr", "(", "component", ",", "self", ".", "METHOD", ")", ":", "return", "getattr", "(", "component", ",", "self", ".", "METHOD", ")", "elif", "hasattr", "(", "component", ",", "HTMLRenderer", ".", "METHOD", ")", ":", "return", "getattr", "(", "component", ",", "HTMLRenderer", ".", "METHOD", ")", "else", ":", "msg", "=", "\"The component object {} does not have a {} method.\"", "raise", "exceptions", ".", "MooseDocsException", "(", "msg", ",", "type", "(", "component", ")", ",", "self", ".", "METHOD", ")" ]

[ "Move", "grid", "cursor", "when", "a", "cell", "is", "right", "-", "clicked" ]

[ "def", "OnRightClick", "(", "self", ",", "event", ")", ":", "self", ".", "SetGridCursor", "(", "event", ".", "GetRow", "(", ")", ",", "event", ".", "GetCol", "(", ")", ")", "event", ".", "Skip", "(", ")" ]

[ "This", "prepends", "newpath", "elements", "to", "the", "given", "oldpath", ".", "Will", "only", "add", "any", "particular", "path", "once", "(", "leaving", "the", "first", "one", "it", "encounters", "and", "ignoring", "the", "rest", "to", "preserve", "path", "order", ")", "and", "will", "os", ".", "path", ".", "normpath", "and", "os", ".", "path", ".", "normcase", "all", "paths", "to", "help", "assure", "this", ".", "This", "can", "also", "handle", "the", "case", "where", "the", "given", "old", "path", "variable", "is", "a", "list", "instead", "of", "a", "string", "in", "which", "case", "a", "list", "will", "be", "returned", "instead", "of", "a", "string", "." ]

[ "def", "PrependPath", "(", "oldpath", ",", "newpath", ",", "sep", "=", "os", ".", "pathsep", ",", "delete_existing", "=", "1", ",", "canonicalize", "=", "None", ")", ":", "orig", "=", "oldpath", "is_list", "=", "1", "paths", "=", "orig", "if", "not", "is_List", "(", "orig", ")", "and", "not", "is_Tuple", "(", "orig", ")", ":", "paths", "=", "paths", ".", "split", "(", "sep", ")", "is_list", "=", "0", "if", "is_String", "(", "newpath", ")", ":", "newpaths", "=", "newpath", ".", "split", "(", "sep", ")", "elif", "not", "is_List", "(", "newpath", ")", "and", "not", "is_Tuple", "(", "newpath", ")", ":", "newpaths", "=", "[", "newpath", "]", "# might be a Dir", "else", ":", "newpaths", "=", "newpath", "if", "canonicalize", ":", "newpaths", "=", "list", "(", "map", "(", "canonicalize", ",", "newpaths", ")", ")", "if", "not", "delete_existing", ":", "# First uniquify the old paths, making sure to ", "# preserve the first instance (in Unix/Linux,", "# the first one wins), and remembering them in normpaths.", "# Then insert the new paths at the head of the list", "# if they're not already in the normpaths list.", "result", "=", "[", "]", "normpaths", "=", "[", "]", "for", "path", "in", "paths", ":", "if", "not", "path", ":", "continue", "normpath", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "normcase", "(", "path", ")", ")", "if", "normpath", "not", "in", "normpaths", ":", "result", ".", "append", "(", "path", ")", "normpaths", ".", "append", "(", "normpath", ")", "newpaths", ".", "reverse", "(", ")", "# since we're inserting at the head", "for", "path", "in", "newpaths", ":", "if", "not", "path", ":", "continue", "normpath", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "normcase", "(", "path", ")", ")", "if", "normpath", "not", "in", "normpaths", ":", "result", ".", "insert", "(", "0", ",", "path", ")", "normpaths", ".", "append", "(", "normpath", ")", "paths", "=", "result", "else", ":", "newpaths", "=", "newpaths", "+", "paths", "# prepend new paths", "normpaths", "=", "[", "]", "paths", "=", "[", "]", "# now we add them only if they are unique", "for", "path", "in", "newpaths", ":", "normpath", "=", "os", ".", "path", ".", "normpath", "(", "os", ".", "path", ".", "normcase", "(", "path", ")", ")", "if", "path", "and", "not", "normpath", "in", "normpaths", ":", "paths", ".", "append", "(", "path", ")", "normpaths", ".", "append", "(", "normpath", ")", "if", "is_list", ":", "return", "paths", "else", ":", "return", "sep", ".", "join", "(", "paths", ")" ]

[ "Iterate", "over", "all", "values", "." ]

[ "def", "itervalue", "(", "self", ")", ":", "return", "iter", "(", "self", ".", "values", "(", ")", ")" ]

[ "Instantiates", "the", "vector", "Student", "s", "t", "-", "distributions", "on", "R^k", "." ]

[ "def", "__init__", "(", "self", ",", "df", ",", "loc", "=", "None", ",", "scale_identity_multiplier", "=", "None", ",", "scale_diag", "=", "None", ",", "scale_tril", "=", "None", ",", "scale_perturb_factor", "=", "None", ",", "scale_perturb_diag", "=", "None", ",", "validate_args", "=", "False", ",", "allow_nan_stats", "=", "True", ",", "name", "=", "\"VectorStudentT\"", ")", ":", "parameters", "=", "locals", "(", ")", "graph_parents", "=", "[", "df", ",", "loc", ",", "scale_identity_multiplier", ",", "scale_diag", ",", "scale_tril", ",", "scale_perturb_factor", ",", "scale_perturb_diag", "]", "with", "ops", ".", "name_scope", "(", "name", ")", ":", "with", "ops", ".", "name_scope", "(", "\"init\"", ",", "values", "=", "graph_parents", ")", ":", "# The shape of the _VectorStudentT distribution is governed by the", "# relationship between df.batch_shape and affine.batch_shape. In", "# pseudocode the basic procedure is:", "# if df.batch_shape is scalar:", "# if affine.batch_shape is not scalar:", "# # broadcast distribution.sample so", "# # it has affine.batch_shape.", "# self.batch_shape = affine.batch_shape", "# else:", "# if affine.batch_shape is scalar:", "# # let affine broadcasting do its thing.", "# self.batch_shape = df.batch_shape", "# All of the above magic is actually handled by TransformedDistribution.", "# Here we really only need to collect the affine.batch_shape and decide", "# what we're going to pass in to TransformedDistribution's", "# (override) batch_shape arg.", "affine", "=", "bijectors", ".", "Affine", "(", "shift", "=", "loc", ",", "scale_identity_multiplier", "=", "scale_identity_multiplier", ",", "scale_diag", "=", "scale_diag", ",", "scale_tril", "=", "scale_tril", ",", "scale_perturb_factor", "=", "scale_perturb_factor", ",", "scale_perturb_diag", "=", "scale_perturb_diag", ",", "validate_args", "=", "validate_args", ")", "distribution", "=", "student_t", ".", "StudentT", "(", "df", "=", "df", ",", "loc", "=", "array_ops", ".", "zeros", "(", "[", "]", ",", "dtype", "=", "affine", ".", "dtype", ")", ",", "scale", "=", "array_ops", ".", "ones", "(", "[", "]", ",", "dtype", "=", "affine", ".", "dtype", ")", ")", "batch_shape", ",", "override_event_shape", "=", "(", "distribution_util", ".", "shapes_from_loc_and_scale", "(", "affine", ".", "shift", ",", "affine", ".", "scale", ")", ")", "override_batch_shape", "=", "distribution_util", ".", "pick_vector", "(", "distribution", ".", "is_scalar_batch", "(", ")", ",", "batch_shape", ",", "constant_op", ".", "constant", "(", "[", "]", ",", "dtype", "=", "dtypes", ".", "int32", ")", ")", "super", "(", "_VectorStudentT", ",", "self", ")", ".", "__init__", "(", "distribution", "=", "distribution", ",", "bijector", "=", "affine", ",", "batch_shape", "=", "override_batch_shape", ",", "event_shape", "=", "override_event_shape", ",", "validate_args", "=", "validate_args", ",", "name", "=", "name", ")", "self", ".", "_parameters", "=", "parameters" ]

[ "Decode", "string", "according", "to", "RFC", "2231" ]

[ "def", "decode_rfc2231", "(", "s", ")", ":", "parts", "=", "s", ".", "split", "(", "TICK", ",", "2", ")", "if", "len", "(", "parts", ")", "<=", "2", ":", "return", "None", ",", "None", ",", "s", "return", "parts" ]

[ "Parse", "and", "return", "a", "string", "between", "quotes", "or", "doublequotes", "TODO", ":", "Deprecated", "to", "be", "removed", "at", "next", "drop", "of", "binary", "compatibility" ]

[ "def", "parseQuotedString", "(", "self", ")", ":", "ret", "=", "libxml2mod", ".", "xmlParseQuotedString", "(", "self", ".", "_o", ")", "return", "ret" ]

[ "Fill", "up", "the", "include_dict", "with", "new", "includes", "found", "from", "the", "file", "." ]

[ "def", "UpdateIncludeState", "(", "filename", ",", "include_dict", ",", "io", "=", "codecs", ")", ":", "headerfile", "=", "None", "try", ":", "headerfile", "=", "io", ".", "open", "(", "filename", ",", "'r'", ",", "'utf8'", ",", "'replace'", ")", "except", "IOError", ":", "return", "False", "linenum", "=", "0", "for", "line", "in", "headerfile", ":", "linenum", "+=", "1", "clean_line", "=", "CleanseComments", "(", "line", ")", "match", "=", "_RE_PATTERN_INCLUDE", ".", "search", "(", "clean_line", ")", "if", "match", ":", "include", "=", "match", ".", "group", "(", "2", ")", "include_dict", ".", "setdefault", "(", "include", ",", "linenum", ")", "return", "True" ]

[ "Reports", "for", "long", "function", "bodies", "." ]

[ "def", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "function_state", ",", "error", ")", ":", "lines", "=", "clean_lines", ".", "lines", "line", "=", "lines", "[", "linenum", "]", "joined_line", "=", "''", "starting_func", "=", "False", "regexp", "=", "r'(\\w(\\w|::|\\*|\\&|\\s)*)\\('", "# decls * & space::name( ...", "match_result", "=", "Match", "(", "regexp", ",", "line", ")", "if", "match_result", ":", "# If the name is all caps and underscores, figure it's a macro and", "# ignore it, unless it's TEST or TEST_F.", "function_name", "=", "match_result", ".", "group", "(", "1", ")", ".", "split", "(", ")", "[", "-", "1", "]", "if", "function_name", "==", "'TEST'", "or", "function_name", "==", "'TEST_F'", "or", "(", "not", "Match", "(", "r'[A-Z_]+$'", ",", "function_name", ")", ")", ":", "starting_func", "=", "True", "if", "starting_func", ":", "body_found", "=", "False", "for", "start_linenum", "in", "xrange", "(", "linenum", ",", "clean_lines", ".", "NumLines", "(", ")", ")", ":", "start_line", "=", "lines", "[", "start_linenum", "]", "joined_line", "+=", "' '", "+", "start_line", ".", "lstrip", "(", ")", "if", "Search", "(", "r'(;|})'", ",", "start_line", ")", ":", "# Declarations and trivial functions", "body_found", "=", "True", "break", "# ... ignore", "elif", "Search", "(", "r'{'", ",", "start_line", ")", ":", "body_found", "=", "True", "function", "=", "Search", "(", "r'((\\w|:)*)\\('", ",", "line", ")", ".", "group", "(", "1", ")", "if", "Match", "(", "r'TEST'", ",", "function", ")", ":", "# Handle TEST... macros", "parameter_regexp", "=", "Search", "(", "r'(\\(.*\\))'", ",", "joined_line", ")", "if", "parameter_regexp", ":", "# Ignore bad syntax", "function", "+=", "parameter_regexp", ".", "group", "(", "1", ")", "else", ":", "function", "+=", "'()'", "function_state", ".", "Begin", "(", "function", ")", "break", "if", "not", "body_found", ":", "# No body for the function (or evidence of a non-function) was found.", "error", "(", "filename", ",", "linenum", ",", "'readability/fn_size'", ",", "5", ",", "'Lint failed to find start of function body.'", ")", "elif", "Match", "(", "r'^\\}\\s*$'", ",", "line", ")", ":", "# function end", "function_state", ".", "Check", "(", "error", ",", "filename", ",", "linenum", ")", "function_state", ".", "End", "(", ")", "elif", "not", "Match", "(", "r'^\\s*$'", ",", "line", ")", ":", "function_state", ".", "Count", "(", ")" ]

[ "Set", "deltime" ]

[ "def", "tmin", "(", "value", "=", "None", ")", ":", "state", ".", "time_selection", ".", "set_tmin", "(", "_maybe_convert", "(", "value", ",", "float", ")", ")", "state", ".", "time_selection", ".", "print_show", "(", ")" ]

[ "Column", "format", "." ]

[ "def", "column_format", "(", "self", ")", "->", "str", "|", "None", ":", "return", "self", ".", "_column_format" ]

[ "Initialization", "steps", "that", "should", "happen", "lazily", "typically", "right", "before", "the", "first", "forward", "pass", "." ]

[ "def", "_lazy_init", "(", "self", ")", "->", "None", ":", "# Initialize param attributes lazily, in case the param's dtype or", "# device changes after __init__.", "for", "p", "in", "self", ".", "params", ":", "self", ".", "_init_param_attributes", "(", "p", ")", "# Initialize _is_root and setup streams. These steps would ideally", "# happen in __init__, but _is_root can only be determined after the", "# entire model hierarchy is setup, thus we run it lazily.", "if", "self", ".", "_is_root", "is", "None", ":", "# _is_root means that we are in the outermost module's forward.", "self", ".", "_set_is_root", "(", ")", "self", ".", "_setup_streams", "(", ")", "if", "self", ".", "_is_root", ":", "# Buffers stay on GPU, and don't get sharded. Since _cast_buffers", "# applies recursively, we only call this from the root instance.", "self", ".", "_cast_buffers", "(", ")", "# Don't free the full params for the outer-most (root) instance,", "# In most cases, root instance contains params in the last layers", "# or has no params. In these cases, those params will be needed", "# immediately after for the backward pass. Note that this only", "# applies currently when freeing parameters at end of layer's", "# forward pass.", "self", ".", "reshard_after_forward", "=", "False", "# Due to the use of streams, we need to make sure the previous", "# ``optim.step()`` is done before we all-gather parameters.", "self", ".", "_wait_for_previous_optim_step", "(", ")" ]

[ "Add", "target", "to", "the", "list", "of", "targets", "in", "this", "project", "that", "should", "be", "build", "only", "by", "explicit", "request", "." ]

[ "def", "mark_targets_as_explicit", "(", "self", ",", "target_names", ")", ":", "# Record the name of the target, not instance, since this", "# rule is called before main target instaces are created.", "assert", "is_iterable_typed", "(", "target_names", ",", "basestring", ")", "self", ".", "explicit_targets_", ".", "update", "(", "target_names", ")" ]

[ "read", "a", "character", "array", "from", "a", "file", "in", "csv", "format" ]

[ "def", "csvread", "(", "fileName", ",", "delim", "=", "','", ")", ":", "import", "misc", "fileHandle", "=", "open", "(", "fileName", ",", "\"r\"", ")", "line", "=", "fileHandle", ".", "readline", "(", ")", "if", "delim", "==", "' '", ":", "delim", "=", "None", "data", "=", "misc", ".", "emptyLOL", "(", "len", "(", "line", ".", "split", "(", "delim", ")", ")", ")", "dim", "=", "len", "(", "data", ")", "while", "1", ":", "line", "=", "line", "[", ":", "-", "1", "]", "fields", "=", "line", ".", "split", "(", "delim", ")", "if", "len", "(", "fields", ")", "!=", "dim", ":", "print", "'badline:'", ",", "line", "for", "i", "in", "range", "(", "dim", ")", ":", "data", "[", "i", "]", ".", "append", "(", "fields", "[", "i", "]", ")", "line", "=", "fileHandle", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "if", "len", "(", "data", ")", "==", "1", ":", "data", "=", "data", "[", "0", "]", "return", "data" ]

[ "Create", "a", "mock", "that", "will", "accept", "any", "method", "calls", "." ]

[ "def", "CreateMockAnything", "(", "self", ")", ":", "new_mock", "=", "MockAnything", "(", ")", "self", ".", "_mock_objects", ".", "append", "(", "new_mock", ")", "return", "new_mock" ]

[ "Returns", "a", "value", "equal", "to", "a", "(", "rounded", ")", "having", "the", "exponent", "of", "b", "." ]

[ "def", "quantize", "(", "self", ",", "a", ",", "b", ")", ":", "a", "=", "_convert_other", "(", "a", ",", "raiseit", "=", "True", ")", "return", "a", ".", "quantize", "(", "b", ",", "context", "=", "self", ")" ]

[ "Registers", "a", "Python", "object", "obj", "for", "the", "given", "name", "." ]

[ "def", "register", "(", "self", ",", "obj", ",", "name", "=", "None", ")", ":", "if", "not", "name", ":", "name", "=", "obj", ".", "__name__", "if", "name", "in", "self", ".", "_registry", ":", "raise", "KeyError", "(", "\"Name '%s' has been registered in '%s'!\"", "%", "(", "name", ",", "self", ".", "_name", ")", ")", "# logging.vlog(1, \"Registering %s (%s) in %s.\", name, obj, self._name)", "self", ".", "_registry", "[", "name", "]", "=", "obj" ]

[ "Check", "if", "arg", "is", "a", "device", "or", "partition", "to", "create", "an", "LV", "out", "of", "it", "with", "a", "distinct", "volume", "group", "name", "assigning", "LV", "tags", "on", "it", "and", "ultimately", "returning", "the", "logical", "volume", "object", ".", "Failing", "to", "detect", "a", "device", "or", "partition", "will", "result", "in", "error", "." ]

[ "def", "prepare_data_device", "(", "self", ",", "device_type", ",", "osd_uuid", ")", ":", "device", "=", "self", ".", "args", ".", "data", "if", "disk", ".", "is_partition", "(", "device", ")", "or", "disk", ".", "is_device", "(", "device", ")", ":", "# we must create a vg, and then a single lv", "lv_name_prefix", "=", "\"osd-{}\"", ".", "format", "(", "device_type", ")", "kwargs", "=", "{", "'device'", ":", "device", ",", "'tags'", ":", "{", "'ceph.type'", ":", "device_type", "}", ",", "'slots'", ":", "self", ".", "args", ".", "data_slots", ",", "}", "logger", ".", "debug", "(", "'data device size: {}'", ".", "format", "(", "self", ".", "args", ".", "data_size", ")", ")", "if", "self", ".", "args", ".", "data_size", "!=", "0", ":", "kwargs", "[", "'size'", "]", "=", "self", ".", "args", ".", "data_size", "return", "api", ".", "create_lv", "(", "lv_name_prefix", ",", "osd_uuid", ",", "*", "*", "kwargs", ")", "else", ":", "error", "=", "[", "'Cannot use device ({}).'", ".", "format", "(", "device", ")", ",", "'A vg/lv path or an existing device is needed'", "]", "raise", "RuntimeError", "(", "' '", ".", "join", "(", "error", ")", ")", "raise", "RuntimeError", "(", "'no data logical volume found with: {}'", ".", "format", "(", "device", ")", ")" ]

[ "Converts", "a", "sparse", "representation", "into", "a", "dense", "tensor", "." ]

[ "def", "sparse_to_dense", "(", "sparse_indices", ",", "output_shape", ",", "sparse_values", ",", "default_value", "=", "0", ",", "validate_indices", "=", "True", ",", "name", "=", "None", ")", ":", "return", "gen_sparse_ops", ".", "_sparse_to_dense", "(", "sparse_indices", ",", "output_shape", ",", "sparse_values", ",", "default_value", "=", "default_value", ",", "validate_indices", "=", "validate_indices", ",", "name", "=", "name", ")" ]

[ "Sets", "the", ":", "class", ":", "FlatMenuBar", "options", "whether", "to", "show", "a", "toolbar", "to", "use", "LCD", "screen", "settings", "etc", "..." ]

[ "def", "SetOptions", "(", "self", ",", "options", ")", ":", "self", ".", "_options", "=", "options", "self", ".", "_showToolbar", "=", "options", "&", "FM_OPT_SHOW_TOOLBAR", "self", ".", "_showCustomize", "=", "options", "&", "FM_OPT_SHOW_CUSTOMIZE", "self", ".", "_isLCD", "=", "options", "&", "FM_OPT_IS_LCD", "self", ".", "_isMinibar", "=", "options", "&", "FM_OPT_MINIBAR", "self", ".", "SetBarHeight", "(", ")", "self", ".", "Refresh", "(", ")", "self", ".", "Update", "(", ")" ]

[ "Find", "distributions", "." ]

[ "def", "find_distributions", "(", "self", ",", "context", "=", "Context", "(", ")", ")", ":" ]

[ "Check", "if", "we", "are", "currently", "one", "level", "inside", "an", "extern", "C", "block", "." ]

[ "def", "InExternC", "(", "self", ")", ":", "return", "self", ".", "stack", "and", "isinstance", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "_ExternCInfo", ")" ]

[ "Returns", "whether", "the", "call", "completed", "without", "raising", "an", "exception", ".", "Will", "raise", "AssertionError", "if", "the", "result", "is", "not", "ready", "." ]

[ "def", "successful", "(", "self", ")", ":", "assert", "self", ".", "ready", "(", ")", "return", "self", ".", "_success" ]

[ "Check", "if", "we", "are", "currently", "one", "level", "inside", "an", "inline", "ASM", "block", "." ]

[ "def", "InAsmBlock", "(", "self", ")", ":", "return", "self", ".", "stack", "and", "self", ".", "stack", "[", "-", "1", "]", ".", "inline_asm", "!=", "_NO_ASM" ]

[ "Print", "detailed", "version", "and", "platform", "information", "for", "error", "reporting" ]

[ "def", "show_info", "(", ")", ":", "show_versions", "(", ")", "def", "print_entry", "(", "label", ",", "value", ")", ":", "print", "(", "f\" {label: <20}: {value: <8}\"", ")", "print", "(", "\"\\nPlatform:\"", ")", "print_entry", "(", "\"OS / Arch\"", ",", "f\"{_platform.system()} {_platform.machine()}\"", ")", "print_entry", "(", "\"SIMD Level\"", ",", "runtime_info", "(", ")", ".", "simd_level", ")", "print_entry", "(", "\"Detected SIMD Level\"", ",", "runtime_info", "(", ")", ".", "detected_simd_level", ")", "pool", "=", "default_memory_pool", "(", ")", "print", "(", "\"\\nMemory:\"", ")", "print_entry", "(", "\"Default backend\"", ",", "pool", ".", "backend_name", ")", "print_entry", "(", "\"Bytes allocated\"", ",", "f\"{pool.bytes_allocated()} bytes\"", ")", "print_entry", "(", "\"Max memory\"", ",", "f\"{pool.max_memory()} bytes\"", ")", "print_entry", "(", "\"Supported Backends\"", ",", "', '", ".", "join", "(", "supported_memory_backends", "(", ")", ")", ")", "print", "(", "\"\\nOptional modules:\"", ")", "modules", "=", "[", "\"csv\"", ",", "\"cuda\"", ",", "\"dataset\"", ",", "\"feather\"", ",", "\"flight\"", ",", "\"fs\"", ",", "\"gandiva\"", ",", "\"json\"", ",", "\"orc\"", ",", "\"parquet\"", ",", "\"plasma\"", "]", "for", "module", "in", "modules", ":", "status", "=", "\"Enabled\"", "if", "_module_is_available", "(", "module", ")", "else", "\"-\"", "print", "(", "f\" {module: <20}: {status: <8}\"", ")", "print", "(", "\"\\nFilesystems:\"", ")", "filesystems", "=", "[", "\"GcsFileSystem\"", ",", "\"HadoopFileSystem\"", ",", "\"S3FileSystem\"", "]", "for", "fs", "in", "filesystems", ":", "status", "=", "\"Enabled\"", "if", "_filesystem_is_available", "(", "fs", ")", "else", "\"-\"", "print", "(", "f\" {fs: <20}: {status: <8}\"", ")", "print", "(", "\"\\nCompression Codecs:\"", ")", "codecs", "=", "[", "\"brotli\"", ",", "\"bz2\"", ",", "\"gzip\"", ",", "\"lz4_frame\"", ",", "\"lz4\"", ",", "\"snappy\"", ",", "\"zstd\"", "]", "for", "codec", "in", "codecs", ":", "status", "=", "\"Enabled\"", "if", "Codec", ".", "is_available", "(", "codec", ")", "else", "\"-\"", "print", "(", "f\" {codec: <20}: {status: <8}\"", ")" ]

[ "Create", "a", "base", "class", "with", "a", "metaclass", "." ]

[ "def", "with_metaclass", "(", "meta", ",", "*", "bases", ")", ":", "# This requires a bit of explanation: the basic idea is to make a dummy", "# metaclass for one level of class instantiation that replaces itself with", "# the actual metaclass.", "class", "metaclass", "(", "meta", ")", ":", "def", "__new__", "(", "cls", ",", "name", ",", "this_bases", ",", "d", ")", ":", "return", "meta", "(", "name", ",", "bases", ",", "d", ")", "return", "type", ".", "__new__", "(", "metaclass", ",", "'temporary_class'", ",", "(", ")", ",", "{", "}", ")" ]

[ "Get", "credentials", "by", "calling", "assume", "role", "." ]

[ "def", "_get_credentials", "(", "self", ")", ":", "kwargs", "=", "self", ".", "_assume_role_kwargs", "(", ")", "client", "=", "self", ".", "_create_client", "(", ")", "return", "client", ".", "assume_role", "(", "*", "*", "kwargs", ")" ]

[ "Preprocesses", "the", "source", "with", "all", "extensions", ".", "This", "is", "automatically", "called", "for", "all", "parsing", "and", "compiling", "methods", "but", "*", "not", "*", "for", ":", "meth", ":", "lex", "because", "there", "you", "usually", "only", "want", "the", "actual", "source", "tokenized", "." ]

[ "def", "preprocess", "(", "self", ",", "source", ",", "name", "=", "None", ",", "filename", "=", "None", ")", ":", "return", "reduce", "(", "lambda", "s", ",", "e", ":", "e", ".", "preprocess", "(", "s", ",", "name", ",", "filename", ")", ",", "self", ".", "iter_extensions", "(", ")", ",", "text_type", "(", "source", ")", ")" ]

[ "Return", "a", "flat", "background", "workspace", "." ]

[ "def", "_createFlatBkg", "(", "ws", ",", "wsType", ",", "windowWidth", ",", "wsNames", ",", "algorithmLogging", ")", ":", "if", "wsType", "==", "common", ".", "WS_CONTENT_DETS", ":", "bkgWSName", "=", "wsNames", ".", "withSuffix", "(", "'flat_bkg_for_detectors'", ")", "else", ":", "bkgWSName", "=", "wsNames", ".", "withSuffix", "(", "'flat_bkg_for_monitors'", ")", "bkgWS", "=", "CalculateFlatBackground", "(", "InputWorkspace", "=", "ws", ",", "OutputWorkspace", "=", "bkgWSName", ",", "Mode", "=", "'Moving Average'", ",", "OutputMode", "=", "'Return Background'", ",", "SkipMonitors", "=", "False", ",", "NullifyNegativeValues", "=", "False", ",", "AveragingWindowWidth", "=", "windowWidth", ",", "EnableLogging", "=", "algorithmLogging", ")", "firstBinStart", "=", "bkgWS", ".", "dataX", "(", "0", ")", "[", "0", "]", "firstBinEnd", "=", "bkgWS", ".", "dataX", "(", "0", ")", "[", "1", "]", "bkgWS", "=", "CropWorkspace", "(", "InputWorkspace", "=", "bkgWS", ",", "OutputWorkspace", "=", "bkgWS", ",", "XMin", "=", "firstBinStart", ",", "XMax", "=", "firstBinEnd", ",", "EnableLogging", "=", "algorithmLogging", ")", "return", "bkgWS" ]

[ "Duplicate", "a", "node", ".", "This", "is", "part", "of", "the", "factory", ";", "override", "if", "you", "want", "another", "kind", "of", "node", "to", "be", "built", "." ]

[ "def", "dupNode", "(", "self", ",", "treeNode", ")", ":", "if", "treeNode", "is", "None", ":", "return", "None", "return", "treeNode", ".", "dupNode", "(", ")" ]

[ "Reverses", "the", "effects", "of", "setSrgbEncode", "." ]

[ "def", "delSrgbEncode", "(", "self", ")", ":", "if", "\"SrgbEncode\"", "in", "self", ".", "configuration", ":", "old_enable", "=", "self", ".", "configuration", "[", "\"SrgbEncode\"", "]", "del", "self", ".", "configuration", "[", "\"SrgbEncode\"", "]", "return", "self", ".", "reconfigure", "(", "old_enable", ",", "\"SrgbEncode\"", ")", "return", "True" ]

[ "Formats", "records", "and", "adds", "colors", "as", "needed", ".", "The", "records", "do", "not", "get", "a", "leading", "hour", "format", "if", "the", "logging", "level", "is", "above", "*", "INFO", "*", "." ]

[ "def", "format", "(", "self", ",", "rec", ")", ":", "try", ":", "msg", "=", "rec", ".", "msg", ".", "decode", "(", "'utf-8'", ")", "except", "Exception", ":", "msg", "=", "rec", ".", "msg", "use", "=", "colors_lst", "[", "'USE'", "]", "if", "(", "use", "==", "1", "and", "rec", ".", "stream", ".", "isatty", "(", ")", ")", "or", "use", "==", "2", ":", "c1", "=", "getattr", "(", "rec", ",", "'c1'", ",", "None", ")", "if", "c1", "is", "None", ":", "c1", "=", "''", "if", "rec", ".", "levelno", ">=", "logging", ".", "ERROR", ":", "c1", "=", "colors", ".", "RED", "elif", "rec", ".", "levelno", ">=", "logging", ".", "WARNING", ":", "c1", "=", "colors", ".", "YELLOW", "elif", "rec", ".", "levelno", ">=", "logging", ".", "INFO", ":", "c1", "=", "colors", ".", "GREEN", "c2", "=", "getattr", "(", "rec", ",", "'c2'", ",", "colors", ".", "NORMAL", ")", "msg", "=", "'%s%s%s'", "%", "(", "c1", ",", "msg", ",", "c2", ")", "else", ":", "# remove single \\r that make long lines in text files", "# and other terminal commands", "msg", "=", "re", ".", "sub", "(", "r'\\r(?!\\n)|\\x1B\\[(K|.*?(m|h|l))'", ",", "''", ",", "msg", ")", "if", "rec", ".", "levelno", ">=", "logging", ".", "INFO", ":", "# the goal of this is to format without the leading \"Logs, hour\" prefix", "if", "rec", ".", "args", ":", "return", "msg", "%", "rec", ".", "args", "return", "msg", "rec", ".", "msg", "=", "msg", "rec", ".", "c1", "=", "colors", ".", "PINK", "rec", ".", "c2", "=", "colors", ".", "NORMAL", "return", "logging", ".", "Formatter", ".", "format", "(", "self", ",", "rec", ")" ]

[ "Read", "a", "PNM", "header", "returning", "(", "format", "width", "height", "depth", "maxval", ")", ".", "width", "and", "height", "are", "in", "pixels", ".", "depth", "is", "the", "number", "of", "channels", "in", "the", "image", ";", "for", "PBM", "and", "PGM", "it", "is", "synthesized", "as", "1", "for", "PPM", "as", "3", ";", "for", "PAM", "images", "it", "is", "read", "from", "the", "header", ".", "maxval", "is", "synthesized", "(", "as", "1", ")", "for", "PBM", "images", "." ]

[ "def", "read_pnm_header", "(", "infile", ",", "supported", "=", "(", "'P5'", ",", "'P6'", ")", ")", ":", "# Generally, see http://netpbm.sourceforge.net/doc/ppm.html", "# and http://netpbm.sourceforge.net/doc/pam.html", "supported", "=", "[", "strtobytes", "(", "x", ")", "for", "x", "in", "supported", "]", "# Technically 'P7' must be followed by a newline, so by using", "# rstrip() we are being liberal in what we accept. I think this", "# is acceptable.", "type", "=", "infile", ".", "read", "(", "3", ")", ".", "rstrip", "(", ")", "if", "type", "not", "in", "supported", ":", "raise", "NotImplementedError", "(", "'file format %s not supported'", "%", "type", ")", "if", "type", "==", "strtobytes", "(", "'P7'", ")", ":", "# PAM header parsing is completely different.", "return", "read_pam_header", "(", "infile", ")", "# Expected number of tokens in header (3 for P4, 4 for P6)", "expected", "=", "4", "pbm", "=", "(", "'P1'", ",", "'P4'", ")", "if", "type", "in", "pbm", ":", "expected", "=", "3", "header", "=", "[", "type", "]", "# We have to read the rest of the header byte by byte because the", "# final whitespace character (immediately following the MAXVAL in", "# the case of P6) may not be a newline. Of course all PNM files in", "# the wild use a newline at this point, so it's tempting to use", "# readline; but it would be wrong.", "def", "getc", "(", ")", ":", "c", "=", "infile", ".", "read", "(", "1", ")", "if", "not", "c", ":", "raise", "Error", "(", "'premature EOF reading PNM header'", ")", "return", "c", "c", "=", "getc", "(", ")", "while", "True", ":", "# Skip whitespace that precedes a token.", "while", "c", ".", "isspace", "(", ")", ":", "c", "=", "getc", "(", ")", "# Skip comments.", "while", "c", "==", "'#'", ":", "while", "c", "not", "in", "'\\n\\r'", ":", "c", "=", "getc", "(", ")", "if", "not", "c", ".", "isdigit", "(", ")", ":", "raise", "Error", "(", "'unexpected character %s found in header'", "%", "c", ")", "# According to the specification it is legal to have comments", "# that appear in the middle of a token.", "# This is bonkers; I've never seen it; and it's a bit awkward to", "# code good lexers in Python (no goto). So we break on such", "# cases.", "token", "=", "strtobytes", "(", "''", ")", "while", "c", ".", "isdigit", "(", ")", ":", "token", "+=", "c", "c", "=", "getc", "(", ")", "# Slight hack. All \"tokens\" are decimal integers, so convert", "# them here.", "header", ".", "append", "(", "int", "(", "token", ")", ")", "if", "len", "(", "header", ")", "==", "expected", ":", "break", "# Skip comments (again)", "while", "c", "==", "'#'", ":", "while", "c", "not", "in", "'\\n\\r'", ":", "c", "=", "getc", "(", ")", "if", "not", "c", ".", "isspace", "(", ")", ":", "raise", "Error", "(", "'expected header to end with whitespace, not %s'", "%", "c", ")", "if", "type", "in", "pbm", ":", "# synthesize a MAXVAL", "header", ".", "append", "(", "1", ")", "depth", "=", "(", "1", ",", "3", ")", "[", "type", "==", "strtobytes", "(", "'P6'", ")", "]", "return", "header", "[", "0", "]", ",", "header", "[", "1", "]", ",", "header", "[", "2", "]", ",", "depth", ",", "header", "[", "3", "]" ]

[ "Adjust", "the", "saturation", "of", "an", "RGB", "image", "by", "a", "random", "factor", "." ]

[ "def", "random_saturation", "(", "image", ",", "lower", ",", "upper", ",", "seed", "=", "None", ")", ":", "if", "upper", "<=", "lower", ":", "raise", "ValueError", "(", "'upper must be > lower.'", ")", "if", "lower", "<", "0", ":", "raise", "ValueError", "(", "'lower must be non-negative.'", ")", "# Pick a float in [lower, upper]", "saturation_factor", "=", "random_ops", ".", "random_uniform", "(", "[", "]", ",", "lower", ",", "upper", ",", "seed", "=", "seed", ")", "return", "adjust_saturation", "(", "image", ",", "saturation_factor", ")" ]

[ "Returns", "the", "number", "of", "entries" ]

[ "def", "get_len", "(", "self", ")", ":", "return", "len", "(", "self", ".", "entry_list", ")" ]

[ "Clips", "fp32", "master", "gradients", "via", "torch", ".", "nn", ".", "utils", ".", "clip_grad_norm", "." ]

[ "def", "clip_fp32_grads", "(", "self", ",", "max_norm", ",", "norm_type", "=", "2", ")", ":", "if", "not", "self", ".", "overflow", ":", "fp32_params", "=", "[", "]", "for", "param_group", "in", "self", ".", "optimizer", ".", "param_groups", ":", "for", "param", "in", "param_group", "[", "'params'", "]", ":", "fp32_params", ".", "append", "(", "param", ")", "return", "torch", ".", "nn", ".", "utils", ".", "clip_grad_norm", "(", "fp32_params", ",", "max_norm", ",", "norm_type", ")", "else", ":", "return", "-", "1" ]

[ "Reports", "for", "long", "function", "bodies", "." ]

[ "def", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "function_state", ",", "error", ")", ":", "lines", "=", "clean_lines", ".", "lines", "line", "=", "lines", "[", "linenum", "]", "joined_line", "=", "''", "starting_func", "=", "False", "regexp", "=", "r'(\\w(\\w|::|\\*|\\&|\\s)*)\\('", "# decls * & space::name( ...", "match_result", "=", "Match", "(", "regexp", ",", "line", ")", "if", "match_result", ":", "# If the name is all caps and underscores, figure it's a macro and", "# ignore it, unless it's TEST or TEST_F.", "function_name", "=", "match_result", ".", "group", "(", "1", ")", ".", "split", "(", ")", "[", "-", "1", "]", "if", "function_name", "==", "'TEST'", "or", "function_name", "==", "'TEST_F'", "or", "(", "not", "Match", "(", "r'[A-Z_]+$'", ",", "function_name", ")", ")", ":", "starting_func", "=", "True", "if", "starting_func", ":", "body_found", "=", "False", "for", "start_linenum", "in", "xrange", "(", "linenum", ",", "clean_lines", ".", "NumLines", "(", ")", ")", ":", "start_line", "=", "lines", "[", "start_linenum", "]", "joined_line", "+=", "' '", "+", "start_line", ".", "lstrip", "(", ")", "if", "Search", "(", "r'(;|})'", ",", "start_line", ")", ":", "# Declarations and trivial functions", "body_found", "=", "True", "break", "# ... ignore", "if", "Search", "(", "r'{'", ",", "start_line", ")", ":", "body_found", "=", "True", "function", "=", "Search", "(", "r'((\\w|:)*)\\('", ",", "line", ")", ".", "group", "(", "1", ")", "if", "Match", "(", "r'TEST'", ",", "function", ")", ":", "# Handle TEST... macros", "parameter_regexp", "=", "Search", "(", "r'(\\(.*\\))'", ",", "joined_line", ")", "if", "parameter_regexp", ":", "# Ignore bad syntax", "function", "+=", "parameter_regexp", ".", "group", "(", "1", ")", "else", ":", "function", "+=", "'()'", "function_state", ".", "Begin", "(", "function", ")", "break", "if", "not", "body_found", ":", "# No body for the function (or evidence of a non-function) was found.", "error", "(", "filename", ",", "linenum", ",", "'readability/fn_size'", ",", "5", ",", "'Lint failed to find start of function body.'", ")", "elif", "Match", "(", "r'^\\}\\s*$'", ",", "line", ")", ":", "# function end", "function_state", ".", "Check", "(", "error", ",", "filename", ",", "linenum", ")", "function_state", ".", "End", "(", ")", "elif", "not", "Match", "(", "r'^\\s*$'", ",", "line", ")", ":", "function_state", ".", "Count", "(", ")" ]

[ "Booleans", "indicating", "if", "dates", "are", "the", "first", "day", "of", "the", "month", "." ]

[ "def", "is_month_start", "(", "self", ")", ":", "return", "(", "self", ".", "day", "==", "1", ")", ".", "fillna", "(", "False", ")" ]

[ "Read", "the", "TPIE", "stream", "in", "file_name", "(", "str", ")", "and", "print", "its", "header", "as", "JSON", "to", "output_file", "(", "file", ")", "." ]

[ "def", "read", "(", "file_name", ",", "output_file", ")", ":", "with", "open", "(", "file_name", ",", "'rb'", ")", "as", "stream", ":", "values", "=", "stream_header", ".", "unpack_from", "(", "stream", ".", "read", "(", "stream_header", ".", "size", ")", ")", "header_data", "=", "dict", "(", "zip", "(", "field_names", ",", "values", ")", ")", "json", ".", "dump", "(", "header_data", ",", "output_file", ",", "indent", "=", "0", ",", "sort_keys", "=", "True", ",", "separators", "=", "(", "','", ",", "': '", ")", ")", "output_file", ".", "write", "(", "'\\n'", ")", "output_file", ".", "flush", "(", ")" ]

[ "Set", "the", "foreground", "or", "background", "color", "to", "white", ".", "The", "foreground", "color", "will", "be", "set", "if", "fg", "tests", "True", ".", "The", "background", "color", "will", "be", "set", "if", "fg", "tests", "False", "." ]

[ "def", "white", "(", "self", ",", "fg", "=", "True", ")", ":", "if", "self", ".", "enabled", ":", "if", "fg", ":", "return", "\"\\x1b[37m\"", "else", ":", "return", "\"\\x1b[47m\"", "return", "''" ]

[ "Returns", "an", "available", "iOS", "Simulator", "device", "for", "testing", "." ]

[ "def", "lookup_or_create_device", "(", "self", ",", "name", ",", "device_type", ",", "runtime", ")", ":", "assert", "(", "runtime", ".", "available", ")", "testing_device", "=", "self", ".", "device", "(", "name", "=", "name", ",", "runtime", "=", "runtime", ",", "should_ignore_unavailable_devices", "=", "True", ")", "if", "testing_device", ":", "return", "testing_device", "testing_device", "=", "Device", ".", "create", "(", "name", ",", "device_type", ",", "runtime", ")", "assert", "(", "testing_device", ".", "available", ")", "return", "testing_device" ]

[]

[ "def", "tree_hash_from_str", "(", "str_as_bytes", ")", ":", "return", "bytes_to_hex", "(", "tree_hash", "(", "chunk_hashes", "(", "str_as_bytes", ")", ")", ")" ]

[ "Initialize", "to", "empty", "." ]

[ "def", "reset", "(", "self", ")", ":", "self", ".", "settings", "=", "''", "self", ".", "files", "=", "{", "}" ]

[ "FakeLearnedScaleQuantPerChannelGradD" ]

[ "def", "fake_learned_scale_quant_perchannel_grad_d_compute", "(", "dout", ",", "input_data", ",", "alpha_data", ",", "quant_max_data", ",", "neg_trunc", ",", "kernel_name", "=", "\"fake_learned_scale_quant_perchannel_grad_d\"", ")", ":", "input_shape", "=", "te", ".", "lang", ".", "cce", ".", "util", ".", "shape_to_list", "(", "input_data", ".", "shape", ")", "eps", "=", "tvm", ".", "const", "(", "1e-6", ",", "input_data", ".", "dtype", ")", "alpha_data", "=", "te", ".", "lang", ".", "cce", ".", "vcmpsel", "(", "te", ".", "lang", ".", "cce", ".", "vabs", "(", "alpha_data", ")", ",", "eps", ",", "'ge'", ",", "alpha_data", ",", "eps", ")", "alpha_data", "=", "te", ".", "lang", ".", "cce", ".", "broadcast", "(", "alpha_data", ",", "input_shape", ",", "input_data", ".", "dtype", ")", "quant_max_data", "=", "te", ".", "lang", ".", "cce", ".", "broadcast", "(", "quant_max_data", ",", "input_shape", ",", "input_data", ".", "dtype", ")", "input_x", "=", "te", ".", "lang", ".", "cce", ".", "vdiv", "(", "input_data", ",", "alpha_data", ")", "input_div_alpha", "=", "input_x", "if", "neg_trunc", ":", "input_x", "=", "te", ".", "lang", ".", "cce", ".", "round_to", "(", "input_x", ",", "1.0", ",", "0.0", ")", "else", ":", "input_x", "=", "te", ".", "lang", ".", "cce", ".", "round_to", "(", "input_x", ",", "1.0", ",", "-", "1.0", ")", "nudge_input", "=", "te", ".", "lang", ".", "cce", ".", "floor", "(", "te", ".", "lang", ".", "cce", ".", "vadds", "(", "te", ".", "lang", ".", "cce", ".", "vmul", "(", "input_x", ",", "quant_max_data", ")", ",", "0.5", ")", ")", "input_quant", "=", "te", ".", "lang", ".", "cce", ".", "vdiv", "(", "nudge_input", ",", "quant_max_data", ")", "dtype", "=", "input_div_alpha", ".", "dtype", ".", "lower", "(", ")", "shape", "=", "te", ".", "lang", ".", "cce", ".", "util", ".", "shape_to_list", "(", "input_div_alpha", ".", "shape", ")", "dx", "=", "dout", "tensor_one", "=", "tvm", ".", "const", "(", "1.0", ",", "input_div_alpha", ".", "dtype", ")", "tensor_one", "=", "te", ".", "lang", ".", "cce", ".", "broadcast", "(", "tensor_one", ",", "shape", ")", "out_of_upper_bounds", "=", "te", ".", "lang", ".", "cce", ".", "vcmpsel", "(", "input_div_alpha", ",", "1.0", ",", "'gt'", ",", "1.0", ",", "0.0", ")", "if", "neg_trunc", ":", "out_of_lower_bounds", "=", "te", ".", "lang", ".", "cce", ".", "vcmpsel", "(", "input_div_alpha", ",", "0.0", ",", "'lt'", ",", "1.0", ",", "0.0", ")", "else", ":", "out_of_lower_bounds", "=", "te", ".", "lang", ".", "cce", ".", "vcmpsel", "(", "input_div_alpha", ",", "-", "1.0", ",", "'lt'", ",", "1.0", ",", "0.0", ")", "out_of_bounds", "=", "te", ".", "lang", ".", "cce", ".", "vadd", "(", "out_of_lower_bounds", ",", "out_of_upper_bounds", ")", "dx", "=", "te", ".", "lang", ".", "cce", ".", "vmul", "(", "dx", ",", "te", ".", "lang", ".", "cce", ".", "vsub", "(", "tensor_one", ",", "out_of_bounds", ")", ")", "sign", "=", "_sign_function", "(", "dtype", ",", "input_div_alpha", ")", "# The following lines are equivalent to :", "# dalpha_each = dout * sign if out of bounds", "# dout * (input_quant - input_div_alpha) if within bounds", "quant_error", "=", "te", ".", "lang", ".", "cce", ".", "vsub", "(", "input_quant", ",", "input_div_alpha", ")", "within_bounds", "=", "te", ".", "lang", ".", "cce", ".", "vsub", "(", "tensor_one", ",", "out_of_bounds", ")", "error_within_bounds", "=", "te", ".", "lang", ".", "cce", ".", "vmul", "(", "quant_error", ",", "within_bounds", ")", "grad_range", "=", "te", ".", "lang", ".", "cce", ".", "vmadd", "(", "sign", ",", "error_within_bounds", ",", "out_of_bounds", ")", "dalpha_each", "=", "te", ".", "lang", ".", "cce", ".", "vmul", "(", "dout", ",", "grad_range", ")", "return", "[", "dx", ",", "dalpha_each", "]" ]

[ "Alter", "axes", "labels", "." ]

[ "def", "rename", "(", "self", ",", "mapper", ":", "Optional", "[", "Renamer", "]", "=", "None", ",", "*", ",", "index", ":", "Optional", "[", "Renamer", "]", "=", "None", ",", "columns", ":", "Optional", "[", "Renamer", "]", "=", "None", ",", "axis", ":", "Optional", "[", "Axis", "]", "=", "None", ",", "copy", ":", "bool", "=", "True", ",", "inplace", ":", "bool", "=", "False", ",", "level", ":", "Optional", "[", "Level", "]", "=", "None", ",", "errors", ":", "str", "=", "\"ignore\"", ",", ")", "->", "Optional", "[", "\"DataFrame\"", "]", ":", "return", "super", "(", ")", ".", "rename", "(", "mapper", "=", "mapper", ",", "index", "=", "index", ",", "columns", "=", "columns", ",", "axis", "=", "axis", ",", "copy", "=", "copy", ",", "inplace", "=", "inplace", ",", "level", "=", "level", ",", "errors", "=", "errors", ",", ")" ]

[ "An", "Alias", "is", "not", "recorded", "in", ".", "sconsign", "files" ]

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

[ "Get", "id", "of", "current", "thread", "suitable", "for", "logging", "as", "an", "unsigned", "quantity", "." ]

[ "def", "_get_thread_id", "(", ")", ":", "# pylint: disable=protected-access", "thread_id", "=", "six", ".", "moves", ".", "_thread", ".", "get_ident", "(", ")", "# pylint:enable=protected-access", "return", "thread_id", "&", "_THREAD_ID_MASK" ]

[ "Initialize", "a", "BaseLogger", "." ]

[ "def", "__init__", "(", "self", ",", "name", ",", "logging_config", "=", "None", ",", "build_logger_server", "=", "None", ",", "parent", "=", "None", ")", ":", "logging", ".", "Logger", ".", "__init__", "(", "self", ",", "name", ",", "level", "=", "logging", ".", "DEBUG", ")", "self", ".", "_logging_config", "=", "logging_config", "self", ".", "_build_logger_server", "=", "build_logger_server", "if", "parent", ":", "self", ".", "parent", "=", "parent", "self", ".", "propagate", "=", "True" ]

[ "Calculates", "a", "covariance", "matrix", "shrunk", "on", "the", "diagonal" ]

[ "def", "shrunk_covariance", "(", "emp_cov", ",", "shrinkage", "=", "0.1", ")", ":", "emp_cov", "=", "check_array", "(", "emp_cov", ")", "n_features", "=", "emp_cov", ".", "shape", "[", "0", "]", "mu", "=", "np", ".", "trace", "(", "emp_cov", ")", "/", "n_features", "shrunk_cov", "=", "(", "1.", "-", "shrinkage", ")", "*", "emp_cov", "shrunk_cov", ".", "flat", "[", ":", ":", "n_features", "+", "1", "]", "+=", "shrinkage", "*", "mu", "return", "shrunk_cov" ]

[ "Creates", "a", "constraint", "function", "that", "returns", "true", "if", "the", "current", "robot", "has", "the", "ball", ".", ":", "return", ":", "Constraint", "function", "for", "current", "robot", "having", "the", "ball", "." ]

[ "def", "has_ball", "(", ")", "->", "role", ".", "ConstraintFn", ":", "def", "constraint_fn", "(", "robot", ":", "rc", ".", "Robot", ",", "prev_result", ":", "Optional", "[", "role", ".", "RoleResult", "]", ",", "world_state", ":", "rc", ".", "WorldState", ",", ")", "->", "bool", ":", "return", "robot", ".", "has_ball_sense", "return", "constraint_fn" ]

[ "B", "-", "batch", "size", "U", "-", "label", "length", "H", "-", "Hidden", "dimension", "size", "L", "-", "Number", "of", "decoder", "layers", "=", "2" ]

[ "def", "predict", "(", "self", ",", "y", ",", "state", "=", "None", ",", "add_sos", "=", "True", ")", ":", "if", "isinstance", "(", "y", ",", "torch", ".", "Tensor", ")", ":", "y", "=", "self", ".", "prediction", "[", "\"embed\"", "]", "(", "y", ")", "elif", "isinstance", "(", "y", ",", "torch", ".", "nn", ".", "utils", ".", "rnn", ".", "PackedSequence", ")", ":", "# Teacher-forced training mode", "# (B, U) -> (B, U, H)", "y", ".", "_replace", "(", "data", "=", "self", ".", "prediction", "[", "\"embed\"", "]", "(", "y", ".", "data", ")", ")", "else", ":", "# inference mode", "B", "=", "1", "if", "state", "is", "None", "else", "state", "[", "0", "]", ".", "size", "(", "1", ")", "y", "=", "torch", ".", "zeros", "(", "(", "B", ",", "1", ",", "self", ".", "pred_n_hidden", ")", ")", ".", "to", "(", "device", "=", "self", ".", "joint_net", "[", "0", "]", ".", "weight", ".", "device", ",", "dtype", "=", "self", ".", "joint_net", "[", "0", "]", ".", "weight", ".", "dtype", ")", "# preprend blank \"start of sequence\" symbol", "if", "add_sos", ":", "B", ",", "U", ",", "H", "=", "y", ".", "shape", "start", "=", "torch", ".", "zeros", "(", "(", "B", ",", "1", ",", "H", ")", ")", ".", "to", "(", "device", "=", "y", ".", "device", ",", "dtype", "=", "y", ".", "dtype", ")", "y", "=", "torch", ".", "cat", "(", "[", "start", ",", "y", "]", ",", "dim", "=", "1", ")", ".", "contiguous", "(", ")", "# (B, U + 1, H)", "else", ":", "start", "=", "None", "# makes del call later easier", "# if state is None:", "# batch = y.size(0)", "# state = [", "# (torch.zeros(batch, self.pred_n_hidden, dtype=y.dtype, device=y.device),", "# torch.zeros(batch, self.pred_n_hidden, dtype=y.dtype, device=y.device))", "# for _ in range(self.pred_rnn_layers)", "# ]", "y", "=", "y", ".", "transpose", "(", "0", ",", "1", ")", "# .contiguous() # (U + 1, B, H)", "g", ",", "hid", "=", "self", ".", "prediction", "[", "\"dec_rnn\"", "]", "(", "y", ",", "state", ")", "g", "=", "g", ".", "transpose", "(", "0", ",", "1", ")", "# .contiguous() # (B, U + 1, H)", "del", "y", ",", "start", ",", "state", "return", "g", ",", "hid" ]

[ "A", "cached", "operation", "which", "reads", "the", "value", "of", "this", "variable", "." ]

[ "def", "value", "(", "self", ")", ":", "if", "self", ".", "_cached_value", "is", "not", "None", ":", "return", "self", ".", "_cached_value", "with", "ops", ".", "colocate_with", "(", "None", ",", "ignore_existing", "=", "True", ")", ":", "with", "ops", ".", "device", "(", "self", ".", "_handle", ".", "device", ")", ":", "return", "gen_resource_variable_ops", ".", "read_variable_op", "(", "self", ".", "_handle", ",", "dtype", "=", "self", ".", "_dtype", ")" ]

[ "Disconnect", "(", "self", "int", "id", "int", "lastId", "=", "-", "1", "EventType", "eventType", "=", "wxEVT_NULL", "PyObject", "func", "=", "None", ")", "-", ">", "bool" ]

[ "def", "Disconnect", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "EvtHandler_Disconnect", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "Shape", "function", "for", "a", "BiasAddGrad", "op", "." ]

[ "def", "bias_add_grad_shape", "(", "op", ")", ":", "input_shape", "=", "op", ".", "inputs", "[", "0", "]", ".", "get_shape", "(", ")", ".", "with_rank_at_least", "(", "2", ")", "try", ":", "data_format", "=", "op", ".", "get_attr", "(", "\"data_format\"", ")", "except", "ValueError", ":", "data_format", "=", "None", "if", "data_format", "==", "b\"NCHW\"", ":", "output_shape", "=", "input_shape", "[", "-", "3", "]", "else", ":", "output_shape", "=", "input_shape", "[", "-", "1", "]", "return", "[", "output_shape", "]" ]

[ "Construct", "an", "image", "path", "from", "the", "image", "s", "index", "identifier", "." ]

[ "def", "image_path_from_index", "(", "self", ",", "index", ")", ":", "image_path", "=", "os", ".", "path", ".", "join", "(", "self", ".", "_data_path", ",", "index", "+", "self", ".", "_image_ext", ")", "assert", "os", ".", "path", ".", "exists", "(", "image_path", ")", ",", "'Path does not exist: {}'", ".", "format", "(", "image_path", ")", "return", "image_path" ]

[ "Prepend", "message", "to", "the", "exception", "." ]

[ "def", "prepend_message_to_exception", "(", "message", ",", "exc", ")", ":", "exc", ".", "args", "=", "(", "message", "+", "str", "(", "exc", ")", ",", ")", "return" ]

[ "Initializes", "a", "new", "database", "." ]

[ "def", "__init__", "(", "self", ",", "no_pruning", "=", "False", ")", ":", "EventConsumer", ".", "__init__", "(", "self", ")", "self", ".", "_no_pruning", "=", "no_pruning", "# Processes by id maps from process ID to command line.", "self", ".", "_processes_by_id", "=", "{", "}", "# Threads by id maps from thread ID to owning process ID.", "self", ".", "_threads_by_id", "=", "{", "}" ]

[ "Determine", "the", "subject", "for", "the", "email", "." ]

[ "def", "getSubject", "(", "self", ",", "record", ")", ":", "return", "self", ".", "subject" ]

[]

[ "def", "__init__", "(", "self", ",", "prefer_binary", "=", "False", ",", "# type: bool", "allow_all_prereleases", "=", "False", ",", "# type: bool", ")", ":", "# type: (...) -> None", "self", ".", "allow_all_prereleases", "=", "allow_all_prereleases", "self", ".", "prefer_binary", "=", "prefer_binary" ]

[ "Convenience", "function", "which", "attempts", "to", "statically", "apply", "logical_not", "." ]

[ "def", "_logical_not", "(", "x", ")", ":", "x_", "=", "_static_value", "(", "x", ")", "if", "x_", "is", "None", ":", "return", "math_ops", ".", "logical_not", "(", "x", ")", "return", "constant_op", ".", "constant", "(", "np", ".", "logical_not", "(", "x_", ")", ")" ]

[ "Set", "whether", "to", "simplify", "or", "not", ".", "If", "True", "it", "will", "avoid", "displaying", "equal", "edges", "i", ".", "e", ".", "only", "one", "edge", "between", "two", "nodes", ".", "removing", "the", "duplicated", "ones", "." ]

[ "def", "set_simplify", "(", "self", ",", "simplify", ")", ":", "self", ".", "obj_dict", "[", "'simplify'", "]", "=", "simplify" ]

[ "Method", "for", "importing", "web", "transaction", "variables", "in", "bulk", "." ]

[ "def", "webInput", "(", "self", ",", "names", ",", "namesMulti", "=", "(", ")", ",", "default", "=", "''", ",", "src", "=", "'f'", ",", "defaultInt", "=", "0", ",", "defaultFloat", "=", "0.00", ",", "badInt", "=", "0", ",", "badFloat", "=", "0.00", ",", "debug", "=", "False", ")", ":", "src", "=", "src", ".", "lower", "(", ")", "isCgi", "=", "not", "self", ".", "_CHEETAH__isControlledByWebKit", "if", "isCgi", "and", "src", "in", "(", "'f'", ",", "'v'", ")", ":", "global", "_formUsedByWebInput", "if", "_formUsedByWebInput", "is", "None", ":", "_formUsedByWebInput", "=", "cgi", ".", "FieldStorage", "(", ")", "source", ",", "func", "=", "'field'", ",", "_formUsedByWebInput", ".", "getvalue", "elif", "isCgi", "and", "src", "==", "'c'", ":", "raise", "RuntimeError", "(", "\"can't get cookies from a CGI script\"", ")", "elif", "isCgi", "and", "src", "==", "'s'", ":", "raise", "RuntimeError", "(", "\"can't get session variables from a CGI script\"", ")", "elif", "isCgi", "and", "src", "==", "'v'", ":", "source", ",", "func", "=", "'value'", ",", "self", ".", "request", "(", ")", ".", "value", "elif", "isCgi", "and", "src", "==", "'s'", ":", "source", ",", "func", "=", "'session'", ",", "self", ".", "request", "(", ")", ".", "session", "(", ")", ".", "value", "elif", "src", "==", "'f'", ":", "source", ",", "func", "=", "'field'", ",", "self", ".", "request", "(", ")", ".", "field", "elif", "src", "==", "'c'", ":", "source", ",", "func", "=", "'cookie'", ",", "self", ".", "request", "(", ")", ".", "cookie", "elif", "src", "==", "'v'", ":", "source", ",", "func", "=", "'value'", ",", "self", ".", "request", "(", ")", ".", "value", "elif", "src", "==", "'s'", ":", "source", ",", "func", "=", "'session'", ",", "self", ".", "request", "(", ")", ".", "session", "(", ")", ".", "value", "else", ":", "raise", "TypeError", "(", "\"arg 'src' invalid\"", ")", "sources", "=", "source", "+", "'s'", "converters", "=", "{", "''", ":", "_Converter", "(", "'string'", ",", "None", ",", "default", ",", "default", ")", ",", "'int'", ":", "_Converter", "(", "'int'", ",", "int", ",", "defaultInt", ",", "badInt", ")", ",", "'float'", ":", "_Converter", "(", "'float'", ",", "float", ",", "defaultFloat", ",", "badFloat", ")", ",", "}", "#pprint.pprint(locals()); return {}", "dic", "=", "{", "}", "# Destination.", "for", "name", "in", "names", ":", "k", ",", "v", "=", "_lookup", "(", "name", ",", "func", ",", "False", ",", "converters", ")", "dic", "[", "k", "]", "=", "v", "for", "name", "in", "namesMulti", ":", "k", ",", "v", "=", "_lookup", "(", "name", ",", "func", ",", "True", ",", "converters", ")", "dic", "[", "k", "]", "=", "v", "# At this point, 'dic' contains all the keys/values we want to keep.", "# We could split the method into a superclass", "# method for Webware/WebwareExperimental and a subclass for Cheetah.", "# The superclass would merely 'return dic'. The subclass would", "# 'dic = super(ThisClass, self).webInput(names, namesMulti, ...)'", "# and then the code below.", "if", "debug", ":", "print", "(", "\"<PRE>\\n\"", "+", "pprint", ".", "pformat", "(", "dic", ")", "+", "\"\\n</PRE>\\n\\n\"", ")", "self", ".", "searchList", "(", ")", ".", "insert", "(", "0", ",", "dic", ")", "return", "dic" ]

[ "Check", "for", "common", "Python", "keywords", "in", "spec", "." ]

[ "def", "check_keywords", "(", "spec", ")", ":", "spec", "=", "re", ".", "sub", "(", "QUOTED", ",", "\"\"", ",", "spec", ")", "match", "=", "re", ".", "search", "(", "KEYWORDS", ",", "spec", ")", "if", "match", ":", "raise", "ValueError", "(", "\"keyword '%s' found in spec\"", "%", "match", ".", "group", "(", "1", ")", ")" ]

[]

[ "def", "shutdown", "(", "self", ")", ":", "self", ".", "_shutdown", "(", "\"external call\"", ")", "return", "1", ",", "\"success\"", ",", "1" ]

[ "Extends", "the", "stack", "of", "variable", "renamings", "." ]

[ "def", "extend_context", "(", "context", ":", "List", "[", "Callable", "[", "[", "Text", "]", ",", "Text", "]", "]", ",", "old_name", ":", "Text", ",", "new_name", ":", "Text", ")", ":", "new_context", "=", "list", "(", "context", ")", "new_context", ".", "append", "(", "lambda", "s", ":", "new_name", "if", "s", "==", "old_name", "else", "s", ")", "return", "new_context" ]

[ "Return", "the", "utility", "commands", "list", "for", "the", "menu", "." ]

[ "def", "get_draft_utility_commands_menu", "(", ")", ":", "return", "[", "\"Draft_SetStyle\"", ",", "\"Draft_ApplyStyle\"", ",", "\"Separator\"", ",", "\"Draft_Layer\"", ",", "\"Draft_AddNamedGroup\"", ",", "\"Draft_AddToGroup\"", ",", "\"Draft_SelectGroup\"", ",", "\"Draft_ToggleConstructionMode\"", ",", "\"Draft_AddConstruction\"", ",", "\"Separator\"", ",", "\"Draft_ToggleDisplayMode\"", ",", "\"Draft_ToggleGrid\"", ",", "\"Draft_SelectPlane\"", ",", "\"Draft_WorkingPlaneProxy\"", ",", "\"Separator\"", ",", "\"Draft_Heal\"", ",", "\"Draft_ToggleContinueMode\"", ",", "\"Draft_ShowSnapBar\"", "]" ]

[ "Open", "the", "current", "base", "file", "with", "the", "(", "original", ")", "mode", "and", "encoding", ".", "Return", "the", "resulting", "stream", "." ]

[ "def", "_open", "(", "self", ")", ":", "if", "self", ".", "encoding", "is", "None", ":", "stream", "=", "open", "(", "self", ".", "baseFilename", ",", "self", ".", "mode", ")", "else", ":", "stream", "=", "codecs", ".", "open", "(", "self", ".", "baseFilename", ",", "self", ".", "mode", ",", "self", ".", "encoding", ")", "return", "stream" ]

[ "Writes", "the", "GLES2", "Implemention", "unit", "test", "." ]

[ "def", "WriteGLES2Header", "(", "self", ",", "f", ")", ":", "self", ".", "type_handler", ".", "WriteGLES2Header", "(", "self", ",", "f", ")" ]

[ "Generate", "placeholder", "variables", "to", "represent", "the", "input", "tensors", "." ]

[ "def", "placeholder_inputs", "(", ")", ":", "images_placeholder", "=", "tf", ".", "placeholder", "(", "tf", ".", "float32", ",", "shape", "=", "(", "None", ",", "mnist", ".", "IMAGE_PIXELS", ")", ")", "labels_placeholder", "=", "tf", ".", "placeholder", "(", "tf", ".", "int32", ",", "shape", "=", "(", "None", ")", ")", "return", "images_placeholder", ",", "labels_placeholder" ]

[ "Add", "documentation", "to", "a", "function", "." ]

[ "def", "_add_doc", "(", "func", ",", "doc", ")", ":", "func", ".", "__doc__", "=", "doc" ]

[ "Update", "nesting", "state", "with", "current", "line", "." ]

[ "def", "Update", "(", "self", ",", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", ":", "line", "=", "clean_lines", ".", "elided", "[", "linenum", "]", "# Update pp_stack first", "self", ".", "UpdatePreprocessor", "(", "line", ")", "# Count parentheses. This is to avoid adding struct arguments to", "# the nesting stack.", "if", "self", ".", "stack", ":", "inner_block", "=", "self", ".", "stack", "[", "-", "1", "]", "depth_change", "=", "line", ".", "count", "(", "'('", ")", "-", "line", ".", "count", "(", "')'", ")", "inner_block", ".", "open_parentheses", "+=", "depth_change", "# Also check if we are starting or ending an inline assembly block.", "if", "inner_block", ".", "inline_asm", "in", "(", "_NO_ASM", ",", "_END_ASM", ")", ":", "if", "(", "depth_change", "!=", "0", "and", "inner_block", ".", "open_parentheses", "==", "1", "and", "_MATCH_ASM", ".", "match", "(", "line", ")", ")", ":", "# Enter assembly block", "inner_block", ".", "inline_asm", "=", "_INSIDE_ASM", "else", ":", "# Not entering assembly block. If previous line was _END_ASM,", "# we will now shift to _NO_ASM state.", "inner_block", ".", "inline_asm", "=", "_NO_ASM", "elif", "(", "inner_block", ".", "inline_asm", "==", "_INSIDE_ASM", "and", "inner_block", ".", "open_parentheses", "==", "0", ")", ":", "# Exit assembly block", "inner_block", ".", "inline_asm", "=", "_END_ASM", "# Consume namespace declaration at the beginning of the line. Do", "# this in a loop so that we catch same line declarations like this:", "# namespace proto2 { namespace bridge { class MessageSet; } }", "while", "True", ":", "# Match start of namespace. The \"\\b\\s*\" below catches namespace", "# declarations even if it weren't followed by a whitespace, this", "# is so that we don't confuse our namespace checker. The", "# missing spaces will be flagged by CheckSpacing.", "namespace_decl_match", "=", "Match", "(", "r'^\\s*namespace\\b\\s*([:\\w]+)?(.*)$'", ",", "line", ")", "if", "not", "namespace_decl_match", ":", "break", "new_namespace", "=", "_NamespaceInfo", "(", "namespace_decl_match", ".", "group", "(", "1", ")", ",", "linenum", ")", "self", ".", "stack", ".", "append", "(", "new_namespace", ")", "line", "=", "namespace_decl_match", ".", "group", "(", "2", ")", "if", "line", ".", "find", "(", "'{'", ")", "!=", "-", "1", ":", "new_namespace", ".", "seen_open_brace", "=", "True", "line", "=", "line", "[", "line", ".", "find", "(", "'{'", ")", "+", "1", ":", "]", "# Look for a class declaration in whatever is left of the line", "# after parsing namespaces. The regexp accounts for decorated classes", "# such as in:", "# class LOCKABLE API Object {", "# };", "#", "# Templates with class arguments may confuse the parser, for example:", "# template <class T", "# class Comparator = less<T>,", "# class Vector = vector<T> >", "# class HeapQueue {", "#", "# Because this parser has no nesting state about templates, by the", "# time it saw \"class Comparator\", it may think that it's a new class.", "# Nested templates have a similar problem:", "# template <", "# typename ExportedType,", "# typename TupleType,", "# template <typename, typename> class ImplTemplate>", "#", "# To avoid these cases, we ignore classes that are followed by '=' or '>'", "class_decl_match", "=", "Match", "(", "r'\\s*(template\\s*<[\\w\\s<>,:]*>\\s*)?'", "r'(class|struct)\\s+([A-Z_]+\\s+)*(\\w+(?:::\\w+)*)'", "r'(([^=>]|<[^<>]*>|<[^<>]*<[^<>]*>\\s*>)*)$'", ",", "line", ")", "if", "(", "class_decl_match", "and", "(", "not", "self", ".", "stack", "or", "self", ".", "stack", "[", "-", "1", "]", ".", "open_parentheses", "==", "0", ")", ")", ":", "self", ".", "stack", ".", "append", "(", "_ClassInfo", "(", "class_decl_match", ".", "group", "(", "4", ")", ",", "class_decl_match", ".", "group", "(", "2", ")", ",", "clean_lines", ",", "linenum", ")", ")", "line", "=", "class_decl_match", ".", "group", "(", "5", ")", "# If we have not yet seen the opening brace for the innermost block,", "# run checks here.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "CheckBegin", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "# Update access control if we are inside a class/struct", "if", "self", ".", "stack", "and", "isinstance", "(", "self", ".", "stack", "[", "-", "1", "]", ",", "_ClassInfo", ")", ":", "classinfo", "=", "self", ".", "stack", "[", "-", "1", "]", "access_match", "=", "Match", "(", "r'^(.*)\\b(public|private|protected|signals)(\\s+(?:slots\\s*)?)?'", "r':(?:[^:]|$)'", ",", "line", ")", "if", "access_match", ":", "classinfo", ".", "access", "=", "access_match", ".", "group", "(", "2", ")", "# Check that access keywords are indented +1 space. Skip this", "# check if the keywords are not preceded by whitespaces.", "indent", "=", "access_match", ".", "group", "(", "1", ")", "if", "(", "len", "(", "indent", ")", "!=", "classinfo", ".", "class_indent", "+", "1", "and", "Match", "(", "r'^\\s*$'", ",", "indent", ")", ")", ":", "if", "classinfo", ".", "is_struct", ":", "parent", "=", "'struct '", "+", "classinfo", ".", "name", "else", ":", "parent", "=", "'class '", "+", "classinfo", ".", "name", "slots", "=", "''", "if", "access_match", ".", "group", "(", "3", ")", ":", "slots", "=", "access_match", ".", "group", "(", "3", ")", "error", "(", "filename", ",", "linenum", ",", "'whitespace/indent'", ",", "3", ",", "'%s%s: should be indented +1 space inside %s'", "%", "(", "access_match", ".", "group", "(", "2", ")", ",", "slots", ",", "parent", ")", ")", "# Consume braces or semicolons from what's left of the line", "while", "True", ":", "# Match first brace, semicolon, or closed parenthesis.", "matched", "=", "Match", "(", "r'^[^{;)}]*([{;)}])(.*)$'", ",", "line", ")", "if", "not", "matched", ":", "break", "token", "=", "matched", ".", "group", "(", "1", ")", "if", "token", "==", "'{'", ":", "# If namespace or class hasn't seen a opening brace yet, mark", "# namespace/class head as complete. Push a new block onto the", "# stack otherwise.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "seen_open_brace", "=", "True", "else", ":", "self", ".", "stack", ".", "append", "(", "_BlockInfo", "(", "True", ")", ")", "if", "_MATCH_ASM", ".", "match", "(", "line", ")", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "inline_asm", "=", "_BLOCK_ASM", "elif", "token", "==", "';'", "or", "token", "==", "')'", ":", "# If we haven't seen an opening brace yet, but we already saw", "# a semicolon, this is probably a forward declaration. Pop", "# the stack for these.", "#", "# Similarly, if we haven't seen an opening brace yet, but we", "# already saw a closing parenthesis, then these are probably", "# function arguments with extra \"class\" or \"struct\" keywords.", "# Also pop these stack for these.", "if", "not", "self", ".", "SeenOpenBrace", "(", ")", ":", "self", ".", "stack", ".", "pop", "(", ")", "else", ":", "# token == '}'", "# Perform end of block checks and pop the stack.", "if", "self", ".", "stack", ":", "self", ".", "stack", "[", "-", "1", "]", ".", "CheckEnd", "(", "filename", ",", "clean_lines", ",", "linenum", ",", "error", ")", "self", ".", "stack", ".", "pop", "(", ")", "line", "=", "matched", ".", "group", "(", "2", ")" ]

[ "Returns", "a", "list", "of", "all", "the", "node", "and", "sub", "nodes", "." ]

[ "def", "FlattenFilter", "(", "node", ")", ":", "node_list", "=", "[", "]", "if", "(", "node", ".", "attributes", "and", "node", ".", "getAttribute", "(", "'Name'", ")", "==", "'_excluded_files'", ")", ":", "# We don't add the \"_excluded_files\" filter.", "return", "[", "]", "for", "current", "in", "node", ".", "childNodes", ":", "if", "current", ".", "nodeName", "==", "'Filter'", ":", "node_list", ".", "extend", "(", "FlattenFilter", "(", "current", ")", ")", "else", ":", "node_list", ".", "append", "(", "current", ")", "return", "node_list" ]

[ "Prints", "a", "list", "of", "all", "the", "error", "-", "categories", "used", "by", "error", "messages", "." ]

[ "def", "PrintCategories", "(", ")", ":", "sys", ".", "stderr", ".", "write", "(", "''", ".", "join", "(", "' %s\\n'", "%", "cat", "for", "cat", "in", "_ERROR_CATEGORIES", ")", ")", "sys", ".", "exit", "(", "0", ")" ]

[ "Check", "to", "see", "whether", "key", "is", "in", "rhs", "." ]

[ "def", "equals", "(", "self", ",", "rhs", ")", ":", "return", "self", ".", "_key", "in", "rhs" ]

[ "Apply", "template", "parameters", "to", "this", "object", "." ]

[ "def", "template", "(", "self", ",", "*", "args", ":", "SafeExpType", ")", "->", "\"MockObj\"", ":", "if", "len", "(", "args", ")", "!=", "1", "or", "not", "isinstance", "(", "args", "[", "0", "]", ",", "TemplateArguments", ")", ":", "args", "=", "TemplateArguments", "(", "*", "args", ")", "else", ":", "args", "=", "args", "[", "0", "]", "return", "MockObj", "(", "f\"{self.base}{args}\"", ")" ]

[ "Decorator", ":", "attach", "new", "configuration", "functions", "to", ":", "py", ":", "class", ":", "waflib", ".", "Build", ".", "BuildContext", "and", ":", "py", ":", "class", ":", "waflib", ".", "Configure", ".", "ConfigurationContext", ".", "The", "methods", "bound", "will", "accept", "a", "parameter", "named", "mandatory", "to", "disable", "the", "configuration", "errors", "::" ]

[ "def", "conf", "(", "f", ")", ":", "def", "fun", "(", "*", "k", ",", "*", "*", "kw", ")", ":", "mandatory", "=", "True", "if", "'mandatory'", "in", "kw", ":", "mandatory", "=", "kw", "[", "'mandatory'", "]", "del", "kw", "[", "'mandatory'", "]", "try", ":", "return", "f", "(", "*", "k", ",", "*", "*", "kw", ")", "except", "Errors", ".", "ConfigurationError", ":", "if", "mandatory", ":", "raise", "setattr", "(", "Options", ".", "OptionsContext", ",", "f", ".", "__name__", ",", "fun", ")", "setattr", "(", "ConfigurationContext", ",", "f", ".", "__name__", ",", "fun", ")", "setattr", "(", "Build", ".", "BuildContext", ",", "f", ".", "__name__", ",", "fun", ")", "return", "f" ]

[ "For", "each", "element", "in", "a", "return", "a", "copy", "of", "the", "string", "where", "all", "characters", "occurring", "in", "the", "optional", "argument", "deletechars", "are", "removed", "and", "the", "remaining", "characters", "have", "been", "mapped", "through", "the", "given", "translation", "table", "." ]

[ "def", "translate", "(", "a", ",", "table", ",", "deletechars", "=", "None", ")", ":", "a_arr", "=", "numpy", ".", "asarray", "(", "a", ")", "if", "issubclass", "(", "a_arr", ".", "dtype", ".", "type", ",", "unicode_", ")", ":", "return", "_vec_string", "(", "a_arr", ",", "a_arr", ".", "dtype", ",", "'translate'", ",", "(", "table", ",", ")", ")", "else", ":", "return", "_vec_string", "(", "a_arr", ",", "a_arr", ".", "dtype", ",", "'translate'", ",", "[", "table", "]", "+", "_clean_args", "(", "deletechars", ")", ")" ]

[ "UnsetAsSortKey", "(", "self", ")" ]

[ "def", "UnsetAsSortKey", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "SettableHeaderColumn_UnsetAsSortKey", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

[ "GetMenu", "(", "self", ")", "-", ">", "Menu" ]

[ "def", "GetMenu", "(", "*", "args", ",", "*", "*", "kwargs", ")", ":", "return", "_core_", ".", "MenuItem_GetMenu", "(", "*", "args", ",", "*", "*", "kwargs", ")" ]

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

[ "def", "leggrid3d", "(", "x", ",", "y", ",", "z", ",", "c", ")", ":", "return", "pu", ".", "_gridnd", "(", "legval", ",", "c", ",", "x", ",", "y", ",", "z", ")" ]

[ "Assign", "a", "Python", "object", "to", "a", "protobuf", "message", "based", "on", "the", "Python", "type", "(", "in", "recursive", "fashion", ")", ".", "Lists", "become", "repeated", "fields", "/", "messages", "dicts", "become", "messages", "and", "other", "types", "are", "assigned", "directly", ".", "For", "convenience", "repeated", "fields", "whose", "values", "are", "not", "lists", "are", "converted", "to", "single", "-", "element", "lists", ";", "e", ".", "g", ".", "my_repeated_int_field", "=", "3", "is", "converted", "to", "my_repeated_int_field", "=", "[", "3", "]", "." ]

[ "def", "assign_proto", "(", "proto", ",", "name", ",", "val", ")", ":", "is_repeated_field", "=", "hasattr", "(", "getattr", "(", "proto", ",", "name", ")", ",", "'extend'", ")", "if", "is_repeated_field", "and", "not", "isinstance", "(", "val", ",", "list", ")", ":", "val", "=", "[", "val", "]", "if", "isinstance", "(", "val", ",", "list", ")", ":", "if", "isinstance", "(", "val", "[", "0", "]", ",", "dict", ")", ":", "for", "item", "in", "val", ":", "proto_item", "=", "getattr", "(", "proto", ",", "name", ")", ".", "add", "(", ")", "for", "k", ",", "v", "in", "six", ".", "iteritems", "(", "item", ")", ":", "assign_proto", "(", "proto_item", ",", "k", ",", "v", ")", "else", ":", "getattr", "(", "proto", ",", "name", ")", ".", "extend", "(", "val", ")", "elif", "isinstance", "(", "val", ",", "dict", ")", ":", "for", "k", ",", "v", "in", "six", ".", "iteritems", "(", "val", ")", ":", "assign_proto", "(", "getattr", "(", "proto", ",", "name", ")", ",", "k", ",", "v", ")", "else", ":", "setattr", "(", "proto", ",", "name", ",", "val", ")" ]

[ "Processes", "a", "single", "line", "in", "the", "file", "." ]

[ "def", "ProcessLine", "(", "filename", ",", "file_extension", ",", "clean_lines", ",", "line", ",", "include_state", ",", "function_state", ",", "class_state", ",", "error", ",", "extra_check_functions", "=", "[", "]", ")", ":", "raw_lines", "=", "clean_lines", ".", "raw_lines", "ParseNolintSuppressions", "(", "filename", ",", "raw_lines", "[", "line", "]", ",", "line", ",", "error", ")", "CheckForFunctionLengths", "(", "filename", ",", "clean_lines", ",", "line", ",", "function_state", ",", "error", ")", "CheckForMultilineCommentsAndStrings", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckStyle", "(", "filename", ",", "clean_lines", ",", "line", ",", "file_extension", ",", "class_state", ",", "error", ")", "CheckLanguage", "(", "filename", ",", "clean_lines", ",", "line", ",", "file_extension", ",", "include_state", ",", "error", ")", "CheckForNonStandardConstructs", "(", "filename", ",", "clean_lines", ",", "line", ",", "class_state", ",", "error", ")", "CheckPosixThreading", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckInvalidIncrement", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "CheckMakePairUsesDeduction", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")", "for", "check_fn", "in", "extra_check_functions", ":", "check_fn", "(", "filename", ",", "clean_lines", ",", "line", ",", "error", ")" ]

[ "Se", "gestiona", "este", "evento", "ante", "la", "posibilidad", "de", "que", "la", "ventana", "quiera", "controlar", "los", "doble", "clicks", "sobre", "la", "cabecera", "normalmente", "para", "cambiar", "el", "orden", "de", "la", "columna", "llamando", "a", "la", "rutina", "correspondiente", "si", "existe", "(", "gridDobleClickCabecera", ")", "y", "con", "el", "argumento", "del", "objeto", "columna" ]

[ "def", "mouseCabecera", "(", "self", ",", "numColumna", ")", ":", "if", "hasattr", "(", "self", ".", "wParent", ",", "\"gridMouseCabecera\"", ")", ":", "self", ".", "wParent", ".", "gridMouseCabecera", "(", "self", ",", "self", ".", "oColumnasR", ".", "columna", "(", "numColumna", ")", ")" ]

[ "Loads", "the", "data", "from", "the", "given", "json", "file", "returns", "them", "as", "dict", "." ]

[ "def", "load_json_file", "(", "json_file", ")", ":", "with", "open", "(", "json_file", ",", "'r'", ")", "as", "j_file", ":", "return", "json", ".", "load", "(", "j_file", ")" ]

[ "Fraction", "of", "shared", "hits", "with", "reco", "hits", "as", "denominator", "for", "best", "-", "matching", "TrackingParticle", "starting", "from", "the", "first", "hit", "of", "a", "track", "." ]

[ "def", "bestMatchingTrackingParticleFromFirstHitShareFrac", "(", "self", ")", ":", "return", "self", ".", "bestFromFirstHitSimTrkShareFrac", "(", ")" ]